Constructor; creates a new int object. You must use the int constructor when using int.toString() and int.valueOf(). You do not use a constructor when using the properties of an int object. The new int constructor is primarily used as a placeholder. An int object is not the same as the int() function that converts a parameter to a primitive value.

See also

	 var n1:int = new int(3.4);
	 var n2:int = new int(-10);
	 

Returns a string representation of the number in exponential notation. The string contains one digit before the decimal point and up to 20 digits after the decimal point, as specified by the fractionDigits parameter.

Parameters

var num:Number = 315003;
trace(num.toExponential(2)); // 3.15e+5

Returns a string representation of the number in fixed-point notation. Fixed-point notation means that the string will contain a specific number of digits after the decimal point, as specified in the fractionDigits parameter. The valid range for the fractionDigits parameter is from 0 to 20. Specifying a value outside this range throws an exception.

Parameters

var num:Number = 7.31343;
trace(num.toFixed(3)); // 7.313

var num:Number = 4;
trace(num.toFixed(2)); // 4.00

Returns a string representation of the number either in exponential notation or in fixed-point notation. The string will contain the number of digits specified in the precision parameter.

Parameters

var num:Number = 31.570;
trace(num.toPrecision(3)); // 31.6

var num:Number = 4000;
trace(num.toPrecision(3)); // 4.00e+3

Returns the string representation of an int object.

Parameters

	 var myint:int = new int(9);
	 trace(myint.toString(2)); // 1001
	 trace(myint.toString(8)); // 11
	 

The following example results in a hexadecimal value.

	 var r:int = new int(250);
	 var g:int = new int(128);
	 var b:int = new int(114);
	 var rgb:String = "0x"+ r.toString(16)+g.toString(16)+b.toString(16);
	 trace(rgb); // 0xfa8072
	 

Returns the primitive value of the specified int object.

	 var numSocks:int = new int(2);
	 trace(numSocks.valueOf()); // 2
	 

The largest representable 32-bit signed integer, which is 2,147,483,647.

	trace("int.MIN_VALUE = "+int.MIN_VALUE);
	trace("int.MAX_VALUE = "+int.MAX_VALUE);
	

This code logs the following values:

	int.MIN_VALUE = -2147483648
	int.MAX_VALUE = 2147483647
	

The smallest representable 32-bit signed integer, which is -2,147,483,648.

     trace("int.MIN_VALUE = "+int.MIN_VALUE);
     trace("int.MAX_VALUE = "+int.MAX_VALUE);
     

This code logs the following values:

	int.MIN_VALUE = -2147483648
	int.MAX_VALUE = 2147483647
     

1. Two int variables a and b are declared in the constructor.
2. The two ints are added using the method addIntegers().
3. A third int variable c is assigned the outcome of parseInteger(), which checks the validity of the string passed to it to ensure that it is an integer value in the acceptable range for int data types and returns an int equal to the integer value of the string if it is valid.
4. The int variables a and c are added together using addIntegers().

package {
    import flash.display.Sprite;

    public class IntExample extends Sprite {    
        public function IntExample() {
            var a:int = 512;
            var b:int = -128;
            
            trace(addIntegers(a, b)); // 384

            var c:int = parseInteger("32");
            
            trace(addIntegers(a, c)); // 544
        }
            
        public function addIntegers(a:int, b:int):int {
            return a + b;
        }
        
        public function parseInteger(str:String):int {
            var num:Number = parseInt(str);
            if(!isNaN(num) && num <= int.MAX_VALUE && num >= int.MIN_VALUE) {
                return int(num);
            }
            
            return 0;
        }
        
    }
}