Primitive und komplexe Werte in JavaScript_Javascript-Tipps

Vorherige Wörter

JavaScript-Datentypen können in zwei Typen unterteilt werden: primitive Typen und Referenztypen. Primitive Typen werden auch als Basistypen oder einfache Typen bezeichnet. Zu den grundlegenden Datentypen von JavaScript gehören Undefinierte, Null-, Boolesche, Zahlen- und Referenztypen, die in Javascript auch als Objekttypen bezeichnet werden. Dementsprechend werden ihre Werte auch als primitive Werte bzw. komplexe Werte bezeichnet

Funktionen

Urwert

Einfach ausgedrückt: Primitivwerte sind feste und einfache Werte, bei denen es sich um einfache Datensegmente handelt, die im Stapel gespeichert sind, dh ihre Werte werden direkt am Ort des Variablenzugriffs gespeichert.

Ein primitiver Wert ist die niedrigste oder einfachste Form, die in Javascript verfügbare Daten oder Informationen darstellt. Werte primitiver Typen werden als primitive Werte bezeichnet, da sie nicht reduzierbar sind. Das heißt, Zahlen sind Zahlen, Zeichen sind Zeichen, boolesche Werte sind wahr oder falsch und null und undefiniert sind null und undefiniert. Die Werte selbst sind einfach und können keine aus anderen Werten zusammengesetzten Werte darstellen

Welche Typen sind primitive Typen?

Der primitive Typ hat die folgenden fünf Typen: Undefiniert, Null, Boolean, Zahl, String

Wir können typeof verwenden, um zu bestimmen, ob ein Typ im Geltungsbereich eines bestimmten Typs liegt.

Operatortyp

Die Verwendung des Operators „typeof“ für eine Variable oder einen Wert gibt einen der folgenden Werte zurück:

Hinweis:

1. Der Rückgabewert ist vom Typ String.

2. Im Vergleich zum Originaltyp gibt es immer noch einen Unterschied zwischen „typeof(null)“ und „object“.

Komplexer Wert

Komplexe Werte können aus vielen verschiedenen Arten von JavaScript-Objekten bestehen. Die Größe eines komplexen Objekts im Speicher ist unbekannt, da ein komplexes Objekt jeden beliebigen Wert enthalten kann und nicht nur einen bestimmten bekannten Wert

Speichermethode

Stapelspeicher

Da der ursprüngliche Wert einen festen Platz einnimmt und ein einfaches Datensegment ist, wird er im Stapel gespeichert, um die Geschwindigkeit der Variablenabfrage zu verbessern

Heapspeicher

Da sich die Größe des komplexen Werts ändert, kann er nicht auf dem Stapel gespeichert werden. Andernfalls wird die Geschwindigkeit der Variablenabfrage verringert, sodass er im Heap (Heap) gespeichert wird zeigt auf das Speicherobjekt Der Speicherort

Zugriffsmethode

Zugriff nach Wert

Primitive Werte werden als nicht reduzierbare Werte gespeichert und manipuliert, indem sie durch Referenzierung ihren Wert übertragen

var myString = 'foo';
var myStringCopy = myString;
var myString = null;
console.log(myString,myStringCopy);//null,'foo' 

Angebotsbesuch

Komplexe Werte werden anhand von Referenzen gespeichert und manipuliert, nicht anhand des tatsächlichen Werts. Wenn Sie eine Variable erstellen, die ein komplexes Objekt enthält, ist ihr Wert eine Referenzadresse im Speicher. Wenn Sie auf ein komplexes Objekt verweisen, verwenden Sie dessen Namen (d. h. Variable oder Objekteigenschaft), um den Objektwert über die Referenzadresse im Speicher zu erhalten

var myObject = {};
var copyOfMyObject = myObject;//没有复制值，而是复制了引用
myObject.foo = 'bar';//操作myObject中的值
//现在如果输出myObject和copyOfMyObject，则都会输出foo属性，因为它们引用的是同一个对象
console.log(myObject,copyOfMyObject);//Object{foo="bar"} 

Vergleich

Primitive Werte verwenden einen Wertvergleich, während komplexe Werte einen Referenzvergleich verwenden. Komplexe Werte sind nur dann gleich, wenn sie sich auf dasselbe Objekt beziehen (also dieselbe Adresse haben). Selbst zwei Variablen, die dasselbe Objekt enthalten, sind einander nicht gleich, da sie nicht auf dasselbe Objekt verweisen

var price1 = 10;
var price2 = 10;
var price3 = new Number('10');
var price4 = price3;
console.log(price1 == price2);//true
console.log(price1 == price3);//false
price4 = 10;
console.log(price4 == price3);//true
console.log(price4 === price3);//false 
var objectFoo = {same:'same'};
var objectBar = {same:'same'};
console.log(objectFoo == objectBar);//false
var objectA = {foo: 'bar'};
var objectB = objectA;
console.log(objectA == objectB);//true 

Dynamische Attribute

Für komplexe Werte können Sie ihnen Eigenschaften und Methoden hinzufügen, und Sie können ihre Eigenschaften und Methoden auch ändern und löschen, aber einfache Werte können keine Eigenschaften und Methoden hinzufügen

Komplexe Werte unterstützen dynamische Objekteigenschaften, da wir ein Objekt definieren, dann eine Referenz erstellen und dann das Objekt aktualisieren können und alle Variablen, die auf das Objekt verweisen, aktualisiert werden. Eine neue Variable zeigt auf ein vorhandenes komplexes Objekt und das Objekt wird nicht kopiert. Aus diesem Grund werden komplexe Werte manchmal als Referenzwerte bezeichnet. Komplexe Werte können beliebig viele Referenzen haben und verweisen immer auf dasselbe Objekt, auch wenn sich das Objekt ändert

var str = 'test';
str.property = true;
console.log(str.property);//undefined　 
var objA = {property: 'value'};
var pointer1 = objA;
var pointer2 = pointer1;
objA.property = null;
console.log(objA.property,pointer1.property,pointer2.property);//null null null 

Jenis Pembungkusan

Apabila nilai primitif digunakan sebagai objek yang dicipta oleh pembina, Javascript akan menukarnya menjadi objek supaya sifat dan kaedah objek boleh digunakan, kemudian buang sifat objek dan tukar semula kepada nilai primitif