Understanding Variable Scope and Closures in JavaScript and Python

Recently, while working on a timed log implementation in Node.js, I encountered an issue when trying to replicate the functionality in Python. This experience highlighted the differences in how JavaScript and Python handle variable scope within nested functions. Understanding these differences is crucial for any developer working with both languages. Let’s dive into the details.

JavaScript Closures

In JavaScript, closures are a powerful feature that allows functions to access variables from an enclosing scope. Or, to quote MSDN (emphasis mine):

A closure is the combination of a function bundled together (enclosed) with references to its surrounding state (the lexical environment). In other words, a closure gives you access to an outer function’s scope from an inner function. In JavaScript, closures are created every time a function is created, at function creation time.

Here’s an example:

const test = () => {
  let start = 0;
  return () => {
    start = start + 1;
    console.log("val", start);

const increment = test();
increment(); // val 1
increment(); // val 2

In this example, the test function returns another function that increments and logs the start variable. The inner function retains access to start even after test has finished executing. This is possible because of closures, which keep a reference to the variables in the outer function’s scope.

Python Closures

Python also supports closures, but the way it handles variable scope within nested functions is slightly different. Here’s a similar example in Python:

def test():
    start = 0
    def t():
        nonlocal start
        start = start + 1
        print("val", start)
    return t

increment = test()
increment()  # val 1
increment()  # val 2

Initially, the code may look similar, but there’s a crucial difference: the nonlocal keyword. In Python, variables defined in an enclosing scope (like start in the test function) are inaccessible by default within inner functions. To access such a variable, you must declare it as nonlocal.

Key Differences in default scope behavior

  • JavaScript: Inner functions can read and modify variables from the outer function’s scope without any additional declarations.
  • Python: You must use the nonlocal keyword in order to access variables from the enclosing scope within inner functions.

Practical Implications

Understanding these differences is crucial when translating code between JavaScript and Python or when working with both languages simultaneously. For instance, if you implement a timed log in Node.js and later decide to port it to a Python script, you need to adjust how you handle variable scope to ensure your code functions correctly.

Here’s an example scenario:

JavaScript Timed Log Implementation:

const logWithCount = () => {
  let count = 0;
  return () => {
    console.log("Log count:", count);

const logger = logWithCount();
while (true) {

Python Equivalent:

import time

def log_with_count():
    count = 0
    def logger():
        nonlocal count
        count += 1
        print("Log count:", count)
    return logger

logger = log_with_count()
while True:

In both implementations, the closure retains access to the count variable, allowing it to increment and log correctly at each interval.

By understanding and leveraging the nuances of variable scope and closures in both JavaScript and Python, you can write more effective and bug-free code.

Feel free to share your thoughts on variable scope and closures in JavaScript and Python. How have these concepts impacted your coding practices? I’d love to hear your insights and experiences!