The best thing that JavaScript ever got was closures. A function in JavaScript has access to any variables defined in the outer scope. Closures are best explained with examples:

function outerFunction(arg) {
    var variableInOuterFunction = arg;

    function bar() {
        console.log(variableInOuterFunction); // Access a variable from the outer scope

    // Call the local function to demonstrate that it has access to arg

outerFunction("hello closure"); // logs hello closure!

You can see that the inner function has access to a variable (variableInOuterFunction) from the outer scope. The variables in the outer function have been closed by (or bound in) the inner function. Hence the term closure. The concept in itself is simple enough and pretty intuitive.

Now the awesome part: The inner function can access the variables from the outer scope even after the outer function has returned. This is because the variables are still bound in the inner function and not dependent on the outer function. Again let's look at an example:

function outerFunction(arg) {
    var variableInOuterFunction = arg;
    return function() {

var innerFunction = outerFunction("hello closure!");

// Note the outerFunction has returned
innerFunction(); // logs hello closure!

Reason why it's awesome

It allows you to compose objects easily e.g. the revealing module pattern:

function createCounter() {
    let val = 0;
    return {
        increment() { val++ },
        getVal() { return val }

let counter = createCounter();
console.log(counter.getVal()); // 1
console.log(counter.getVal()); // 2

At a high level it is also what makes something like Node.js possible (don't worry if it doesn't click in your brain right now. It will eventually 🌹):

// Pseudo code to explain the concept
server.on(function handler(req, res) {
    loadData( {
        // the `res` has been closed over and is available

results matching ""

    No results matching ""