| Language version: | ActionScript 3.0
|
A data type representing an IEEE-754 double-precision floating-point number. You can manipulate primitive numeric
values by using the methods and properties associated with the Number class. This class is identical to the
JavaScript Number class.
The properties of the Number class are static, which means you do not need an object to use them, so you
do not need to use the constructor.
The Number data type adheres to the double-precision IEEE-754 standard.
The Number data type is useful when you need to use floating-point values.
Flash runtimes handle int and uint data types more efficiently than Number, but Number is
useful in situations where the range of values required exceeds the valid range
of the int and uint data types. The Number class can be used to
represent integer values well beyond the valid range of the int and uint data types.
The Number data type can use up to 53 bits to represent integer values, compared to
the 32 bits available to int and uint. The default value of a variable typed as Number is NaN (Not a Number).
View the examples.
public function Number(num:Object)
| Language version: | ActionScript 3.0
|
Creates a Number object with the specified value. This constructor has the same effect
as the Number() public native function that converts an object of a different type
to a primitive numeric value.
Parameters
| num:Object — The numeric value of the Number instance being created or a value
to be converted to a Number. The default value is 0 if num is
not specified. Using the constructor without specifying a num parameter is not
the same as declaring a variable of type Number with no value assigned (such as var myNumber:Number), which
defaults to NaN. A number with no value assigned is undefined and the equivalent of
new Number(undefined).
|
See also
AS3 function toExponential(fractionDigits:uint):String
| Language version: | ActionScript 3.0
|
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
| fractionDigits:uint — An integer between 0 and 20, inclusive, that represents the desired number of decimal places.
|
Returns
Throws
| RangeError — Throws an exception if the fractionDigits argument is outside the range 0 to 20.
|
Example
The following example shows how
toExponential(2) returns a string in
exponential notation.
var num:Number = 315003;
trace(num.toExponential(2)); // 3.15e+5
AS3 function toFixed(fractionDigits:uint):String
| Language version: | ActionScript 3.0
|
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
| fractionDigits:uint — An integer between 0 and 20, inclusive, that represents the desired number of decimal places.
|
Returns
Throws
| RangeError — Throws an exception if the fractionDigits argument is outside the range 0 to 20.
|
Example
The following example shows how
toFixed(3) returns a string that rounds
to three decimal places.
var num:Number = 7.31343;
trace(num.toFixed(3)); // 7.313
The following example shows how
toFixed(2) returns a string that adds
trailing zeroes.
var num:Number = 4;
trace(num.toFixed(2)); // 4.00
AS3 function toPrecision(precision:uint):String
| Language version: | ActionScript 3.0
|
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
| precision:uint — An integer between 1 and 21, inclusive, that represents the desired number of digits to represent in the resulting string.
|
Returns
Throws
| RangeError — Throws an exception if the precision argument is outside the range 1 to 21.
|
Example
The following example shows how
toPrecision(3) returns a string with
only three digits. The string is in fixed-point notation because exponential notation is not required.
var num:Number = 31.570;
trace(num.toPrecision(3)); // 31.6
The following example shows how
toPrecision(3) returns a string with
only three digits. The string is in exponential notation because the resulting number does not
contain enough digits for fixed-point notation.
var num:Number = 4000;
trace(num.toPrecision(3)); // 4.00e+3
AS3 function toString(radix:Number = 10):String
| Language version: | ActionScript 3.0
|
Returns the string representation of the specified Number object (myNumber).
If the value of the Number object is a decimal number without a leading zero (such as .4),
Number.toString() adds a leading zero (0.4).
Parameters
| radix:Number (default = 10)radix parameter, the default value
is 10.
|
Returns
| String —
The numeric representation of the Number object as a string.
|
AS3 function valueOf():Number
| Language version: | ActionScript 3.0
|
Returns the primitive value type of the specified Number object.
Returns
| Number —
The primitive type value of the Number object.
|
public static const MAX_VALUE:Number
| Language version: | ActionScript 3.0
|
The largest representable number (double-precision IEEE-754). This number is
approximately 1.79e+308.
public static const MIN_VALUE:Number
| Language version: | ActionScript 3.0
|
The smallest (closest to zero, not most negative) representable IEEE-754 number that does not compare equal to zero. On most platforms this number is approximately 5e-324, but it can be larger on systems that do not support denormalized numbers. For example, on iOS this constant's value is 2.225e-308.
Note: The absolute smallest representable number overall is -Number.MAX_VALUE.
public static const NaN:Number
| Language version: | ActionScript 3.0
|
The IEEE-754 value representing Not a Number (NaN).
See also
public static const NEGATIVE_INFINITY:Number
| Language version: | ActionScript 3.0
|
Specifies the IEEE-754 value representing negative infinity. The value of this property
is the same as that of the constant -Infinity.
Negative infinity is a special numeric value that is returned when a mathematical
operation or function returns a negative value larger than can be
represented.
public static const POSITIVE_INFINITY:Number
| Language version: | ActionScript 3.0
|
Specifies the IEEE-754 value representing positive infinity. The value of this property
is the same as that of the constant Infinity.
Positive infinity is a special numeric value that is returned when a mathematical
operation or function returns a value larger than can be represented.
The following example shows how a number with six digits after the decimal place
is truncated (with rounding) to a number with two digits after the decimal point.
package {
import flash.display.Sprite;
public class NumberExample extends Sprite {
public function NumberExample() {
var num:Number = new Number(10.456345);
var str:String = num.toFixed(2);
trace(num); // 10.456345
trace(str); // 10.46
}
}
}
© 2004-2022 Adobe Systems Incorporated. All rights reserved.
Wed Sep 28 2022, 6:12 PM GMT+01:00
Object
Hide Inherited Public Properties
Show Inherited Public Properties