gistfile1.md

Scope chain

• Quand le code javascript est executé, un contexte d'execution est créé.
• Plusieurs contextes d'execution peuvent être empilés au cours de l'execution d'un programme.
• Le contexte d'execution peut être representé comme un object :

function add(num1, num2){
    return num1 + num2;
}

var result = add(5, 10);

var person = {
    name: "Nicholas",
    age: 30
};

function displayInfo(){
    var count = 5;
    with(person){  // ajoute l'objet global "person" au scope du contexte d'execution courant
        alert(name + " is " + age);
        alert("count is " + count);
    }
}

displayInfo();

//http://archive.oreilly.com/pub/a/server-administration/excerpts/even-faster-websites/writing-efficient-javascript.html

Déclaration de fonction vs Expression de fonction

En javascript il y a deux façon de définir une fonction, soit en la déclarant, soit en l'exprimant.

On déclare une function en utilisant directement le mot clé "function". Toute fonction déclarée doit être nommée.

//La fonction suivante se nomme "ma_fonction".
function ma_fonction(){
  console.log(arguments);
}

Exprimer une fonction c'est la définir sans passer par le mot clé directement par le mot clé "fonction", mais en insérant celui çi dans une expression plus large. La plupard du temps, on exprime une fonction en l'assignant à une variable.

//La fonction suivante n'est pas nommée.
var f = function(){
  console.log(arguments);
}

//on exprime la même fonction en la nommant
var f = ma_fonction(){
  console.log(arguments);
}

La remontée de variable

Au moment de la création d'un contexte d'éxécution, les déclarations de fonction et de variables ( donc les fonctions déclarées et les variables ) sont remontées au début du scope ( hoisting/hoisted).

Seulement le contenu de la variable lui ne sera affecté lors de l'appel de la variable.

console.log(fonction_declaree);
console.log(fonction_declaree());

function fonction_declaree(){
    console.log(arguments.callee);
}

console.log(function_exprimee);

var function_exprimee =  function() {
    console.log(arguments.callee);
}

Pour toute définition d'une variable, il y a une déclaration de cette variable au début de sa portée et une affectation à l'endroit de sa définition

Immediately-Invoked Function Expression IIFE

Exprimer une fonction et la déclarée immédiatement.

(function() {
  var n = 1;
  console.log(n);
})();

console.log(n); // pas accessible hors du contexte de l'IIFE

//pas le droit de faire ça : 

function() {
  ...
}

// ... car toute fonction déclarée doit avoir un nom

var a = function() {
  ...
}()

var a = (function() {
  return {
        test: function(){ console.log(this);}
  }
})()

Portée des variable

function f(){    

    var x = 20;    

    console.log(x);
}

f();             // 20
console.log(x);  // 10

var x = 10;

function f(){    
    var y = 15;

    function g(){
        var z = 25;
        console.log(x+y+z);    
    }    
    g();
}

f(); // this displays 50

//http://odetocode.com/blogs/scott/archive/2007/07/10/closure-on-javascript-closures.aspx