Una variable puede almacenar dos tipos de valores: valores de tipo primitivo (primitive values) y valores de tipo de referencia (reference values).

ES6 introdujo un nuevo tipo de datos primitivo, Symbol, que representa un valor único. Es el séptimo tipo de datos del lenguaje JavaScript; los seis anteriores son: Undefined, Null, booleano (Boolean), cadena (String), número (Number) y objeto (Object).

Tipos primitivos

En JavaScript hay 6 tipos de datos básicos: Undefined, Null, Boolean, Number, String, Symbol (nuevo en ES6)!

Convención:Los tipos de datos básicos son equivalentes a los tipos de datos primitivos.

El acceso a los valores de los tipos de datos básicos es por valor.

• Los valores de los tipos primitivos son inmutables.

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

• La comparación de los tipos primitivos es una comparación de sus valores.

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

  Arriba, los tipos de datos de a y b son diferentes, pero también se puede realizar la comparación de valores, porque antes de la comparación se realizó automáticamente una conversión implícita de tipos de datos.

  • == : solo realiza la comparación de valores

  • === : no solo compara los valores, sino también los tipos de datos

• Las variables de tipos primitivos se almacenan en la memoria de pila (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

El diagrama es el siguiente: la memoria de pila incluye el identificador de la variable y el valor de la variable.

Tipos de referencia

Aparte de los 6 tipos de datos básicos anteriores, el resto son tipos de referencia, denominados colectivamente tipo Object. Si se subdividen, hay: tipo Object, tipo Array, tipo Date, tipo RegExp, tipo Function, etc.

El acceso a los valores de los tipos de referencia es por referencia.

• Los valores de los tipos de referencia son 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 comparación de los tipos de referencia es una comparación de referencias.

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

  Debido a que obj1 y obj2 hacen referencia respectivamente a dos objetos diferentes almacenados en la memoria de montón (Heap), ¡los valores (direcciones de referencia) de las variables obj1 y obj2 también son diferentes!

• Los valores de los tipos de referencia son objetos (Object) guardados en la memoria de montón (Heap).
  A diferencia de otros lenguajes de programación, JavaScript no puede manipular directamente el espacio de memoria (montón) de los objetos.

  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
  };

El diagrama es el siguiente:

• La memoria de pila (Stack) guarda el identificador de la variable y el puntero que apunta al objeto en la memoria de montón (Heap).

• La memoria de montón (Heap) guarda el contenido del objeto.

Detección de tipos

• typeof: se utiliza a menudo para detectar si una variable es un tipo de datos primitivo.

  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   

• instanceof: se utiliza para determinar si el objeto al que apunta la propiedad prototype de un constructor existe en la cadena de prototipos de otro objeto a detectar.

  En pocas palabras, consiste en determinar si una variable de tipo de referencia es específicamente un objeto de un cierto tipo.

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

Dirección del artículo original: https://segmentfault.com/a/1190000006752076