# 扩展已有类型的操作：扩展与辅助设计

学习目标：对比不同语言在不修改原有类型源码的前提下扩展行为的设计取舍，理解扩展函数、Extension Trait 与自由工具函数的边界。

前置知识与范围：字符串操作与模块作用域。以扩展判断字符串是否全为空白（is_blank）为例，演示外部能力挂载。

# 问题与边界

为现有的字符串类型提供一个非空与空白判断能力 is_blank：

判断契约：若字符串为空字符串 ""，或仅由 ASCII 空白字符（空格、制表符等）构成，返回 true；若包含至少一个可见字符（如 " app "），返回 false。
约束条件：标准库字符串类型不允许被二次修改，禁止通过破坏全局原型或猴子补丁（Monkey Patching）污染运行环境。

测试用例：

"" -> true
" " -> true
" app " -> false

# 关键差异

语言	语法形态	作用域与污染控制	底层实现本质
Rust	Extension Trait 模式：`impl StrExt for str`	严格局部作用域控制（只有 `use` 该 trait 时才可见）	静态分派泛型调用
Go	显式独立包函数 `IsBlank(s)`	无猴子补丁能力，严格包级隔离	纯函数显式传参
Java	静态工具类 `StringUtils.isBlank(s)`	静态导入使用	静态辅助方法
JavaScript	独立纯函数 `isBlank(s)`	禁止修改 `String.prototype`	外部函数接收参数
TypeScript	独立纯函数或模块声明合并（Module Augmentation）	需谨慎使用全局接口扩展	编译期类型扩展或独立函数
Kotlin	原生扩展函数 `fun String.isBlankStr()`	文件/包级作用域导入	编译为静态方法，语法糖支持点号调用
Python	独立模块函数 `is_blank(s)`	CPython 拦截对内置 `str` 的动态挂载	模块函数传参
C++	自由函数 `is_blank(std::string_view)`	命名空间（Namespace）隔离与 ADL 查找	自由非成员函数

# 各语言实现

# Rust

Rust// 定义扩展 Trait
trait StrExt {
    fn is_blank(&self) -> bool;
}

// 为原生的 str 切片类型实现该扩展 Trait
impl StrExt for str {
    fn is_blank(&self) -> bool {
        self.trim().is_empty()
    }
}

fn main() {
    assert!("".is_blank());
    assert!("   ".is_blank());
    assert!(!" app ".is_blank());

    println!("is_blank: {}", "   ".is_blank());
}

Rust 的 Extension Trait 极其优雅：只有显式导入了该 Trait 的模块才能调用 is_blank，避免了无节制的全局名字冲突。

# Go

Gopackage main

import (
	"fmt"
	"strings"
)

// Go 拒绝向外部类型挂载方法，倡导清晰可见的独立包函数
func IsBlank(s string) bool {
	return len(strings.TrimSpace(s)) == 0
}

func main() {
	if !IsBlank("") || !IsBlank("   ") || IsBlank(" app ") {
		panic("mismatch")
	}

	fmt.Printf("is_blank: %t\n", IsBlank("   "))
}

Go 语言故意不提供扩展方法语法，要求代码必须通过明确的 package.Function(arg) 形式调用。

# Java

Javapublic class Main {
    // 经典的 Java 静态工具类模式
    public static final class StringUtils {
        private StringUtils() {}

        public static boolean isBlank(String s) {
            return s == null || s.trim().isEmpty();
        }
    }

    public static void main(String[] args) {
        assert StringUtils.isBlank("");
        assert StringUtils.isBlank("   ");
        assert !StringUtils.isBlank(" app ");

        System.out.println("is_blank: " + StringUtils.isBlank("   "));
    }
}

在 Java 语言中，类似 Apache Commons 的静态工具类（Utils）是为已有类补充能力的工业规范。

# JavaScript

JavaScriptconst assert = {
  equal: (a, b) => { if (a !== b) throw new Error(`${a} !== ${b}`); },
  deepEqual: (a, b) => { if (JSON.stringify(a) !== JSON.stringify(b)) throw new Error(`${JSON.stringify(a)} !== ${JSON.stringify(b)}`); },
  throws: (fn, errType) => {
    try { fn(); throw new Error("expected throw"); } catch (e) {
      if (e.message === "expected throw") throw e;
      if (errType && !(e instanceof errType)) throw e;
    }
  }
};

// 规范工程实践：使用独立纯函数，绝不污染 String.prototype
function isBlank(s) {
  return typeof s === "string" && s.trim().length === 0;
}

assert.equal(isBlank(""), true);
assert.equal(isBlank("   "), true);
assert.equal(isBlank(" app "), false);

console.log(`is_blank: ${isBlank("   ")}`);

严禁向全局 String.prototype 注入自定义属性。若两个第三方库注入了同名但行为细微不同的方法，会引发严重的全局隐蔽破坏。

# TypeScript

TypeScriptconst assert = {
  equal: (a: unknown, b: unknown) => { if (a !== b) throw new Error(`${a} !== ${b}`); },
  deepEqual: (a: unknown, b: unknown) => { if (JSON.stringify(a) !== JSON.stringify(b)) throw new Error(`${JSON.stringify(a)} !== ${JSON.stringify(b)}`); },
  throws: (fn: () => void, errType?: unknown) => {
    try { fn(); throw new Error("expected throw"); } catch (e: unknown) {
      if (e instanceof Error && e.message === "expected throw") throw e;
      if (typeof errType === "function" && !(e instanceof errType)) throw e;
    }
  }
};

function isBlank(s: string): boolean {
  return s.trim().length === 0;
}

assert.equal(isBlank(""), true);
assert.equal(isBlank("   "), true);
assert.equal(isBlank(" app "), false);

console.log(`is_blank: ${isBlank("   ")}`);

TypeScript 推荐使用纯函数加类型守卫，保持代码的高可测性与可移植性。

# Kotlin

Kotlin// 原生扩展函数：使 String 获得点号调用能力
fun String.isBlankStr(): Boolean {
    return this.trim().isEmpty()
}

fun main() {
    check("".isBlankStr())
    check("   ".isBlankStr())
    check(!" app ".isBlankStr())

    println("is_blank: ${"   ".isBlankStr()}")
}

Kotlin 的扩展函数是静态解析的（Static Dispatch），本质在字节码层被编译为以原对象为首参数的静态方法，兼具了流畅度与零运行时侵入。

# Python

Pythondef is_blank(s: str) -> bool:
    return len(s.strip()) == 0

if __name__ == "__main__":
    assert is_blank("") is True
    assert is_blank("   ") is True
    assert is_blank(" app ") is False

    print(f"is_blank: {is_blank('   ')}")

CPython 内部对内置不可变类型（如 str）实现了 C 级锁定，尝试给 str.is_blank = ... 会直接抛出 TypeError: can't set attributes on built-in/extension type。

# C++

C++#include <iostream>
#include <string_view>
#include <cctype>
#include <algorithm>
#include <cassert>

bool is_blank(std::string_view s) {
    return std::all_of(s.begin(), s.end(), [](unsigned char c) {
        return std::isspace(c);
    });
}

int main() {
    assert(is_blank(""));
    assert(is_blank("   "));
    assert(!is_blank(" app "));

    std::cout << std::boolalpha << "is_blank: " << is_blank("   ") << "\n";
}

C++ 依靠自由非成员函数和命名空间来组织针对已有数据类型的操作算法库（如 <algorithm> 体系）。

# 迁移误区与适用限制

原型污染与猴子补丁的恶果：在动态语言中强行修改内置全局对象原型，容易与后续语言版本推出的同名官方 API 发生冲突破坏（破坏 Web 兼容性）。
扩展函数的多态误区：Kotlin 的扩展函数在编译期静态分派，若子类中也定义了同名扩展，调用哪个版本取决于引用的声明类型而非运行时的动态类型。

# 运行与验证

语言版本基线见示例基线。所有程序运行后控制台输出均为：

纯文本is_blank: true

空串、纯空白与非空字符串断言校验全部通过。