Zahl in JavaScript

JavaScript hat nur einen Nummerentyp und keine separate Angabe von Ganzzahlen und Fließkommazahlen.

Daher können Zahlen in JavaScript sowohl mit als auch ohne Dezimalpunkt angegeben werden.

var a =　25;　//　Ohne Dezimalpunkt
var b =　80.05;　　//　Mit Dezimalpunkt

In beiden Fällen ist der Datentyp eine Zahl und gleich, egal ob die Zahl einen Dezimalpunkt hat oder nicht.

In JavaScript kann die wissenschaftliche Exponentialdarstellung verwendet werden, um sehr große oder sehr kleine Zahlen zu verkürzen, wie in den folgenden Beispielen gezeigt:

let num1　=　957e8;　//　95700000000
let num2　=　957e-8;//　0.00000957

JavaScript numbers are considered accurate, up to15bit digits. This means that the number will be rounded up to the16bit after rounding to the fourth decimal place:

let num1　=　999999999999999;　//　The value remains unchanged　999999999999999
let num2　=　9999999999999999;//　Rounded up to　10000000000000000

Internal representation of numbers

Unlike other languages, JavaScript does not define different types of numbers, such as integers, short integers, long integers, floating-point numbers, etc.

JavaScript numbers have64Bit precision, also known as double precision.

The internal representation is based on IEEE 754Standard.

64The bit is allocated between the sign, exponent, and decimal part of the number, as shown below:

Adding numbers and concatenating strings

From the previous chapters, we can know that,+Operators are used for adding numbers and concatenating strings.

If it is a number, add the numbers. If it is a string, concatenate the strings.

If two numbers are added together, the result will be a number:

let x =　50;
let y =　10;
let z = x　+　y;　　//　z =　60 (a number)

If two strings are concatenated, the result will be a string concatenation:

let x = "50";
let y = "10";
let z = x　+　y;　　//　z =　5010　(a string)

If a number and a string are concatenated, the result will be a string concatenation:

let x =　50;
let y = "10";
let z = x　+　y;　　//　z =　5010　(a string)

If a string and a number are concatenated, the result will be a string concatenation:

let x = "50";
let y =　10;
let z = x　+　y;　　//　z =　5010　(a string)

JavaScript evaluates expressions from left to right. Different sequences can produce different results.

In the following example, first convert50 + 10added together because x and y are both numbers, then60 +"30” concatenated because z is a string:

let x =　50;
let y =　10;
let z = "30";
let sum = x　+　y　+　z;　　//　sum =　6030 (a string)

A common mistake, expecting this result to be60:

let x =　50;
let y =　10;
let z = "The sum is: "　+　x　+　y;

You can use parentheses to resolve the above issue:

let x =　50;
let y =　10;
let z = "The sum is: "　+　(x　+　y);

Numeric strings and mathematical expressions

JavaScript strings can contain numeric values.

　　let x =　50;　　//　x is a number
　　let y = "50";　　//　y is a string

If a string contains a numeric value, a mathematical expression can be executed in JavaScript.

Division can be performed:

let x = "50"　/　"10";　　//　x  =　5

Multiplication can be performed:

let x = "50"　*　"10";　　//　x  =　500

Exponentiation can be performed:

let x = "5"　**　"3";　　//　x  =　125

Increment can be performed:

let x = "50";
x++;　//　x  =　51

Subtraction can be performed:

let x = "50"　-　"10";　　//　x  =　40

Addition cannot be performed:

let x = "50"　+　"10";　　//　x  =　5010

Hinweis:If two strings are added together, the result will be a string concatenation.

JavaScript NaN-Not a Number

In JavaScript, the reserved word NaN stands for 'Not a Number'.

Wenn Sie mathematische Operationen mit numerischen und nicht-numerischen Werten ausführen, gibt NaN zurück.

var x =　50　/　"oldtoolbag.com";　　//　x  =  NaN (Not a Number)

Wenn jedoch eine Zeichenkette numerische Werte enthält, kann mit JavaScript mathematische Ausdrücke ausgeführt werden:

var x =　50　/　"10";　　//　x  =　5

Sie können das globale JavaScript isNaN()Funktion, um zu bestimmen, ob ein Wert eine Zahl ist:

var x =　50　/　"oldtoolbag.com";
isNaN(x);//　gibt true zurück, weil x keine Zahl ist

Wird ein Wert, der in der NaN-Operation verwendet wird, einem Variablen mit dem Namen NaN zugewiesen, so wird auch ein Wert zurückgegeben, selbst wenn der andere Operand ein gültiger Zahl ist:

var x = NaN;
var y =　27;
var z = x　+　y;　　//　z  =  NaN

NaN ist eine Zahl; typeof NaN gibt number zurück:

typeof NaN;　　　//　wird "number" zurückgeben

JavaScript Unendlich

Infinity (positiver Unendlich) oder-Infinity (negativer Unendlich) wird zurückgegeben, wenn die berechnete Zahl den größten verfügbaren Wert in JavaScript überschreitet.

Diese Fälle treten auch bei undefinierten Werten auf, z.B. bei der Division durch Null:

var x =　5　/　0;　　　//　wird unendlich zurückgegeben
var y =　-5　/　0;　　//　wird negativer Unendlich zurückgegeben

Technisch gesprochen, Infinity (positiver Unendlich) wird angezeigt, wenn die Zahl den Wert number übersteigt1.797693134862315E+308，es stellt das obere Limit in JavaScript dar.

Gleichzeitig-Infinity (negativer Unendlich) wird angezeigt, wenn die Zahl den unteren Grenzwert überschreitet-1.797693134862316E+308.

Infinity ist eine Zahl: typeof Infinity gibt number zurück:

typeof Infinity;　　　//　wird "number" zurückgeben

Die Zahl Infinity kann auch im Zyklus verwendet werden:

var num =　5;
while (num != Infinity) {　
//　Dieser Code wird bis zu num = ∞ ausgeführt
}

JavaScript Basis

Standardmäßig zeigt JavaScript Zahlen in der Form10istderdekompositorische

Zahlen können auch hexadezimal (Grundzahl16），binär (Grundzahl2）und oktaler (Grundzahl8）dargestellt.

Das Präfix für hexadezimale Zahlen ist 0x:

var x = 0xFF;　　//　x  =　255

Der Präfix für binäre Zahlen ist 0b:

var x = 0b1111;//　x  =　15

Schreiben Sie keine Zahl mit führender Null (z.B. 0121）。Falls die Zahl mit führenden Nullen geschrieben wird, wird JavaScript die Zahl als oktaler interpretieren:

var x = 016;

Sie können dies verwendentoString()Methode von2bis36die Zahl zurückgibt.

hexadezimal istBasis16，dezimal istBasis10，oktaler istBasis8，binär istBasis2.

var num =　255;
num.toString(10);　　//　returns　255
num.toString(16);　　//　returns ff
num.toString(8);　　　//　returns　377
num.toString(2);　　　//　returns　11111111

Numerische Primärwahrnehmung und numerisches Objekt

In der Regel werden JavaScript-Zahlen aus Texten als ursprüngliche Werte erstellt:

var num =　50;

Man kann aber auch die Zahl mit dem new-Schlüsselwort als Objekt definieren:

var num = new Number(50);

Um die Unterschiede zwischen beiden zu testen, initialisieren wir eine numerische Primärwahrnehmung und ein numerisches Objekt.

var num1　=　50;
var num2　= new Number(50);
typeof num1//　returns number
typeof num2//　returns object

Hinweis:Erstellen Sie keine Zahlen als Objekte. Dies verringert die Ausführungszeit und führt zu einigen unerwarteten Ergebnissen.

Bei der Verwendung des ==-Operators sind Zahlen gleich:

var num1　=　50;
var num2　= new Number(50);
document.write(num1　== num2);　//　geben true zurück, weil num1und num2haben gleiche Werte

Bei der Verwendung des ===-Operator sind gleiche Zahlen ungleich, da der ===-Operator sowohl Wert als auch Typ erwarten:

var num1　=　50;
var num2　= new Number(50);
document.write(num1　=== num2);　//　geben false zurück, weil num1und num2haben unterschiedliche Typen

Objekte können nicht verglichen werden:

var num1　= new Number(50);
var num2　= new Number(50);
document.write(num1　== num2);　//　geben false zurück, weil num1und num2sind unterschiedliche Objekte
document.write(num1　=== num2);　//　geben false zurück, weil num1und num2sind unterschiedliche Objekte

Beachten Sie den Unterschied zwischen (==) und (===). Beim Vergleich von zwei JavaScript-Objekten wird immer false zurückgegeben.