「闭包、柯里化、响应式编程」10+ 高级编程技巧全解（多语言实战）

🚀 1. 闭包（Closure）

定义：闭包是函数与其定义时的作用域绑定在一起的结构。即使函数在外部调用，它仍然可以访问原作用域中的变量。

用途：

• 封装私有变量
• 构造计数器、缓存器
• 延迟计算

示例：

JavaScript

functionmakeCounter(){letcount=0;returnfunction(){return++count;};}constcounter=makeCounter();console.log(counter());// 1

Python

defmake_counter():count=0defcounter():nonlocalcount count+=1returncountreturncounter

Java（匿名类模拟）

interfaceCounter{intnext();}CountermakeCounter(){returnnewCounter(){intcount=0;publicintnext(){return++count;}};}

Rust

fnmake_counter()->implFnMut()->i32{letmutcount=0;move||{count+=1;count}}

🧠 2. 柯里化（Currying）

定义：将一个多参数函数转化为一系列单参数函数。

用途：

• 参数预设
• 函数复用
• 与组合式编程搭配使用

示例：

JavaScript

constmultiply=a=>b=>a*b;constdouble=multiply(2);console.log(double(5));// 10

Python

defmultiply(a):returnlambdab:a*b

TypeScript

functionmultiply(a:number):(b:number)=>number{returnb=>a*b;}

Rust

fnmultiply(a:i32)->implFn(i32)->i32{move|b|a*b}

🧩 3. 函数组合（Function Composition）

定义：将多个函数组合成一个函数，前一个函数的输出是后一个函数的输入。

用途：

• 构建数据处理管道
• 清晰表达逻辑

示例：

JavaScript

constcompose=(f,g)=>x=>f(g(x));

Python

defcompose(f,g):returnlambdax:f(g(x))

TypeScript

constcompose=<T,U,V>(f:(x:U)=>V,g:(x:T)=>U)=>(x:T)=>f(g(x));

Rust

fncompose<F,G,A,B,C>(f:F,g:G)->implFn(A)->CwhereF:Fn(B)->C,G:Fn(A)->B,{move|x|f(g(x))}

🌀 4. 惰性求值（Lazy Evaluation）

定义：表达式不会立即计算，而是在真正需要时才计算。

用途：

• 节省内存
• 流式处理
• 构建无限序列

示例：

Python

deflazy_range(n):foriinrange(n):yieldi

JavaScript

function*lazyRange(n){for(leti=0;i<n;i++){yieldi;}}

Rust

fnlazy_range(n:usize)->implIterator<Item=usize>{0..n}

Java

IntStream.range(0,n).forEach(System.out::println);

🧱 5. 依赖注入（Dependency Injection）

定义：将依赖项作为参数传入，而不是在函数内部创建。

用途：

• 解耦模块
• 提高可测试性

示例：

Java

classService{privatefinalLoggerlogger;publicService(Loggerlogger){this.logger=logger;}}

Python

classService:def__init__(self,logger):self.logger=logger

TypeScript

classService{constructor(privatelogger:Logger){}}

Rust

structService<'a>{logger:&'adynLogger,}

🔄 6. 递归与尾递归优化

定义：递归是函数调用自身解决问题，尾递归是递归调用在函数最后一步执行，可被优化为循环。

用途：

• 树结构、图结构
• 算法实现

示例：

JavaScript

functionfactorial(n,acc=1){returnn<=1?acc:factorial(n-1,acc*n);}

Python

deffactorial(n,acc=1):ifn<=1:returnaccreturnfactorial(n-1,acc*n)

Rust

fnfactorial(n:u64,acc:u64)->u64{ifn<=1{acc}else{factorial(n-1,acc*n)}}

🧬 7. 泛型编程（Generic Programming）

定义：编写与类型无关的代码。

用途：

• 提高复用性
• 类型安全

示例：

Java

public<T>voidprintArray(T[]array){for(Titem:array){System.out.println(item);}}

TypeScript

functionidentity<T>(arg:T):T{returnarg;}

Rust

fnidentity<T>(x:T)->T{x}

Python

fromtypingimportTypeVar T=TypeVar('T')defidentity(x:T)->T:returnx

🔐8. 不可变数据结构（Immutable Data Structures）

定义：数据一旦创建就不能修改。

用途：

• 并发安全
• 状态管理

示例：

JavaScript

conststate={count:0};constnewState={...state,count:state.count+1};

Java

List<String>immutableList=List.of("a","b","c");

Rust

letstate=vec![1,2,3];letnew_state={letmuts=state.clone();s.push(4);s};

🧨 9. 元编程（Metaprogramming）

定义：代码可以操作代码，比如动态生成函数、修改类结构。

用途：

• 自动化工具
• 框架开发

示例：

Python（装饰器）

deflog(func):defwrapper(*args,**kwargs):print(f"Calling{func.__name__}")returnfunc(*args,**kwargs)returnwrapper

Java（反射）

Methodmethod=MyClass.class.getMethod("doSomething");method.invoke(obj);

Rust（宏）

macro_rules!say_hello{()=>{println!("Hello!");};}

🧙‍♂️ 10. 响应式编程（Reactive Programming）

定义：数据流和变化传播自动响应。

用途：

• UI 框架
• 流式数据处理

示例：

RxJS

import{fromEvent}from'rxjs';fromEvent(document,'click').subscribe(()=>console.log('Clicked!'));

Java（Reactor）

Flux.just(1,2,3).map(i->i*2).subscribe(System.out::println);

Kotlin（Flow）

flowOf(1,2,3).map{it*2}.collect{println(it)}