Swfit的学习大致有几个重点：
元组，可选兴，函数，闭包
这些是较之OC有很大不同的地方，学会了这些swift也算是入门了

闭包有三种形式：
全局函数：有名字但不能捕获任何值。
嵌套函数：有名字，也能捕获封闭函数内的值。
闭包表达式:无名闭包，使用轻量级语法，可以根据上下文环境捕获值。

捕获值

1、闭包可以在其定义的上下文中捕获常量或变量。即使定义这些常量和变量的原域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。我认为可以理解为捕获增加了原常量或变量的引用计数。
2、Swift最简单的闭包形式是嵌套函数，也就是定义在其他函数的函数体内的函数。嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。

func makeIncrementer(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementer() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}

let a = makeIncrementer(forIncrement:10)
print(a())

全局函数

什么叫全局函数？全局函数不能捕获值？啥意思呢？一阵懵逼。


func testGlobalFunc()
{
//这不是捕获了外部的value吗？
    print(value);
}

testGlobalFunc()

我的理解是这样的：
全局函数是定义在类之外的不属于任何类的函数。
写OC的时候常常会用到各种宏定义,但是Swift中没有宏,通常是通过全局常量或者全局函数来实现这一效果.我们只需要建一个文件(假设叫Global.swift),把想用的定义在里面,无须导入头文件什么的,就可以在全局用啦.
在类中实现的函数是成员函数，也就是我们一般说的函数

//
//  Global.swift
//
//  Created by apple on 2020/3/29.
//

import Foundation
import UIKit

/**
 *   替代oc中的#define,列举一些常用宏
 */
let kScreenWidth = UIScreen.main.bounds.size.width

// 屏幕的物理宽度
func kScreenWidthFun() ->CGFloat
{
    return kScreenWidth
}

func kScreenHeighFun() ->CGFloat
{
    return UIScreen.main.bounds.size.height
}

一、闭包引入

普通函数写法

func square(num:Int)->Int{
   return num*num
}
print(square(num:3))

闭包写法

let fun1 = {
    (num:Int)->Int in
    return num*num
}
print(type(of:fun1))//fun1类型：(Int) -> Int
print(fun1(4))

闭包表达式语法
1、由一对{}开始和结束；
2、in关键字把闭包分成两部分：参数与返回值、闭包体
思考1：demo是不是一个闭包

let demo = {print("hello")}
print(type(of:demo))// () -> ()

第二部分：闭包缩写

需求：把我们的java成绩放到了一个数组里，定义一个函数，把大于某个阈值的成绩返回给我

func getScore(score:[Int],con:(Int)->Bool)->[Int]{
    var newScore = [Int]()
    for item in score{
        if con(item){
            newScore.append(item)
        }
    }
    return newScore
}
var score = [66,89,80,33,100]
print(getScore(score:score,con:{(s:Int)->Bool in return s>40}))

省略1：省略->返回类型(自动推断出返回值是一个Bool)

print(getScore(score:score,con:{(s:Int) in return s>40}))

省略2：省略参数类型和括号(自动推断出参数类型是Int)

print(getScore(score:score,con:{s in return s>40}))

省略3：单行表达式闭包可以省略 return 关键字来

print(getScore(score:score,con:{s in s>40}))

省略4：省略参数列表定义，用 $0,$ 1等等指代参数，同时省略in

print(getScore(score:score,con:{$0>40}))

第三部分：尾随闭包

使用情景：当闭包表达式作为最后一个参数传递给函数时，可以单独提出来
问题1：尾随指的是跟在别人后面闭包到底跟在谁后面？-函数后面
问题2：用尾随闭包的好处？提升代码的可读性

func printInfo(info:String,printFun:(String)->Void){
    printFun(info)
}

//普通调用方式
printInfo(info:"hello world",printFun:{s in print(s+"~~~")})

//使用尾随闭包进行调用
printInfo(info:"hello world"){s in print(s+"~~~")}

闭包是引用类型

let b = a
print(b()) //输出结果为20

let c = makeIncrementer(forIncrement:10)
print(c())

逃逸闭包

闭包要出逃，出逃到哪里呢？逃到函数外使用！牛掰！
需求：闭包作为一个参数传递一个函数，但是这个闭包我不立马使用，先把这个闭包存起来，过会再用

var recv:()->Void = {print("")}
var x = 10
//方案一：定义一个函数，接受一个普通闭包为参数
func test1(closure:()->Void){
    recv = closure //此段代码报错，原因是普通闭包作为参数，会在函数结束之后被销毁，无法在函数外使用。
}
test1{
    x=100
}
recv()

// 方案二：逃逸闭包
/*
逃逸闭包特点如下：
1、可以在函数结束后使用；
2、寿命长！逃逸闭包声明周期长于函数，只要它的引用被其他对象持有，就不会随着函数结束而释放掉
3、通过@escaping 指定一个闭包是逃逸闭包
*/
func test2(closure:@escaping ()->Void){
    recv = closure 
}
test2{
    x = 200
}
recv()
print(x)

逃逸闭包在网络访问中会经常用到！

Swift之闭包