Ein tieferes Verständnis primitiver Typen in JS

Primitive Typen in JavaScript umfassen Undefiniert, Null, Zahl, Boolean und String. Andere Variablen sind Referenztypen, also Objekttyp. Primitive Typen werden im „Stapelspeicher“ gespeichert, während Referenztypen im „Heap-Speicher“ gespeichert werden. Bei der Verwendung von Variablen in JavaScript spielt der Speicherort der Variablen im Speicher jedoch normalerweise keine große Rolle.

Der „typeof“-Operator wird verwendet, um den Datentyp des Variablenwerts zu ermitteln. typeof kann Variablennamen oder Literalwerte als Operanden akzeptieren und eine Zeichenfolge zurückgeben, die die Informationen zum Variablentyp beschreibt. Es ist zu beachten, dass der Rückgabewert von typeof nicht dem Typ in JavaScript entspricht:

• „undefiniert“ – der Variablenwert ist undefiniert

• „Zahl“ – der Variablenwert ist ein numerischer Wert

• "boolean" ——Der Variablenwert ist ein boolescher Wert

• "string" ——Der Variablenwert ist eine Zeichenfolge

• "object"——Der Variablenwert ist ein Objekt oder null

• " function"——Variable Der Wert ist eine Funktion

Darüber hinaus ist typeof ein Operator wie (+, -), keine Funktion. Obwohl die Verwendung von „typeof(12)“ keinen Fehler verursacht, wird z Der Operator „typeof 12“ ist die geeignete Art, ihn zu verwenden.

1, undefiniert und null

Die Definition des undefinierten Typs im ECMA-262-Dokument lautet:

Der undefinierte Typ hat genau einen Wert, der als undefiniert bezeichnet wird undefiniert .

Der undefinierte Typ hat nur einen eindeutigen Wert „undefiniert“. Der Wert der Variablen ist undefiniert, was bedeutet, dass die Variable nicht initialisiert wurde. Bei Variablen, die nicht mit var deklariert wurden, wird bei der Verwendung ein Fehler generiert, bei Verwendung des Operators „typeof“ wird jedoch „undefiniert“ zurückgegeben:

var foo;
alert(foo);        // undefined
alert(bar);        // 错误
alert(typeof foo); // undefined
alert(typeof bar); // undefined

undefiniert wird als globale Variable implementiert (und nicht als Literalwert wie null), und zwar Wert ist „undefiniert“. In ECMAScript 3 können undefinierte andere Werte zugewiesen werden und es wurde korrigiert, dass es in ECMAScript 5 schreibgeschützt ist.

Null-Typ hat auch nur einen Wert, null, der zur Darstellung eines „leeren Werts“ verwendet wird. In den meisten Programmiersprachen werden Literale wie Null, Null usw. verwendet, um leere Werte darzustellen. Aber im Gegensatz zu anderen Programmiersprachen verwendet JavaScript nicht null, um den Wert einer nicht initialisierten Variablen (dargestellt durch undefiniert) darzustellen. Die logische Bedeutung von

null besteht darin, einen Nullobjektzeiger darzustellen. Die üblichen Objekte in JavaScript enthalten keine einfachen Datentypen, daher bedeutet null logischerweise, dass die Variable auf einen Objekttyp mit einem Nullwert zeigt (kein Literal „{}“).

Aus diesem Grund können Sie verstehen, warum die Verwendung des Operators „typeof“ zum Erhalten des Typs eines Nullwerts zu „Objekt“ führt. Die Bedeutung des Nullwerts in JavaScript für den Objekttyp ähnelt 0 für den Zahlentyp und „“ für den String-Typ.

Sowohl undefiniert als auch null werden zur Beschreibung eines „Nullwerts“ verwendet, aber im logischen Sinne ist undefiniert eher „untergeordnet“ als null. Unter normalen Umständen ist es nicht erforderlich, den Variablenwert explizit als undefiniert anzugeben.

Für eine Variable, die ein Objekt speichern soll, aber nicht tatsächlich auf ein Objekt zeigt, sollte der Variablenwert auf null gesetzt werden, um die Rolle von null als Nullobjektzeiger widerzuspiegeln und ihn von undefiniert zu unterscheiden.

2. Numerische Werte

ECMAScript verwendet ein vereinfachtes numerisches Modell. Es gibt nur einen numerischen Typ, Number, ohne einen separaten Integer-Typ abzutrennen. In Bezug auf die Implementierung übernimmt der Zahlentyp das 64-Bit-Gleitkommaformat mit doppelter Genauigkeit, das im IEEE 754-Standard definiert ist.

Im 64-Bit-Gleitkommaformat werden 52 Bit zur Darstellung der Mantisse verwendet, 11 Bit stellen den Exponenten dar und 1 Bit ist das Vorzeichen. Daher liegt der Bereich der Ganzzahlen, den JavaScript darstellen kann, zwischen -Math.pow(2,53) und Math.pow(2,53). Über diesen Bereich hinaus kann die Genauigkeit von Zahlen mit niedrigen Ziffern nicht garantiert werden.

var n = Math.pow(2,53); // 9007199254740992
alert(n === n + 1);     // true, 9007199254740992 + 1得到的值还是9007199254740992

Wenn Sie in der tatsächlichen Webentwicklung einen Long Int-Typ zur Verarbeitung im Hintergrund an Javascript übergeben müssen (z. B. Java), ist es sehr wahrscheinlich, dass das erhaltene Ergebnis nach der Analyse der JSON-Daten in den Number-Typ durch JavaScript lautet nicht das, was Sie wollen: es Die letzten paar Ziffern haben sich geändert.

JavaScript verwendet Gleitkommawerte für Operationen, sodass es wie bei allen anderen Programmiersprachen, die das IEEE 754-Standardformat zur Darstellung von Gleitkommazahlen verwenden, im Dezimalteil zu Präzisionsproblemen kommt. Vermeiden Sie Gleichheitsurteile zu Dezimalteilen in Ihrem Code. (Der ganzzahlige Teil ist präzise)

var a = 0.1;
var b = 0.2;
alert(a + b === 0.3); // false

Wenn der Wert die Obergrenze der Zahl überschreitet, die JavaScript darstellen kann (Überlauf), wird er automatisch in einen Unendlichkeitswert (oder -Infinity, negative Unendlichkeit) umgewandelt, der die Unendlichkeit darstellt Der Wert liegt unendlich nahe bei 0 und wenn er den JavaScript-Darstellungsbereich überschreitet (Unterlauf), wird er auf 0 (oder -0, dasselbe wie 0) gesetzt. JavaScript verursacht keine Überlauffehler (auch nicht bei der Division durch Null).

var a = Number.MAX_VALUE * 2;          //Infinity
var b = Number.MIN_VALUE / 2;          //0
var c = 1 / 0;                         //Infinity or NaN, 依JS执行环境不同
var d = 0 / 0;                         // NaN

Der Zahlentyp definiert einen speziellen Wert NaN, der keine Zahl ist. Die Bedeutung von NaN bedeutet, dass kein Wert erhalten wird, wo ein Wert erhalten werden sollte. Jede arithmetische Operation, die NaN als Operanden verwendet, führt zu NaN.

另外NaN也是唯一一个使用对自身进行相等判断会得到false的数值。NaN的这个怪异之处破坏了JavaScript运算符的对称性。如果在代码中需要通过比较数值大小进行分支判断，就需要注意可能出现NaN的情况，因为使用NaN与其他数值进行大小比较总会得到false，而这可能不是你想要的结果。

var a = 10;   
a = a - "not number"         // NaN
alert(a === a)；             // false
var b = 12 + a;              // NaN
var c = 10;
alert(b >= c || b < c);      // false

另一个Number类型中不常引人注目的地方是位运算。JavaScript中提供了按位操作运算符。在很多其他编程语言中，按位操作可以进行硬件级处理，所以非常快。

但是JavaScript没有整数类型，它的位操作是先把数值转换为32位整数，然后进行计算，然后再转换回去，JavaScript绝大部分运行环境是在浏览器中，与硬件相隔较远，因此位操作执行很慢。

3、字符串

与很多其他编程语言中一样，JavaScript中的字符串值也是不可变的，改变一个字符串变量的值，相当于重新生成了一个字符串并把它赋值给变量。JavaScript中的简单类型无法进行方法调用（作为this调用函数），但我们还是可以进行诸如

"abcdefg".toUpperCase();

这样的操作。这是因为JavaScript为简单数据类型提供了一种方式，把它们包装为对象类型，然后进行方法调用。”"abcdefg"“先被隐式地包装为对象，然后使用包装出的对象调用toUpperCase方法，待方法调用结束后，JavaScript再隐式地把包装对象回收。

其它简单数据类型也使用同样的方式。也可以使用JavaScript提供的构造函数显示地创建包装对象，JavaScript提供了String()、Number()和Boolean()三个构造函数，分别用于构建String、Number和Boolean类型的包装对象。

4、类型转换

ECMA-262中对数据类型的转换有详细的定义，很多JavaScript的参考资料也会列出类型转换的详细规则，这里就不再赘述了，下面只讨论一些值得注意的问题。

JavaScript有两组相等比较运算符：”===“和”!==“、”==“和”!=“。Crockford在著作《JavaScript：The Good Parts》里面列举的Bad Parts中的第一个就是”==“运算符。

原因在于”==“运算符会执行隐式的类型转换，而JavaScript中类型转换的规则又非常复杂，很容易导致代码中出现不易发现的bug。与”===“和其他编程语言中的”==“不同，JavaScript中的”==“运算符并不具备传递性： ∀x∀y∀z(x == y ∧ y == z → x == z)并不成立：

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

Crockford和Zakas都建议不要使用“==”运算符，而使用“===”代替。若不遵循这个建议，使用“==”运算符时，请务必确保你明确知道两个比较变量的类型信息，以免发生预料之外的类型转换。

另外一个经常用到类型转换的地方是分支判断。if（和其它）语句并不要求进行分支判断的表达式结果必须为Boolean类型，而会根据特定的规则把判断表达式的结果转换为true或false后再进行判断。

if (obj !== undefined && obj !== null) {
    // code
}

// 上面的判断条件可以替换为

if （obj) {
    // code
}

上面代码中的obj代表一个对象变量，若其值为undefined或null，则被转换为false，反之转换为true。这种方式并不完全安全，若使用的变量是简单数据类型，就需要注意一些特殊值的转换规则，否则代码可能不会按照预想的方式执行。

if (typeof num === "number" && num) { 
    // if num is 0, get false
    //code
}

上面代码的本意是获取一个有效的数值类型，屏蔽了其他类型和num的值为NaN的情况（NaN会转换false）。但代码中有一个纰漏，它忽略了num值为0的情况。

0值会被转换为false，从而导致下面的代码不会被执行，这可能与编码者的本意相违背。同样使用String类型作为分支条件，也要考虑""会被自动转换为false的情况。

与分支判断中的类型转换相似的情况，是采用短路方式为变量赋值。由于JavaScript中”&&“和”||“操作符的特性，我们经常采用短路方式为变量赋值。

”&&“操作符会返回表达式中第一个可以转换为false的操作数或最后一个操作数（全为true时）；”||“操作符返回表达式中第一个可以转换为true的操作数或最后一个操作数（全为false时）。

var obj = obj1 || obj2 || {}; 
var attr = obj && pro && attr;

与分支判断一样，需要警惕表达式中可能出现的特殊值：0，""，null等。

JavaScript的类型模型，提供了极大的灵活性的同时也带来了很多陷阱，编码过程中需要小心地规避这些陷阱，因为代码审查很容易忽略它们，出现问题时，它们也往往很难被发现。

更多计算机编程相关知识，请访问：编程入门！！

Das obige ist der detaillierte Inhalt vonEin tieferes Verständnis primitiver Typen in JS. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!