(一)函数

---

1.如果函数的传入参数不同时，函数名可以是一样的（但是传入参数一样，返回值不一样的时候不行?或许某种方式可以区别）

2.如果函数的返回参数有多个，可以通过元祖返回 -> (min:Int , max:Int)

3.name为参数名称,realName为参数标签,在函数内部使用的为参数名称(即位于后面的),在调用函数时使用的为参数标签(即位于前面的)

greeting(realName: "张驰")

func greeting(realName name:String) {
        print("你好 \(name)")
    }

4.如果函数有参数标签并且用表示的话，调用函数的时候可以不显示名称。（不使用参数标签时，调用函数时必须显示标签名称，如果没有标签名称则必须显示参数名称）

///参数标签为_时
greeting("张驰")
func greeting(_ name:String) {
        print("你好 \(name)")
    }

///参数标签正常时
greeting(helloMan: "张驰")
func greeting(helloMan name:String) {
        print("你好 \(name)")
    }

///没有参数标签时
greeting(name: "张驰")
func greeting(name:String) {
        print("你好 \(name)")
    }

5.函数默认参数值，设置默认参数值之后，函数调用的时候可以不显示这个参数，也可以带上，且带上时的参数会覆盖默认参数。

///此时 输出的time值为7
greeting(helloMan: "张驰", time: 7)
///这个函数也可以这样调用  greeting(helloMan: "张驰")
func greeting(helloMan name:String, time:Int = 3) {
        print(time)
    }

6. 这种写法默认传入一个该类型的数组，但是写参数的时候实际上还是多个该类型的参数。 (一个函数里只能有一个可变参数，但是可以同时存在其他参数)

let x = average(1,2,3,4,5)
        print(x)
func average (_ numbers:Double...) -> Double {
        var total:Double = 0
        
        for item in numbers {
            total += item
        }
        return total / Double(numbers.count)
    }

7.在函数内部，参数默认是let不可变得。

8.如果想要参数指在函数内部可以修改并且可以影响传入时的值，则在参数类型前面加一个inout，传入的对应参数必须是可变的，不能为let，参数不能有默认值（如 func action(a:Int = 2){.....}）（类似于传入了一个指针地址，所有内部修改，外部的值也跟着改变了）

9.每个函数都有特定的函数类型，比如下面函数的类型为 (Int,Int)->Int (传入参数类型为Int，Int 传出类型为Int)

func plus (_ a:Int,_ b:Int) -> Int {
        return a + b
    }

下面这个函数的类型为 ()->void

func printHelloWorld() {
    print("hello, world")
}

10.嵌套函数只能被函数内部调用。将嵌套函数作为返回值，就相当于可以在函数外部调用嵌套函数了。

(二)闭包

---

1. 闭包采取如下三种形式之一：

• 全局函数是一个有名字但是不会捕获任何值得闭包。
• 嵌套函数是一个有名字且可以捕获其封闭函数域内值得闭包。
• 闭包表达式是一种利用轻量级语法所写的可以捕获其上下文中的变量或者常量值的匿名闭包。

提倡以下优化:

• 利用上下文推断参数和返回值的类型。
• 隐式返回单表达式闭包，即单表达式闭包可以省略return。
• 参数名称缩写。
• 尾随闭包语法。

2.闭包表达式。闭包表达式可以是inout参数，但是不能有默认值，使用可变要放在最后一位，可以使用元祖作为参数或者返回值。

let names = [1,4,2,3,5]
        
        let x = names.sorted { (a1:Int,a2:Int) -> Bool in
            return a1>a2
        }
        print(x)
        
        let x2 = names.sorted { (a1:Int,a2:Int) -> Bool in
            return a1>a2
        }
        print(x2)
        
        //根据上下文推断类型.
        let x3 = names.sorted { a1, a2 in
            return a1>a2
        }
        print(x3)
        
        //单表达式闭包隐式返回 (函数实体只有一行时使用)
        let x4 = names.sorted { a1, a2 in
            a1>a2
        }
        print(x4)
        
        //参数名称缩写
        let x5 = names.sorted { $0>$1 }
        print(x5)
        
        //运算符方法
        let x6 = names.sorted(by: >)
        print(x6)

3.尾随闭包:如果你需要讲一个很长的闭包表达式传入函数并作为最后一个参数，可以使用尾随闭包来增强代码的可读性。
如果闭包是函数的唯一参数时，甚至可以隐藏()

reversedNames = names.sorted { $0 > $1 }

4.闭包或者参数总是常量，除非是 outin修饰的。闭包捕获的应该是变量的引用，如果在闭包内或者闭包结束后变量的值没有改变，改为捕获一份对值得拷贝。