Une variable peut stocker deux types de valeurs : des valeurs primitives et des valeurs de référence.

ES6 a introduit un nouveau type de données primitif, Symbol, qui représente une valeur unique. C'est le septième type de données du langage JavaScript ; les six premiers sont : Undefined, Null, Boolean, String, Number, Object.

Types primitifs

Il existe 6 types de données primitifs en JavaScript : Undefined, Null, Boolean, Number, String, Symbol (nouveau dans ES6) !

Convention :Les types de données primitifs sont équivalents aux types primitifs.

Les valeurs des types de données primitifs sont accessibles par valeur.

• Les valeurs des types primitifs sont immuables.

  var str = "123hello321";
  str.toUpperCase();     // 123HELLO321
  console.log(str);      // 123hello321

• La comparaison des types primitifs est une comparaison de leurs valeurs.

  var a = 1;
  var b = true;
  console.log(a == b);    // true
  console.log(a === b);   // false

  Ci-dessus, a et b ont des types de données différents, mais ils peuvent toujours être comparés par valeur car une conversion de type implicite est automatiquement effectuée avant la comparaison.

  • == : ne compare que les valeurs

  • === : ne compare pas seulement les valeurs, mais aussi les types de données

• Les variables de types primitifs sont stockées dans la mémoire de pile (Stack).

  var a,b;
  a = "zyj";
  b = a;
  console.log(a);   // zyj
  console.log(b);   // zyj
  a = "呵呵";       // 改变 a 的值，并不影响 b 的值
  console.log(a);   // 呵呵
  console.log(b);   // zyj

Schéma comme suit : la mémoire de pile contient l'identifiant de la variable et la valeur de la variable.

Types de référence

En dehors des 6 types de données primitifs ci-dessus, les autres sont des types de référence, collectivement appelés le type Object. En détail, ils comprennent : le type Object, le type Array, le type Date, le type RegExp, le type Function, etc.

Les valeurs des types de référence sont accessibles par référence.

• Les valeurs des types de référence sont mutables.

  var obj = {name:"zyj"};   // 创建一个对象
  obj.name = "percy";       // 改变 name 属性的值
  obj.age = 21;             // 添加 age 属性
  obj.giveMeAll = function(){
    return this.name + " : " + this.age;
  };                        // 添加 giveMeAll 方法
  obj.giveMeAll();

• La comparaison des types de référence est une comparaison de références.

  var obj1 = {};    // 新建一个空对象 obj1
  var obj2 = {};    // 新建一个空对象 obj2
  console.log(obj1 == obj2);    // false
  console.log(obj1 === obj2);   // false

  Comme obj1 et obj2 font référence à deux objets différents stockés dans la mémoire tas, les valeurs (adresses de référence) des variables obj1 et obj2 sont également différentes !

• Les valeurs des types de référence sont des objets (Object) stockés dans la mémoire tas (Heap).
  Contrairement à d'autres langages de programmation, JavaScript ne peut pas manipuler directement l'espace mémoire (mémoire tas) des objets.

  var a = {name:"percy"};
  var b;
  b = a;
  a.name = "zyj";
  console.log(b.name);    // zyj
  b.age = 22;
  console.log(a.age);     // 22
  var c = {
    name: "zyj",
    age: 22
  };

Schéma comme suit :

• La mémoire pile stocke l'identifiant de la variable et un pointeur vers l'objet dans la mémoire tas.

• La mémoire tas stocke le contenu de l'objet.

Détection des types

• typeofest souvent utilisé pour détecter si une variable est le type de données le plus élémentaire

  var a;
  typeof a;    // undefined
  
  a = null;
  typeof a;    // object
  
  a = true;
  typeof a;    // boolean
  
  a = 666;
  typeof a;    // number 
  
  a = "hello";
  typeof a;    // string
  
  a = Symbol();
  typeof a;    // symbol
  
  a = function(){}
  typeof a;    // function
  
  a = [];
  typeof a;    // object
  a = {};
  typeof a;    // object
  a = /aaa/g;
  typeof a;    // object   

• instanceofsert à déterminer si l'objet pointé par la propriété prototype d'un constructeur existe dans la chaîne de prototypes d'un autre objet à détecter

  En termes simples, il s'agit de déterminer si une variable de type référence est un objet d'un type spécifique.

  ({}) instanceof Object              // true
  ([]) instanceof Array               // true
  (/aa/g) instanceof RegExp           // true
  (function(){}) instanceof Function  // true

Adresse d'origine : https://segmentfault.com/a/1190000006752076