返回函数

#笔记 #Python #lua

Lua 返回函数

  1. 定义一个返回函数的函数：

    function createMultiplier(x)
    return function(y)
        return x * y
    end
end

  2. 使用返回的函数：

    local multiplyBy2 = createMultiplier(2)
print(multiplyBy2(5))  -- 输出 10

其他编程语言中的类似功能

  1. JavaScript：

    function createMultiplier(x) {
    return function(y) {
        return x * y;
    };
}

const multiplyBy2 = createMultiplier(2);
console.log(multiplyBy2(5));  // 输出 10

  2. Python：

    def create_multiplier(x):
    def multiplier(y):
        return x * y
    return multiplier

multiply_by_2 = create_multiplier(2)
print(multiply_by_2(5))  # 输出 10

  3. Ruby：

    def create_multiplier(x)
    return Proc.new { |y| x * y }
end

multiply_by_2 = create_multiplier(2)
puts multiply_by_2.call(5)  # 输出 10

Java
在 Java 中，可以使用匿名内部类或 lambda 表达式（Java 8 及以上）来实现返回函数。

import java.util.function.Function;

public class Main {
    public static Function<Integer, Integer> createMultiplier(int x) {
        return y -> x * y;
    }

    public static void main(String[] args) {
        Function<Integer, Integer> multiplyBy2 = createMultiplier(2);
        System.out.println(multiplyBy2.apply(5));  // 输出 10
    }
}

C
C 语言不直接支持返回函数，但可以使用函数指针和静态变量或结构体来模拟类似的行为。

#include <stdio.h>

typedef int (*MultiplierFunc)(int);

typedef struct {
    int x;
    MultiplierFunc func;
} Multiplier;

int multiplierFunc(int y, Multiplier* mult) {
    return mult->x * y;
}

Multiplier createMultiplier(int x) {
    Multiplier mult;
    mult.x = x;
    mult.func = (MultiplierFunc)multiplierFunc;
    return mult;
}

int main() {
    Multiplier multiplyBy2 = createMultiplier(2);
    printf("%d\n", multiplyBy2.func(5, &multiplyBy2));  // 输出 10
    return 0;
}

Go
在 Go 中，可以轻松地通过返回一个匿名函数来实现返回函数的功能。

package main

import "fmt"

func createMultiplier(x int) func(int) int {
    return func(y int) int {
        return x * y
    }
}

func main() {
    multiplyBy2 := createMultiplier(2)
    fmt.Println(multiplyBy2(5))  // 输出 10
}

Rust

fn create_multiplier(x: i32) -> Box<dyn Fn(i32) -> i32> {
    Box::new(move |y: i32| x * y)
}

fn main() {
    let multiply_by_2 = create_multiplier(2);
    println!("{}", multiply_by_2(5));  // 输出 10
}
  1. 函数 create_multiplier：接受一个 i32 类型的参数 x，返回一个实现 Fn(i32) -> i32 特征的闭包。因为 Rust 的闭包类型是动态的，我们使用 Box<dyn Fn(i32) -> i32> 来进行类型包装。
  2. move 关键字：将 x 的所有权移动到闭包中，以便闭包可以在需要时使用 x。
  3. 使用返回的闭包：调用 create_multiplier 函数并传入 2，然后调用返回的闭包并传入 5，得到结果 10。

总结