# 函数(Function)

函数是编程语言常见的功能,它可以封装一批代码,对外接收参数,然后返回值。被封装的逻辑,可以被不同的其他代码调用,达到共同复用逻辑的目的。

函数用 function 关键字定义,后面跟着函数名和圆括号。

同时注意,定义函数涉及作用域。

# 定义函数

函数可以通过函数声明和匿名函数表达式两种方式进行定义。这两种方式在语法上有所不同,但都可以用来创建函数。

# 函数声明(Function Declaration)

一个函数定义(也称为函数声明,或函数语句)由一系列在 function 关键字后的内容组成,依次为:

  • 函数的名称。
  • 函数参数列表,包围在括号中并由逗号分隔。
  • 函数返回值类型,除返回类型为 void 外,函数必须明确标明返回值类型。
  • 定义函数的 uts 语句,用大括号 {} 括起来。

例如,以下的代码定义了一个简单的函数。函数名为 add,有2个参数 x 和 y,都是 string类型,函数的返回值类型也是 string。

函数的内容是将入参 x 和 y 相加,赋值给变量z,然后通过 return关键字返回z。

function add(x :string, y :string) :string {
    let z : string = x + " " + y
	return z;
}

# 函数表达式(Function Expression)

虽然上面的函数声明在语法上是一个语句,但函数也可以由函数表达式创建。这样的函数可以是匿名的。

例如,函数 add 也可这样来定义:

const add = function (x: string, y: string): string {
    return x + " " + y
}

UTS 中不存在变量提升,在函数表达式中不可以访问未声明的变量(包括自身)。

const fn = function () {
    console.log(fn) // 编译报错,此时 fn 还未声明
}
fn()
const fn: (() => void) | null = null
fn = function () {
    console.log(fn) // 此时 fn 可以正常访问
}
fn()

# 箭头函数

箭头函数表达式(也称胖箭头函数)相比函数表达式具有较短的语法。箭头函数总是匿名的,也就是不需要函数名。

// 以下是不使用箭头函数的写法
const arr = ["Hydrogen", "Helium", "Lithium", "Beryllium"];
const a2 = arr.map(function (s): number {
    return s.length;
});
console.log(a2); // logs [ 8, 6, 7, 9 ]

// 以下是使用箭头函数的写法,逻辑是等价的
const a3 = arr.map((s): number => s.length);
console.log(a3); // logs [ 8, 6, 7, 9 ]

# 无返回值的函数(void)

如果这个函数不需要返回值,可以省略返回值类型也可以使用 void 关键字进行显式声明,同时函数内部末尾也可以省略 return。

function add(x: string, y: string): void {
    let z: string = x + " " + y
    console.log(z)
    // return
}

# 异步函数

使用 async 关键字来声明一个异步函数,异步函数返回一个 Promise 对象。

注意:在 HBuilderX 3.93 以下的版本或者 iOS 平台,异步函数返回的不是 Promise 对象,请分别参考:安卓 异步函数iOS 异步函数

注意:异步函数在底层使用协程实现,异步函数内与异步函数外同时操作同一个对象时,由于其能并发执行,其操作顺序可能与预期不一致,会产生竞态条件与线程安全性问题。

async function foo(): Promise<void> {
  // ...
}

foo().then(function() {
  console.log('done')
})

async 函数可能包含 0 个或者多个 await await 表达式会暂停整个 async 函数的执行进程并出让其控制权,只有当其等待的基于 promise 的异步操作被兑现或被拒绝之后才会恢复进程。promise 的解决值会被当作该 await 表达式的返回值。使用 async / await 关键字就可以在异步代码中使用普通的 try / catch 代码块。

async function foo(): Promise<void> {
  try {
    await aPromise
  } catch (error) {
    console.log(error)
  }
}

async 函数一定会返回一个 promise 对象。如果一个 async 函数的返回值看起来不是 promise,那么它将会被隐式地包装在一个 promise 中。

async function foo(): Promise<number> {
  return 1
}

# 调用函数

定义一个函数并不会自动的执行它。定义了函数仅仅是赋予函数以名称并明确函数被调用时该做些什么。调用函数才会以给定的参数真正执行这些动作。

定义了函数 add 后,你可以如下这样调用它:

function add(x :string, y :string) :string {
    let z :string = x + " " + y
	return z;
}
add("hello", "world"); // 调用add函数

上述语句通过提供参数 "hello" 和 "world" 来调用函数。

虽然调用了add函数,但并没有获取到返回值。如需要获取返回值,需要再赋值:

function add(x :string, y :string) :string {
	let z :string = x + " " + y
	return z;
}
let s :string = add("hello", "world");
console.log(s) // hello world

# 函数作用域

在函数内定义的变量不能在函数之外的任何地方访问,因为变量仅仅在该函数的域的内部有定义。相对应的,一个函数可以访问定义在其范围内的任何变量和函数。

const hello :string = "hello";
const world :string = "world";

function add(): string {
	let s1 :string = "123";
    return hello + world; // 可以访问到 hello 和 world
}

# 嵌套函数

你可以在一个函数里面嵌套另外一个函数。嵌套(内部)函数对其容器(外部)函数是私有的。它自身也形成了一个闭包。一个闭包是一个可以自己拥有独立的环境与变量的表达式(通常是函数)。

既然嵌套函数是一个闭包,就意味着一个嵌套函数可以”继承“容器函数的参数和变量。换句话说,内部函数包含外部函数的作用域。

可以总结如下:

  • 内部函数只可以在外部函数中访问。
  • 内部函数形成了一个闭包:它可以访问外部函数的参数和变量,但是外部函数却不能使用它的参数和变量。

举例:

function addSquares(a: number, b: number): number {
    function square(x: number): number {
        return x * x;
    }
    return square(a) + square(b);
}
addSquares(2, 3); // returns 13
addSquares(3, 4); // returns 25
addSquares(4, 5); // returns 41

# 命名冲突

当同一个闭包作用域下两个参数或者变量同名时,就会产生命名冲突。更近的作用域有更高的优先权,所以最近的优先级最高,最远的优先级最低。这就是作用域链。链的第一个元素就是最里面的作用域,最后一个元素便是最外层的作用域。

举例:

function outside(): (x: number) => number {
    let x = 5;
    const inside = function (x: number): number {
        return x * 2;
    };
    return inside;
}

outside()(10); // 返回值为 20 而不是 10

命名冲突发生在 return x 上,inside 的参数 x 和 outside 变量 x 发生了冲突。这里的作用链域是 {inside, outside}。因此 inside 的 x 具有最高优先权,返回了 20(inside 的 x)而不是 10(outside 的 x)。

# 闭包

uts 允许函数嵌套,并且内部函数可以访问定义在外部函数中的所有变量和函数,以及外部函数能访问的所有变量和函数。

但是,外部函数却不能够访问定义在内部函数中的变量和函数。这给内部函数的变量提供了一定的安全性。

此外,由于内部函数可以访问外部函数的作用域,因此当内部函数生存周期大于外部函数时,外部函数中定义的变量和函数的生存周期将比内部函数执行时间长。当内部函数以某一种方式被任何一个外部函数作用域访问时,一个闭包就产生了。

举例:

const pet = function (name: string): () => string {
    //外部函数定义了一个变量"name"
    const getName = function (): string {
        //内部函数可以访问 外部函数定义的"name"
        return name;
    };
    //返回这个内部函数,从而将其暴露在外部函数作用域
    return getName;
};
const myPet = pet("Vivie");
myPet(); // 返回结果 "Vivie"

# 作为值传递

使用函数表达式(Function Expression)的创建的函数可以作为值进行传递,使用函数声明(Function Declaration)创建的函数不能作为一个值进行传递。

function fn1() {

}

const fn2 = function () {

}

const fn3 = fn2 // 正确,值为函数表达式
const fn4 = fn1 // 错误,值为函数声明

console.log(fn1) // 错误,值为函数声明
console.log(fn2) // 正确,值为函数表达式
console.log(function () {

}) // 正确,值为函数声明

# 函数类型

函数表达式也拥有类型,其类型表达式为 (参数名:参数类型)=>返回值类型,如:

const fn: (x: string) => void

函数表达式必须与其类型定义中的参数类型、参数个数以及返回值类型严格匹配

fn = function (x: string) { } // 正确,类型匹配
fn = function (x: string, y: string) { } // 错误,参数类型不匹配
fn = function (x: string): string { return x } // 错误,返回类型不匹配

# 默认参数

函数参数可以设默认值,当省略相应的参数时使用默认值。此时该参数也就成了可选参数。

function multiply(a:number, b:number = 1):number {
  return a*b;
}
multiply(5); // a为5,未传b的值,b默认为1,结果为5

可以在常规的函数定义的场景下使用默认参数,例如:

function print(msg:string = "") {
  console.log(msg)
}
print(); // ""


class Persion {
	test(msg: string | null = null) { // 默认值可以为null
		
	}
}

通过函数表达式定义的函数不支持使用默认参数

// 该变量会被编译成Swift或者Kottlin的闭包表达式,其不支持使用默认参数。
const test = function(msg: string | null) { }

因为需要作为值进行传递,对象字面量中定义的方法会自动转换为函数表达式,所以也不支持默认参数

// 该属性会被编译成Swift或者Kottlin的闭包表达式,其不支持使用默认参数。
export  {
	data: {
		test(msg: string | null) {
			
		}
	}
}

# 剩余参数

剩余参数语法允许我们将一个不定数量的参数表示为一个数组。

使用 ... 操作符定义函数的最后一个参数为剩余参数。

function fn(str: string, ...args: string[]) {
  console.log(str, args)
}

在这种情况下可以传递可变数量的参数给函数:

fn('a') // 'a' []
fn('a', 'b', 'c') // 'a' ['b', 'c']

也可以使用展开语法传递一个数组值给函数的剩余参数(转到 swift 时未支持):

fn('a', ...['b', 'c']) // 'a' ['b', 'c']