前端的 Python 入门指南（四）：参数传递方式对比 - 值与引用传递 vs 可变不可变数据的优劣分析+副作用分析

《前端的 Python 入门指南》系列文章：

（一）：常用语法和关键字对比
（二）：函数的定义、参数、作用域对比
（三）：数据类型对比 - 彻底的一切皆对象实现和包装对象异同
（四）：参数传递方式对比 - 值与引用传递 vs 可变不可变数据
（五）：面向对象特性之继承实现的方式对比 - 基于原型链和基于类各有什么优缺点

在 JavaScript 和 Python 中，函数参数传递机制和数据的可变性是两个核心概念。它们对程序的行为和副作用产生了深远的影响。对于前端开发者来说，理解 Python 和 JavaScript 在 值传递与引用传递、可变与不可变数据 上的异同点，将有助于更高效地编写代码，避免潜在的副作用问题。

本文将探讨两种语言的参数传递机制，分析它们的优劣，以及如何利用这些机制编写高质量代码。

1. 值传递 vs 引用传递

什么是值传递和引用传递？

值传递：传递参数时，函数内部接收到的是参数的副本，对副本的修改不会影响原始数据。
引用传递：传递参数时，函数内部接收到的是原始对象的引用，对引用的修改会直接影响原始数据。

JavaScript 的参数传递机制

JavaScript 使用 按值传递 和 按共享引用传递：

原始类型（Primitive Types）：按值传递。

javascript">let x = 10;
function modify(val) {val = 20;  // 修改的是 val 的副本
}
modify(x);
console.log(x);  // 10，原始值不受影响

引用类型（Objects, Arrays）：按共享引用传递。

javascript">let obj = { key: "value" };
function modify(o) {o.key = "newValue";  // 修改原对象内容
}
modify(obj);
console.log(obj.key);  // "newValue"，原对象被修改

Python 的参数传递机制

Python 使用 “传对象引用”（Pass by Object Reference）：

传递的是对象的引用，但行为取决于对象的可变性：
- 不可变对象（如 int, str, tuple）：重新赋值不会影响原始数据。
- 可变对象（如 list, dict, set）：修改内容会影响原始数据。

不可变对象

python">x = 10
def modify(val):val = 20  # 重新赋值，不影响原始对象
modify(x)
print(x)  # 10

可变对象

python">obj = {"key": "value"}
def modify(o):o["key"] = "newValue"  # 修改对象内容
modify(obj)
print(obj["key"])  # "newValue"，原对象被修改

2. 可变与不可变数据

Python 的参数行为与对象的可变性密切相关，而 JavaScript 对原始类型和引用类型的处理也与数据结构的可变性息息相关。

可变对象的优劣

优点：

高效操作：无需复制整个对象即可修改内容。
灵活性高：可以直接在函数内部操作共享的数据。

缺点：

副作用问题：函数可能无意中改变原始数据，导致难以预测的行为。
不适合并发：多线程操作可变数据容易引发竞争条件（Race Condition）。

不可变对象的优劣

优点：

无副作用：函数无法改变原始数据，减少了不可预测的行为。
线程安全：在多线程或异步环境中，不可变数据更安全。
简化调试：不可变数据的状态更容易追踪。

缺点：

性能开销：每次修改数据都需要创建新的副本，尤其对大数据结构可能不够高效。
操作复杂：需要使用替代方法来模拟“修改”不可变对象。

3. 副作用对比：如何避免问题？

JavaScript 中的副作用与避免

常见副作用：

函数修改传入的对象，影响外部代码逻辑。
使用全局变量或对象的共享状态，导致难以调试的问题。

避免方法：

使用 Object.assign 或解构赋值创建副本：

javascript">let obj = { key: "value" };
function modify(o) {let newObj = { ...o, key: "newValue" };  // 创建副本return newObj;
}
console.log(modify(obj));  // 新对象
console.log(obj);  // 原对象未受影响

在函数中使用纯函数（无副作用）：

javascript">function add(a, b) {return a + b;  // 不修改任何外部数据
}

Python 中的副作用与避免

常见副作用：

函数内部修改了可变对象（如 list 或 dict），影响调用者的数据。
使用全局变量导致意外结果。

避免方法：

传递副本而非原始对象：

python">def modify(o):o = o.copy()  # 创建副本o["key"] = "newValue"return oobj = {"key": "value"}
new_obj = modify(obj)
print(new_obj)  # {"key": "newValue"}
print(obj)      # {"key": "value"}

尽量使用不可变对象：

python">def modify_tuple(t):return t + (42,)  # 创建新元组tpl = (1, 2, 3)
new_tpl = modify_tuple(tpl)
print(new_tpl)  # (1, 2, 3, 42)
print(tpl)      # (1, 2, 3)

封装全局变量访问：
使用函数参数或类来封装需要修改的状态，避免直接修改全局变量。

4. 两者的优劣对比

特性	JavaScript	Python
参数传递机制	原始类型按值传递，引用类型按共享引用传递	所有对象按引用传递，但行为取决于对象的可变性
副作用控制	倾向于直接修改引用类型，需显式创建副本避免副作用	使用可变对象可能导致副作用，不可变对象天然防止副作用
操作效率	修改引用类型时高效，但易出错	可变对象修改高效，不可变对象需要拷贝，性能略低
适用场景	适合需要快速迭代的场景，如动态 UI 更新	适合数据安全性要求高或多线程操作的场景

5. 总结与实践建议

理解语言特性：
- JavaScript 和 Python 在参数传递时都需要注意共享引用对原始数据的影响。
- Python 的行为与对象的可变性密切相关，而 JavaScript 需要明确区分原始类型和引用类型。
避免副作用：
- 在函数中修改共享对象可能会引发不可预期的问题，建议通过创建副本或使用不可变数据来减少副作用。
- 在 Python 中，优先考虑使用不可变数据（如 tuple）。
性能优化：
- 对大数据结构，使用可变对象修改内容更高效。
- 如果副本是必须的，尽量只复制必要的数据以减少性能开销。