JavaScript
Inbyggda konstanter

Verksamheter som returnerar NaN

Matematiska operationer på andra värden än siffror returnerar NaN.

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

Ett undantag: matris med ett enda nummer.

[2] * [3]  // Returns 6

Kom också ihåg att operatören + slår samman strängar.

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

Genom att dela noll med noll returneras NaN .

0 / 0         // NaN

Obs: I matematik i allmänhet (till skillnad från i JavaScript-programmering) är det inte möjligt att dela med noll.

Matematikbibliotekets funktioner som returnerar NaN

Generellt kommer Math som ges icke-numeriska argument att returnera NaN.

Math.floor("a")

Kvadratroten till ett negativt nummer returnerar NaN, eftersom Math.sqrt inte stöder imaginära eller komplexa siffror.

Math.sqrt(-1)

Testning av NaN med användning av isNaN ()

window.isNaN()

Den globala funktionen isNaN() kan användas för att kontrollera om ett visst värde eller uttryck utvärderas till NaN . Denna funktion (kort sagt) kontrollerar först om värdet är ett tal, om inte försöker konvertera det (*) och kontrollerar sedan om det resulterande värdet är NaN . Av denna anledning kan denna testmetod orsaka förvirring .

^{(*) Metoden "konvertering" är inte så enkel, se ECMA-262 18.2.3 för en detaljerad förklaring av algoritmen.}

Dessa exempel hjälper dig att bättre förstå 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

Den sista är lite knepig: att kontrollera om en Array är NaN . För att göra detta konverterar Number() -konstruktorn först matrisen till en sträng, sedan till ett nummer; detta är orsaken till att isNaN([]) och isNaN([34]) båda returnerar false , men isNaN([1, 2]) och isNaN([true]) båda återlämnar true : eftersom de konverteras till "" , "34" , "1,2" respektive "true" . I allmänhet betraktas en grupp NaN av isNaN() såvida den inte bara har ett element vars strängrepresentation kan konverteras till ett giltigt nummer .

// 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

null

null används för att representera den avsiktliga frånvaron av ett objektvärde och är ett primitivt värde. Till skillnad från undefined är det inte en egenskap för det globala objektet.

Det är lika med undefined men inte identiskt med det.

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

OBSERVERA : typeof null är 'object' .

typeof null; // 'object';

För korrekt kontroll av om ett värde är null , jämför det med den strikta jämställdhetsoperatören

var a = null;

a === null; // true

odefinierad och noll

Vid första anblicken kan det se ut som att null och undefined princip är desamma, men det finns subtila men viktiga skillnader.

undefined är frånvaron av ett värde i kompilatorn, för där det borde vara ett värde har det inte lagts ett, som för en icke tilldelad variabel.

• undefined är ett globalt värde som representerar frånvaron av ett tilldelat värde.
  • typeof undefined === 'undefined'
• null är ett objekt som indikerar att en variabel uttryckligen har tilldelats "inget värde".
  • typeof null === 'object'

Att ställa in en variabel till undefined innebär att variabeln inte finns. Vissa processer, till exempel JSON-serialisering, kan ta bort undefined egenskaper från objekt. Däremot null egenskaper indikerar kommer att bevaras så att du kan uttryckligen förmedla begreppet "tom" egendom.

Följande utvärdering till undefined :

• En variabel när den deklareras men inte tilldelas ett värde (dvs. definierat)

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

• Få tillgång till värdet på en egendom som inte finns

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

• Returvärdet för en funktion som inte returnerar ett värde

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

• Värdet på ett funktionsargument som deklareras men har utelämnats från funktionssamtalet

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

undefined är också en egenskap för det globala window .

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

Oändlighet och oändlighet

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

Infinity är en egenskap hos det globala objektet (därför en global variabel) som representerar matematisk oändlighet. Det är en hänvisning till Number.POSITIVE_INFINITY

Det är större än något annat värde, och du kan få det genom att dela med 0 eller genom att utvärdera uttrycket för ett tal som är så stort att det går över. Detta betyder faktiskt att det inte finns någon delning med 0 fel i JavaScript, det finns Infinity!

Det finns också- -Infinity som är matematisk negativ oändlighet, och den är lägre än något annat värde.

För att få- -Infinity negerar du Infinity , eller får en hänvisning till den i Number.NEGATIVE_INFINITY .

- (Infinity); // -Infinity

Låt oss nu ha kul med exempel:

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 står för "Inte ett nummer." När en matematisk funktion eller operation i JavaScript inte kan returnera ett specifikt nummer, returnerar det värdet NaN istället.

Det är en egenskap hos det globala objektet och en hänvisning till Number.NaN

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

Kanske förvirrande anses NaN fortfarande vara ett nummer.

typeof NaN; // 'number'

Kontrollera inte om NaN använder jämställdhetsoperatören. Se istället isNaN .

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

Antal konstanter

Number har några inbyggda konstanter som kan vara användbara

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

I många fall kommer de olika operatörerna i Javascript att bryta med värden utanför intervallet ( Number.MIN_SAFE_INTEGER , Number.MAX_SAFE_INTEGER )

Observera att Number.EPSILON representerar skillnaden mellan ett och det minsta Number större än ett, och därmed den minsta möjliga skillnaden mellan två olika Number värden. En anledning till att använda detta beror på beskaffenheten av hur nummer lagras av JavaScript, se Kontrollera att två nummer är lika