ECMAScript 6 est pratiquement devenu un standard de l'industrie. Il se répand beaucoup plus rapidement que ES5, principalement parce que les navigateurs modernes prennent en charge ES6 assez rapidement, en particulier Chrome et Firefox, qui prennent déjà en charge la grande majorité des fonctionnalités d'ES6.
1. let, const et portée de bloc
let permet la création d'une portée de bloc. ES6 recommande d'utiliser let pour définir des variables dans les fonctions au lieu de var :
var a = 2;
{
let a = 3;
console.log(a); // 3
}
console.log(a); // 2
Une autre façon de déclarer des variables, également valable dans une portée de bloc, est const, qui permet de déclarer une constante. Dans ES6, une constante déclarée avec const est similaire à un pointeur ; elle pointe vers une référence, ce qui signifie que cette "constante" n'est pas immuable. Par exemple :
{
const ARR = [5,6];
ARR.push(7);
console.log(ARR); // [5,6,7]
ARR = 10; // TypeError
}
Il y a plusieurs points à noter :
- Les variables déclarées avec le mot-clé let n'ont pas de caractéristiques de hoisting.
- Les déclarations avec let et const ne sont valides qu'au sein du bloc le plus proche (à l'intérieur des accolades).
- Lors de la déclaration avec le mot-clé constant const, utilisez des noms de variables en majuscules, tels que : CAPITAL_CASING
- const doit recevoir une valeur lors de sa déclaration.
2. Fonctions fléchées
Dans ES6, les fonctions fléchées sont une forme abrégée de fonctions. Les paramètres sont entourés de parenthèses, suivis de =>, puis du corps de la fonction :
var getPrice = function() {
return 4.55;
};
// Implementation with Arrow Function
var getPrice = () => 4.55;
Notez que la fonction fléchée getPrice dans l'exemple ci-dessus utilise un corps de fonction concis, qui ne nécessite pas d'instruction return. L'exemple ci-dessous utilise un corps de fonction normal :
let arr = ['apple', 'banana', 'orange'];
let breakfast = arr.map(fruit => {
return fruit + 's';
});
console.log(breakfast); // apples bananas oranges
Bien sûr, les fonctions fléchées ne rendent pas seulement le code concis ; le this dans une fonction est toujours lié à l'objet lui-même. Voici quelques exemples :
function Person() {
this.age = 0;
setInterval(function growUp() {
// 在非严格模式下,growUp() 函数的 this 指向 window 对象
this.age++;
}, 1000);
}
var person = new Person();
Nous avons souvent besoin d'utiliser une variable pour sauvegarder this, puis d'y faire référence dans la fonction growUp :
function Person() {
var self = this;
self.age = 0;
setInterval(function growUp() {
self.age++;
}, 1000);
}
L'utilisation de fonctions fléchées peut éviter ce problème :
function Person(){
this.age = 0;
setInterval(() => {
// |this| 指向 person 对象
this.age++;
}, 1000);
}
var person = new Person();
3. Valeurs par défaut pour les paramètres de fonction
ES6 vous permet de définir des valeurs par défaut pour les paramètres de fonction :
let getFinalPrice = (price, tax=0.7) => price + price * tax; getFinalPrice(500); // 850
4. Opérateur Spread / Rest
L'opérateur Spread / Rest fait référence à ..., et le fait qu'il soit Spread ou Rest dépend du contexte.
Lorsqu'il est utilisé dans un itérable, il s'agit d'un opérateur Spread :
function foo(x,y,z) {
console.log(x,y,z);
}
let arr = [1,2,3];
foo(...arr); // 1 2 3
Lorsqu'il est utilisé pour passer des arguments à une fonction, il s'agit d'un opérateur Rest :
function foo(...args) {
console.log(args);
}
foo( 1, 2, 3, 4, 5); // [1, 2, 3, 4, 5]
5. Extensions des littéraux d'objet
ES6 permet une syntaxe abrégée lors de la déclaration de littéraux d'objet pour initialiser des variables de propriété et définir des méthodes, et permet également des opérations calculées dans les propriétés d'objet :
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. Littéraux binaires et octaux
ES6 prend en charge les littéraux binaires et octaux. En préfixant un nombre avec 0o ou 0O, il peut être converti en valeur octale :
let oValue = 0o10; console.log(oValue); // 8 let bValue = 0b10; // 二进制使用 `0b` 或者 `0B` console.log(bValue); // 2
7. Déstructuration d'objets et de tableaux
La déstructuration peut éviter les variables intermédiaires lors de l'affectation des valeurs d'un objet :
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. Superclasse Object
ES6 permet d'utiliser la méthode super dans les objets :
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. Syntaxe des templates et délimiteurs
ES6 offre un moyen très concis d'assembler un ensemble de chaînes et de variables.
- ${ ... } est utilisé pour afficher une variable
- ` est utilisé comme délimiteur
let user = 'Barret';
console.log(`Hi ${user}!`); // Hi Barret!
10. for...of VS for...in
for...of est utilisé pour parcourir un itérable, comme un tableau :
let nicknames = ['di', 'boo', 'punkeye'];
nicknames.size = 3;
for (let nickname of nicknames) {
console.log(nickname);
}
// 结果: di, boo, punkeye
for...in est utilisé pour parcourir les propriétés d'un objet :
let nicknames = ['di', 'boo', 'punkeye'];
nicknames.size = 3;
for (let nickname in nicknames) {
console.log(nickname);
}
Result: 0, 1, 2, size
11. Map et WeakMap
ES6 dispose de deux nouvelles structures de données de type collection : Map et WeakMap. En fait, tout objet peut être considéré comme une Map.
Un objet est constitué de plusieurs paires clé-valeur. Dans une Map, n'importe quel type peut être utilisé comme clé d'un objet, par exemple :
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 est une Map, sauf que toutes ses clés sont des références faibles, ce qui signifie que les éléments dans WeakMap ne sont pas pris en compte lors du ramasse-miettes, vous n'avez donc pas à vous soucier des problèmes de fuite de mémoire lorsque vous l'utilisez.
Un autre point à noter est que toutes les clés de WeakMap doivent être des objets. Elle ne possède que quatre méthodes : delete(key), has(key), get(key) et 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 et WeakSet
Un objet Set est une collection de valeurs uniques. Les valeurs en double sont ignorées, et les types de valeurs peuvent être des types primitifs et des types de référence :
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 });
Vous pouvez parcourir un objet Set avec forEach et 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 possède également les méthodes delete() et clear().
WeakSet
Semblable à WeakMap, un objet WeakSet vous permet de stocker des références faibles à des objets dans une collection. Les objets dans WeakSet ne sont autorisés à apparaître qu'une seule fois :
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. Classes
ES6 dispose d'une syntaxe de classe. Il est à noter que class ici n'est pas un nouveau modèle d'héritage d'objet ; ce n'est qu'un sucre syntaxique pour la chaîne de prototypes.
Dans les fonctions, utilisez le mot-clé static pour définir les méthodes et les propriétés du constructeur :
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.."
Héritage et super dans les classes :
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 permet à une sous-classe d'hériter d'une classe parente. Notez que la fonction constructeur de la sous-classe doit exécuter la fonction super().
Bien sûr, vous pouvez aussi appeler des méthodes de la classe parente dans les méthodes de la sous-classe, telles que super.parentMethodName().
En savoir plus sur les classes ici.
Quelques points à noter :
- Les déclarations de classe ne sont pas hissées. Si vous voulez utiliser une certaine classe, vous devez la définir avant de l'utiliser, sinon une ReferenceError sera levée.
- Vous n'avez pas besoin d'utiliser le mot-clé function pour définir des fonctions dans une classe.
14. Symbol
Symbol est un nouveau type de données dont la valeur est unique et immuable. Le but de l'introduction de Symbol dans ES6 est de générer un identifiant unique, mais vous ne pouvez pas accéder à cet identifiant :
var sym = Symbol( "some optional description" ); console.log(typeof sym); // symbol
Notez que l'opérateur new ne peut pas être utilisé avant Symbol ici.
S'il est utilisé comme propriété d'un objet, alors cette propriété sera non énumérable :
var o = {
val: 10,
[ Symbol("random") ]: "I'm a symbol",
};
console.log(Object.getOwnPropertyNames(o)); // val
Pour obtenir les propriétés Symbol d'un objet, vous devez utiliser Object.getOwnPropertySymbols(o).
15. Itérateurs
Les itérateurs permettent d'accéder à un élément d'une collection de données à la fois. Lorsque le pointeur pointe vers le dernier élément de la collection de données, l'itérateur se termine. Il fournit une fonction next() pour parcourir une séquence, et cette méthode renvoie un objet contenant les propriétés done et value.
En ES6, vous pouvez définir un itérateur par défaut pour un objet via Symbol.iterator. Chaque fois qu'un objet doit être itéré, l'exécution de sa méthode @@iterator peut renvoyer un itérateur permettant d'obtenir des valeurs.
Un tableau est un itérateur par défaut :
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 }
Vous pouvez personnaliser un itérateur pour un objet via [Symbol.iterator]().
16. Générateurs
Les fonctions génératrices sont une nouvelle fonctionnalité d'ES6. Elles permettent à une fonction de renvoyer un objet itérable qui génère plusieurs valeurs.
À l'usage, vous verrez la syntaxe * et un nouveau mot-clé 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 }
Chaque fois que yield est exécuté, la valeur renvoyée devient la valeur suivante de l'itérateur.
17. Promesses
ES6 prend en charge nativement Promise. Une Promise est un objet en attente d'exécution asynchrone. Lorsqu'elle termine son exécution, son état devient resolved ou rejected.
var p = new Promise(function(resolve, reject) {
if (/* condition */) {
// fulfilled successfully
resolve(/* value */);
} else {
// error, rejected
reject(/* reason */);
}
});
Chaque Promise possède une méthode .then. Cette méthode accepte deux paramètres : le premier est une fonction de rappel pour gérer l'état resolved, et le second est une fonction de rappel pour gérer l'état rejected :
p.then((val) => console.log("Promise Resolved", val),
(err) => console.log("Promise Rejected", err));
Original : https://github.com/metagrover/ES6-for-humans
Traduction : http://www.barretlee.com/blog/2016/07/09/a-kickstarter-guide-to-writing-es6/
Traducteur/Petit frère barbu