Was sind JavaScript-Datentypen und -Variablen? Wie konvertiert man zwischen ihnen?

Datentyp

definiert die folgenden Datentypen in JavaScript:

Zahl

JavaScript unterscheidet nicht zwischen Ganzzahlen und Gleitkommazahlen und wird durch Zahl dargestellt. Folgende Zahlentypen sind zulässig:

123; // 整数123
0.456; // 浮点数0.456
1.2345e3; // 科学计数法表示1.2345x1000，等同于1234.5
-99; // 负数
NaN; // NaN表示Not a Number，当无法计算结果时用NaN表示

Unendlich; // Unendlich bedeutet unendlich. Wenn der Wert den Maximalwert überschreitet, den die Zahl von JavaScript darstellen kann, wird er als Unendlichkeit ausgedrückt.
Da Computer Binärzahlen verwenden, ist es manchmal bequemer, hexadezimale Zahlen zur Darstellung von Ganzzahlen zu verwenden. Die Basis wird durch hexadezimale Zahlen dargestellt das Präfix 0x und 0-9, a-f, zum Beispiel: 0xff00, 0xa5b4c3d2 usw. Sie sind genau die gleichen wie die in Dezimalzahlen ausgedrückten Werte.
Zahl kann direkt vier arithmetische Operationen ausführen. Die Regeln stimmen mit der Mathematik überein:

1 + 2; // 3
(1 + 2) * 5 / 2; // 7.5
2 / 0; // Infinity
0 / 0; // NaN
10 % 3; // 1
10.5 % 3; // 1.5

Beachten Sie, dass % die Restoperation ist.

String

Ein String ist ein beliebiger Text, der in einfache Anführungszeichen oder doppelte Anführungszeichen eingeschlossen ist, wie etwa „abc“, „xyz“ und usw. Bitte beachten Sie, dass '' oder "" selbst nur eine Ausdrucksweise und kein Teil der Zeichenfolge ist. Daher hat die Zeichenfolge 'abc' nur 3 Zeichen a, b, c >Boolescher Wert

Der Ausdruck des Booleschen Werts ist genau derselbe wie der der Booleschen Algebra: wahr und falsch, entweder wahr oder falsch true oder false stellt einen booleschen Wert dar, der auch durch boolesche Operationen berechnet werden kann:

&&-Operation ist nur dann eine UND-Operation Alles ist wahr, das Ergebnis der &&-Operation ist wahr:

true; // 这是一个true值
false; // 这是一个false值
2 > 1; // 这是一个true值
2 >= 3; // 这是一个false值

|| Die Operation ist eine ODER-Operation, solange eine davon wahr ist , das Ergebnis der ||.-Operation ist wahr:

true && true; // 这个&&语句计算结果为true
true && false; // 这个&&语句计算结果为false
false && true && false; // 这个&&语句计算结果为false

Die Operation ist eine unäre Operation, die zu wahr wird falsch und falsch in wahr:

false || false; // 这个||语句计算结果为false
true || false; // 这个||语句计算结果为true
false || true || false; // 这个||语句计算结果为true

Boolesche Werte werden häufig in bedingten Urteilen verwendet, wie zum Beispiel:

! true; // 结果为false
! false; // 结果为true
! (2 > 5); // 结果为true

Vergleichsoperator

var age = 15;
if (age >= 18) {
 alert('adult');
} else {
 alert('teenager');
}

Wenn wir Zahl vergleichen, können wir über den Vergleichsoperator einen booleschen Wert erhalten:

Tatsächlich ermöglicht JavaScript den Vergleich jedes Datentyps:

2 > 5; // false
5 >= 2; // true
7 == 7; // true

Sonderzahlung Achten Sie beim Entwerfen von JavaScript-Vergleichsoperatoren auf den Gleichheitsoperator:

false == 0; // true
false === 0; // false

Der erste ist ==-Vergleich, der den Datentyp vor dem Vergleich automatisch konvertiert. Oft erhalten Sie sehr seltsame Ergebnisse ;
Der zweite ist === Der Datentyp wird nicht automatisch konvertiert. Wenn die Datentypen inkonsistent sind, wird ein erneuter Vergleich durchgeführt Fehler in JavaScript, verwenden Sie nicht immer den Vergleich ===. Eine weitere Ausnahme ist NaN, eine spezielle Zahl, die nicht mit allen anderen Werten, einschließlich sich selbst, gleich ist:

Die einzige Möglichkeit, NaN zu erkennen, ist die Funktion isNaN():

NaN === NaN; // false

Achten Sie abschließend auf die Gleichheitsvergleich von Gleitkommazahlen:

isNaN(NaN); // true

Dies ist kein Designfehler in JavaScript, der zu Fehlern im Betrieb führt, da Computer dies nicht genau können stellen Endlosschleifen-Dezimalzahlen dar. Um zu vergleichen, ob zwei Gleitkommazahlen gleich sind, können sie nur den absoluten Wert ihrer Differenz berechnen, um zu sehen, ob dieser kleiner als ein bestimmter Schwellenwert ist:

1 / 3 === (1 - 2 / 3); // false

null und undefiniert

Math.abs(1 / 3 - (1 - 2 / 3)) < 0.0000001; // true

null stellt a dar. Der Wert von „empty“ unterscheidet sich von 0 und die leere Zeichenfolge '' 0 ist a numerischer Wert, '' stellt eine Zeichenfolge der Länge 0 dar und null steht für „leer“. In anderen Sprachen gibt es auch Darstellungen von Null, die denen von JavaScript ähneln. Beispielsweise verwendet Java ebenfalls Null, Swift verwendet Null und Python verwendet None. In JavaScript gibt es jedoch auch undefiniert, was null ähnelt, was „undefiniert“ bedeutet. Die Designer von JavaScript hoffen, null zur Darstellung eines leeren Werts und undefiniert zur Darstellung eines undefinierten Werts verwenden zu können. Die Tatsachen haben gezeigt, dass dies keinen Nutzen hat und der Unterschied zwischen den beiden von geringer Bedeutung ist. In den meisten Fällen sollten wir null verwenden. undefiniert ist nur nützlich, wenn bestimmt wird, ob Funktionsparameter übergeben werden.
ArrayEin Array ist eine in der Reihenfolge angeordnete Sammlung, und jeder Wert der Sammlung wird als Element bezeichnet. JavaScript-Arrays können jeden Datentyp enthalten. Zum Beispiel:

Das obige Array enthält 6 Elemente. Arrays werden durch [] dargestellt und Elemente werden durch , getrennt.

Eine andere Möglichkeit, ein Array zu erstellen, ist die Funktion Array():

[1, 2, 3.14, 'Hello', null, true];

Aus Gründen der Lesbarkeit des Codes ist es jedoch dringend Es wird empfohlen, [] direkt zu verwenden.

Auf die Elemente eines Arrays kann per Index zugegriffen werden. Beachten Sie, dass Indizes bei 0 beginnen:

new Array(1, 2, 3); // 创建了数组[1, 2, 3]

Object

var arr = [1, 2, 3.14, 'Hello', null, true];
arr[0]; // 返回索引为0的元素，即1
arr[5]; // 返回索引为5的元素，即true
arr[6]; // 索引超出了范围，返回undefined

JavaScript Ein Objekt ist ein ungeordnetes Objekt Sammlung von Schlüsseln und Werten, zum Beispiel:

var person = {
 name: 'Bob',
 age: 20,
 tags: ['js', 'web', 'mobile'],
 city: 'Beijing',
 hasCar: true,
 zipcode: null
};

JavaScript对象的键都是字符串类型，值可以是任意数据类型。上述person对象一共定义了6个键值对，其中每个键又称为对象的属性，例如，person的name属性为'Bob'，zipcode属性为null。
要获取一个对象的属性，我们用对象变量.属性名的方式：

person.name; // 'Bob'
person.zipcode; // null

变量

变量的概念基本上和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。
变量在JavaScript中就是用一个变量名表示，变量名是大小写英文、数字、$和_的组合，且不能用数字开头。变量名也不能是JavaScript的关键字，如if、while等。申明一个变量用var语句，比如：

var a; // 申明了变量a，此时a的值为undefined
var $b = 1; // 申明了变量$b，同时给$b赋值，此时$b的值为1
var s_007 = '007'; // s_007是一个字符串
var Answer = true; // Answer是一个布尔值true
var t = null; // t的值是null

变量名也可以用中文，但是，请不要给自己找麻烦。
在JavaScript中，使用等号=对变量进行赋值。可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量，但是要注意只能用var申明一次，例如：

var a = 123; // a的值是整数123
a = 'ABC'; // a变为字符串

这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。例如Java是静态语言，赋值语句如下：

int a = 123; // a是整数类型变量，类型用int申明
a = "ABC"; // 错误：不能把字符串赋给整型变量

和静态语言相比，动态语言更灵活，就是这个原因。
请不要把赋值语句的等号等同于数学的等号。比如下面的代码：

var x = 10;
x = x + 2;

如果从数学上理解x = x + 2那无论如何是不成立的，在程序中，赋值语句先计算右侧的表达式x + 2，得到结果12，再赋给变量x。由于x之前的值是10，重新赋值后，x的值变成12。

strict模式

JavaScript在设计之初，为了方便初学者学习，并不强制要求用var申明变量。这个设计错误带来了严重的后果：如果一个变量没有通过var申明就被使用，那么该变量就自动被申明为全局变量：

i = 10; // i现在是全局变量

在同一个页面的不同的JavaScript文件中，如果都不用var申明，恰好都使用了变量i，将造成变量i互相影响，产生难以调试的错误结果。

使用var申明的变量则不是全局变量，它的范围被限制在该变量被申明的函数体内（函数的概念将稍后讲解），同名变量在不同的函数体内互不冲突。

为了修补JavaScript这一严重设计缺陷，ECMA在后续规范中推出了strict模式，在strict模式下运行的JavaScript代码，强制通过var申明变量，未使用var申明变量就使用的，将导致运行错误。

启用strict模式的方法是在JavaScript代码的第一行写上：

'use strict';

这是一个字符串，不支持strict模式的浏览器会把它当做一个字符串语句执行，支持strict模式的浏览器将开启strict模式运行JavaScript。

来测试一下你窗体顶端

'use strict';
// 如果浏览器支持strict模式，
// 下面的代码将报ReferenceError错误:

数据类型如何转换：

1. Konvertieren Sie in die Zahl xxx*1.0
Konvertieren Sie in die Zeichenfolge xxx+""
2. Extrahieren Sie einen anderen Werttyp aus einem Wert und schließen Sie die Konvertierung ab.
. Extrahieren Sie die Ganzzahl aus der Zeichenfolge: parseInt();
Beispiel: Das Ergebnis von parseInt("123zhang") ist 123
.Extrahieren Sie die Gleitkommazahl aus der Zeichenfolge: parseFloat(); >Beispiel: Das Ergebnis von parseFloat("0.55zhang") ist 0,55
Führen Sie einen Javascript-Code aus, der durch eine Zeichenfolge dargestellt wird: eval();
Beispiel: das Ergebnis von zhang=eval("1+1 ") ist zhang=2
. In String konvertieren: toString();
Beispiel: Das Ergebnis von zhang=eval("1+1") ist zhang=2
3. Konvertieren Sie den gesamten Wert von von einem Typ in einen anderen Drei Datentypen (sogenannte Basisdatentypkonvertierung),
Drei Methoden der Basisdatentypkonvertierung:
In Zeichentyp konvertieren: String(); Beispiel: Das Ergebnis von String(678) ist „ 678"
. In numerischen Typ konvertieren: Number(); Beispiel: Das Ergebnis von Number("678") ist 678
. In booleschen Typ konvertieren: Boolean(); Beispiel: Das Ergebnis von Boolean("aaa ") ist wahr

Versuchen Sie bei der Verwendung dieser Methoden ggf., Ausnahmen bei der Ausführung von Parametern und Methoden zu beurteilen und zu behandeln.
Wie im Referenzdokument zu sehen ist, ist das Folgende eine Zusammenfassung der Ausführungseffizienz:
Unter IE ist der erste der schnellste, der zweite der zweite und der dritte der schlechteste, aber der Unterschied beträgt nur 100.000 Mal . Der Unterschied beträgt nur einige Hundert Millisekunden.
Unter FF sind der erste und der zweite Typ grundsätzlich gleichwertig, und der dritte Typ ist der langsamste.
Der Geschwindigkeitsunterschied ist grundsätzlich vernachlässigbar. Denn der Unterschied ist sehr gering.
Aufgrund der Einfachheit des Codes ist die erste Methode jedoch offensichtlich einfach zu schreiben und leicht zu lesen,
und bei der zweiten Methode tritt kein Fehler auf, da ein Objekt keine toString-Methode hat. Außerdem war er immer der Schnellste.
Ich bin es also gewohnt, die erste Methode zu verwenden, um die Datentypkonvertierung abzuschließen.
Wenn Sie jedoch beispielsweise „123456abcd“ benötigen, um die darin enthaltenen Zahlen zu extrahieren, sollten Sie natürlich Funktionen wie parsetInt und parseFloat verwenden .
Bitte beachten Sie jedoch, dass das Konvertierungsergebnis manchmal NaN usw. ist, sodass Sie es beurteilen müssen.

Das obige ist der detaillierte Inhalt vonWas sind JavaScript-Datentypen und -Variablen? Wie konvertiert man zwischen ihnen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!