Sieben Werttypen und Typoperator in JavaScript

Ich habe vor, JavaScript von den Grundlagen her zu überprüfen.

Übrigens möchte ich teilen und zusammenfassen, was ich gelernt habe

---

Eingebaute Typen

In JavaScript gibt es sieben integrierte Typen, darunter sechs Grundtypen und einen Referenztyp

• Grundtyp

• Zahl (Zahl)

• Zeichenfolge

• boolean

• undefiniert

• null (leerer Wert)

• Symbol (Symbol) [ES6-Spezifikation neu]

• Referenz Typ

• Objekt (Objekt)

Hinweis: Array-Array und Funktionsfunktion sind auch spezielle Objekte Das heißt Sagen wir, sie sind „Subtypen“ von Objekten und auch Referenzwerte

Der Grundtyp ist ein einfaches Datensegment, das im Stapelspeicher gespeichert ist, und es gibt einen festen Platz im Speicher
Der Referenztyp ist Der Zugriff auf im Heap gespeicherte Objekte im Speicher erfolgt per Referenz. Der Stapelspeicher speichert den Zeiger auf das Objekt (die Zugriffsadresse des Objekts wird gespeichert).
Der Grund für die Aufteilung des Stapels in den Speicher liegt darin, dass er mit dem verknüpft ist Der Garbage-Collection-Mechanismus des Browsers stellt den Betrieb sicher. Es belegt die geringste Menge an Speicher
Es spielt keine Rolle, wenn Sie das oben Gesagte nicht verstehen, solange Sie wissen, dass der Grundtyp Stapeldaten sind und die Referenz Typ sind Heap-Daten.typeof Der Operator

kann auch als Typof-Operator bezeichnet werden. Der Operator Operator bezieht sich auf dasselbe

Durch diesen Typof können wir überprüfen der Werttyp

Die Zeichenfolge seines Rückgabetyps (Englisch in Kleinbuchstaben), aber nicht alle Typen können identifiziert werden

Wir haben diese sieben Typen auf der Konsole ausgegeben und ein Problem gefunden

console.log(typeof 123);
// "number"console.log(typeof '123');
// "string"console.log(typeof true);
// "boolean"console.log(typeof undefined);
// "undefined"console.log(typeof Symbol());
// "symbol"console.log(typeof null);
// "object"  <-注意看这里console.log(typeof {demo: 123});
// "object"

typeof null tatsächlich „Objekt“ zurückgegeben

Nun, es ist wie erwartet. Es ist anders
Es wurde versprochen, „null“ zurückzugeben
Tatsächlich handelt es sich hierbei um ein historisches Problem. Dieser Fehler besteht seit mehr als 20 Jahren (älter). als ich)
Wahrscheinlich für immer Es wird nicht repariert, weil es zu viele Websysteme betrifft und die Kosten für die „Reparatur“ unvorstellbar sind

Aber wir können den Nullwerttyp auf diese Weise beurteilen

---

Denn egal welches Objekt, auch ein leeres Objekt, es wird wahr sein, wenn es in einen booleschen Wert konvertiert wird (ich werde später darüber sprechen, wenn ich Typkonvertierung schreibe)

var foo = null;if(!foo && typeof foo === 'object'){    console.log('这是一个空值...');
}

Damit Sie es beurteilen können null gefällt mir so, aber ich scheine es nicht benutzt zu haben

Zurück Als wir zum Thema typeof kamen, haben wir auch ein Problem gefunden

---

typeof hat eine spezielle Behandlung dafür Funktionen, die erstklassige Bürger in JavaScript sind – ausführbare Objekte

console.log(typeof function(){});// "function"

Obwohl Funktionen Objekte sind, kann der Typ des Operators „Funktion“ unterscheiden und zurückgeben.

Der Grund, warum die Funktion aufgerufen werden kann, liegt daran, dass sie vorhanden ist ein internes Attribut [[call]], also ein „aufrufbares Objekt“. Wir werden später darüber sprechen
Ach ja, obwohl Arrays auch spezielle Objekte sind, erkennt typeof sie nicht
Wenn Sie Wenn Sie Arrays unterscheiden möchten, können Sie lesen, was ich darüber geschrieben habe, wie man Arrays identifiziert
Typ der Rückgabewerte umfasst also diese Zeichenfolgen
Zahl, Zeichenfolge, boolescher Wert, undefiniert, Objekt, Funktion, Symbol

Da wir nun über „typeof“ sprechen, gibt es noch einen weiteren kleinen Wissenspunkt

---

Es ist auch leicht, Fehler zu machen, und es kann zu Interviewfragen kommen

console.log(typeof NaN)// "number"

Aber das kann Es ist kein Fehler

Not a number NaN auf Englisch
Not a Number
'Not a number' Das bedeutet: Eine Zahl, die keine Zahl ist, ist eine ZahlDas spielt keine Rolle, das tut es Ist egal
Denken Sie jetzt daran, dass NaN vom Typ Zahl ist

Oh, übrigens fiel mir plötzlich ein

---

Obwohl „typeof“ auf diese Weise verwendet werden kann

Aber es ist keine Funktion, keine Funktion, keine Funktion (Wichtige Dinge werden dreimal gesagt) typeof(a + b) ist ein unärer Operator. Denken Sie daran, dass
die obige Verwendung nur eine Typprüfung für das Ergebnis der Operandenoperation ist der Ausdruck

Wert und Typ

Hier erkläre ich ein solches Problem

In JavaScript haben Variablen keine Typen, nur Werte haben Typen

Der Operator „typeof“ gibt einen String zurück des Typs des von der Variablen gehaltenen Werts
Weil wir eine schwache Typsprache sind
Also können wir den Typ des von der Variablen gehaltenen Werts ändern

Obwohl der Variablenwerttyp sein kann geändert, wir dürfen dies nicht tun, wenn wir Projekte schreiben

var foo = 123;console.log(typeof foo);
// "number"foo = true;console.log(typeof foo);
// "boolean"foo = 'abc';console.log(typeof foo);
// "string"

Wir können Variablen Präfixe hinzufügen oder spezielle Symbole hinzufügen, um uns daran zu erinnern, welche Art von Variable wir deklarieren

Zum Beispiel retArr, bFlag, strLen und dergleichen

Art von nicht deklariertem

Dieses nicht deklarierte Wort ist natürlich der Schlüssel zur Nichtexistenz von Wörtern

Aber warum schreibe ich so

Schauen wir uns eine Frage an

console.log(foo);

我没定义foo就打印，于是

果不其然，浏览器蒙圈了
给大家翻译成中文：未捕获引用错误: foo没有定义
可能大家都不会去注意，其实这是很容易让人误会的
在这了 is not defined != is undefind
因为我连声明都没声明，怎么谈定义
所以如果浏览器报出is not declared或许更准确
我们暂且把这种连定义都没定义的变量看作“undeclared”变量
但是对于这种“undeclared”未定义的变量，typeof有特殊的安全防范机制

console.log(typeof foo);// "undefined"

出乎意料的，它对于undeclared变量并没有报错，而是返回了“undefined”
虽然我们觉得它返回“undeclared”更容易理解一些（我们的要求太高了）
其实它没有报错就相当不错了
这种容错对于我们来说还是很有帮助的
比如说我们想知道全局空间有没有变量foo

if(foo){  //若不存在会报错
    //...}if(typeof foo !== 'undefined'){  //不存在也不会报错
    //...}if(window.foo){  //不存在同样不会报错
    //...}

最后一种通过window对象调用与undeclared变量不同
访问不存在的对象属性是不会报错的，而是返回undefined(是类型而不是字符串)
不过如果我们全局对象不是window的话，就不能使用这种方法了（比如，node.js）

总结

JavaScript内置类型:

• 基本类型（栈数据）：number、string、boolean、undefined、null、object、symbol（ES6规范新增）

• 引用类型（堆数据）：object

typeof操作符返回值：

• “number”

• “string”

• “boolean”

• “undefined”

• “object”

• “function”【sp】

• “symbol”

typeof null -> “object” 历史遗留bug

typeof NaN -> ‘number’ 注意

变量没有类型，其持有值有类型

typeof的容错机制可以用来检查undeclared（未声明）变量

 以上就是JavaScript中的七种值类型与typeof运算符的内容，更多相关内容请关注PHP中文网（www.php.cn）！