В чем смысл закрытия в javascript?

Question

см из Интернета

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

function a(){   
    var scope = "local scope"; 
    function f(){return scope;}  
    return f; 
} 
console.log(a()());//it can get the value 'local scope' 

мой вопрос, что это отличается с этим кодом

function a(){   
    var scope = "local scope"; 
    return scope; 
} 
console.log(a());//it can get the value 'local scope' too 

так какая смысл закрытия?

Зачем нужно возвращать значение путем обертывания function?

Answer 1

Вот возможное использование закрытия:

var getUid = function() { 
    var uid = 1; 
    return function() { 
     return uid++; 
    }; 
}; 

// invoke the wrapping function immediately 
// to create a single local scope 
getUid = getUid(); 

getUid(); // 1 
getUid(); // 2 
getUid(); // 3 

Как вы можете видеть, закрытие позволяет сохранить «UID» локальную переменную «живой» между вызовами функций. Его значение сохраняется в памяти, он является постоянным, в отличие от, когда нет внутренней функции:

var getUid = function() { 
    var uid = 1; 
    return uid++; 
}; 

getUid(); // 1 
getUid(); // 1 
getUid(); // 1 

Чтобы подвести итог, интересный материал о затворов является возможность сделать локальные переменные persistents.

В вашем примере есть что-то, что стоит заметить. Обратите внимание на то, что письмо a()() такое же, как написание (a())(). Это означает, что вы сначала вызываете функцию обертывания «a», , которая создает новую область, поэтому все внутри «a» полностью воссоздано.

Если вы продолжаете создавать новые области, таким образом, нет причин использовать закрытие. Действительно, делая это, вы теряете способность сохранять постоянные переменные между вызовами функций (как объяснялось выше). Давайте посмотрим, что произойдет с getUid(), если использовать этот способ:

var getUid = function() { 
    var uid = 1; 
    return function() { 
     return uid++; 
    }; 
}; 

getUid()(); // 1 
getUid()(); // 1 
getUid()(); // 1 

Тот же результат, как если бы не было никакой внутренней функции. Не очень полезно? Тем не менее, вы все равно можете воспользоваться вызовом функции оберточной несколько раз, если вам нужно создать несколько областей, но вы должны будете хранить внутренние функции в переменных:

var getUidA = getUid(); // scope A 
var getUidB = getUid(); // scope B 

getUidA(); // A 1 
getUidA(); // A 2 
getUidB(); // B 1 
getUidA(); // A 3 
getUidB(); // B 2 

Я не уверен, что есть намного больше скажем, об основах закрытия, прокомментируют программисты-программисты. В любом случае, если вы чувствуете готовность к головным болям, вас может заинтересовать то, что происходит на низком уровне в памяти: https://stackoverflow.com/a/31778897/1636522.

Answer 2

Для того, что закрытие прочитать это одно, лучше всего объяснить
JavaScript closures vs. anonymous functions

function a(){   
    var scope = "local scope"; 
    return scope; 
} 
console.log(a()); 

В этом случае вы можете вернуть только локальную переменную, вы не можете применить любую операцию на переменную, если вам нужна

function a(){   
    var scope = "local scope"; 
    function f(b){return scope + b;}  
    return f; 
} 
console.log(a()('found here')); 
console.log(a()(' not found here')); 

Но в этом случае вы можете манипулировать этими данными, если вам это нужно.

Я хочу сказать, что нам может понадобиться закрытие.