【第六章-函数】0. 前言部分

【6.0 前言】

一、笔记一

1.函数可以像Int或者String那样被赋值给变量,也可以作为另一个函数的输入参数,或者另一个函数的返回值来使用
2.函数能够捕获其作用域之外的变量
3.有两种方法可以创建函数,一种是func关键字,另一种是{ }. 在swift中,后一种被称为`闭包表达式`

例如1：函数赋值给变量

    func test1() {
        let funcVar = printInt
        funcVar(2)
    }
    
    func printInt(i: Int) {
        print("you passed \(i)")
    }
    

例如2：写一个接受函数作为参数的函数

    // 写一个接受函数作为参数的函数
    func useFunction(function: (_ passValue: Int) -> ()) {
        function(4)
    }
    
    func test2() {
        let funcVar = printInt
        useFunction(function: printInt(i:))
        useFunction(function: funcVar)
    }
    
    // 这样,就可以写出"高阶"函数了
    // 也可以在其他函数中,返回一个函数
    func returnFunc() -> (Int) -> String {
        func innerFunc(_ i: Int) -> String {
            return "you passed \(i)"
        }
        
        return innerFunc(_:)
    }

例如3：函数可以捕获存在于他们作用范围之外的变量

    func counterFunc() -> (Int) -> String {
        var counter = 0
        func innerFunc(_ i: Int) -> String {
            counter += i
            return "running total: \(counter)"
        }
        
        return innerFunc(_:)
    }
    
    
    func test4() {
        let f = counterFunc()
        print(f(3))
        print(f(4))
        
        let g = counterFunc()
        print(g(2))
        print(g(7))
        // 打印结果:
        /*
         running total: 3
         running total: 7
         running total: 2
         running total: 9
         */
        // 上述结果不会互相影响
    }

二、笔记二

函数可以使用{ } 来声明为闭包表达式
在swift中,定义函数的方法有两种
1. 使用func关键字
2. 使用闭包表达式

例如1：使用func关键字

    func doubler(i: Int) -> Int {
        return i * 2
    }
    
    func test5() {
        let res = [1, 2, 3, 4].map(doubler)
        print(res)
    }

例如2: 使用闭包表达式

// 使用闭包表达式
    func test6() {
        let doubleAlt = {(i: Int) -> Int in
            return i * 2
        }
        let res = [1, 2, 3, 4].map(doubleAlt)
        print(res)
        
        let res1 = [1, 2, 3].map{ $0 * 2}
        
        // MARK: 笔记3
        // 简化之路:
        let res2 = [1, 2, 3].map( { (i: Int) -> Int in return i * 2 } ) //最原始写法
        let res3 = [1, 2, 3].map( { i in return i * 2 } ) // 根据数组自动推导参数类型为Int
        let res4 = [1, 2, 3].map( {i in i * 2 } ) // 只包含单一表达式,可以省略return
        let res5 = [1, 2, 3].map( {$0 * 2 } ) // swift自动为函数的参数提供简写形式,$0表示第一个参数,$1表示第二个参数,以此类推
        let res6 = [1, 2, 3].map() { $0 * 2 } // 函数的最后一个参数是闭包表达式,可以将闭包表达式移到函数调用的圆括号的外部
        let res7 = [1, 2, 3].map { $0 * 2 } // 如果一个函数除了闭包表达式没有别的参数,那么方法名后面的调用时的圆括号也可以省略
        
        print(res1,res2,res3,res4,res5,res6,res7)
    }

例如3：使用闭包避免for循环

    func test7() {
        var arr = [UInt32]()
        for _ in 0..<3 {
            let res = arc4random()
            arr.append(res)
            print(res)
        }
        print(arr)
        
        let res = (0..<3).map{ _ in arc4random() }
        print(res)
    }
    

例如4：闭包的类型推导

    
    func test8() {
        let isEven = { $0 % 2 == 0 } // 这里isEven被推断为: Int -> Bool
//        ExpressibleByIntegerLiteral
        
        // 指定其他返回类型的几种方式
        let isEvenAlt = { (i: Int8) -> Bool in i % 2 == 0 }
        let isEvenAlt2: (Int8) -> Bool = { $0 % 2 == 0 }
        let isEvenAlt3 = { $0 % 2 == 0 } as (Int8) -> Bool
        
        let a: NSInteger = 3
//        a.NSIntegerisEven
//        4.isEven
        let res = isEvenV(i: 3)
        print(res)
    }

例如5: 定义一个顶层函数

    // 定义一个顶层函数
    func isEvenV<T: FixedWidthInteger>(i: T) -> Bool {
        return i % 2 == 0
    }
       
    // 如果想要把这个顶层函数赋值给变量,那么需要决定它的具体类型.
    // 因为变量不能持有泛型函数
    func test9() {
        let int8isEven: (Int8) -> Bool = isEvenV
        let a: Int8 = 3
        let res = int8isEven(3)
        print(res)
    }

// 也可以写个扩展
/*
extension Int {
    var isEven: Bool {
        return self % 2 == 0
    }
}

extension NSInteger {
    var NSIntegerisEven: Bool {
        return self % 2 == 0
    }
}
*/

最后总结：关于命名的问题

// 关于命名的问题:
// 1. 使用func声明的函数也可以是闭包,就和 { } 声明的是一样
// 2.闭包指的是一个函数及其捕获的变量的组合
// 3. 闭包表达式和func函数没有区别,都可以是函数,也都可以是闭包