Explication détaillée des problèmes liés aux variables JavaScript

Cet article se concentre sur la différence entre les deux types de données différents contenus dans les variables JavaScript : les valeurs de type de base et les valeurs de type de référence. De plus, j'ai brièvement évoqué la relation entre ECMAScript et JavaScript.

Le titre est Variables JavaScript, mais plus précisément, il devrait s'agir de variables ECMAScript.

Dans les années 1990, Netscape et Microsoft ont lancé deux versions différentes de JavaScript, qui n'étaient pas propices au développement et à l'utilisation de JavaScript, incitant l'Association européenne des fabricants d'ordinateurs (ECMA, The European Computer La Manufacturers Association a commencé à s'occuper de la normalisation de JavaScript, complétant ainsi le fameux ECMA-262 - une norme qui définit un nouveau langage de script appelé ECMAScript.

Une implémentation JavaScript complète comprend ECMAScript, le modèle d'objet de document (DOM, modèle d'objet de document) et le modèle d'objet de navigateur (BOM, modèle d'objet de navigateur). ECMAScript, en tant que base de base et d'implémentation de JavaScript, est une description du langage en termes de syntaxe, de types, d'instructions, de mots-clés, de mots réservés, d'opérateurs et d'objets spécifiés par la norme ECMA-262.

Les variables ECMAScript spécifiées dans la norme ECMA-262 sont typées de manière lâche et peuvent être utilisées pour enregistrer tout type de données, de sorte que les opérations d'initialisation de variables de différents types peuvent être placées en une seule instruction Il est légal d'exécuter le code suivant.

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

　 Les variables définies avec l'opérateur var deviendront des variables locales dans la portée où la variable est définie et seront détruites immédiatement après avoir quitté la portée. Par exemple, si vous définissez une variable dans une fonction, la variable est créée lorsque la fonction est appelée, mais une fois la fonction terminée, la variable n'est plus accessible.

Il existe 6 types de données dans ECMAScript (seulement 6, ECMAScript ne prend en charge aucun mécanisme pour créer des types personnalisés).

Les types de données de base comprennent 5 types - sous-fin, nul, booléen, nombre, chaîne. Ces 5 types de données de base sont accessibles par valeur et leurs valeurs appartiennent aux données de base. Les types mentionnés au début de l'article sont de simples segments de données qui peuvent manipuler la valeur réelle stockée dans la variable.

Le sixième type est le type de données complexe - objet, qui est essentiellement composé d'un ensemble de paires nom-valeur non ordonnées. Il s'agit d'une valeur de type référence et est stockée dans un objet mémoire. . JavaScript ne permet pas la manipulation directe de l'espace mémoire d'un objet. Lorsque vous utilisez un objet, vous utilisez en réalité une référence à l'objet plutôt qu'à l'objet réel.

Bien qu'il ne soit pas nécessaire de préciser de quel type de données il s'agit lors de la définition d'une variable, les opérations pouvant être effectuées sur les valeurs des types de base et des types de référence sont toujours très différent.

　Ajout d'attributs

Pour les valeurs de type référence, vous pouvez ajouter des attributs et des méthodes à ajoutez, modifiez et supprimez, comme indiqué dans le code suivant :

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

Si l'objet obj n'est pas détruit ou si l'attribut name n'est pas supprimé, cet attribut existera toujours.

En regardant les valeurs de type de base :

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

La chaîne de nom a un attribut age ajouté et se voit attribuer une valeur de 20, mais le suivant Cet attribut a disparu lors de la première visite.

Cela montre que les attributs ne peuvent être ajoutés dynamiquement qu'aux valeurs de type référence.

Copier la valeur de la variable

À partir de la variable Copier la valeur de type de base de a vers la variable b créera une nouvelle valeur sur l'objet variable b et copiera la valeur dans la variable a In l'emplacement attribué, enregistrez indépendamment. Toute opération impliquant ces deux variables ne s’affectera pas.

　　若从变量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。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!