Les variables ECMAScript ont deux types de données différents :Basic types, reference types. Il existe également d'autres noms, par exemplePrimitive types and object types，Types with methods and types without methods, cela peut aussi être divisé enMutable types and immutable types, en fait ces noms sont tous basés sur ces deuxType characteristicspour les nommer, chacun peut les appeler comme il veut o(╯□╰)o .
1. Types de base
Les types de données de base sont : undefined, boolean, number, string, null. Les types de base sont accessibles par valeur, ce qui signifie que vous pouvez manipuler la valeur réelle stockée dans la variable. Les types de base ont les caractéristiques suivantes :
1. Les valeurs des types de base sont immuables :
Aucune méthode ne peut modifier la valeur d'un type de base, par exemple une chaîne :
var name = 'jozo'; name.toUpperCase(); // 输出 'JOZO' console.log(name); // 输出 'jozo'
Vous constaterez que le nom d'origine n'a pas changé ; à la place, une nouvelle chaîne est renvoyée après l'appel de la méthode toUpperCase().
Regardons un autre exemple :
var person = 'jozo';
person.age = 22;
person.method = function(){//...};
console.log(person.age); // undefined
console.log(person.method); // undefined
D'après le code ci-dessus, nous pouvons voir que nous ne pouvons pas ajouter de propriétés et de méthodes aux types de base, ce qui montre à nouveau que les types de base sont immuables ;
2. La comparaison des types de base est une comparaison de valeurs :
Ils sont égaux uniquement lorsque leurs valeurs sont égales.
Mais vous pourriez faire ceci :
var a = 1; var b = true; console.log(a == b);//true
Ne sont-ils pas égaux ? En fait, c'estType conversionet==la connaissance de l'opérateur ==. C'est-à-dire que, lorsque l'on utilise == pour comparer deux variables de types différents, une conversion de type est effectuée. Par exemple, dans la comparaison ci-dessus, true est d'abord converti en nombre 1, puis comparé au nombre 1, donc le résultat est true. C'est parce que lorsque les types des deux valeurs comparées sont différents, l'opérateur == effectue une conversion de type, mais lorsque les types des deux valeurs sont identiques, même == est équivalent à ===.
var a = 'jozo'; var b = 'jozo'; console.log(a === b);//true
3. Les variables de types de base sont stockées dans la zone de pile (la zone de pile désigne la mémoire de pile en mémoire)
Supposons qu'il existe les variables de types de base suivantes :
var name = 'jozo'; var city = 'guangzhou'; var age = 22;
Alors sa structure de stockage est comme indiqué ci-dessous :
La zone de pile comprend l'identifiant de variable et la valeur de variable.
2. Types de référence
Les types de référence sont plus amusants et intéressants.
En JavaScript, à part les types de base ci-dessus(number,string,boolean,null,undefined)tout le reste correspond aux types de référence, que l'on peut aussi appeler des objets. Les objets sont des collections de propriétés et de méthodes. C'est-à-dire que les types de référence peuvent avoir des propriétés et des méthodes, et que les propriétés peuvent contenir des types de base et des types de référence. Examinons quelques caractéristiques des types de référence :
1. Les valeurs des types de référence sont mutables
Nous pouvons ajouter des propriétés et des méthodes aux types de référence, et nous pouvons aussi supprimer leurs propriétés et méthodes, par exemple :
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
Le code ci-dessus montre que les types de référence peuvent avoir des propriétés et des méthodes, et qu'ils peuvent être modifiés dynamiquement.
2. Les valeurs des types de référence sont des objets stockés à la fois dans la mémoire de pile et dans la mémoire de tas
JavaScript est différent des autres langages en ce qu'il ne permet pas d'accéder directement aux positions en mémoire, ce qui signifie qu'il ne peut pas opérer directement sur l'espace mémoire des objets. Alors, sur quoi opérons-nous ? En fait, nous opérons sur des références à des objets, donc les valeurs des types de référence sont accessibles par référence.
Pour être précis, le stockage des types de référence nécessite que la zone de pile et la zone de tas de la mémoire (la zone de tas désigne la mémoire de tas en mémoire) fonctionnent ensemble. La mémoire de pile stocke l'identifiant de la variable et le pointeur vers l'objet dans la mémoire de tas, ce que l'on peut aussi appeler l'adresse de l'objet dans la mémoire de tas.
Supposons qu'il existe les objets suivants :
var person1 = {name:'jozo'};
var person2 = {name:'xiaom'};
var person3 = {name:'xiaoq'};
Alors, la situation de stockage de ces trois objets en mémoire est comme indiqué ci-dessous :
3. La comparaison des types de référence est une comparaison de références
var person1 = '{}';
var person2 = '{}';
console.log(person1 == person2); // true
Lorsque l'on a parlé ci-dessus de la comparaison des types de base, il a été mentionné que lorsque les types de deux valeurs comparées sont les mêmes, cela équivaut à utiliser ===, donc la sortie est true. Regardons à nouveau :
var person1 = {};
var person2 = {};
console.log(person1 == person2); // false
Vous avez peut-être déjà repéré le défaut. L'exemple ci-dessus compare deux chaînes, tandis que l'exemple ci-dessous compare deux objets. Pourquoi des objets qui semblent exactement identiques ne sont-ils pas égaux ?
N'oubliez pas, on accède aux types de référence par référence. Autrement dit, il compare si les adresses mémoire des deux objets dans le tas sont identiques. De toute évidence, person1 et person2 ont des adresses différentes dans le tas :
Ce sont donc deux objets complètement différents, donc false est renvoyé ;
3. Affectation simple
Lors de l'affectation d'un type de base d'une variable à une autre, une nouvelle valeur est créée dans cette variable, puis cette valeur est copiée à l'emplacement alloué à la nouvelle variable :
var a = 10; var b = a; a ++ ; console.log(a); // 11 console.log(b); // 10
À ce moment-là, la valeur stockée dans a est 10. Lorsque a est utilisé pour initialiser b, la valeur stockée dans b est également 10, mais le 10 dans b est complètement indépendant de celui dans a. Cette valeur n'est qu'une copie de la valeur dans a. Après cela, ces deux variables peuvent participer à n'importe quelles opérations sans s'influencer mutuellement.
C'est-à-dire qu'après l'opération d'affectation des types de base, les deux variables ne s'influencent pas mutuellement.
4. Référence d'objet
Lors de l'affectation d'une valeur d'un type de référence d'une variable à une autre, une copie de la valeur de l'objet stocké dans la variable est également placée dans l'espace alloué à la nouvelle variable. Comme mentionné précédemment lors de la discussion sur les types de référence, ce qui est stocké dans la variable est l'adresse de l'objet dans la mémoire tas. Par conséquent, contrairement à une affectation simple, cette copie de la valeur est en réalité un pointeur, et ce pointeur pointe vers un objet stocké dans la mémoire tas. Après l'opération d'affectation, les deux variables détiennent la même adresse d'objet, donc les deux variables pointent vers le même objet. Par conséquent, modifier l'une ou l'autre variable affectera l'autre :
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
Leur relation est illustrée ci-dessous :
Par conséquent, l'affectation des types de référence est en réalité l'affectation du pointeur vers l'adresse de l'objet stockée dans la zone de pile. Par conséquent, les deux variables pointent vers le même objet, et toute opération les affectera mutuellement.
Lien original : https://segmentfault.com/a/1190000002789651