Fig-TreeWalker/docs/zh_CN/05-函数.md

函数

函数定义

基本语法

func 函数名(参数列表) -> 返回类型 {
    函数体
}

示例

// 简单函数
func greet() -> Null {
    io.println("Hello!");
}

// 带参数的函数
func add(a: Int, b: Int) -> Int {
    return a + b;
}

// 省略返回类型（默认为 Any）
func say(message: String) {
    io.println(message);
    // 没有 return，返回 null
}

参数

必需参数

func power(base: Double, exponent: Double) -> Double {
    return base ** exponent;
}

默认参数

参数可以指定默认值：

func createPerson(name: String, age: Int = 18) -> Null {
    io.println(name + " is " + age + " years old");
}

// 调用
createPerson("Alice");        // 使用默认 age=18
createPerson("Bob", 25);      // 指定 age=25

可变参数

使用 ... 表示可变参数，接收一个 List：

func sum(numbers...) -> Int {
    var total = 0;
    var i = 0;
    for i = 0; i < numbers.length(); i = i + 1 {
        total = total + numbers.get(i);
    }
    return total;
}

// 调用
sum(1, 2, 3);          // 返回 6
sum(1, 2, 3, 4, 5);    // 返回 15

可变参数不支持类型限制，获取到的总是 List 类型。

返回值

显式返回

使用 return 语句返回值：

func max(a: Int, b: Int) -> Int {
    if a > b {
        return a;
    } else {
        return b;
    }
}

无返回值

函数如果没有 return 语句，返回 null：

func log(message: String) -> Null {
    io.println("[LOG] " + message);
    // 函数结束，返回 null
}

func process(data: List) {
    if data.length() == 0 {
        return;  // 提前返回 null
    }
    // 处理数据...
    // 函数结束，返回 null
}

函数作为值

函数赋值

函数是一等公民，可以赋值给变量：

var addFunc = func(a: Int, b: Int) -> Int {
    return a + b;
};

// 调用
var result = addFunc(3, 4);  // result = 7

函数作为参数

func applyOperation(x: Int, y: Int, op: Function) -> Int {
    return op(x, y);
}

func multiply(a: Int, b: Int) -> Int {
    return a * b;
}

// 调用
var product = applyOperation(3, 4, multiply);  // product = 12

函数作为返回值

func makeMultiplier(factor: Int) -> Function {
    return func(x: Int) -> Int {
        return x * factor;
    };
}

// 调用
var double = makeMultiplier(2);
var triple = makeMultiplier(3);

io.println(double(5));  // 输出 10
io.println(triple(5));  // 输出 15

匿名函数

Lambda 表达式

// 完整形式
var square = func(x: Int) {
    return x * x;
};

// 简写形式（单表达式）
var squareShort = func(x: Int) => x * x;

// 调用
io.println(square(5));      // 输出 25
io.println(squareShort(5)); // 输出 25

立即调用函数表达式

var result = func(x: Int, y: Int){
    return x + y;
}(3, 4);  // result = 7

闭包

捕获外部变量

函数可以捕获其定义作用域中的变量：

func makeCounter() -> Function {
    var count = 0;
    
    return func(){
        count = count + 1;
        return count;
    };
}

// 使用
var counter = makeCounter();
io.println(counter());  // 输出 1
io.println(counter());  // 输出 2
io.println(counter());  // 输出 3

每个闭包有自己独立的捕获变量：

var c1 = makeCounter();
var c2 = makeCounter();

io.println(c1());  // 输出 1
io.println(c1());  // 输出 2
io.println(c2());  // 输出 1（独立的计数）

递归函数

函数可以调用自身：

func factorial(n: Int) -> Int {
    if n <= 1 {
        return 1;
    }
    return n * factorial(n - 1);
}

// 调用
io.println(factorial(5));  // 输出 120

嵌套函数定义

func outer(x: Int) -> Int {
    func inner(y: Int) -> Int {
        return y * 2;
    }
    
    return inner(x) + 1;
}

// 调用
io.println(outer(10));  // 输出 21

函数调用

普通调用

func calculate(a: Int, b: Int, c: Int) -> Int {
    return a + b * c;
}

// 位置参数调用
var result = calculate(1, 2, 3);  // 1 + 2*3 = 7

方法调用语法

对象的方法调用：

var list = [1, 2, 3];
var length = list.length();  // 方法调用

函数示例

实用函数组合

import std.io;

// 高阶函数示例
func compose(f: Function, g: Function) -> Function {
    return func(x: Any) -> Any {
        return f(g(x));
    };
}

// 使用
func addOne(x: Int) -> Int {
    return x + 1;
}

func double(x: Int) -> Int {
    return x * 2;
}

var addThenDouble = compose(double, addOne);
io.println(addThenDouble(5));  // (5+1)*2 = 12

回调函数模式

func processData(data: List, callback: Function) -> Null {
    var i = 0;
    for i = 0; i < data.length(); i = i + 1 {
        var result = callback(data.get(i));
        io.println("处理结果: " + result);
    }
}

// 使用
var numbers = [1, 2, 3, 4, 5];
processData(numbers, func(x){
    return x * x;
});