ECMAScript 6 se ha convertido básicamente en el estándar de la industria, y su velocidad de adopción es mucho mayor que la de ES5. La razón principal es que los navegadores modernos han brindado soporte a ES6 con bastante rapidez, especialmente Chrome y Firefox, que ya admiten la gran mayoría de las características de ES6.


1. let, const y el ámbito de bloque

let permite crear un ámbito a nivel de bloque. ES6 recomienda usar let para definir variables en funciones, en lugar de var:

var a = 2;
{
  let a = 3;
  console.log(a); // 3
}
console.log(a); // 2

Otra forma de declarar variables que también es válida en el ámbito de bloque es const, que permite declarar una constante. En ES6, una constante declarada con const es similar a un puntero: apunta a una referencia. Es decir, esta "constante" no es inmutable, por ejemplo:

{
  const ARR = [5,6];
  ARR.push(7);
  console.log(ARR); // [5,6,7]
  ARR = 10; // TypeError
}

Hay varios puntos a tener en cuenta:

  • Las variables declaradas con la palabra clave let no tienen la característica de elevación (hoisting).
  • Las declaraciones con let y const solo son válidas en el bloque más cercano (dentro de las llaves).
  • Cuando declares una constante con const, usa variables en mayúsculas, como: CAPITAL_CASING
  • const debe ser asignada en el momento de la declaración.

2. Funciones flecha (Arrow Functions)

En ES6, las funciones flecha son una forma abreviada de las funciones. Se usan paréntesis para envolver los parámetros, seguidos de =>, y a continuación el cuerpo de la función:

var getPrice = function() {
  return 4.55;
};
 
// Implementation with Arrow Function
var getPrice = () => 4.55;

Ten en cuenta que la función flecha getPrice del ejemplo anterior utiliza un cuerpo conciso y no necesita una declaración return. El siguiente ejemplo utiliza un cuerpo de función normal:

let arr = ['apple', 'banana', 'orange'];
 
let breakfast = arr.map(fruit => {
  return fruit + 's';
});
 
console.log(breakfast); // apples bananas oranges

Por supuesto, las funciones flecha no solo hacen que el código sea más conciso; el this dentro de la función siempre está vinculado y apunta al propio objeto. Puedes verlo en los siguientes ejemplos:

function Person() {
  this.age = 0;
 
  setInterval(function growUp() {
    // 在非严格模式下,growUp() 函数的 this 指向 window 对象
    this.age++;
  }, 1000);
}
var person = new Person();

A menudo necesitamos usar una variable para guardar this y luego hacer referencia a ella dentro de la función growUp:

function Person() {
  var self = this;
  self.age = 0;
 
  setInterval(function growUp() {
    self.age++;
  }, 1000);
}

Con las funciones flecha, puedes ahorrarte esta molestia:

function Person(){
  this.age = 0;
 
  setInterval(() => {
    // |this| 指向 person 对象
    this.age++;
  }, 1000);
}
 
var person = new Person();

3. Valores predeterminados de los parámetros de función

ES6 te permite establecer valores predeterminados para los parámetros de las funciones:

let getFinalPrice = (price, tax=0.7) => price + price * tax;
getFinalPrice(500); // 850

4. Operador Spread / Rest

El operador Spread / Rest se refiere a ..., y si es Spread o Rest depende del contexto.

Cuando se usa en iteradores, es un operador Spread:

function foo(x,y,z) {
  console.log(x,y,z);
}
 
let arr = [1,2,3];
foo(...arr); // 1 2 3

Cuando se usa para pasar argumentos a una función, es un operador Rest:

function foo(...args) {
  console.log(args);
}
foo( 1, 2, 3, 4, 5); // [1, 2, 3, 4, 5]

5. Extensiones de objetos literales

ES6 permite usar una sintaxis abreviada al declarar objetos literales para inicializar variables de propiedades y definir métodos, y también permite realizar operaciones computadas en las propiedades de los objetos:

function getCar(make, model, value) {
  return {
    // 简写变量
    make,  // 等同于 make: make
    model, // 等同于 model: model
    value, // 等同于 value: value
 
    // 属性可以使用表达式计算值
    ['make' + make]: true,
 
    // 忽略 `function` 关键词简写对象函数
    depreciate() {
      this.value -= 2500;
    }
  };
}
 
let car = getCar('Barret', 'Lee', 40000);
 
// output: {
//     make: 'Barret',
//     model:'Lee',
//     value: 40000,
//     makeBarret: true,
//     depreciate: [Function: depreciate]
// }

6. Literales binarios y octales

ES6 admite literales binarios y octales. Agregando 0o o 0O delante del número se convierte en un valor octal:

let oValue = 0o10;
console.log(oValue); // 8
 
let bValue = 0b10; // 二进制使用 `0b` 或者 `0B`
console.log(bValue); // 2

7. Desestructuración de objetos y arrays

La desestructuración evita crear variables intermedias al asignar objetos:

function foo() {
  return [1,2,3];
}
let arr = foo(); // [1,2,3]
 
let [a, b, c] = foo();
console.log(a, b, c); // 1 2 3
 
function bar() {
  return {
    x: 4,
    y: 5,
    z: 6
  };
}
let {x: x, y: y, z: z} = bar();
console.log(x, y, z); // 4 5 6

8. Super en objetos

ES6 permite usar super en los objetos:

var parent = {
  foo() {
    console.log("Hello from the Parent");
  }
}
 
var child = {
  foo() {
    super.foo();
    console.log("Hello from the Child");
  }
}
 
Object.setPrototypeOf(child, parent);
child.foo(); // Hello from the Parent
             // Hello from the Child

9. Sintaxis de plantillas y delimitadores

En ES6 hay una forma muy concisa de ensamblar un conjunto de cadenas y variables.

  • ${ ... } se usa para renderizar una variable
  • ` se usa como delimitador
let user = 'Barret';
console.log(`Hi ${user}!`); // Hi Barret!

10. for...of VS for...in

for...of se usa para recorrer un iterador, como un array:

let nicknames = ['di', 'boo', 'punkeye'];
nicknames.size = 3;
for (let nickname of nicknames) {
  console.log(nickname);
}
// 结果: di, boo, punkeye

for...in se usa para recorrer las propiedades de un objeto:

let nicknames = ['di', 'boo', 'punkeye'];
nicknames.size = 3;
for (let nickname in nicknames) {
  console.log(nickname);
}
Result: 0, 1, 2, size

11. Map y WeakMap

ES6 introduce dos nuevas estructuras de datos: Map y WeakMap. De hecho, cada objeto puede considerarse un Map.

Un objeto está compuesto por varios pares clave-valor. En un Map, cualquier tipo puede usarse como clave (key) del objeto, como por ejemplo:

var myMap = new Map();
 
var keyString = "a string",
    keyObj = {},
    keyFunc = function () {};
 
// 设置值
myMap.set(keyString, "value 与 'a string' 关联");
myMap.set(keyObj, "value 与 keyObj 关联");
myMap.set(keyFunc, "value 与 keyFunc 关联");
 
myMap.size; // 3
 
// 获取值
myMap.get(keyString);    // "value 与 'a string' 关联"
myMap.get(keyObj);       // "value 与 keyObj 关联"
myMap.get(keyFunc);      // "value 与 keyFunc 关联"

WeakMap

WeakMap es un Map, con la diferencia de que todas sus claves son referencias débiles. Esto significa que los elementos de un WeakMap no se tienen en cuenta en la recolección de basura, por lo que no debes preocuparte por fugas de memoria al usarlo.

Otro punto a tener en cuenta es que todas las claves de un WeakMap deben ser objetos. Solo tiene cuatro métodos: delete(key), has(key), get(key) y set(key, val):

let w = new WeakMap();
w.set('a', 'b'); 
// Uncaught TypeError: Invalid value used as weak map key
 
var o1 = {},
    o2 = function(){},
    o3 = window;
 
w.set(o1, 37);
w.set(o2, "azerty");
w.set(o3, undefined);
 
w.get(o3); // undefined, because that is the set value
 
w.has(o1); // true
w.delete(o1);
w.has(o1); // false

12. Set y WeakSet

Un objeto Set es un conjunto de valores no repetidos; los valores duplicados se ignoran. Los tipos de valor pueden ser tipos primitivos y tipos de referencia:

let mySet = new Set([1, 1, 2, 2, 3, 3]);
mySet.size; // 3
mySet.has(1); // true
mySet.add('strings');
mySet.add({ a: 1, b:2 });

Se puede recorrer un objeto Set con forEach y for...of:

mySet.forEach((item) => {
  console.log(item);
    // 1
    // 2
    // 3
    // 'strings'
    // Object { a: 1, b: 2 }
});
 
for (let value of mySet) {
  console.log(value);
    // 1
    // 2
    // 3
    // 'strings'
    // Object { a: 1, b: 2 }
}

Set también tiene los métodos delete() y clear().

WeakSet

Similar a WeakMap, el objeto WeakSet te permite almacenar referencias débiles de objetos en una colección. Los objetos en un WeakSet solo pueden aparecer una vez:

var ws = new WeakSet();
var obj = {};
var foo = {};
 
ws.add(window);
ws.add(obj);
 
ws.has(window); // true
ws.has(foo);    // false, foo 没有添加成功
 
ws.delete(window); // 从结合中删除 window 对象
ws.has(window);    // false, window 对象已经被删除

13. Clases

ES6 tiene la sintaxis class. Cabe destacar que class aquí no es un nuevo modelo de herencia de objetos, sino una forma de azúcar sintáctico sobre la cadena de prototipos.

Se usa la palabra clave static para definir métodos y propiedades del constructor:

class Task {
  constructor() {
    console.log("task instantiated!");
  }
 
  showId() {
    console.log(23);
  }
 
  static loadAll() {
    console.log("Loading all tasks..");
  }
}
 
console.log(typeof Task); // function
let task = new Task(); // "task instantiated!"
task.showId(); // 23
Task.loadAll(); // "Loading all tasks.."

Herencia y superclase en las clases:

class Car {
  constructor() {
    console.log("Creating a new car");
  }
}
 
class Porsche extends Car {
  constructor() {
    super();
    console.log("Creating Porsche");
  }
}
 
let c = new Porsche();
// Creating a new car
// Creating Porsche

extends permite que una subclase herede de la clase padre. Ten en cuenta que en el constructor de la subclase es necesario ejecutar super().

Por supuesto, también puedes llamar a los métodos de la clase padre desde los métodos de la subclase, como super.parentMethodName().

Lee más sobre las clases aquí.

Hay algunos puntos que vale la pena señalar:

  • Las declaraciones de clases no se elevan (hoisting). Si quieres usar una clase, debes definirla antes de usarla; de lo contrario, se lanzará un error ReferenceError.
  • Para definir funciones dentro de una clase no se necesita la palabra clave function.

14. Symbol

Symbol es un nuevo tipo de datos cuyo valor es único e inmutable. El propósito de introducir symbol en ES6 es generar un identificador único, aunque no puedes acceder a ese identificador:

var sym = Symbol( "some optional description" );
console.log(typeof sym); // symbol

Nota: no se puede usar el operador new delante de Symbol.

Si se usa como propiedad de un objeto, esta propiedad no será enumerable:

var o = {
    val: 10,
    [ Symbol("random") ]: "I'm a symbol",
};
 
console.log(Object.getOwnPropertyNames(o)); // val

Para obtener las propiedades symbol de un objeto, es necesario usar Object.getOwnPropertySymbols(o).

15. Iteradores (Iterators)

Los iteradores permiten acceder a un elemento de una colección de datos a la vez. Cuando el puntero apunta al último elemento de la colección, el iterador finaliza. Proporciona la función next() para recorrer una secuencia; este método devuelve un objeto con las propiedades done y value.

En ES6, se puede establecer un iterador predeterminado para un objeto mediante Symbol.iterator. Cada vez que el objeto necesite ser recorrido, se ejecuta su método @@iterator para devolver un iterador que se usa para obtener valores.

Un array es por defecto un iterador:

var arr = [11,12,13];
var itr = arr[Symbol.iterator]();
 
itr.next(); // { value: 11, done: false }
itr.next(); // { value: 12, done: false }
itr.next(); // { value: 13, done: false }
 
itr.next(); // { value: undefined, done: true }

Puedes personalizar el iterador de un objeto mediante [Symbol.iterator]().

16. Generators

Las funciones Generator son una nueva característica de ES6; permiten que un objeto iterable devuelto por una función genere múltiples valores.

En su uso verás la sintaxis * y una nueva palabra clave yield:

function *infiniteNumbers() {
  var n = 1;
  while (true){
    yield n++;
  }
}
 
var numbers = infiniteNumbers(); // returns an iterable object
 
numbers.next(); // { value: 1, done: false }
numbers.next(); // { value: 2, done: false }
numbers.next(); // { value: 3, done: false }

Cada vez que se ejecuta yield, el valor devuelto se convierte en el siguiente valor del iterador.

17. Promises

ES6 tiene soporte nativo para Promise. Una Promise es un objeto que espera ser ejecutado de forma asíncrona; cuando termina su ejecución, su estado cambia a resolved o rejected.

var p = new Promise(function(resolve, reject) {  
  if (/* condition */) {
    // fulfilled successfully
    resolve(/* value */);  
  } else {
    // error, rejected
    reject(/* reason */);  
  }
});

Cada Promise tiene un método .then que acepta dos parámetros: el primero es un callback para manejar el estado resolved y el segundo para manejar el estado rejected:

p.then((val) => console.log("Promise Resolved", val),
       (err) => console.log("Promise Rejected", err));

Original: https://github.com/metagrover/ES6-for-humans

Traducción: http://www.barretlee.com/blog/2016/07/09/a-kickstarter-guide-to-writing-es6/

Traducido por Hermano Bigote