~ Contribute

Suggest a correction or improvement. The author reviews it before it goes live.

Comment0 / 300

en/tutorials/js/11js-scope-closures

# JavaScript Scope & Closures

Scope determines where variables are accessible. Closures let functions remember their creation environment.

## What Is Scope?

```javascript
let globalVar = "I am global";

function example() {
  let localVar = "I am local";
  console.log(globalVar); // accessible
  console.log(localVar);  // accessible
}

example();
// console.log(localVar); // Error
```

**Remember:** Variables are only accessible within their scope.

## Function vs Block Scope

```javascript
// Function scope — var leaks out
for (var j = 0; j < 3; j++) {}
console.log(j); // 3

// Block scope — let stays inside
for (let i = 0; i < 3; i++) {}
console.log(i); // Error: i is not defined
```

**Tip:** Always use `let` and `const` instead of `var`.

## Closures

A closure is a function that remembers its outer scope:

```javascript
function createCounter() {
  let count = 0;
  return function() {
    count++;
    return count;
  };
}

let counter = createCounter();
counter(); // 1
counter(); // 2
counter(); // 3
```

**Remember:** The inner function retains access to `count` even after `createCounter()` returns.

## Practical Closures: Data Privacy

```javascript
function createUser(name) {
  let _name = name;
  return {
    getName() { return _name; },
    setName(newName) { _name = newName; }
  };
}

let user = createUser("John");
user.getName();  // "John"
user.setName("Jane");
user.getName();  // "Jane"
```

## Complete Example: Memoization

```javascript
function memoize(fn) {
  let cache = {};
  return function(...args) {
    let key = JSON.stringify(args);
    if (key in cache) return cache[key];
    let result = fn(...args);
    cache[key] = result;
    return result;
  };
}

let square = memoize((n) => n * n);
square(5); // 25 (computed)
square(5); // 25 (cached)
```

## Best Practices

1. **Use `let` and `const`** — for block-scoped variables
2. **Minimize global scope** — wrap code in modules
3. **Use closures for privacy** — hide internal state
4. **Avoid closures in loops** — can cause unexpected behavior

## Common Mistakes

1. **Using `var` in loops** — leads to scoping bugs
2. **Closures in loops** — all closures reference the same variable
3. **Memory leaks** — closures holding references to large objects
4. **Overusing globals** — causes naming conflicts

No changes yet

cancel