recommended elevation, online understanding is personal, you can refer to, but have their own understanding is the best.

I think the better answer is:

1. Closure conditions: a, outer function nesting inner function; b, inner function referencing variables in outer function; c, outer function returning inner function;
2, js garbage collection mechanism: when a variable is not referenced, it is recycled
3. When each function is declared, an active object containing variables within the scope of the function is generated

give a simple example to analyze:

function a() {
    var x = 1
    var y = 100
    console.log(y)
    yPP
    return function b() {
        console.log(xPP)
    }
}
var result= a() // 100
var result1 = a() // 100
-----------------------------
result() // 1
result() // 2

in the above example, when there is no closure, I destroy the function scope after I execute a, then x is also destroyed, so the result of two execution should be twice 1. But the second time is 2, which means that the internal x has not been destroyed, that is, the x in the scope of a function has been saved.

starts the analysis with the above three points: when the
a function is declared, an active object containing the variables within the scope of the a function is created, which can be called the local parameter x inside the aa,aa; when the
b function is declared, the x in aa is referenced; after the
a function is executed, the global variable result refers to the b function.
the garbage collection mechanism combined with JS, x references will not be destroyed, b references will not be destroyed, result is a global variable will not be destroyed, x can be retained, thus forming a closure. Because the y in aa is not referenced, it is destroyed.

above is my understanding. Finally, I can answer the application of closures. I won't answer them here. There are many

to sum up, the suggested answer is to add the above three points to the application

closures are functions that have access to variables in the scope of another function. The "JavaScript Advanced programming"

closure is a function nested function, and variables outside the function can be used inside the function.

A function that can access variables of an external function, for example:

function a(x){
      var z=3;
      function b(y){  // axz
          console.log(x+y+(PPz));
     }
    return b;
}

the first-level function calls the second-level function, and the second-level function accesses the first-level function lexical scope variable is called closure, and the simpler point is the function nest function

remember which book you read, and the best way to understand closures is to compare it with the concept of class :

• The class is the data with methods.
• closure is a method with data.

explanation: the closure is formed when the current function can access variables in other scopes.
function:
1. Expand the scope of variables
2. Prevent variables from being destroyed (garbage collection mechanism)

define function a , function b
satisfy:

• Variables within the scope of the function b are referenced in the scope of the function a . (a captures the free variable of b)
• The function a can be executed outside the scope of the function b . (the variable object of b cannot be destroyed normally)

forms a closure .
how to answer each person's expression, just mean it.

// 
function b(){
    var z = 3;
    function a(y){
        console.log(z + y);  // a  b z
    }
    return a;
}
var c = b();
c(1);  // a  b 

popularly speaking: there is a function in the function; further understanding: the wrapped function can access the variables of the wrapped function;

after looking at all the answers, everyone's understanding is the same, except for one thing: does the closure have to be accessed by the outside world?
the answer is: No!

function a(x){
      var z=3;
      function b(y){  // axz
          console.log(x+y+(PPz));
     }
    return b;
}

is it still a closure to remove return?
the answer is: Yes!
it is both an internal function and a closure, and the two do not conflict.

definition of closures on mdn:

closure is a combination of a function and the lexical environment in which it is declared.

as long as it is satisfied, this is a function, which uses external variables inside, and it is a closure. The first example on
mdn:

function init() {
    var name = "Mozilla"; // name  init 
    function displayName() { // displayName() ,
        alert(name); // 
    }
    displayName();
}
init();

because the diaplayName cannot be accessed again, the name in the closure is also recycled.
by definition, displayName is a closure, although it has no use for eggs.

-split line--

in addition, by definition, any function can be a closure in a broad sense, because external references in the lexical environment may be empty.
so if the interviewer asks you about closures, I suggest you ask him first whether to answer the definition of closures or most practices, in a narrow sense or in a broad sense.

I think this is not bad. I don't quite understand closures either. https://codeshelper.com/a/11...

• closures have been used by many people from the beginning to the end, but they are not recommended until now, which will cause logic confusion

function nesting function