simuler une boucle avec un itérateur

let a = ["d","e","n","i","s"];

for (let val, ret, it = a[Symbol.iterator]();
(ret = it.next()) && !ret.done;
) {
val = ret.value;
console.log( val );
}

"d" "e" "n" "i" "s"

l'opérateur ...

le comportement de l'opérateur ... dépend de comment et où il est utilisé.

spread	gathers
function fx(x,y,z) { console.log( x, y, z ); } fx( ...[1,2,3] );	function fx(x, y, ...z) { console.log( x, y, z ); } Fx( 1, 2, 3, 4, 5 );

portee

regardez la vidéo et tenter d'évaluer la valeur d'une expression.



Les deux codes suivants sont équivalents

ES2015	Before ES2015
let x = "G"; function f() {   console.log(x); } {   let x = "B";   console.log(`x = ${x}`);   f(); }	"use strict"; var x = "G"; function f() {   console.log(x); } {   var _x = "B";   console.log("x = " + _x);   f(); }

A la node.js

  
let map = function(input,callback){
let results = [],
handleIterationResult = function(error,result){
if (error) {callback(error); return;}
results.push(result);
if (results.length === input.length){
callback(null,results);
}
};
input.forEach(function(num){
sum(num,handleIterationResult);
});
};
let sum = function (num, callback){
callback(null, num + num);
};

map([2,4,1], function (error,result){
if (error) {console.error(error);return; };
console.log(result);
});

ES6

exemple de décomposition

Allez dans votre console et tapez :
const doc = document.documentElement;
const { clientWidth, clientHeight } = doc;
console.log( `la largeur de la fenêtre est : ${clientWidth} ` );

MAp en action

let tag = [];

explore = (node) => {
    for (let elt of node.children) {
            tag.push(elt.nodeName);
            explore(elt);
      }
    }

explore(document.body); //

getEleCnt = (arr) => {
      return arr.reduce(function(prev,next){
         prev.has(next) ? prev.set(next,prev.get(next) + 1) :prev.set(next,1);        
        return prev;
      },new Map());
    }
 
let allCntEle = getEleCnt(tag);

for(let [u, r] of allCntEle.entries())
console.log(`${u}: ${r}`);