JavaScript函数与对象基础：构建模块化代码的第一步

一、代码失控的起点：平铺全局状态

初学JavaScript时，最容易写出的代码形态是“平铺式逻辑”：在脚本顶部声明一批变量，随后写若干条直接对这些变量进行赋值或计算的语句。在页面简单、仅有几十行脚本时，这种写法能迅速看到效果；然而一旦业务扩展，这种无序性会立即转化为代码缺陷。

请看下面这段典型的未经模块化处理的代码：

// 散落在全局的购物车相关变量
let cartTotal = 0;
let discountRate = 0.9;
let itemsCount = 0;

// 另一处可能由其他业务模块引入的变量（无意冲突）
let discountRate = 0.85; // 语法报错或意外覆盖原有逻辑

function calculatePrice(price) {
  cartTotal += price * discountRate;
  itemsCount++;
}

这段代码暴露了两个根本性隐患：一是变量直接暴露在全局执行环境，任何后续加载的第三方脚本或其他业务逻辑都可以直接读写甚至覆盖它们；二是状态变更缺乏访问控制，任何地方都能执行 cartTotal = -100，破坏数据的完整性。

二、函数：建立隔离边界与行为契约

模块化的核心前提是作用域隔离。在JavaScript中，函数天然具备创建局部作用域的能力。声明在函数内部的变量，其生命周期和可见范围默认被限制在函数调用栈内，外部环境无法直接穿透访问。

通过函数构建良好模块化构件的关键原则，是把函数当作明确的“行为契约”：优先依赖形参输入，通过返回值输出结果，尽量避免在函数体内部读取或修改外部非局部变量（即控制副作用）。

// 纯粹的计算函数：不修改外部状态，输入相同则输出必定相同
function applyDiscount(price, rate) {
  // 参数防御性校验
  if (typeof price !== 'number' || price < 0) {
    throw new TypeError('价格必须为非负数值');
  }
  const effectiveRate = (rate >= 0 && rate <= 1) ? rate : 1;
  return Number((price * effectiveRate).toFixed(2));
}

// 外部使用：通过参数传递输入，通过变量接收返回值
const finalPrice = applyDiscount(199.9, 0.85);

当一段计算过程被收敛进 applyDiscount 之后，调用方无需了解函数内部是如何做数值保留和舍入的，只需要关注输入什么参数、得到什么结果。这不仅方便代码测试，更为后续代码组合奠定了干净的基础。

三、对象：将散落状态与操作组织成实体

仅有函数还不够。如果在处理复杂业务时，每次调用函数都需要把七八个零散变量作为参数传递，代码依然会变得冗长且脆弱。这时需要使用对象（Object）将相关联的数据与处理它们的方法打包在一起。

从散落代码重构为对象，通常包含四个严谨的操作步骤：

1. 识别关联数据：梳理当前场景下必须协同变化的变量，例如商品的名称、单价、库存数量。
2. 聚合为对象属性：建立对象字面量，将散乱变量转化为对象的键值对属性，形成统一的命名空间。
3. 挂载操作方法：将专用于处理该对象数据的函数移入对象中，使其作为对象的方法存在。
4. 绑定上下文访问：在方法内部通过 this 访问自身属性，形成“数据与行为自洽”的实体。

按照上述步骤重构的代码如下：

// 聚合后的单一业务对象
const productItem = {
  id: 'P-1002',
  title: 'JavaScript核心指南',
  price: 59.00,
  stock: 20,

  // 对象方法：直接操作内部属性
  sell(quantity) {
    if (quantity <= 0) {
      console.warn('购买数量必须大于0');
      return false;
    }
    if (quantity > this.stock) {
      console.warn('库存不足');
      return false;
    }
    this.stock -= quantity;
    return Number((quantity * this.price).toFixed(2));
  }
};

// 使用方式：语义清晰且不再污染全局
const cost = productItem.sell(2); // 返回 118.00，productItem.stock 变为 18

四、结合进阶：用工厂函数与闭包构建轻量模块

直接定义对象字面量虽然解决了变量散落问题，但在实际工程中仍然存在一个局限：对象中的属性默认是完全公开的。在前面的例子中，外部代码依然可以直接执行 productItem.stock = -999，绕过了方法中的校验规则。

要构建真正健壮的模块，需要将函数的闭包特性与对象的方法暴露相结合，这就是经典的“工厂函数模块模式”。该模式通过函数创建私有作用域，保存不可被外部直接篡改的内部状态，最后仅返回一个包含操作接口的对象。

/**
 * 购物车模块工厂
 * @param {number} initialDiscount 初始折扣率 (0-1)
 * @returns {Object} 暴露的公共操作API
 */
function createCart(initialDiscount = 1) {
  // 1. 私有状态：外部代码无法直接读取或修改
  let items = [];
  let discount = initialDiscount;

  // 2. 私有辅助函数：仅供内部逻辑调用
  function calculateSubtotal() {
    return items.reduce((sum, item) => sum + item.price * item.quantity, 0);
  }

  // 3. 返回公开接口对象 (Public API)
  return {
    addItem(name, price, quantity = 1) {
      if (price <= 0 || quantity <= 0) {
        throw new Error('商品单价和数量必须大于0');
      }
      items.push({ name, price, quantity });
    },
    
    getItemsCount() {
      return items.reduce((count, item) => count + item.quantity, 0);
    },

    getTotalPrice() {
      const subtotal = calculateSubtotal();
      return Number((subtotal * discount).toFixed(2));
    }
  };
}

// 实例化并使用模块
const myCart = createCart(0.9);
myCart.addItem('设计模式精讲', 68.0, 2);

console.log(myCart.getTotalPrice()); // 输出: 122.4 (68 * 2 * 0.9)
console.log(myCart.items);          // 输出: undefined (无法越权直接修改私有数组)

五、总结：迈向现代模块化的进阶基石

理解函数对作用域的划定，以及对象对状态与行为的组织，是掌握JavaScript程序设计的核心分水岭。即使在广泛使用 import 与 export 的现代ES模块规范中，文件模块的本质依然是将当前文件视作一个独立的函数作用域，并通过暴露对象或函数导出公开接口。