JavaScript
Wbudowane stałe

Operacje, które zwracają NaN

Operacje matematyczne na wartościach innych niż liczby zwracają NaN.

"a" + 1
"b" * 3
"cde" - "e"
[1, 2, 3] * 2

Wyjątek: tablice z jedną liczbą.

[2] * [3]  // Returns 6

Pamiętaj również, że operator + łączy łańcuchy.

"a" + "b"  // Returns "ab"

Dzielenie zera przez zero zwraca NaN .

0 / 0         // NaN

Uwaga: W matematyce ogólnie (w przeciwieństwie do programowania JavaScript) dzielenie przez zero nie jest możliwe.

Funkcje biblioteki matematycznej zwracające NaN

Zasadniczo funkcje Math którym podano argumenty nienumeryczne, zwracają NaN.

Math.floor("a")

Pierwiastek kwadratowy z liczby ujemnej zwraca NaN, ponieważ Math.sqrt nie obsługuje liczb urojonych lub zespolonych .

Math.sqrt(-1)

Testowanie pod kątem NaN za pomocą isNaN ()

window.isNaN()

Za pomocą funkcji globalnej isNaN() można sprawdzić, czy określona wartość lub wyrażenie ma wartość NaN . Ta funkcja (w skrócie) najpierw sprawdza, czy wartość jest liczbą, jeśli nie, próbuje ją przekonwertować (*), a następnie sprawdza, czy wynikową wartością jest NaN . Z tego powodu ta metoda testowania może powodować zamieszanie .

^{(*) Metoda „konwersji” nie jest taka prosta, szczegółowe wyjaśnienie algorytmu znajduje się w ECMA-262 18.2.3 .}

Poniższe przykłady pomogą ci lepiej zrozumieć zachowanie isNaN() :

isNaN(NaN);          // true
isNaN(1);            // false: 1 is a number
isNaN(-2e-4);        // false: -2e-4 is a number (-0.0002) in scientific notation
isNaN(Infinity);     // false: Infinity is a number
isNaN(true);         // false: converted to 1, which is a number
isNaN(false);        // false: converted to 0, which is a number
isNaN(null);         // false: converted to 0, which is a number
isNaN("");           // false: converted to 0, which is a number
isNaN(" ");          // false: converted to 0, which is a number
isNaN("45.3");       // false: string representing a number, converted to 45.3
isNaN("1.2e3");      // false: string representing a number, converted to 1.2e3
isNaN("Infinity");   // false: string representing a number, converted to Infinity
isNaN(new Date);     // false: Date object, converted to milliseconds since epoch
isNaN("10$");        // true : conversion fails, the dollar sign is not a digit
isNaN("hello");      // true : conversion fails, no digits at all
isNaN(undefined);    // true : converted to NaN
isNaN();             // true : converted to NaN (implicitly undefined)
isNaN(function(){}); // true : conversion fails
isNaN({});           // true : conversion fails
isNaN([1, 2]);       // true : converted to "1, 2", which can't be converted to a number

Ten ostatni jest nieco trudny: sprawdzenie, czy Array to NaN . Aby to zrobić, konstruktor Number() najpierw konwertuje tablicę na ciąg, a następnie na liczbę; jest to powód, dla którego zarówno isNaN([]) i isNaN([34]) zwracają wartość false , ale zarówno isNaN([1, 2]) i isNaN([true]) zwracają wartość true : ponieważ są konwertowane na "" , "34" , "1,2" i "true" . Ogólnie rzecz biorąc, tablica jest uznawana za NaN przez isNaN() chyba że zawiera tylko jeden element, którego reprezentację ciągu można przekonwertować na prawidłową liczbę .

// The one and only 
Number.isNaN(NaN);          // true

// Numbers
Number.isNaN(1);            // false
Number.isNaN(-2e-4);        // false
Number.isNaN(Infinity);     // false

// Values not of type number
Number.isNaN(true);         // false
Number.isNaN(false);        // false
Number.isNaN(null);         // false
Number.isNaN("");           // false
Number.isNaN(" ");          // false
Number.isNaN("45.3");       // false
Number.isNaN("1.2e3");      // false
Number.isNaN("Infinity");   // false
Number.isNaN(new Date);     // false
Number.isNaN("10$");        // false
Number.isNaN("hello");      // false
Number.isNaN(undefined);    // false
Number.isNaN();             // false
Number.isNaN(function(){}); // false
Number.isNaN({});           // false
Number.isNaN([]);           // false
Number.isNaN([1]);          // false
Number.isNaN([1, 2]);       // false
Number.isNaN([true]);       // false

zero

null służy do reprezentowania celowego braku wartości obiektu i jest wartością pierwotną. W przeciwieństwie do undefined , nie jest własnością obiektu globalnego.

Jest równy undefined ale nie identyczny z nim.

null == undefined; // true
null === undefined; // false

Ostrożny: typeof null jest 'object' .

typeof null; // 'object';

Aby poprawnie sprawdzić, czy wartość jest null , porównaj ją z operatorem ścisłej równości

var a = null;

a === null; // true

niezdefiniowany i zerowy

Na pierwszy rzut oka może się wydawać, że null i undefined są w zasadzie takie same, jednak istnieją subtelne, ale ważne różnice.

undefined jest brak wartości w kompilatorze, ponieważ tam, gdzie powinna być wartością, nie została wstawiona, jak w przypadku nieprzypisanej zmiennej.

• undefined jest wartością globalną, która reprezentuje brak przypisanej wartości.
  • typeof undefined === 'undefined'
• null to obiekt wskazujący, że zmiennej przypisano jawnie „brak wartości”.
  • typeof null === 'object'

Ustawienie zmiennej na undefined oznacza, że zmienna faktycznie nie istnieje. Niektóre procesy, takie jak serializacja JSON, mogą usuwać undefined właściwości z obiektów. Natomiast właściwości null wskazują, że zostaną zachowane, dzięki czemu można jawnie przekazać pojęcie „pustej” właściwości.

Poniższe oceny do undefined :

• Zmienna, gdy jest zadeklarowana, ale nie ma przypisanej wartości (tj. Zdefiniowana)

  • let foo;
    console.log('is undefined?', foo === undefined);
    // is undefined? true
    

• Dostęp do wartości właściwości, która nie istnieje

  • let foo = { a: 'a' };
    console.log('is undefined?', foo.b === undefined);
    // is undefined? true
    

• Zwracana wartość funkcji, która nie zwraca wartości

  • function foo() { return; }
    console.log('is undefined?', foo() === undefined);
    // is undefined? true
    

• Wartość argumentu funkcji, który jest zadeklarowany, ale został pominięty w wywołaniu funkcji

  • function foo(param) { 
      console.log('is undefined?', param === undefined);
    }
    foo('a');
    foo();
    // is undefined? false
    // is undefined? true
    

undefined jest także własnością globalnego obiektu window .

// Only in browsers
console.log(window.undefined); // undefined
window.hasOwnProperty('undefined'); // true    

Nieskończoność i nieskończoność

1 / 0; // Infinity
// Wait! WHAAAT?

Infinity jest właściwością obiektu globalnego (a więc zmiennej globalnej), która reprezentuje matematyczną nieskończoność. Jest to odniesienie do Number.POSITIVE_INFINITY

Jest większa niż jakakolwiek inna wartość i można ją uzyskać, dzieląc przez 0 lub oceniając wyrażenie liczby tak dużej, że się przepełnia. Oznacza to, że w JavaScript nie ma podziału na 0 błędów, jest nieskończoność!

Istnieje również -Infinity która jest matematyczną ujemną nieskończonością i jest niższa niż jakakolwiek inna wartość.

Aby uzyskać -Infinity , negujesz Infinity lub uzyskasz odniesienie do niego w Number.NEGATIVE_INFINITY .

- (Infinity); // -Infinity

Teraz zabawmy się przykładami:

Infinity > 123192310293; // true
-Infinity < -123192310293; // true
1 / 0; // Infinity
Math.pow(123123123, 9123192391023); // Infinity
Number.MAX_VALUE * 2; // Infinity
23 / Infinity; // 0
-Infinity; // -Infinity
-Infinity === Number.NEGATIVE_INFINITY; // true
-0; // -0 , yes there is a negative 0 in the language
0 === -0; // true
1 / -0; // -Infinity
1 / 0 === 1 / -0; // false
Infinity + Infinity; // Infinity

var a = 0, b = -0;

a === b; // true
1 / a === 1 / b; // false

// Try your own!

NaN

NaN oznacza „Not a Number”. Gdy funkcja matematyczna lub operacja w JavaScript nie może zwrócić określonej liczby, zwraca wartość NaN .

Jest to właściwość obiektu globalnego i odwołanie do Number.NaN

window.hasOwnProperty('NaN'); // true
NaN; // NaN

Być może mylące jest to, że NaN wciąż jest uważany za liczbę.

typeof NaN; // 'number'

Nie sprawdzaj NaN za pomocą operatora równości. Zamiast tego zobacz isNaN .

NaN == NaN  // false
NaN === NaN // false

Stałe liczbowe

Konstruktor Number ma wbudowane stałe, które mogą być przydatne

Number.MAX_VALUE;          // 1.7976931348623157e+308
Number.MAX_SAFE_INTEGER;   // 9007199254740991

Number.MIN_VALUE;          // 5e-324
Number.MIN_SAFE_INTEGER;   // -9007199254740991

Number.EPSILON;            // 0.0000000000000002220446049250313

Number.POSITIVE_INFINITY;  // Infinity
Number.NEGATIVE_INFINITY;  // -Infinity

Number.NaN;                // NaN

W wielu przypadkach różne operatory w JavaScript będą łamać wartościami spoza zakresu ( Number.MIN_SAFE_INTEGER , Number.MAX_SAFE_INTEGER )

Należy zauważyć, że Number.EPSILON oznacza różnić się między jedną a najmniejszy Number większą niż jeden, a zatem najmniejszą możliwą różnicę między różnymi Number wartości. Jednym z powodów tego jest fakt, że JavaScript jest przechowywany w liczbach, zobacz Sprawdzanie równości dwóch liczb