Detaillierte Erläuterung der Probleme im Zusammenhang mit JavaScript-Variablen

Dieser Artikel konzentriert sich auf den Unterschied zwischen zwei verschiedenen Datentypen, die in JavaScript-Variablen enthalten sind – Basistypwerte und Referenztypwerte. Darüber hinaus habe ich kurz auf die Beziehung zwischen ECMAScript und JavaScript eingegangen.

Der Titel lautet JavaScript-Variablen, genauer gesagt sollten es ECMAScript-Variablen sein.

In den 1990er Jahren brachten Netscape und Microsoft zwei verschiedene Versionen von JavaScript auf den Markt, die der Entwicklung und Verwendung von JavaScript nicht förderlich waren, was den Europäischen Computerherstellerverband (ECMA, The European Computer Die Manufacturers Association begann sich mit der Standardisierung von JavaScript zu befassen und vollendete damit den berühmten ECMA-262 – einen Standard, der eine neue Skriptsprache namens ECMAScript definiert.

Eine vollständige JavaScript-Implementierung umfasst ECMAScript, Document Object Model (DOM, Document Object Model) und Browser Object Model (BOM, Browser Object Model). Als Kernstück von JavaScript und Grundlage seiner Implementierung ist ECMAScript eine Beschreibung der Sprache in Bezug auf Syntax, Typen, Anweisungen, Schlüsselwörter, reservierte Wörter, Operatoren und Objekte, die durch den ECMA-262-Standard spezifiziert werden.

ECMAScript-Variablen, die im ECMA-262-Standard spezifiziert sind, sind lose typisiert und können zum Speichern beliebiger Datentypen verwendet werden, sodass die Operationen zum Initialisieren von Variablen verschiedener Typen platziert werden können in einer Anweisung Es ist legal, den folgenden Code auszuführen.

 var message = "hello",  //string     
 age = 20,           //number3     
 found = false；　　　//boolean　

　 Mit dem var-Operator definierte Variablen werden zu lokalen Variablen in dem Bereich, in dem die Variable definiert ist, und werden sofort nach Verlassen des Bereichs zerstört. Wenn Sie beispielsweise eine Variable innerhalb einer Funktion definieren, wird die Variable beim Aufruf der Funktion erstellt, nach dem Beenden der Funktion kann jedoch nicht mehr auf die Variable zugegriffen werden.

Es gibt 6 Datentypen in ECMAScript (nur 6, ECMAScript unterstützt keinen Mechanismus zum Erstellen benutzerdefinierter Typen).

Zu den Basisdatentypen gehören 5 Typen: Unterdefiniert, Null, Boolescher Wert, Zahl, Zeichenfolge. Auf diese 5 Basisdatentypen wird nach Wert zugegriffen, und ihre Werte gehören zu den Basisdaten Die am Anfang des Artikels erwähnten Typwerte sind einfache Datensegmente, die den in der Variablen gespeicherten tatsächlichen Wert manipulieren können.

Der sechste Typ ist der komplexe Datentyp – Objekt, der im Wesentlichen aus einer Menge ungeordneter Name-Wert-Paare besteht. Es ist ein Referenztyp-Objekt und wird im Speicher gespeichert . JavaScript erlaubt keine direkte Manipulation des Speicherplatzes eines Objekts. Wenn Sie ein Objekt bedienen, bedienen Sie tatsächlich einen Verweis auf das Objekt und nicht auf das eigentliche Objekt.

Obwohl es beim Definieren einer Variablen nicht erforderlich ist, anzugeben, um welchen Datentyp es sich handelt, sind die Operationen, die an den Werten von Basistypen und Referenztypen ausgeführt werden können, folgende immer noch ganz anders.

　Attribute hinzufügen

Für Referenztypwerte können Sie Attribute und Methoden hinzufügen Hinzufügen, Ändern und Löschen, wie im folgenden Code gezeigt:

var obj = new object();  //创建对象并保存在obj中
obj.name = "Marry";      //添加名为name的属性，赋予字符串值“Marry”
alert(obj.name);         //弹出"Marry"

Wenn das obj-Objekt nicht zerstört oder das Namensattribut nicht gelöscht wird, ist dieses Attribut immer vorhanden.

Betrachtet man die grundlegenden Typwerte:

var name = "Marry";  //创建字符串
name.age = 20;       //添加名为age的属性，赋予number值20
alert(name.age);     //弹出"underfined"

Der Namenszeichenfolge wurde ein Altersattribut hinzugefügt und ihr wird ein Wert von 20 zugewiesen. aber das Folgende: Dieses Attribut ist beim ersten Besuch verschwunden.

Dies zeigt, dass Attribute nur dynamisch zu Referenztypwerten hinzugefügt werden können.

Variablenwert kopieren

Aus Variable Durch Kopieren des Grundtypwerts von a in die Variable b wird ein neuer Wert für das Objekt Variable b erstellt und der Wert in die Variable a kopiert den zugewiesenen Ort, selbstständig speichern. Alle Vorgänge, an denen diese beiden Variablen beteiligt sind, wirken sich nicht gegenseitig aus.

　　若从变量c向变量d复制引用类型的值，同样会将存储在变量d对象中的值复制一份放到为变量c分配的空间中，但这个值的副本实际是一个指针，与变量d指向堆内存中的同一个对象。两个变量实际引用同一个对象，改变其中一个变量，将影响另一个变量。

　　具体区别见如下例子：

//基本类型值
var num1 = 5;var num2 = num1;
num2 = num2 + 5;
alert(num1);                   
//5alert(num2);                   
//10/
/引用类型值
var obj1 = new object();var obj2 = obj1;
obj1.name = "Marry";
alert(obj2.name);            
//"Marry"

 　　函数传参

　　ECMAScript中所有函数的参数都是按值传递的，即将函数外部的值复制给函数内部的参数。鉴于基本类型值与引用类型值复制变量的不同，其函数传参的效果也不同。

　　在向参数传递基本类型值时，被传递的参数被赋给一个局部变量，函数内部参数的变化不影响函数外部的变量；向参数传递引用类型值时，会把这个值在内存中的地址复制给一个局部变量，因此这个局部变量的变化将会反映在函数的外部。如下列例子：

//传递基本类型值function addnum(num) {
    num += 10;    return num; 
}var num1 = 5;var num2 = addnum(num1);
alert(num1);                  
//5，无变化alert(num2);                  
//15//传递引用类型值
function setage(obj) {
    obj.age = 20;
}var obj1 = new object();
setage(obj1)
alert(obj1.age);            //20

在局部作用域中修改的对象反映在全局作用域中，很多人会以为这是按引用传递。但函数对象确实都是按值传递，见下列例子：

function setage(obj) {
    obj.age = 20;
    obj = new object();
    obj.age = 30;
}var obj1 = new object();
setage(obj1)
alert(obj1.age);           
//20

　　此例中在函数内部为obj重新定义了一个对象，且为其age属性重新赋值，但这一变化并未反映在函数外部，说明obj1 并不是按引用传递的。实际函数内重新定义的对象为局部对象，在退出函数后就会被立即销毁。

　　检测类型

　　基本类型值可以通过typeof检测，但typeof检测引用类型时只能返回object。所以为了知道某个值是什么类型的对象，ECMAScript提供了instanceof操作符，语法如下：

result = variable instanceof constructor

如果变量是引用类型的实例，instanceof操作符就会返回true。

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Probleme im Zusammenhang mit JavaScript-Variablen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!