[ Web Proxy ]
URL:
Viewing: https://ko.javascript.info/number [Back]  [Original]
KO
. .
[] [] [] []
    EPUB/PDF
    javascript.info :
    :
    Light themeDark theme
    DanskEnglishEspaolFranaisIndonesiaItalianoTrkeOzbek
    2023 12 1

    .

    1. ' (double precision floating point number)' 64 IEEE-754 . .

    2. BigInt . 253 -253 BigInt . BigInt , BigInt .

    , .

    10 . 10(one billion) .

    let billion = 1000000000;

    0 , . 0 . 10(billion) '1bn' , 73 '7.3bn' . .

    'e' 0 .

    let billion = 1e9;  // 10, 1 9 0

alert( 7.3e9 );  // 73 (7,300,000,000)

    , 'e' e e 10 .

    1e3 === 1 * 1000
1.23e6 === 1.23 * 1000000

    1( 1) .

    let ms = 0.000001;

    'e' . 0 .

    let ms = 1e-6; // 1  6

    0.000001 0 6 0.000001 1e-6 .

    'e' , 10 .

    // 10     
1e-3 === 1 / 1000 // 0.001

// 10     
1.23e-6 === 1.23 / 1000000 // 0.00000123

    16, 2, 8

    16 . 16 . 16 0x .

    :

    alert( 0xff ); // 255
alert( 0xFF ); // 255 (       .)

    2 8 , 0b 0o .

    let a = 0b11111111; // 255 2
let b = 0o377; // 255 8

alert( a == b ); // true,  , a b

    3. parseInt ( ).

    toString(base)

    num.toString(base) base num , .

    :

    let num = 255;

alert( num.toString(16) );  // ff
alert( num.toString(2) );   // 11111111

    base 2 36 , 10.

    base .

    • base=16 16 , . 0 9, 10 A F .

    • base=2 . 0 1 .

    • base=36 base , 0..9 A..Z . . 36 url . .

      alert( 123456..toString(36) ); // 2n9c

    123456..toString(36) . toString .. .

    123456.toString(36) , . .

    (123456).toString(36) .

    (rounding) .

    .

    Math.floor
    (). 3.1 3, -1.1 -2 .
    Math.ceil
    . 3.1 4, -1.1 -1 .
    Math.round
    . 3.1 3, 3.6 4, -1.1 -1 .
    Math.trunc (Internet Explorer )
    . 3.1 3 -1.1 -1 .

    .

    Math.floor Math.ceil Math.round Math.trunc
    3.1 3 4 3 3
    3.6 3 4 4 3
    -1.1 -2 -1 -1 -1
    -1.6 -2 -1 -2 -1

    . n-th ?

    1.2345 1.23 .

    .

    1. , 100 100 10 , .

      let num = 1.23456;

alert( Math.floor(num * 100) / 100 ); // 1.23456 -> 123.456 -> 123 -> 1.23

    2. n toFixed(n) .

      let num = 12.34;
alert( num.toFixed(1) ); // "12.3"

      toFixed Math.round .

      let num = 12.36;
alert( num.toFixed(1) ); // "12.4"

      toFixed . 0 .

      let num = 12.34;
alert( num.toFixed(5) ); // "12.34000",   5   0 .

      , +num.toFixed(5) Number() .

    64 IEEE-754 64 . 64 52 , 11 ( 0), 1 .

    64 Infinity .

    alert( 1e500 ); // Infinity

    , (loss of precision) .

    .

    alert( 0.1 + 0.2 == 0.3 ); // false

    0.1 0.2 0.3 false .

    ! 0.3 ?

    alert( 0.1 + 0.2 ); // 0.30000000000000004

    . . $0.10 $0.20 . $0.30000000000000004 .

    ?

    0 1 . 10 0.1, 0.2 .

    0.1 1 10 1/10. 10 . 1/10 1/3 . 1/3 0.33333(3) .

    10 10 3 10 . 2 2 1/10 2 .

    10 1/3 , 2 0.1 0.2 .

    IEEE-754 . ' .

    .

    alert( 0.1.toFixed(20) ); // 0.10000000000000000555

    ' .

    0.1 + 0.2 0.3 .

    .

    .

    PHP, Java, C, Perl, Ruby .

    ? . toFixed(n) .

    let sum = 0.1 + 0.2;
alert( sum.toFixed(2) ); // 0.30

    toFixed . 2 . $0.30 . .

    let sum = 0.1 + 0.2;
alert( +sum.toFixed(2) ); // 0.3

    100( ) , 100 . . .

    alert( (0.1 * 10 + 0.2 * 10) / 10 ); // 0.3
alert( (0.28 * 100 + 0.14 * 100) / 100); // 0.4200000000000001

    10 .

    . , 30% . . ' .

    .

    //   !
alert( 9999999999999999 ); // 10000000000000000 .

    . 64 , 52 . (the least significant digit) .

    . .

    0

    0 -0 0 .

    0 , .

    0 -0 0 .

    isNaN isFinite

    ?

    • Infinity -Infinity
    • NaN

    , .

    • isNaN(value) NaN 

      alert( isNaN(NaN) ); // true
alert( isNaN("str") ); // true

      ? "=== NaN ?" . '. NaN NaN .

      alert( NaN === NaN ); // false

    • isFinite(value) NaN/Infinity/-Infinity true 

      alert( isFinite("15") ); // true
alert( isFinite("str") ); // false, NaN .
alert( isFinite(Infinity) ); // false, Infinity .

    isFinite .

    let num = +prompt(" .", '');

//     Infinity, -Infinity  false .
alert( isFinite(num) );

    isFinite 0 .

    Object.is

    Object.is === , === .

    1. NaN : Object.is(NaN, NaN) === true.
    2. 0 -0 : Object.is(0, -0) === false. 0 0 -0 .

    , Object.is(a, b) a === b .

    . , Object.is . Object.is SameValue .

    parseInt parseFloat

    + Number() . .

    alert( +"100px" ); // NaN

    .

    CSS '100px', '12pt' . '19' . .

    parseInt parseFloat .

    . . parseInt , parseFloat .

    alert( parseInt('100px') ); // 100
alert( parseFloat('12.5em') ); // 12.5

alert( parseInt('12.3') ); // 12,   .
alert( parseFloat('12.3.4') ); // 12.3,      .

    parseInt parseFloat NaN . .

    alert( parseInt('a123') ); // NaN, a      .
    parseInt(str, radix)

    parseInt() . radix . parseInt 16 , 2 .

    alert( parseInt('0xff', 16) ); // 255
alert( parseInt('ff', 16) ); // 255, 0x  .

alert( parseInt('2n9c', 36) ); // 123456

    Math .

    .

    Math.random()

    0 1 (1 ).

    alert( Math.random() ); // 0.1234567894322
alert( Math.random() ); // 0.5435252343232
alert( Math.random() ); // ... ( )
    Math.max(a, b, c...) / Math.min(a, b, c...)

    / .

    alert( Math.max(3, 5, -10, 0, 1) ); // 5
alert( Math.min(1, 2) ); // 1
    Math.pow(n, power)

    n power .

    alert( Math.pow(2, 10) ); // 2 10 = 1024

    Math . MDN .

    0 .

    • 0 'e' . 123e6 0 6 , 123000000 .
    • 'e' , 10 . 123e-6 0.000123 .

    .

    • 16(0x), 8(0o), 2(0b) .
    • parseInt(str, base) str base (, 2 base 36).
    • num.toString(base) base , .

    12pt 100px .

    • parseInt/parseFloat , .

    .

    • Math.floor, Math.ceil, Math.trunc, Math.round, num.toFixed(precision) .
    • .

    .

    : 5

    , .

    P.S. .

    let a = +prompt("The first number?", "");
let b = +prompt("The second number?", "");

alert( a + b );

    prompt + . + .

    + , a b a b . "1" + "2" = "12" .

    6.35.toFixed(1) == 6.3 ?

    : 4

    Math.round toFixed . 0..4 , 5..9 .

    :

    alert( 1.35.toFixed(1) ); // 1.4

    , 6.35 6.4 6.3 ?

    alert( 6.35.toFixed(1) ); // 6.3

    6.35 ?

    10 6.35 2 . .

    .

    alert( 6.35.toFixed(20) ); // 6.34999999999999964473

    , . . .

    1.35 ?

    alert( 1.35.toFixed(20) ); // 1.35000000000000008882

    . .

    6.35 ?

    .

    alert( (6.35 * 10).toFixed(20) ); // 63.50000000000000000000

    63.5 . 0.5 1/2 . 2 2 .

    alert( Math.round(6.35 * 10) / 10); // 6.35 -> 63.5 -> 64() -> 6.4

    : 5

    readNumber .

    .

    ' null .

    .

    function readNumber() {
  let num;

  do {
    num = prompt("Enter a number please?", 0);
  } while ( !isFinite(num) );

  if (num === null || num === '') return null;

  return +num;
}

alert(`Read: ${readNumber()}`);

    null .

    . null . null 0 .

    null 0 , null .

    .

    : 4

    . ?

    let i = 0;
while (i != 10) {
  i += 0.2;
}

    i 10 .

    i .

    let i = 0;
while (i < 11) {
  i += 0.2;
  if (i > 9.8 && i < 10.2) alert( i );
}

    i 10 .

    0.2 .

    .

    min max

    : 2

    Math.random() 0 1(1 ) .

    random(min, max) min max (max ).

    .

    alert( random(1, 5) ); // 1.2345623452
alert( random(1, 5) ); // 3.7894332423
alert( random(1, 5) ); // 4.3435234525

    We need to map all values from the interval 01 into values from min to max.

    .

    1. 0 1 max-min 0..1 0..max-min .
    2. Now if we add min, the possible interval becomes from min to max.

    The function:

    function random(min, max) {
  return min + Math.random() * (max - min);
}

alert( random(1, 5) );
alert( random(1, 5) );
alert( random(1, 5) );

    A random integer from min to max

    : 2

    Create a function randomInteger(min, max) that generates a random integer number from min to max including both min and max as possible values.

    Any number from the interval min..max must appear with the same probability.

    Examples of its work:

    alert( randomInteger(1, 5) ); // 1
alert( randomInteger(1, 5) ); // 3
alert( randomInteger(1, 5) ); // 5

    You can use the solution of the previous task as the base.

    The simple but wrong solution

    The simple but wrong solution

    The simplest, but wrong solution would be to generate a value from min to max and round it:

    function randomInteger(min, max) {
  let rand = min + Math.random() * (max - min);
  return Math.round(rand);
}

alert( randomInteger(1, 3) );

    The function works, but it is incorrect. The probability to get edge values min and max is two times less than any other.

    If you run the example above many times, you would easily see that 2 appears the most often.

    That happens because Math.round() gets random numbers from the interval 1..3 and rounds them as follows:

    values from 1    ... to 1.4999999999  become 1
values from 1.5  ... to 2.4999999999  become 2
values from 2.5  ... to 2.9999999999  become 3

    Now we can clearly see that 1 gets twice less values than 2. And the same with 3.

    The correct solution

    The correct solution

    There are many correct solutions to the task. One of them is to adjust interval borders. To ensure the same intervals, we can generate values from 0.5 to 3.5, thus adding the required probabilities to the edges:

    function randomInteger(min, max) {
  // now rand is from  (min-0.5) to (max+0.5)
  let rand = min - 0.5 + Math.random() * (max - min + 1);
  return Math.round(rand);
}

alert( randomInteger(1, 3) );

    An alternative way could be to use Math.floor for a random number from min to max+1:

    function randomInteger(min, max) {
  // here rand is from min to (max+1)
  let rand = min + Math.random() * (max + 1 - min);
  return Math.floor(rand);
}

alert( randomInteger(1, 3) );

    Now all intervals are mapped this way:

    values from 1  ... to 1.9999999999  become 1
values from 2  ... to 2.9999999999  become 2
values from 3  ... to 3.9999999999  become 3

    All intervals have the same length, making the final distribution uniform.

    .

    GitHub
    Web Proxy Viewer  |  New URL  |  Original Page