variables prefixed with underline

i have asked this question before and it was closed because i was unable to provide the language it was written in. currently i am looking at these AS3 codes and the variables are prefixed with _ , may i know why? is it because of a convention, if so , why put a _? why do you even need to put a _?

/**
 * Enemy AI - Random movement
 * ---------------------
 * VERSION: 1.0
 * DATE: 1/25/2011
 * AS3
 * UPDATES AND DOCUMENTATION AT: http://www.FreeActionScript.com
 **/
package
{
    import flash.display.MovieClip;
    import flash.events.Event;
    import flash.events.MouseEvent;
    public class Main extends MovieClip
    {
        // player settings
        private var _moveSpeedMax:Number = 1000;
        private var _rotateSpeedMax:Number = 15;
        private var _decay:Number = .98;
        private var _destinationX:int = 150;
        private var _destinationY:int = 150;
        private var _minX:Number = 0;
        private var _minY:Number = 0;
        private var _maxX:Number = 550;
        private var _maxY:Number = 400;
        // pl开发者_如何转开发ayer
        private var _player:MovieClip;
        // global
        private var _dx:Number = 0;
        private var _dy:Number = 0;
        private var _vx:Number = 0;
        private var _vy:Number = 0;
        private var _trueRotation:Number = 0;
        /**
         * Constructor
         */
        public function Main()
        {
            // create player object
            createPlayer();
            // add listeners
            stage.addEventListener(Event.ENTER_FRAME, enterFrameHandler);
        }
        /**
         * Creates player
         */
        private function createPlayer():void
        {
            _player = new Player();
            _player.x = stage.stageWidth / 2;
            _player.y = stage.stageHeight / 2;
            stage.addChild(_player);
        }
        /**
         * EnterFrame Handlers
         */
        private function enterFrameHandler(event:Event):void
        {
            updateCollision();
            updatePosition();
            updateRotation();
        }
        /**
         * Calculate Rotation
         */
        private function updateRotation():void
        {
            // calculate rotation
            _dx = _player.x - _destinationX;
            _dy = _player.y - _destinationY;
            // which way to rotate
            var rotateTo:Number = getDegrees(getRadians(_dx, _dy));
            // keep rotation positive, between 0 and 360 degrees
            if (rotateTo > _player.rotation + 180) rotateTo -= 360;
            if (rotateTo < _player.rotation - 180) rotateTo += 360;
            // ease rotation
            _trueRotation = (rotateTo - _player.rotation) / _rotateSpeedMax;
            // update rotation
            _player.rotation += _trueRotation;
        }
        /**
         * Calculate Position
         */
        private function updatePosition():void
        {
            // update velocity
            _vx += (_destinationX - _player.x) / _moveSpeedMax;
            _vy += (_destinationY - _player.y) / _moveSpeedMax;
            // if close to target
            if (getDistance(_dx, _dy) < 50)
            {
                getRandomDestination();
            }
            // apply decay (drag)
            _vx *= _decay;
            _vy *= _decay;
            // update position
            _player.x += _vx;
            _player.y += _vy;
        }
        /**
         * updateCollision
         */
        protected function updateCollision():void
        {
            // Check X
            // Check if hit top
            if (((_player.x - _player.width / 2) < _minX) && (_vx < 0))
            {
              _vx = -_vx;
            }
            // Check if hit bottom
            if ((_player.x + _player.width / 2) > _maxX && (_vx > 0))
            {
              _vx = -_vx;
            }
            // Check Y
            // Check if hit left side
            if (((_player.y - _player.height / 2) < _minY) && (_vy < 0))
            {
              _vy = -_vy
            }
            // Check if hit right side
            if (((_player.y + _player.height / 2) > _maxY) && (_vy > 0))
            {
              _vy = -_vy;
            }
        }
        /**
         * Calculates a random destination based on stage size
         */
        private function getRandomDestination():void
        {
            _destinationX = Math.random() * (_maxX - _player.width) + _player.width / 2;
            _destinationY = Math.random() * (_maxY - _player.height) + _player.height / 2;
        }
        /**
         * Get distance
         * @param   delta_x
         * @param   delta_y
         * @return
         */
        public function getDistance(delta_x:Number, delta_y:Number):Number
        {
            return Math.sqrt((delta_x*delta_x)+(delta_y*delta_y));
        }
        /**
         * Get radians
         * @param   delta_x
         * @param   delta_y
         * @return
         */
        public function getRadians(delta_x:Number, delta_y:Number):Number
        {
            var r:Number = Math.atan2(delta_y, delta_x);
            if (delta_y < 0)
            {
                r += (2 * Math.PI);
            }
            return r;
        }
        /**
         * Get degrees
         * @param   radians
         * @return
         */
        public function getDegrees(radians:Number):Number
        {
            return Math.floor(radians/(Math.PI/180));
        }
    }
}

---

Two reasons that I do this:

1. Makes it very clear which variables are private.
2. Defining getters/setters makes more sense when you prefix the variable to get/set.

Here's an example:

private var _thing:String = "hello";

public function get thing():String
{
    return _thing;
}

As you can see, _thing is read-only and is accessed via the much nicer class.thing - it's also much more readable i.e. you can easily see which variables are related to which getters and setters.

To answer the latter part of your question; no you do not need to add the underscore at the front of a private property/method, though I do recommend making this a habit - you'll thank yourself for it down the track, as will collaborators if any.

---

It's a naming convention that typically denotes a private class level variable. It's supposed to make the code easier to read by allowing you to be able to determine the scope of the variable.

---

Consider:

..
public class SomeClass{

private var _param1:uint;
private var _param2:string;
private var _param3:displayObject

protected var __param4:int;

public function SomeClass(param1:uint, param2:string, param3:displayObject):void{
    super();
    _param1 = param1;
    _param2 = param2;
    _param3 = param3;
    __param4 = 123;
    //etc...

Not adding anything new, just illustrating the very useful semantic relationship that could be developed when using underscore privates, especially as related to method parameters derived from external sources.

Note also that sometimes a double underscore __ is used for protected variables.

---

It's purpose is to make it clearer in methods that they are instance variables.

In some environments, the convention in C++ is to add the prefix "m" or "m_" (for "member") for the same reason.