函数基础 #

一、函数定义 #

1.1 def函数 #

def 定义动态函数，类似Python：

mojo 
def greet(name):
    return "Hello, " + name + "!"

def main():
    print(greet("Mojo"))

main()

1.2 fn函数 #

fn 定义静态函数，编译时类型检查：

mojo 
fn greet(name: String) -> String:
    return "Hello, " + name + "!"

def main():
    print(greet("Mojo"))

main()

1.3 def vs fn #

特性 def fn
类型检查 运行时 编译时
默认参数 支持 支持
可变参数 支持 有限支持
性能 较慢 更快
错误检测 运行时 编译时

二、函数参数 #

2.1 位置参数 #

mojo 
fn add(a: Int, b: Int) -> Int:
    return a + b

def main():
    print(add(1, 2))

main()

2.2 默认参数 #

mojo 
fn greet(name: String, greeting: String = "Hello") -> String:
    return greeting + ", " + name + "!"

def main():
    print(greet("Mojo"))
    print(greet("Mojo", "Hi"))

main()

2.3 关键字参数 #

mojo 
fn create_user(name: String, age: Int, city: String) -> String:
    return f"{name}, {age}, {city}"

def main():
    print(create_user(name="Alice", age=25, city="Beijing"))
    print(create_user(age=30, name="Bob", city="Shanghai"))

main()

2.4 可变参数 #

mojo 
def sum_all(*numbers):
    var total = 0
    for num in numbers:
        total += num
    return total

def main():
    print(sum_all(1, 2, 3, 4, 5))

main()

2.5 关键字可变参数 #

mojo 
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

def main():
    print_info(name="Alice", age=25, city="Beijing")

main()

三、返回值 #

3.1 单返回值 #

mojo 
fn square(x: Int) -> Int:
    return x * x

def main():
    print(square(5))

main()

3.2 多返回值 #

mojo 
fn divide(a: Int, b: Int) -> (Int, Int):
    return a // b, a % b

def main():
    let quotient, remainder = divide(10, 3)
    print(f"商: {quotient}, 余数: {remainder}")

main()

3.3 无返回值 #

mojo 
fn print_message(msg: String):
    print(msg)

def main():
    print_message("Hello")

main()

3.4 提前返回 #

mojo 
fn find_negative(numbers: List[Int]) -> Int:
    for num in numbers:
        if num < 0:
            return num
    return 0

def main():
    let nums = [1, 2, -3, 4, 5]
    print(find_negative(nums))

main()

四、函数作用域 #

4.1 局部变量 #

mojo 
fn process():
    let local_var = 10
    print(local_var)

def main():
    process()

main()

4.2 全局变量 #

mojo 
var counter = 0

fn increment():
    global counter
    counter += 1

def main():
    print(counter)
    increment()
    print(counter)

main()

4.3 嵌套函数 #

mojo 
def outer():
    let x = 10
    
    def inner():
        print(x)
    
    inner()

def main():
    outer()

main()

五、高阶函数 #

5.1 函数作为参数 #

mojo 
fn apply(x: Int, f: fn(Int) -> Int) -> Int:
    return f(x)

fn double(x: Int) -> Int:
    return x * 2

def main():
    print(apply(5, double))

main()

5.2 函数作为返回值 #

mojo 
fn get_multiplier(factor: Int) -> fn(Int) -> Int:
    fn multiply(x: Int) -> Int:
        return x * factor
    return multiply

def main():
    let double = get_multiplier(2)
    print(double(5))

main()

5.3 匿名函数 #

mojo 
def main():
    let numbers = [1, 2, 3, 4, 5]
    let squared = map(lambda x: x * x, numbers)
    
    for num in squared:
        print(num)

main()

六、递归函数 #

6.1 基本递归 #

mojo 
fn factorial(n: Int) -> Int:
    if n <= 1:
        return 1
    return n * factorial(n - 1)

def main():
    print(factorial(5))

main()

6.2 尾递归 #

mojo 
fn factorial_tail(n: Int, acc: Int = 1) -> Int:
    if n <= 1:
        return acc
    return factorial_tail(n - 1, n * acc)

def main():
    print(factorial_tail(5))

main()

6.3 斐波那契数列 #

mojo 
fn fibonacci(n: Int) -> Int:
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

def main():
    for i in range(10):
        print(fibonacci(i))

main()

七、函数重载 #

7.1 参数类型重载 #

mojo 
fn process(value: Int):
    print(f"Integer: {value}")

fn process(value: String):
    print(f"String: {value}")

fn process(value: Float64):
    print(f"Float: {value}")

def main():
    process(42)
    process("Hello")
    process(3.14)

main()

7.2 参数数量重载 #

mojo 
fn add(a: Int) -> Int:
    return a

fn add(a: Int, b: Int) -> Int:
    return a + b

fn add(a: Int, b: Int, c: Int) -> Int:
    return a + b + c

def main():
    print(add(1))
    print(add(1, 2))
    print(add(1, 2, 3))

main()

八、内联函数 #

8.1 内联优化 #

mojo 
@inline
fn square(x: Int) -> Int:
    return x * x

def main():
    let result = square(5)
    print(result)

main()

8.2 何时使用内联 #

  • 小型函数
  • 频繁调用
  • 性能关键路径

九、函数最佳实践 #

9.1 单一职责 #

mojo 
fn validate_email(email: String) -> Bool:
    return "@" in email and "." in email

fn send_email(email: String, message: String):
    if validate_email(email):
        print(f"Sending to {email}: {message}")

def main():
    send_email("user@example.com", "Hello")

main()

9.2 有意义的命名 #

mojo 
fn calculate_monthly_payment(principal: Float64, rate: Float64, years: Int) -> Float64:
    let monthly_rate = rate / 12 / 100
    let months = years * 12
    return principal * monthly_rate / (1 - (1 + monthly_rate) ** (-months))

def main():
    let payment = calculate_monthly_payment(100000.0, 5.0, 30)
    print(payment)

main()

9.3 文档字符串 #

mojo 
fn calculate_bmi(weight: Float64, height: Float64) -> Float64:
    """
    计算身体质量指数(BMI)。
    
    Args:
        weight: 体重(公斤)
        height: 身高(米)
        
    Returns:
        BMI值
    """
    return weight / (height * height)

def main():
    print(calculate_bmi(70.0, 1.75))

main()

十、总结 #

本章学习了：

  • def和fn函数定义
  • 参数传递方式
  • 返回值处理
  • 作用域规则
  • 高阶函数
  • 递归函数
  • 函数重载
  • 最佳实践

下一章，我们将学习参数与返回值的高级特性。

最后更新：2026-03-27