计算机语言中的变量遮蔽（Shadowing）

2026年08月01日星期六

在编程语言里，遮蔽（Shadowing）指的是这么一种情况：在内层作用域中声明了一个与外层作用域同名的标识符（变量、函数、参数等），导致外层的那个标识符在当前作用域内暂时“看不见”了。

核心机制

外层作用域:  let x = 10
                ↓
内层作用域:  let x = 20  ← 外层的x被遮蔽了
                ↓
           在内层访问x，得到的是20，而非10

要注意的是，遮蔽不是覆盖。外层的变量本身并没有被修改，只是暂时“隐身”了。一旦离开内层作用域，外层变量又恢复可见。

典型示例

JavaScript

let name = "全局";

function greet() {
    let name = "局部";  // 遮蔽了外层的name
    console.log(name);   // "局部"
}

greet();
console.log(name);       // "全局"，外层完好无损

Python

x = 100

def foo():
    x = 200      # 这里创建了一个新的局部变量x，遮蔽了全局的x
    print(x)     # 200

foo()
print(x)         # 100

这里要注意的是，Python中如果写x = 200，会创建局部变量。但如果只是读取外层变量，Python是允许直接访问的（LEGB规则）。如果既想修改又想引用外层变量，就需要用global或nonlocal。

Rust（对Shadowing特别友好）

let x = 5;
let x = x + 1;   // 合法！这里不是修改变量，而是创建了一个同名的新绑定
let x = x * 2;   // 再次遮蔽
println!("{x}"); // 12

Rust甚至允许用不同类型的值来遮蔽：

let spaces = "   ";      // &str
let spaces = spaces.len(); // usize，同名但不同类型

Java

class Example {
    int value = 10;  // 字段

    void method(int value) {  // 参数遮蔽了字段
        System.out.println(value);      // 传入的参数值
        System.out.println(this.value); // 10，用this突破遮蔽
    }
}

遮蔽、覆盖和重定义

这几个概念容易混淆，对比一下就清楚了：

概念	发生场景	本质
遮蔽（Shadowing）	不同作用域，同名变量/参数	内层标识符隐藏了外层标识符
覆盖（Overriding）	子类重写父类方法	运行时多态，替换父类行为
重定义（Redefinition）	同一作用域内重复声明	通常是语法错误（C/C++部分场景除外）

为什么要允许遮蔽？

避免命名污染。内层逻辑不需要关心外层用了什么名字，可以安心使用简洁的变量名，比如i、x、tmp。
类型转换的便利。比如Rust中let s = "text"; let s = s.len();，可以在不改变变量名的情况下转换类型。
函数参数的直观性。方法参数与字段同名（this.name = name）是常见且可读性强的写法。

潜在陷阱

意外遮蔽导致Bug

let user = { name: "Alice" };

if (true) {
    let user = null;  // 不小心遮蔽了，后续代码可能误以为外层的user变了
}

闭包中的“经典陷阱”（不算严格的遮蔽，但相关）

for (var i = 0; i < 3; i++) {
    setTimeout(() => console.log(i), 100);  // 输出3, 3, 3
}
// 用let替代var后，每次迭代有自己的块级作用域，避免了这个问题

遮蔽链过长导致困惑

let a = 1;
{
    let a = 2;
    {
        let a = 3;
        {
            let a = 4;
            // 此时到底是哪个a？需要向上追溯多层，可读性极差
        }
    }
}

不同语言的态度

语言	对遮蔽的态度
Rust	鼓励，视为惯用法
JavaScript/TypeScript	支持，块级作用域（`let`/`const`）引入后更常见
Python	支持函数级遮蔽，但没有块级作用域（`if`/`for`内部赋值不形成新作用域）
C/C++	支持，但容易出错（比如`if (int x = ...) { int x = ...; }`）
Go	支持，但社区建议谨慎使用
Java	支持（字段被参数遮蔽很常见），编译器会警告未使用的遮蔽变量

总结

遮蔽是作用域系统的自然产物，它本身并不是坏事。好的遮蔽能简化代码，坏的遮蔽能隐藏Bug。

所以关键在于：遮蔽的时候保持作用域层级清晰，不要嵌套太深；需要同时访问内外层同名变量时，用语言提供的机制去突破遮蔽，比如this.x、nonlocal、global这些。另外，团队的代码规范里也可以对“无意义的遮蔽”加以限制，比如ESLint的no-shadow规则。

funcman's blog