JavaScript 与 Python 变量作用域的隐式规则与显式声明机制对比 及 函数的作用域

变量作用域

• • JavaScript 局部变量由声明方式和作用域规则隐式划分，全局变量存在隐式声明（严格模式禁止）；
  • Python 局部变量默认隐式定义，但修改外部作用域变量需显式用 global/nonlocal 声明，避免歧义。

JavaScript

1. 局部变量

• 作用域规则：
  • var：函数作用域，声明在函数内任何位置（包括块中）都会提升到函数顶部。

    javascript
    
    function foo() {
      console.log(x); // undefined（变量提升）
      var x = 10;
    }

  • let/const：块级作用域，仅在声明所在的代码块内有效。

    javascript
    
    if (true) {
      let y = 20;
      const z = 30;
    }
    console.log(y); // 报错：y is not defined

• 隐式全局变量：
  • 非严格模式下，函数内未声明的赋值会创建全局变量（挂载到 globalThis）。

    javascript
    
    function bar() {
      undeclared = 100; // 非严格模式：隐式全局变量
    }
    bar();
    console.log(undeclared); // 100

  • 严格模式（'use strict'）下会直接报错：

    javascript
    
    'use strict';
    function strictBar() {
      undeclared = 100; // 报错：ReferenceError
    }

2. 全局变量

• 显式声明：
  • 顶层 var/let/const 声明，或直接赋值给 globalThis。

    javascript
    
    var globalVar1 = 10;
    let globalVar2 = 20;
    globalThis.globalVar3 = 30; // 通用方式（浏览器/Node.js）

• 隐式声明（非严格模式）：
  • 函数内未声明的赋值会泄漏为全局变量（不推荐，严格模式禁止）。

Python

1. 局部变量

• 隐式定义：
  • 函数内直接赋值的变量默认是局部变量，即使全局存在同名变量。

    python
    
    x = 10  # 全局变量
    def foo():
        x = 20  # 局部变量，与全局x无关
        print(x)  # 20
    foo()
    print(x)  # 10

• 作用域优先级：
  • 函数内优先访问局部变量，除非显式声明为全局或嵌套作用域变量。

2. 全局变量控制

• global 关键字：
  • 必须显式声明才能修改全局变量。

    python
    
    y = 10
    def bar():
        global y
        y = 20  # 修改全局变量
    bar()
    print(y)  # 20

  • 未声明时赋值会创建新的局部变量（与全局无关）：

    python
    
    z = 10
    def bad_bar():
        z = 20  # 局部变量，不影响全局
    bad_bar()
    print(z)  # 10

3. 嵌套作用域控制

• nonlocal 关键字：
  • 用于修改嵌套函数中外层函数的变量（非全局）。

    python
    
    def outer():
        outer_var = 10
        def inner():
            nonlocal outer_var
            outer_var = 20  # 修改外层变量
        inner()
        print(outer_var)  # 20
    outer()

  • 未声明时赋值会创建新的局部变量：

    python
    
    def bad_outer():
        outer_var = 10
        def bad_inner():
            outer_var = 20  # 局部变量，不影响外层
        bad_inner()
        print(outer_var)  # 10

核心差异总结

为什么这样设计？

1. JavaScript：
   • 早期设计受函数作用域（var）影响，后续通过 let/const 引入块级作用域以更灵活。
   • 隐式全局变量是历史遗留问题，严格模式已逐步淘汰。
2. Python：
   • 强调代码可读性，通过 global/nonlocal 显式声明避免意外行为。
   • 嵌套函数常见于装饰器等场景，nonlocal 明确变量来源。

最佳实践

• JavaScript：
  • 始终使用 let/const，避免 var 和隐式全局变量。
  • 严格模式（'use strict'）应作为默认。
• Python：
  • 避免过度使用全局变量，优先通过参数和返回值传递数据。
  • 嵌套函数中修改外层变量时，务必用 nonlocal 显式声明。

函数作用域

var a = 1;
var x = function () {
  console.log(a);
};

function f() {
  var a = 2;
  x();
}

f() // 1

a = 1  # 全局变量

def x():
    print(a)  # 引用声明时所在作用域的a

def f():
    a = 2  # 局部变量，与x的作用域无关
    x()    # 调用x

f()  # 输出：1（而非2）

def outer():
    a = 10  # outer的局部变量
    
    def inner():
        print(a)  # inner声明时处于outer作用域，绑定outer的a
    
    return inner

def wrapper():
    a = 20  # wrapper的局部变量
    func = outer()
    func()  # 调用inner，输出10（而非20）

wrapper()  # 输出：10