函数

声明函数

函数用 hs（函数 / fn）声明，用 fanhui（返回 / return）返回：

拼音

hs add(a z64, b z64) z64 {
    fanhui a +[z64] b
}

hs log(msg zifuchuan) kongbai {
    dayin(msg)
}

中文

函数 add(a i64, b i64) i64 {
    返回 a +[i64] b
}

函数 log(msg string) void {
    打印(msg)
}

英文

fn add(a i64, b i64) i64 {
    return a +[i64] b
}

fn log(msg string) void {
    print(msg)
}

返回类型必须写出

返回类型不能省略，没有返回值写 kongbai（void）。 编译器不做返回类型推断。

拼音

hs add(a z64, b z64) z64 { fanhui a + b }   // ✓
hs add(a z64, b z64) { fanhui a + b }       // ✗ 缺少返回类型

hs log(msg zifuchuan) kongbai { dayin(msg) }  // ✓
hs log(msg zifuchuan) { dayin(msg) }          // ✗ 无返回值请写 kongbai

中文

函数 add(a i64, b i64) i64 { 返回 a + b }   // ✓
函数 add(a i64, b i64) { 返回 a + b }       // ✗ 缺少返回类型

函数 log(msg string) void { 打印(msg) }     // ✓
函数 log(msg string) { 打印(msg) }          // ✗ 无返回值请写 void

英文

fn add(a i64, b i64) i64 { return a + b }   // ✓
fn add(a i64, b i64) { return a + b }       // ✗ 缺少返回类型

fn log(msg string) void { print(msg) }      // ✓
fn log(msg string) { print(msg) }           // ✗ 无返回值请写 void

fanhui 必须和返回类型匹配：kongbai 函数不能返回值，非 kongbai 函数不能写不带值的 fanhui。

参数

参数必须声明类型，参数名后面的 leixing（类型 / type）可以省略：

拼音

hs add(a leixing z64, b leixing z64) z64 { fanhui a + b }  // ✓
hs add(a z64, b z64) z64 { fanhui a + b }                  // ✓ 推荐

中文

函数 add(a 类型 i64, b 类型 i64) i64 { 返回 a + b }     // ✓
函数 add(a i64, b i64) i64 { 返回 a + b }               // ✓ 推荐

英文

fn add(a type i64, b type i64) i64 { return a + b }     // ✓
fn add(a i64, b i64) i64 { return a + b }               // ✓ 推荐

默认值

拼音

hs greet(name zifuchuan, times z64 = 3) kongbai {
    bl i leixing z64 = 0
    dang (i < times) {
        dayin(name)
        i = i + 1
    }
}

rukou() {
    greet("cpro")           // times = 3
    greet("cpro", 1)        // times = 1
}

中文

函数 greet(name string, times i64 = 3) void {
    变量 i 类型 i64 = 0
    当 (i < times) {
        打印(name)
        i = i + 1
    }
}

入口() {
    greet("cpro")           // times = 3
    greet("cpro", 1)        // times = 1
}

英文

fn greet(name string, times i64 = 3) void {
    var i type i64 = 0
    while (i < times) {
        print(name)
        i = i + 1
    }
}

rukou() {
    greet("cpro")           // times = 3
    greet("cpro", 1)        // times = 1
}

值传递

参数是值传递，函数内修改参数不影响调用方：

拼音

hs bump(n z64) kongbai {
    n = n + 1           // 只改本地副本
}

rukou() {
    bl x leixing z64 = 1
    bump(x)
    dayin(x)            // 1
}

中文

函数 bump(n i64) void {
    n = n + 1           // 只改本地副本
}

入口() {
    变量 x 类型 i64 = 1
    bump(x)
    打印(x)             // 1
}

英文

fn bump(n i64) void {
    n = n + 1           // 只改本地副本
}

rukou() {
    var x type i64 = 1
    bump(x)
    print(x)            // 1
}

需要避免大对象拷贝、或者要在函数里修改调用方的变量时，用借用参数 &T，见 借用：

拼音

hs total(p &Person) z64 {
    fanhui p.age
}

中文

函数 total(p &Person) i64 {
    返回 p.age
}

英文

fn total(p &Person) i64 {
    return p.age
}

调用

函数可以调用定义在它后面的函数，不需要前置声明；支持递归：

拼音

hs fact(n z64) z64 {
    ruguo (n <= 1) { fanhui 1 }
    fanhui n * fact(n - 1)
}

rukou() {
    dayin(fact(5))                  // 120
    dayin(fact(fact(3)))            // 720
}

中文

函数 fact(n i64) i64 {
    如果 (n <= 1) { 返回 1 }
    返回 n * fact(n - 1)
}

入口() {
    打印(fact(5))                   // 120
    打印(fact(fact(3)))             // 720
}

英文

fn fact(n i64) i64 {
    if (n <= 1) { return 1 }
    return n * fact(n - 1)
}

rukou() {
    print(fact(5))                  // 120
    print(fact(fact(3)))            // 720
}

可失败函数

在返回类型后面加 kecuo（可错 / fails），表示函数可能返回错误，详见 错误处理：

拼音

hs parse(n z64) z64 kecuo {
    ruguo (n < 0) {
        fanhui cuowu("不能是负数")
    }
    fanhui n
}

rukou() {
    changshi {
        dayin(parse(42))
    } buhuo (e) {
        dayin(e.xinxi)
    }
}

中文

函数 parse(n i64) i64 可错 {
    如果 (n < 0) {
        返回 错误("不能是负数")
    }
    返回 n
}

入口() {
    尝试 {
        打印(parse(42))
    } 捕获 (e) {
        打印(e.msg)
    }
}

英文

fn parse(n i64) i64 fails {
    if (n < 0) {
        return Err("不能是负数")
    }
    return n
}

rukou() {
    try {
        print(parse(42))
    } catch (e) {
        print(e.msg)
    }
}

导出给其他文件

函数默认只在本文件可见，加 daochu（导出 / export）后其他文件才能导入，详见 模块与导入：

拼音

// util.cp
daochu hs helper(x z64) z64 { fanhui x * 2 }
hs internal(x z64) z64 { fanhui x + 1 }         // 本文件私有

// main.cp
daoru { helper } laizi "./util.cp"

中文

// util.cp
导出 函数 helper(x i64) i64 { 返回 x * 2 }
函数 internal(x i64) i64 { 返回 x + 1 }         // 本文件私有

// main.cp
导入 { helper } 来自 "./util.cp"

英文

// util.cp
export fn helper(x i64) i64 { return x * 2 }
fn internal(x i64) i64 { return x + 1 }         // 本文件私有

// main.cp
import { helper } from "./util.cp"

不支持

泛型函数、函数重载（同名函数）、具名参数调用（greet(name: "cpro")）均不支持。