4.9 KiB
4.9 KiB
函数
函数定义
基本语法
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;
});