Swift 4 函数与闭包小结

1. 函数的基本格式和使用

//关键字 函数名 (参数)  返回值
func sum(x:Int, y:Int) -> Int {
    return x + y
}

let result = sum(x: 5, y: 6)

//外部参数: 在形参前加一个名字
//外部参数: 不会影响函数的内部调用细节
//外部参数: 让外部调用更加明朗
//外部参数: 使用_,外部调用时,会隐藏形参名称
//外部参数: num1,num2  内部参数: x,y
func sum2(num1 x:Int, num2 y:Int) -> Int {
    return x + y
}

let result2 = sum2(num1: 3, num2: 4)

func sum3(_ x:Int, _ y:Int) -> Int {
    return x + y
}

let result3 = sum3(4, 5)

//MARK: 默认值问题
func sum4(x:Int = 2, y:Int = 4) -> Int {
    return x + y
}
//都可正确计算,不传值默认使用默认值
var result4 = sum4()
      result4 = sum4(x:4)
      result4 = sum4(y:5)
      result4 = sum4(x:4, y:5)

2. 无返回值函数

//MARK: 无返回值的情况
//1. 直接省略
//2. ()
//3. Void
func sum5() {
    print(#function)
}
func sum6() -> () {
    print(#function)
}
func sum7() -> Void{
    print(#function)
}

3. 闭包和关键字in

//MARK: 闭包  在swift中函数也是对象
//swift中,函数式特殊的闭包
//应用场景:1.异步执行完成回调
//应用场景:2.控制器间回调
//应用场景:3.自定义视图回调
//注意事项: 包含self时,注意循环引用

func sum8(x:Int, y:Int) -> Int {
    return x + y
}

//(Int, Int) -> Int
//使用常量记录函数
let results = sum8
print(results(40, 50))

//1. 最简单的闭包--类型  () -> ()  没有参数,没有返回值的匿名函数
let clourse1 = {
    print("简单闭包")
}
//执行闭包
clourse1()

//2. 标准闭包: 无参数,无返回值 :
//使用in关键字分割  无参无返回值,直接省略 () -> () in
//格式: { (参数) -> 返回值类型  in  代码实现   }
let clourse2 = { () -> () in
    print("标准闭包")
}
//闭包执行---   let clourse2: () -> ()
clourse2()

//3. 有参无返回值的闭包
let clourse3 = { (x: Int) -> () in
    print("有参无返回值的闭包")
}
//执行闭包--> let clourse3: (Int) -> ()
clourse3(3)

//4. 有参无返回值的闭包--简写
let clourse4 = { (x: Int) in
    print("有参无返回值的闭包--简写")
}
//let clourse4: (Int) -> ()
clourse4(5)

//5. 无参,有返回值的闭包
let clourse5 = { () -> Int in
    print("无参,有返回值的闭包")
    return 100
}
//let clourse5: () -> Int
let a = clourse5()

//6. 有参,有返回值的闭包
let clourse6 = { (x: Int) -> Int in
    print("有参,有返回值的闭包")
    return 100
}
//let clourse6: (Int) -> Int
let b = clourse6(6)

3. 闭包应用之GCD线程间通信写法

DispatchQueue.global().async {
    print("异步子线程")
    DispatchQueue.main.sync(execute: {
        print("回到主线程")
    })
}

4.闭包(尾随闭包)值网络请求数据简单示例

import UIKit

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        loadData { (result, error) in
            guard let result = result else {return}
            print(result)
        }
    }

    //关键字     变量         变量类型   () -> ()
    //let             callBack: ((_ result: [String : Any]?, _ error: Error?) -> ())
    func loadData(callBack: @escaping ((_ result: [String: Any]?, _ error: Error?) -> ())) -> () {
        DispatchQueue.global().async {
            //异步获取json数据
            let json = [
                "name":"zhouyu",
                "age":16,
                "blog":"https://blog.csdn.net/kuangdacaikuang",
                "work":"iOS开发工程师"
                ] as [String : Any]
            DispatchQueue.main.sync(execute: {
                //主线程处理数据
                var error: Error?
                callBack(json,error)
            })
        }
    }
}

5.尾随闭包

//如果函数最后一个参数是闭包,函数参数可以提前结束,最后一个参数直接使用{}包装的闭包代码

//函数不带有额外参数传入
func loadData2 (callBack: @escaping ((_ result: [String: Any]?, _ error:Error?) -> ())) -> () {
    let json = ["name":"zhouyu","age":28] as [String: Any]
    var error:Error?
    callBack(json,error)
}

//尾随闭包
loadData2 { (result, error) in
    guard let result = result else { return }
    print(result)
}

//函数带有额外参数传入
func loadData (userId: String, callBack: @escaping ((_ result: [String: Any]?, _ error:Error?) -> ())) -> () {
    print(userId)
    let json = ["name":"zhouyu","age":28] as [String: Any]
    var error:Error?
    callBack(json,error)
}

//尾随闭包
loadData(userId: "123456789") { (result, error) in
    guard let result = result else { return }
    print(result)
}

6. 闭包与循环引用 [weak self]

import UIKit

class ViewController: UIViewController {

    var dataSoure:[String: Any]?

    override func viewDidLoad() {
        super.viewDidLoad()

        //[weak self] 闭包中,[weak self],代替闭包中所有的self
        loadData { [weak self]  (result, error) in
            guard let result = result else {return}
            print(result)
            self?.dataSoure = result
            print(self?.dataSoure)
        }
    }

    //关键字     变量         变量类型   () -> ()
    //let             callBack: ((_ result: [String : Any]?, _ error: Error?) -> ())
    func loadData(callBack: @escaping ((_ result: [String: Any]?, _ error: Error?) -> ())) -> () {
        DispatchQueue.global().async {
            //异步获取json数据
            let json = [
                "name":"zhouyu",
                "age":16,
                "blog":"https://blog.csdn.net/kuangdacaikuang",
                "work":"iOS开发工程师"
                ] as [String : Any]
            DispatchQueue.main.sync(execute: {
                //主线程处理数据
                var error: Error?
                callBack(json,error)
            })
        }
    }
}

["name": "zhouyu", "age": 16, "blog": "https://blog.csdn.net/kuangdacaikuang", "work": "iOS开发工程师"]

Optional(["name": "zhouyu", "age": 16, "blog": "https://blog.csdn.net/kuangdacaikuang", "work": "iOS开发工程师"])

//表示闭包中所有的self都是弱引用,需要注意解包
[weak self]
//表示闭包中所有的self都是assign修饰,不会强引用,如果对象释放,指针地址不会变化,对象释放后,继续调用,会出现野指针
[unowned self]