Skip to content

Павел Резуненко / MTAweb

Go to a project
Switch branch/tag
Number.html 13.6 KB
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 
<!DOCTYPE html>
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  <title>The source code</title>
  <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
  <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
  <style type="text/css">
    .highlight { display: block; background-color: #ddd; }
  </style>
  <script type="text/javascript">
    function highlight() {
      document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
    }
  </script>
</head>
<body onload="prettyPrint(); highlight();">
  <pre class="prettyprint lang-js"><span id='Number'>/**
</span> * @class Number
 *
 * Creates a wrapper object to allow you to work with numerical values.
 *
 * The primary uses for the `Number` object are:
 *
 * If the argument cannot be converted into a number, it returns `NaN`.
 *
 * In a non-constructor context (i.e., without the `new` operator), `Number` can
 * be used to perform a type conversion.
 *
 * # Using the `Number` object to assign values to numeric variables
 *
 * The following example uses the `Number` object's properties to assign values to
 * several numeric variables:
 *
 *     biggestNum = Number.MAX_VALUE;
 *     smallestNum = Number.MIN_VALUE;
 *     infiniteNum = Number.POSITIVE_INFINITY;
 *     negInfiniteNum = Number.NEGATIVE_INFINITY;
 *     notANum = Number.NaN;
 *
 * # Using `Number` to convert a `Date` object
 *
 * The following example converts the `Date` object to a numerical value using
 * `Number` as a function:
 *
 *     var d = new Date(&quot;December 17, 1995 03:24:00&quot;);
 *     print(Number(d));
 *
 * This displays &quot;819199440000&quot;.
 *
 * The following example converts the Date object to a numerical value using
 * `Number` as a function:
 *
 * &lt;div class=&quot;notice&quot;&gt;
 * Documentation for this class comes from &lt;a href=&quot;https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Number&quot;&gt;MDN&lt;/a&gt;
 * and is available under &lt;a href=&quot;http://creativecommons.org/licenses/by-sa/2.0/&quot;&gt;Creative Commons: Attribution-Sharealike license&lt;/a&gt;.
 * &lt;/div&gt;
 */

<span id='Number-method-constructor'>/**
</span> * @method constructor
 * Creates new Number object.
 * @param value
 * The numeric value of the object being created.
 */

//Properties

<span id='Number-static-property-MAX_VALUE'>/**
</span> * @property {Number} MAX_VALUE
 * @static
 * The largest positive representable number. The largest negative representable
 * number is `-MAX_VALUE`.
 *
 * The `MAX_VALUE` property has a value of approximately 1.79E+308. Values larger than `MAX_VALUE` are
 * represented as `&quot;Infinity&quot;`.
 *
 * Because `MAX_VALUE` is a static property of `Number`, you always use it as `Number.MAX_VALUE`,
 * rather than as a property of a `Number` object you created.
 *
 * The following code multiplies two numeric values. If the result is less than or equal to
 * `MAX_VALUE`, the `func1` function is called; otherwise, the `func2` function is called.
 *
 *     if (num1 * num2 &lt;= Number.MAX_VALUE)
 *         func1();
 *     else
 *         func2();
 */

<span id='Number-static-property-MIN_VALUE'>/**
</span> * @property {Number} MIN_VALUE
 * @static
 * The smallest positive representable number -- that is, the positive number
 * closest to zero (without actually being zero). The smallest negative
 * representable number is `-MIN_VALUE`.
 *
 * The `MIN_VALUE` property is the number closest to 0, not the most negative number, that JavaScript
 * can represent.
 *
 * `MIN_VALUE` has a value of approximately 5e-324. Values smaller than `MIN_VALUE` (&quot;underflow
 * values&quot;) are converted to 0.
 *
 * Because `MIN_VALUE` is a static property of `Number`, you always use it as `Number.MIN_VALUE`,
 * rather than as a property of a `Number` object you created.
 *
 * The following code divides two numeric values. If the result is greater than or equal to
 * `MIN_VALUE`, the `func1` function is called; otherwise, the `func2` function is called.
 *
 *     if (num1 / num2 &gt;= Number.MIN_VALUE)
 *         func1()
 *     else
 *         func2()
 */

<span id='Number-static-property-NaN'>/**
</span> * @property {Number} NaN
 * @static
 * Special &quot;not a number&quot; value.
 */

<span id='Number-property-NEGATIVE_INFINITY'>/**
</span> * @property {Number} NEGATIVE_INFINITY
 * Special value representing negative infinity; returned on overflow.
 *
 * The value of `Number.NEGATIVE_INFINITY` is the same as the negative value of the global object's
 * Infinity property.
 *
 * This value behaves slightly differently than mathematical infinity:
 *
 * *   Any positive value, including POSITIVE_INFINITY, multiplied by NEGATIVE_INFINITY is NEGATIVE_INFINITY.
 * *   Any negative value, including NEGATIVE_INFINITY, multiplied by NEGATIVE_INFINITY is
 * POSITIVE_INFINITY.
 * *   Zero multiplied by NEGATIVE_INFINITY is NaN.
 * *   NaN multiplied by NEGATIVE_INFINITY is NaN.
 * *   NEGATIVE_INFINITY, divided by any negative value except NEGATIVE_INFINITY, is
 * POSITIVE_INFINITY.
 * *   NEGATIVE_INFINITY, divided by any positive value except POSITIVE_INFINITY, is
 * NEGATIVE_INFINITY.
 * *   NEGATIVE_INFINITY, divided by either NEGATIVE_INFINITY or POSITIVE_INFINITY, is NaN.
 * *   Any number divided by NEGATIVE_INFINITY is Zero.
 *
 * Several JavaScript methods (such as the `Number` constructor, `parseFloat`, and `parseInt`) return
 * `NaN` if the value specified in the parameter is significantly lower than `Number.MIN_VALUE`.
 *
 * You might use the `Number.NEGATIVE_INFINITY` property to indicate an error condition that returns a
 * finite number in case of success. Note, however, that `isFinite` would be more appropriate in such
 * a case.
 *
 * In the following example, the variable smallNumber is assigned a value that is smaller than the
 * minimum value. When the `if` statement executes, `smallNumber` has the value `&quot;-Infinity&quot;`, so
 * `smallNumber` is set to a more manageable value before continuing.
 *
 *     var smallNumber = (-Number.MAX_VALUE) * 2
 *     if (smallNumber == Number.NEGATIVE_INFINITY) {
 *         smallNumber = returnFinite();
 *     }
 */

<span id='Number-property-POSITIVE_INFINITY'>/**
</span> * @property {Number} POSITIVE_INFINITY
 * Special value representing infinity; returned on overflow.
 *
 * The value of `Number.POSITIVE_INFINITY` is the same as the value of the global object's Infinity
 * property.
 *
 * This value behaves slightly differently than mathematical infinity:
 *
 * *   Any positive value, including POSITIVE_INFINITY, multiplied by POSITIVE_INFINITY is
 * POSITIVE_INFINITY.
 * *   Any negative value, including NEGATIVE_INFINITY, multiplied by POSITIVE_INFINITY is
 * NEGATIVE_INFINITY.
 * *   Zero multiplied by POSITIVE_INFINITY is NaN.
 * *   NaN multiplied by POSITIVE_INFINITY is NaN.
 * *   POSITIVE_INFINITY, divided by any negative value except NEGATIVE_INFINITY, is
 * NEGATIVE_INFINITY.
 * *   POSITIVE_INFINITY, divided by any positive value except POSITIVE_INFINITY, is
 * POSITIVE_INFINITY.
 * *   POSITIVE_INFINITY, divided by either NEGATIVE_INFINITY or POSITIVE_INFINITY, is NaN.
 * *   Any number divided by POSITIVE_INFINITY is Zero.
 *
 * Several JavaScript methods (such as the `Number` constructor, `parseFloat`, and `parseInt`) return
 * `NaN` if the value specified in the parameter is significantly higher than `Number.MAX_VALUE`.
 *
 * You might use the `Number.POSITIVE_INFINITY` property to indicate an error condition that returns a
 * finite number in case of success. Note, however, that `isFinite` would be more appropriate in such
 * a case.
 *
 * In the following example, the variable `bigNumber` is assigned a value that is larger than the
 * maximum value. When the if statement executes, `bigNumber` has the value &quot;Infinity&quot;, so `bigNumber`
 * is set to a more manageable value before continuing.
 *
 *     var bigNumber = Number.MAX_VALUE * 2
 *     if (bigNumber == Number.POSITIVE_INFINITY) {
 *         bigNumber = returnFinite();
 *     }
 */

//Methods

<span id='Number-method-toExponential'>/**
</span> * @method toExponential
 * Returns a string representing the number in exponential notation.
 *
 * A string representing a `Number` object in exponential notation with one digit before the decimal
 * point, rounded to `fractionDigits` digits after the decimal point. If the `fractionDigits` argument
 * is omitted, the number of digits after the decimal point defaults to the number of digits necessary
 * to represent the value uniquely.
 *
 * If you use the `toExponential` method for a numeric literal and the numeric literal has no exponent
 * and no decimal point, leave a space before the dot that precedes the method call to prevent the dot
 * from being interpreted as a decimal point.
 *
 * If a number has more digits that requested by the `fractionDigits` parameter, the number is rounded
 * to the nearest number represented by `fractionDigits` digits. See the discussion of rounding in the
 * description of the `toFixed` method, which also applies to `toExponential`.
 *
 *     var num=77.1234;
 *
 *     alert(&quot;num.toExponential() is &quot; + num.toExponential()); //displays 7.71234e+1
 *
 *     alert(&quot;num.toExponential(4) is &quot; + num.toExponential(4)); //displays 7.7123e+1
 *
 *     alert(&quot;num.toExponential(2) is &quot; + num.toExponential(2)); //displays 7.71e+1
 *
 *     alert(&quot;77.1234.toExponential() is &quot; + 77.1234.toExponential()); //displays 7.71234e+1
 *
 *     alert(&quot;77 .toExponential() is &quot; + 77 .toExponential()); //displays 7.7e+1
 *
 * @param {Number} fractionDigits An integer specifying the number of digits after the decimal
 * point. Defaults to as many digits as necessary to specify the number.
 * @return {String} Exponential notation of number.
 */

<span id='Number-method-toFixed'>/**
</span> * @method toFixed
 * Returns a string representing the number in fixed-point notation.
 *
 * @return {String} A string representation of `number` that does not use
 * exponential notation and has exactly `digits` digits after the decimal place.
 * The number is rounded if necessary, and the fractional part is padded with
 * zeros if necessary so that it has the specified length. If `number` is greater
 * than 1e+21, this method simply calls `Number.toString()` and returns a string
 * in exponential notation.
 *
 * @param {Number} digits The number of digits to appear after the decimal point; this may be a
 * value between 0 and 20, inclusive, and implementations may optionally support a larger range of
 * values. If this argument is omitted, it is treated as 0.
 */

<span id='Number-method-toLocaleString'>/**
</span> * @method toLocaleString
 * Returns a human readable string representing the number using the locale of the
 * environment. Overrides the `Object.prototype.toLocaleString` method.
 *
 * This method available to numbers will convert the number into a string which is suitable for
 * presentation in the given locale.
 *
 *     var number = 3500
 *     console.log(number.toLocaleString()); // Displays &quot;3,500&quot; in English locale
 *
 * @return {String} String representing the number.
 */

<span id='Number-method-toPrecision'>/**
</span> * @method toPrecision
 * Returns a string representing the number to a specified precision in fixed-
 * point or exponential notation.
 *
 * A string representing a `Number` object in fixed-point or
 * exponential notation rounded to precision significant digits. See the
 * discussion of rounding in the description of the `toFixed` method, which also
 * applies to `toPrecision`.
 *
 * If the precision argument is omitted, behaves as Number.toString. If it is a
 * non-integer value, it is rounded to the nearest integer. After rounding, if
 * that value is not between 1 and 100 (inclusive), a RangeError is thrown.
 *
 * @param {Number} precision An integer specifying the number of significant digits.
 * @return {String} String that represents `Number` object.
 */

<span id='Number-method-toString'>/**
</span> * @method toString
 * Returns a string representing the specified object. Overrides the
 * `Object.prototype.toString` method.
 *
 * The `Number` object overrides the `toString` method of the `Object` object; it does not inherit
 * `Object.toString`. For `Number` objects, the toString method returns a string representation of the
 * object in the specified radix.
 *
 * The `toString` method parses its first argument, and attempts to return a string representation in
 * the specified radix (base). For radixes above 10, the letters of the alphabet indicate numerals
 * greater than 9. For example, for hexadecimal numbers (base 16), A through F are used.
 *
 * If `toString` is given a radix not between 2 and 36, an exception is thrown.
 *
 * If the radix is not specified, JavaScript assumes the preferred radix is 10.
 *
 *     var count = 10;
 *     print(count.toString());   // displays &quot;10&quot;
 *     print((17).toString());    // displays &quot;17&quot;
 *
 *     var x = 7;
 *     print(x.toString(2));      // displays &quot;111&quot;
 *
 * @param {Number} radix An integer between 2 and 36 specifying the base to use for representing
 * numeric values.
 * @return {String} The number represented as a string.
 */

<span id='Number-method-valueOf'>/**
</span> * @method valueOf
 * Returns the primitive value of the specified object. Overrides the
 * `Object.prototype.valueOf` method.
 *
 * The `valueOf` method of `Number` returns the primitive value of a `Number` object as a number data
 * type.
 *
 * This method is usually called internally by JavaScript and not explicitly in code.
 *
 *     var x = new Number();
 *     print(x.valueOf());     // prints &quot;0&quot;
 *
 * @return {Number} The primitive value of the number.
 */</pre>
</body>
</html>