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

# 函数

## 函数定义

### 基本语法
```go
func 函数名(参数列表) -> 返回类型 {
    函数体
}
```

### 示例
```go
// 简单函数
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
}
```

## 参数

### 必需参数
```go
func power(base: Double, exponent: Double) -> Double {
    return base ** exponent;
}
```

### 默认参数
参数可以指定默认值：
```go
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：
```go
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` 语句返回值：
```go
func max(a: Int, b: Int) -> Int {
    if a > b {
        return a;
    } else {
        return b;
    }
}
```

### 无返回值
函数如果没有 return 语句，返回 null：
```go
func log(message: String) -> Null {
    io.println("[LOG] " + message);
    // 函数结束，返回 null
}

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

## 函数作为值

### 函数赋值
函数是一等公民，可以赋值给变量：
```go
var addFunc = func(a: Int, b: Int) -> Int {
    return a + b;
};

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

### 函数作为参数
```go
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
```

### 函数作为返回值
```go
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 表达式
```go
// 完整形式
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
```

### 立即调用函数表达式
```go
var result = func(x: Int, y: Int){
    return x + y;
}(3, 4);  // result = 7
```

## 闭包

### 捕获外部变量
函数可以捕获其定义作用域中的变量：
```go
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
```

每个闭包有自己独立的捕获变量：
```go
var c1 = makeCounter();
var c2 = makeCounter();

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

## 递归函数

函数可以调用自身：
```go
func factorial(n: Int) -> Int {
    if n <= 1 {
        return 1;
    }
    return n * factorial(n - 1);
}

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

### 嵌套函数定义
```go
func outer(x: Int) -> Int {
    func inner(y: Int) -> Int {
        return y * 2;
    }
    
    return inner(x) + 1;
}

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

## 函数调用

### 普通调用
```go
func calculate(a: Int, b: Int, c: Int) -> Int {
    return a + b * c;
}

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

### 方法调用语法
对象的方法调用：
```go
var list = [1, 2, 3];
var length = list.length();  // 方法调用
```

## 函数示例

### 实用函数组合
```go
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
```

### 回调函数模式
```go
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;
});
```