Closure : one more !

Article

Vous pouvez commencer par lire un article général sur les closures : Article sur les closures

Code

Nous pouvons examiner trois exemples de code et le résultat dans le débogueur :

http://jsbin.com/xuqika/2/edit?html,js,console,output

function f(){
console.log(C);
}
f();
let C = "c";

A l'appel de la fonction C est inconnue !

{

let U = "je suis oubliée par la closure";

function f(){

   console.log(C);

}

let C = "c";

} // bloc

f();

A l'appel de la fonction C est connue. Or le bloc n'est plus accessible (on ne pourrait afficher U en dehors). Cela semble magique ... 

http://jsbin.com/xuqika/3/edit?html,js,console,output

La "closure" est intelligente (elle ne garde vraiment que les variables utiles)
http://jsbin.com/xuqika/3/edit?html,js,console

Historiquement, avant l'arrivée des blocs, nous pouvions générer une closure de la façon suivante :

function A() {
  let a = " a ";
  function B() {
    console.log (a);
  }
  return B;
}

let closure = A();
closure();

Le fermeture (closure) est constituée de la fonction B et de son environnement. Ainsi, l'exécution de la fonction closure permet d'atteindre la variable a.

Le comportement est surprenant car : 
When you declare a variable in a function, you can access this variable only within the function. You can't get this variable once you get out of it.

Voici la vue du débogger.

JS Bin on jsbin.com

map

const liste = [
{age:10,arg:2,exp:2},
{age:1,arg:1},
{age:100,arg:3},
];

function AgeArg({arg,age}){
  return age*arg;
}

let T = liste.map(AgeArg);

console.log(T);

reduce : destructuring

const liste = [
{age:10,arg:2,exp:2},
{age:1,arg:1},
{age:100,arg:3},
];

function AgeArg(acc,{arg,age}){
  return acc+ age*arg;
}

let T = liste.reduce(AgeArg,0);

console.log(T); //321

for_of

const liste = [
{age:10,arg:2,exp:2},
{age:1,arg:1},
{age:100,arg:3},
];

for_of

classique

for (l of liste){
console.log(l.age)
}

destructuring

for ({arg,age} of liste){
console.log(arg*age)
}

foreach array of objet

const liste = [
{age:10,arg:2,exp:2},
{age:1,arg:1},
{age:100,arg:3},
];

forEach

classique

liste.forEach(function(v,i){
console.log(v.arg)
})

arrow

liste.forEach((v,i)=>{
console.log(v.arg)
})

destructuring

liste.forEach(({age,arg},i)=>{
console.log(arg*age)
})

array Random

Array.from({length: Math.random()*9}, (v, k) => k);

Ne pas utiliser V = value qui n'est pas définie