函数

声明函数

函数（function）（也称为方法）在ArkTS也中是一等公民。

函数通过function关键字引入，包含名称、参数列表、返回类型和函数体。

function add(x: string, y: string): string {
    let z: string = `${x} - ${y}`;
    return z;
}
// 输出"hello - lixingyun" 
console.log(add("hello", "lixingyun"));

// 函数的参数和返回值可以是多选的
// 参数既可以是数字，又可以字符串，返回值也一样
function foo(x: number | string): string | number {
    return "2";
}
console.log(foo("1"));

可选参数

其格式为name?: Type，它必须放在必选参数之后。

function add(x: string, y?: string): string {
    let z: string;
    if (y == undefined) {
        z = `${x} - nobody`;
    } else {
        z = `${x} - ${y}`;
    }
    return z;
}
// 输出"hello - nobody"
console.log(add("hello"));
// 输出"hello - wanglin"
console.log(add("hello", "wanglin"));

默认参数

可选参数的另一种形式是设置默认参数。

function multiply(n: number, times: number = 2): number {
    return n * times;
}
// 输出4
console.log(multiply(2));
// 输出6
console.log(multiply(2, 3));

rest参数

这是一种放在可选参数之后的参数形式，其实就是Python中的可变参数或Go中的变长参数。

// 变长参数的格式
function sum(...numbers: number[]): number {       
    let res = 0;
    for (let n of numbers) {
        res += n;
    }
    return res;
}

// 输出0
console.log(sum());
// 输出6
console.log(sum(1, 2, 3));

返回类型

刚才的代码中已经演示了函数的返回类型。

如果可以从函数中推断出返回类型，就可以在函数声明中省略对返回类型的声明。

// 显示指定返回类型为string
function foo(): string {
    return 'foo';
}

// 推断返回类型为string
function bar() {
    return 'bar';
}

// 下面两种是等价的
function hello() {
    console.log('hello');
}
function world(): void {
    console.log('world');
}

变量作用域

函数内外部的变量并不会互相影响。

function join(x: string, y: string): string {
    let z: string = `${x} ${y}`;
    return z;
}
let z: string = "test";

// 输出"hello world" 
console.log(join("hello", "world"));
// 输出"test" 
console.log(z);

匿名函数

匿名函数是没有名字的函数。

let fun1 = function() {
    console.log("匿名函数1");
}
fun1();

// 自调用的匿名函数
let fun2 = function() {
    console.log("匿名函数2");
}();

函数类型

将函数的定义与可执行部分分开，通常用于回调。

// 定义函数类型
type calc = (x: number, y: number) => number;
// 对参数赋值就等于是在调用函数
function trigger(f: calc) {
    console.log(f(2, 10));
}
// 调用函数：计算2的10次方，输出1024
trigger(Math.pow);

Lambda表达式

其语法为：变量 = (参数列表)[: 返回类型] => { 函数体 }，所以它又叫箭头函数。

返回类型是可以省略掉的。

let sum1 = (x: number, y: number): number => { return x + y; }
let sum2 = (x: number, y: number) => { return x + y; }
let sum3 = (x: number, y: number) => x + y;

// 输出都是3
console.log(sum1(1, 2));
console.log(sum2(1, 2));
console.log(sum3(1, 2));

闭包

当内部函数能访问外部函数的变量时，就形成了闭包。

// 定义函数fun，它不接受参数但返回一个函数gun
function fun(): () => number {
    let count = 0;
    let gun = (): number => {
        count++;
        return count;
    };
    return gun;
}

// zun函数每次被调用时count值都要+1
let zun = fun();
// 输出1、2、3、4、5
for(let i = 0; i < 5; i++) {
    console.log(zun());
}

函数重载

也就是同名但参数和功能不同的函数。

// 定义数字参数
function foo(x: number): number {
    return 1;
}
console.log(foo(1));

// 定义字符串参数
function foo(x: string): string {
    return "1";
}
console.log(foo("1"));

// 两个同时定义
function foo(x: number | string): string | number {
    return "2";
}
console.log(foo("2"));

---

感谢支持

更多内容，请移步《超级个体》。