Я правильно понимаю закрытие JavaScript?

Question

Переменные, созданные внутри функции, не могут быть доступны вне функции.

Например, в:

function haha() 
{ 
    var a = 5; 
} 

а не может быть доступен снаружи Haha().

И где укупорочное пригождается:

function haha() 
{ 
    var a = 5; 
    return function hahainside(){ } 
} 
newfunction = hahainside(); 

Теперь, если я называю newfunction(), он может получить доступ к «а» переменной внутри Хаха().

Правильно ли я?

Мне также интересно, почему:

<script> 
    function exclusive() 
    { 
     d = "Robert, Ryo, Yuri"; 
     function returnfunction() { alert(d); } 
     return returnfunction(); 
    } 
    ryo = exclusive(); 
    alert(7); 
</script> 

Я тоже просто интересно, почему alert(7); не отображается на моем браузере.

Answer 1

Вот что вам нужно знать:

var a = 0; 
function haha(){ 
    a = 5; // when calling haha `a` is accessible to everything below where var is declared 
    return function(){ 
    a = 10; // same as notes above 
    } 
} 
var newfunc = haha(); // `a` will become 5 where var is declared 
newfunc(); // now `a` is 10 where var is declared 
console.log(a); // works 

Без var a объявлен вне haha:

function haha(){ 
    var a = 5; // only available in `haha` 
    return function(){ 
    a = 10; // nearly useless - only scoped to `haha` 
    } 
} 
var newfunc = haha(); // `a` will become 5 where var is declared 
newfunc(); // now `a` is 10 where var is declared - can't access `a` where `newfunc` is called 
console.log(a); // undefined 

Может быть, вы хотите Constructor:

function haha(arg){ 
    var whatever = 'something'; // never accessible in a new instance from outside 
    this.a = arg; 
    this.hahaInside = function(val){ 
    this.a = val; 
    } 
} 
var newfunc = new haha(20); // `newfunc.a` is now `20` 
newfunc.a = 12; // `newfunc.a` is now `12` 
newfunc.hahaInside(10); // newfunc.a is now 10 

В качестве объекта:

var haha = { 
    a: 5, 
    hahaInside: function(val){ 
    this.a = val; 
    } 
} 

В объекте нет частных переменных и нет аргументов конструктора. Вам не нужно вызывать новый экземпляр как объект, но вам может понадобиться новый экземпляр. Для того, чтобы избежать написания по ключевому слову this:

if(!Object.create){ 
    Object.create = function(o){ 
    function F(){} 
    F.prototype = o; 
    return new F; 
    } 
} 
var newfunc = Object.create(haha); // new 'newfunc` is a new instance of `haha` 

Реальное использование, нет окончания:

// assuming 3 radio buttons 
var ary = ['a', 'b', 'c'], radioButtons = document.getElementsByName('radButs'); 
var resultVar = ''; 
for(var i=0,l=radioButtons.length; i<l; i++){ 
    radioButtons[i].onclick = function(){ 
     resultVar = ary[i]; 
    } 
} 
// resultVar will always be `'c'` because by the time the click Event is called the loop has run all the through and the scope of `i` is global 

Затвор предотвращает переменную от того область действия выше. Global в этом случае:

// assuming 3 radio buttons 
var ary = ['a', 'b', 'c'], radioButtons = document.getElementsByName('radButs'); 
var resultVar = ''; 
for(var i=0,l=radioButtons.length; i<l; i++){ 
    (function(i){ 
    radioButtons[i].onclick = function(){ 
     resultVar = ary[i]; 
    } 
    })(i); 
} 
// now `resultVar` will be `'a'`, `'b'`, or `'c'` respectively, depending on the radio button that you clicked because `i` becomes separately scoped at each step of the loop even by the time the click Event is called due to user action 

Вы также можете использовать использовать замыкание для создания псевдо-статических функций, как это:

var count = (function(){ 
    var c = 0; 
    return function(){ 
    return c++; 
    } 
})(); 

Теперь каждый раз, когда вы звоните count() он будет делать именно это. Причина этого заключается в том, что функция self-executing вызывается немедленно, показывая в ней var c и возвращает неисполненную функцию, которая увеличивает c, где она была последней областью.