嵌套函数#

定义在源文件顶层的函数被称为全局函数

定义在函数体内的函数被称为嵌套函数

示例, 函数foo内定义了一个嵌套函数nestAdd, 可以在foo内调用该嵌套函数nestAdd, 也可以将嵌套函数nestAdd作为返回值返回, 在foo外对其进行调用:

1
func foo() {
2
    func nestAdd(a: Int64, b: Int64) {
3
        a + b + 3
4
    }
5

6
    println(nestAdd(1, 2))  // 6
7

8
    return nestAdd
9
}
10

11
main() {
12
    let f = foo()
13
    let x = f(1, 2)
14
    println("result: ${x}")
15
}

程序会输出:

1
6
2
result: 6

仓颉函数, 除了在函数外(源文件顶层或结构体、类内)定义, 即 全局函数 或 成员函数

还可以在函数体内定义, 这样在函数体内定义的函数被称为 嵌套函数

嵌套函数可以直接在函数中被调用, 还可以作为函数的返回值返回

Lambda表达式#

1
{ 参数列表 => 一组声明或表达式序列 }

闭包 **#

一个函数或lambda从定义它的静态作用域中捕获了变量, 函数或lambda和捕获的变量一起被称为一个闭包, 这样即使脱离了闭包定义所在的作用域, 闭包也能正常运行

闭包, 我个人理解就是:

1. 闭包形成:

   如果一个函数/lambda, 捕获了定义时 函数/lambda外部的非全局或静态变量时, 此函数和其捕获的变量, 形成一个闭包

   闭包形成之后, 闭包封闭、包装, 将捕获的变量”包装”到函数/lambda内部, 不再直接依赖外部变量

   但, 这里的”包装”形式 针对不同的类型也是有区别的: var或let变量有区别, 值类型和引用类型变量也有区别

2. 闭包调用

   闭包可以直接像函数一样调用, 非特殊通常情况下也可以作为一等公民使用

   而且, 调用时能够访问到捕获的变量, 即使 闭包调用时的作用域 已经不在 被捕获变量 定义时的有效作用域

函数或lambda的定义中对于以下几种变量的访问, 称为变量捕获:

• 函数的参数缺省值中 访问了 本函数之外定义的局部变量

• 函数或lambda内 访问了 本函数或本lambda之外定义的局部变量

• class/struct内定义的不是成员函数的函数或lambda访问了实例成员变量或this

以下情形的变量访问不是变量捕获:

• 对定义在本函数或本lambda内的局部变量的访问

• 对本函数或本lambda的形参的访问

• 对全局变量和静态成员变量的访问

• 对实例成员变量在实例成员函数或属性中的访问

  由于实例成员函数或属性将this作为参数传入, 在实例成员函数或属性内通过this访问所有实例成员变量

变量的捕获发生在闭包定义时, 因此变量捕获有以下规则:

• 被捕获的变量必须在闭包定义时可见, 否则编译报错

• 被捕获的变量必须在闭包定义时已经完成初始化, 否则编译报错

仓颉中, 捕获变量动作发生在闭包定义时

且仓颉闭包中使用到的外部变量, 会被自动捕获

并不是 所有变量在闭包访问都属于变量捕获

变量捕获只针对 非本函数/本lambda的局部变量, 以及成员变量或this

静态变量或全局变量的访问, 不属于变量捕获, 对本身形参的访问就更不属于了

具体下面有所展示

示例 1: 闭包add, 捕获了let声明的局部变量num, 之后通过返回值返回到num定义的作用域之外, 调用add时仍可正常访问num

1
func returnAddNum(): (Int64) -> Int64 {
2
    let num: Int64 = 10
3

4
    func add(a: Int64) {
5
        return a + num
6
    }
7
    add
8
}
9

10
main() {
11
    let f = returnAddNum()
12
    println(f(10))
13
}

程序输出的结果为:

1
20

此例中, 嵌套函数add捕获了 外层函数中let声明的局部变量num, 形成闭包

变量num被”包装”到add中, add作为一等公民返回

示例 2: 捕获的变量必须在闭包定义时可见

1
func f() {
2
    let x = 99
3
    func f1() {
4
        println(x)
5
    }
6
    let f2 = { =>
7
        println(y)            // Error, 无法捕获尚未定义的'y'
8
    }
9
    let y = 88
10
    f1()                      // Print 99
11
    f2()
12
}

示例 3: 捕获的变量必须在闭包定义前完成初始化

1
func f() {
2
    let x: Int64
3
    func f1() {
4
        println(x)            // Error, x 还未初始化
5
    }
6
    x = 99
7
    f1()
8
}

仓颉捕获变量, 只能捕获可见的变量, 且只能捕获已经初始化的变量, 否则编译错误

如果捕获的变量是引用类型, 可修改其可变实例成员变量的值

1
class C {
2
    public var num: Int64 = 0
3
}
4

5
func returnIncrementer(): () -> Unit {
6
    let c: C = C()
7

8
    func incrementer() {
9
        c.num++
10
    }
11

12
    incrementer
13
}
14

15
main() {
16
    let f = returnIncrementer()
17
    f()                           // c.num 增加 1
18
}

仓颉中, 闭包捕获引用类型变量, 可以通过捕获的变量修改原实例的成员变量

为了防止捕获了var声明变量的闭包逃逸, 这类闭包只能被调用, 不能作为一等公民使用, 包括不能赋值给变量, 不能作为实参或返回值使用, 不能直接将闭包的名字作为表达式使用

1
func f() {
2
    var x = 1
3
    let y = 2
4

5
    func g() {
6
        println(x)            // OK, 捕获一个可变变量
7
    }
8
    let b = g                 // Error, g 不能赋值给变量
9

10
    g                         // Error, g 不能用作表达式
11
    g()                       // OK, g 可以被调用
12

13
    g                         // Error, g 不能用作返回值
14
}

仓颉规定, var声明的变量被捕获之后, 闭包只能被调用, 不能作为一等公民使用

主要是为了防止引用类型变量的闭包逃逸

值类型变量被捕获之后, 无论是let还是var, 闭包中拥有的是变量的副本, 不存在逃逸

但引用类型变量被捕获则不同, 引用类型变量被捕获, 捕获的就是此引用变量本身 不是实际实例

如果是let引用类型变量, 则变量被捕获前后 闭包内外引用指向是不会更变的, 这就表示 闭包的捕获期望是不会改变的

即, 可以保证 闭包无论何时、何处被调用, 闭包捕获的变量 一定闭包定义时 捕获到的变量实例

但, 如果是var引用类型变量, 则变量被捕获之后, 因为var可变, 就表示此引用变量的实际指向是可以修改的

即, 闭包内外是可以随时修改引用变量的指向的

这就会导致一个问题, 闭包被调用时, 内部访问被捕获的变量 可能已经不是 闭包定义时捕获的变量了

这就会导致闭包调用非预期的问题

而且, 闭包捕获var引用类型变量, 那么闭包内部也是可以 改变此变量的指向的

如果此时, 闭包能够作为一等公民使用, 那么在外部使用时, 就可能导致各种不安全的行为

下面这段代码, 可以很直接的展示 闭包捕获var引用类型变量 的特点:

1
class JustTest {
2
    var num = 0
3

4
    init(num!: Int64 = 0) {
5
        this.num = num
6
    }
7
}
8

9
func returnAddNum() {
10
    var test = JustTest(num: 1)
11
    println(test.num)               // print: 1
12

13
    func add() {
14
        println(test.num)           // print: 1 / 3
15
        test = JustTest(num: 2)
16
        println(test.num)           // print: 2
17
    }
18
    add()
19
    println(test.num)               // print: 2
20

21
    test = JustTest(num: 3)
22
    println(test.num)               // print: 3
23
    add()
24
    println(test.num)               // print: 2
25
}
26

27
main() {
28
    let f = returnAddNum()
29
}

这段代码执行之后, 将会输出:

1
1
2
1
3
2
4
2
5
3
6
3
7
2
8
2

结果表明, 如果闭包捕获var引用类型变量, 那么 闭包内外修改变量指向, 都会互相影响, 因为这就是同一个引用类型变量

所以, 对捕获了var变量(包括值类型和引用类型)的闭包, 仓颉规定禁止将其当作一等公民使用

需要注意的是, 捕获具有传递性

如果一个函数f调用了捕获var变量的函数g, 且g捕获的var变量不在函数f内定义, 那么函数f同样捕获了var变量, 此时, f也不能作为一等公民使用

以下示例中, g捕获了var声明的变量x, f调用了g, 且g捕获的x不在f内定义, f同样不能作为一等公民使用:

1
func h(){
2
    var x = 1
3

4
    func g() { x }    // 捕获一个可变变量
5

6
    func f() {
7
        g()           // 调用 g
8
    }
9
    return f          // Error
10
}

以下示例中, g捕获了var声明的变量x, f调用了g

但g捕获的x在f内定义, f没有捕获其他var声明的变量, 因此, f仍作为一等公民使用:

1
func h(){
2
    func f() {
3
        var x = 1
4
        func g() { x }    // 捕获一个可变变量
5

6
        g()
7
    }
8
    return f              // Ok
9
}

仓颉中, 变量的捕获具有传递性, 即 如果g()捕获了a, 且在f()内调用了g(), 则视为f()也捕获了a

此时, 如果a是var变量, 那么g()和f()都禁止作为一等公民使用

静态成员变量和全局变量的访问, 不属于变量捕获, 因此访问了var修饰的全局变量、静态成员变量的函数或lambda仍可作为一等公民使用

1
class C {
2
    static public var a: Int32 = 0
3
    static public func foo() {
4
        a++                           // OK
5
        return a
6
    }
7
}
8

9
var globalV1 = 0
10

11
func countGlobalV1() {
12
    globalV1++
13
    C.a = 99
14
    let g = C.foo                     // OK
15
}
16

17
func g(){
18
    let f = countGlobalV1             // OK
19
    f()
20
}