JavaScript 功能继承（Functional Inheritance）与功能混合（Functional Mixins）实战指南

• 教程

本篇指南围绕 JS Tips 仓库中第 75 条提示（what-is-a-functional-inheritance）展开，系统讲解 JavaScript 中一种被低估的对象复用方式：功能继承（Functional Inheritance）。你将从定义、闭包私有数据、动态对象扩展三个维度理解其原理，并通过Animal/Cat的完整示例掌握编写与组合功能混合（Functional Mixins）的实战技能，进而与原型继承、new运算符等经典方案做横向对比，在合适的场景中做出更优设计决策。

什么是功能继承

功能继承（Functional Inheritance）是通过向对象实例应用一个"增强函数"（augmenting function）来继承特性的过程。它不依赖class、extends或prototype链，而是基于 JavaScript 的两个天然能力：

1. 闭包（Closure）：增强函数内部形成一个私有作用域，可以用来保存只有该对象"自己"知道的数据；
2. 动态对象扩展：在运行时向已存在的对象实例追加新的属性与方法。

原文档给出的核心定义如下：

Functional inheritance is the process of inheriting features by applying an augmenting function to an object instance. The function supplies a closure scope which you can use to keep some data private. The augmenting function uses dynamic object extension to extend the object instance with new properties and methods.

用一句话概括工作流：先创建一个基础对象，再通过调用一个或多个增强函数，把新能力"注入"到该对象上。这与"类—子类"的静态继承模型截然不同，继承发生在实例层面，而非类型层面。

基础示例：从 Animal 到 Cat

原文档提供了一个最小但完整的实现。我们先看基础构造函数：

// Base object constructor function function Animal(data) { var that = {}; // Create an empty object that.name = data.name; // Add it a "name" property return that; // Return the object };

注意这里没有任何new关键字，也没有this赋值。Animal只是一个工厂函数：它创建空对象、填充属性、显式返回该对象。这避免了new带来的隐性语义——仓库中另一条提示 Return Values with the 'new' Operator 详细分析了new的行为：当构造函数返回原始值时，会忽略返回值并返回this实例；而当返回对象等非原始值时，则会覆盖this实例。功能继承直接绕过这些规则，始终通过显式return控制产出，行为一目了然。

接下来定义"子对象"Cat，它继承并扩展Animal：

// Create a child object, inheriting from the base Animal function Cat(data) { // Create the Animal object var that = Animal(data); // Extend base object that.sayHello = function() { return 'Hello, I\'m ' + that.name; }; return that; }; // Usage var myCat = Cat({ name: 'Rufi' }); console.log(myCat.sayHello()); // Output: "Hello, I'm Rufi"

运行结果：

Hello, I'm Rufi

这段代码展示了功能继承的两个关键动作：

• 继承：Cat内部调用Animal(data)拿到一个已具备name属性的对象；
• 增强：通过that.sayHello = function() {...}在实例上动态追加方法。

由于Cat返回的正是扩展后的that，调用方拿到的是一个完整拥有name与sayHello的对象。

闭包：让数据真正私有

在上述Cat中，sayHello通过that.name读取数据。而功能继承更强大的用法，是利用闭包为对象保存调用者无法直接访问的私有数据。

回顾仓库中的 Closures inside loops 提示：闭包会捕获其词法作用域中的变量，函数即使在外层执行完毕后仍能访问这些变量。功能继承正是利用这一点——增强函数被调用时，其局部变量被闭包"记住"，而外部代码没有任何句柄能触及它们。

改写示例以展示私有状态：

function Counter(data) { var that = {}; var count = data.start || 0; // count 是闭包内的私有变量 that.get = function() { return count; }; that.increment = function() { count += 1; return that; }; // 返回 that 支持链式调用 that.decrement = function() { count -= 1; return that; }; return that; } var c = Counter({ start: 10 }); c.increment().increment(); console.log(c.get()); // 12 console.log(c.count); // undefined —— 外部无法访问私有变量

这里count只能通过get/increment/decrement三个闭包方法读写，外部读取c.count得到undefined。这与 Return objects to enable chaining of functions 提示中的思路一致——让方法返回对象本身以支持链式调用，同时结合闭包保证了状态的封装性。

动态对象扩展：继承发生在实例层面

功能继承中的"扩展"不需要修改任何类定义或原型对象，只需给实例追加属性：

var pet = Animal({ name: 'Tom' }); pet.meow = function() { return this.name + ' says meow'; };

由于 JavaScript 对象是动态的（参见仓库 Advanced Properties 提示对属性机制的讨论），这种追加不需要任何声明。多个增强函数可以先后作用于同一个实例，这就是下一节"功能混合"的组合基础。

从传递机制上看，这里还有一个容易被忽略的细节：Cat拿到的是Animal返回对象的引用。根据仓库提示 Know the passing mechanism，JavaScript 对对象采用"引用作为值传递"（call-by-sharing）——函数内直接修改传入对象的属性会反映到原对象上。因此Cat内部对that.name的读取以及追加sayHello的操作，都直接作用于Animal创建的那个对象实例，继承是"就地"完成的，而非复制。

功能混合（Functional Mixins）：像流水线一样组装对象

原文档随后给出一个关键概念：

Functional mixins are composable factory functions that add properties and behaviors to objects like stations in an assembly line.

功能混合（Functional Mixins）就是可组合的工厂函数，它们像装配流水线上的工位一样，逐个为对象添加属性和行为。核心模式是：每个 mixin 接收一个对象，返回增强后的对象；多个 mixin 依次调用，能力便逐层叠加。

// 每个 mixin 都是工厂函数：接收对象 -> 增强 -> 返回 function withName(obj, name) { obj.name = name; return obj; } function withGreeting(obj) { obj.sayHello = function() { return 'Hello, I\'m ' + this.name; }; return obj; } function withAge(obj, age) { obj.age = age; obj.getAge = function() { return this.age; }; return obj; } // 流水线式组装 var cat = withAge( withGreeting( withName({}, 'Rufi') ), 3 ); console.log(cat.sayHello()); // Hello, I'm Rufi console.log(cat.getAge()); // 3

也可以借助 IIFE（立即执行函数表达式，参见仓库 Using immediately invoked function expression 提示）将若干 mixin 合并为一个组装函数：

function Cat(data) { return (function(obj) { withName(obj, data.name); withGreeting(obj); withAge(obj, data.age); return obj; })({}); } var myCat = Cat({ name: 'Rufi', age: 3 }); myCat.sayHello(); // Hello, I'm Rufi

组合的关键约束是：mixin 的叠加顺序决定最终对象的行为。若两个 mixin 定义了同名方法，后应用者覆盖先应用者——这正是"流水线"比喻的准确之处。

与原型继承、new运算符的对比

功能继承与经典原型继承（prototype/class/extends）的差异，可通过下表概括：

new运算符的隐性规则在功能继承中完全不存在。正如 Return Values with the 'new' Operator 所揭示的：用new调用时，构造函数返回原始值会被忽略（返回this），返回对象则会"踩踏"（stomp）this实例。功能继承的工厂函数显式return that，行为可预期，不依赖new的魔法。

此外，功能继承中"子类"通过调用"父工厂"实现继承，这与柯里化（Currying，参见仓库 what-is-a-currying-function 提示）在思想上同源：都是通过函数层层包装、逐级组合来构造结果，而不是通过类型层级。

实战：私有状态 + 组合 + 链式调用的完整案例

综合以上所有要素，给出一个可运行的综合示例：

// 基础工厂 function Animal(data) { var that = {}; that.name = data.name; return that; } // 私有能量：闭包实现 function withEnergy(animal, level) { var energy = level || 100; // 私有变量 animal.getEnergy = function() { return energy; }; animal.run = function() { if (energy > 0) { energy -= 10; } return animal; // 链式调用 }; return animal; } // 组合两个能力 function Dog(data) { var that = Animal(data); withEnergy(that, data.energy); that.bark = function() { return that.name + ' barks!'; }; return that; } var dog = Dog({ name: 'Rex', energy: 50 }); dog.run().run(); console.log(dog.getEnergy()); // 30 —— 外部无法直接修改 energy console.log(dog.bark()); // Rex barks!

要点回顾：

• Animal提供基础数据；
• withEnergy以 mixin 形式注入带私有状态的run/getEnergy；
• Dog按流水线顺序组合基础工厂与 mixin，再追加自己的bark；
• 所有方法返回animal，支持链式调用（呼应 Return objects to enable chaining of functions）。

优缺点与适用场景

优点

• 实现简单直观，不依赖new、this、prototype等隐式机制，学习成本低；
• 闭包提供真正的数据私有性，无需命名约定（如_count）来"假装"私有；
• Mixin 天然可组合、可复用，适合横向能力注入（如日志、事件、校验）；
• 每个实例独立创建，状态隔离清晰，不受原型共享污染。

局限

• 每个实例都各自持有方法闭包，内存占用高于原型共享方法；
• 动态追加的属性无法通过instanceof判定"类型"（不存在类型层级）；
• 方法覆盖顺序依赖组合顺序，调用方需理解流水线语义；
• 与工具函数的序列化、深拷贝等操作配合时，闭包内私有状态不可枚举。

适用场景：需要为对象注入横向能力（mixin）、需要真正私有状态、或希望规避this/new语义陷阱的小型对象模型。对于需要大量实例、强类型层级和高性能方法的场景，原型继承仍更合适。

小结

功能继承的本质是**"增强函数 + 闭包 + 动态扩展"三者的组合**：增强函数接收并返回对象实例，闭包负责保存私有数据，动态扩展负责注入属性和方法。基于它演化出的功能混合（Functional Mixins）以工厂函数为单元，像流水线一样逐级组装对象能力，是 JavaScript 中一种简洁、灵活且无隐式魔法（new、this、prototype）的对象复用范式。当你需要可组合的横向能力注入或严格的私有状态时，它值得成为你工具箱中的第一选择。本文对应的原始文档位于 what-is-a-functional-inheritance，仓库中与之配套的闭包、传递机制、new运算符、链式调用与柯里化等提示（closures-inside-loops、know-the-passing-mechanism、return-values-with-the-new-operator）可帮助你继续深入底层原理。

• 教程