ECMAScript-Variablen haben zwei verschiedene Datentypen:Basic types, reference types. Es gibt auch andere Namen, zum BeispielPrimitive types and object types，Types with methods and types without methods, sie lassen sich auch unterteilen inMutable types and immutable types, tatsächlich basieren diese Namen alle auf diesen beidenType characteristicsum sie zu benennen, kann jeder sie nennen, wie er möchte o(╯□╰)o .
1. Basistypen
Die grundlegenden Datentypen sind: undefined, boolean, number, string, null. Auf Basistypen wird per Wert zugegriffen, das heißt, Sie können mit dem tatsächlichen Wert arbeiten, der in der Variablen gespeichert ist. Basistypen haben die folgenden Eigenschaften:
1. Die Werte von Basistypen sind unveränderlich:
Keine Methode kann den Wert eines Basistyps ändern, zum Beispiel bei einer Zeichenkette:
var name = 'jozo'; name.toUpperCase(); // 输出 'JOZO' console.log(name); // 输出 'jozo'
Du wirst feststellen, dass sich der ursprüngliche Name nicht geändert hat; stattdessen wird nach dem Aufruf der Methode toUpperCase() ein neuer String zurückgegeben.
Schauen wir uns ein weiteres an:
var person = 'jozo';
person.age = 22;
person.method = function(){//...};
console.log(person.age); // undefined
console.log(person.method); // undefined
Aus dem obigen Code können wir ersehen, dass wir Basistypen keine Eigenschaften und Methoden hinzufügen können, was wiederum zeigt, dass Basistypen unveränderlich sind;
2. Der Vergleich von Basistypen ist ein Wertevergleich:
Sie sind nur dann gleich, wenn ihre Werte gleich sind.
Aber du könntest dies tun:
var a = 1; var b = true; console.log(a == b);//true
Sind sie nicht gleich? Tatsächlich ist dasType conversionund==Wissen über den ==-Operator. Das heißt, wenn == verwendet wird, um zwei Variablen unterschiedlichen Typs zu vergleichen, wird eine Typumwandlung durchgeführt. Im obigen Vergleich wird beispielsweise true zuerst in die Zahl 1 umgewandelt und dann mit der Zahl 1 verglichen, sodass das Ergebnis true ist. Das liegt daran, dass der ==-Operator eine Typumwandlung durchführt, wenn die Typen der beiden verglichenen Werte unterschiedlich sind; wenn die Typen der beiden Werte jedoch gleich sind, ist selbst == äquivalent zu ===.
var a = 'jozo'; var b = 'jozo'; console.log(a === b);//true
3. Variablen von Basistypen werden im Stack-Bereich gespeichert (der Stack-Bereich bezeichnet den Stack-Speicher im Arbeitsspeicher)
Angenommen, es gibt die folgenden Variablen von Basistypen:
var name = 'jozo'; var city = 'guangzhou'; var age = 22;
Dann ist seine Speicherstruktur wie unten dargestellt:
Der Stack-Bereich umfasst die Variablenkennung und den Variablenwert.
2. Referenztypen
Referenztypen sind unterhaltsamer und interessanter.
In JavaScript gibt es neben den obigen Basistypen(number,string,boolean,null,undefined)alles andere sind Referenztypen, die man auch als Objekte bezeichnen kann. Objekte sind Sammlungen von Eigenschaften und Methoden. Das heißt, Referenztypen können Eigenschaften und Methoden haben, und Eigenschaften können Basistypen und Referenztypen enthalten. Schauen wir uns einige Merkmale von Referenztypen an:
1. Die Werte von Referenztypen sind veränderbar
Wir können Referenztypen Eigenschaften und Methoden hinzufügen und auch ihre Eigenschaften und Methoden löschen, zum Beispiel:
var person = {};//创建个控对象 --引用类型
person.name = 'jozo';
person.age = 22;
person.sayName = function(){console.log(person.name);}
person.sayName();// 'jozo'
delete person.name; //删除person对象的name属性
person.sayName(); // undefined
Der obige Code zeigt, dass Referenztypen Eigenschaften und Methoden haben können und dass sie dynamisch geändert werden können.
2. Die Werte von Referenztypen sind Objekte, die sowohl im Stack-Speicher als auch im Heap-Speicher gespeichert werden
JavaScript unterscheidet sich von anderen Sprachen darin, dass es keinen direkten Zugriff auf Positionen im Speicher erlaubt, was bedeutet, dass es nicht direkt auf den Speicherbereich von Objekten zugreifen kann. Worauf greifen wir also zu? Tatsächlich arbeiten wir mit Referenzen auf Objekte, daher wird auf die Werte von Referenztypen per Referenz zugegriffen.
Genau genommen erfordert die Speicherung von Referenztypen, dass sowohl der Stack-Bereich als auch der Heap-Bereich des Speichers (der Heap-Bereich bezieht sich auf den Heap-Speicher im Speicher) zusammenarbeiten. Der Stack-Speicher speichert den Variablenbezeichner und den Zeiger auf das Objekt im Heap-Speicher, was auch als Adresse des Objekts im Heap-Speicher bezeichnet werden kann.
Angenommen, es gibt die folgenden Objekte:
var person1 = {name:'jozo'};
var person2 = {name:'xiaom'};
var person3 = {name:'xiaoq'};
Dann stellt sich die Speicherung dieser drei Objekte im Speicher wie unten gezeigt dar:
3. Vergleich von Referenztypen ist Vergleich von Referenzen
var person1 = '{}';
var person2 = '{}';
console.log(person1 == person2); // true
Beim obigen Vergleich von Basistypen wurde erwähnt, dass es äquivalent zur Verwendung von === ist, wenn die Typen zweier verglichener Werte gleich sind, sodass die Ausgabe true ist. Schauen wir es uns noch einmal an:
var person1 = {};
var person2 = {};
console.log(person1 == person2); // false
Du hast den Fehler vielleicht schon erkannt. Oben werden zwei Zeichenketten verglichen, während unten zwei Objekte verglichen werden. Warum sind Objekte, die genau gleich aussehen, nicht gleich?
Vergiss nicht, auf Referenztypen wird über Referenzen zugegriffen. Mit anderen Worten: Es wird verglichen, ob die Heap-Speicheradressen der beiden Objekte gleich sind. Offensichtlich haben person1 und person2 unterschiedliche Adressen im Heap-Speicher:
Es handelt sich also um zwei völlig unterschiedliche Objekte, daher wird false zurückgegeben;
3. Einfache Zuweisung
Wenn ein Basistyp von einer Variablen an eine andere zugewiesen wird, wird auf dieser Variablen ein neuer Wert erzeugt, und dann wird dieser Wert an die für die neue Variable reservierte Stelle kopiert:
var a = 10; var b = a; a ++ ; console.log(a); // 11 console.log(b); // 10
Der in a gespeicherte Wert ist zu diesem Zeitpunkt 10. Wenn a verwendet wird, um b zu initialisieren, ist der in b gespeicherte Wert ebenfalls 10, aber die 10 in b ist völlig unabhängig von der in a. Dieser Wert ist nur eine Kopie des Werts in a. Danach können diese beiden Variablen an beliebigen Operationen teilnehmen, ohne sich gegenseitig zu beeinflussen.
Das heißt, nach der Zuweisungsoperation von Basistypen beeinflussen sich die beiden Variablen nicht gegenseitig.
4. Objektreferenz
Wenn ein Wert eines Referenztyps von einer Variablen an eine andere zugewiesen wird, wird ebenfalls eine Kopie des Werts des in der Variablen gespeicherten Objekts in den für die neue Variable reservierten Speicherbereich gelegt. Wie bereits bei der Erörterung von Referenztypen erwähnt, ist das, was in der Variablen gespeichert ist, die Adresse des Objekts im Heap-Speicher. Daher ist diese Kopie des Werts, anders als bei einer einfachen Zuweisung, tatsächlich ein Zeiger, und dieser Zeiger verweist auf ein im Heap-Speicher gespeichertes Objekt. Nach der Zuweisungsoperation enthalten beide Variablen dieselbe Objektadresse, sodass beide Variablen auf dasselbe Objekt verweisen. Daher wirkt sich eine Änderung einer der beiden Variablen auf die andere aus:
var a = {}; // a保存了一个空对象的实例
var b = a; // a和b都指向了这个空对象
a.name = 'jozo';
console.log(a.name); // 'jozo'
console.log(b.name); // 'jozo'
b.age = 22;
console.log(b.age);// 22
console.log(a.age);// 22
console.log(a == b);// true
Ihre Beziehung ist wie unten dargestellt:
Daher ist die Zuweisung von Referenztypen tatsächlich die Zuweisung des Zeigers auf die im Stack-Bereich gespeicherte Adresse des Objekts. Daher verweisen die beiden Variablen auf dasselbe Objekt, und jede Operation wirkt sich auf die andere aus.
Original-Link: https://segmentfault.com/a/1190000002789651