Swift-函数

函数的定义

格式 函数名（形参列表） -> 返回值类型

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

默认值

• 通过给参数设置默认值，在调用的时候，可以任意组合参数，如果不指定，就是使用默认值
• OC中需要定义很多的方法，以及方法实现

func sum2(x: Int = 1, y: Int = 2) -> Int {
        return x + y
    }

外部参数

• 外部参数就是在形参前加一个名字
• 外部参数不会影响函数内部的细节
• 外部参数会让外部调用方看起来更加直观
• 外部参数如果使用 ‘_ ’,z在外部调用函数时，会忽略形参的名字

 func sum1(num1 x: Int, num2 y: Int) -> Int {
        return x + y
    }
 func sum1( _ x: Int, _ y: Int) -> Int {
        // 在Swift中， _ 就是可以忽略任意不感兴趣的内容
        return x + y
    }

override func viewDidLoad() {
        super.viewDidLoad()  
        // Swift 1.0:sum(10,50),所有形参都会省略，其他程序员喜欢
        // Swift 2.0:sum(10,y:50),第一个形参省略
        // Swift 3.0
        print(sum(x: 10, y: 50))
        
        print(sum1(num1: 30, num2: 60))
        
        print(sum2())
        print(sum2(x: 3))
        print(sum2(x: 5, y: 6))
    }

无返回值

主要用在闭包

func demo() {
        print("哈哈")
    }

闭包

闭包类似于OC的block,但是比OC的block应用更广

• 在OC中block是匿名的函数
• 在Swift中函数是特殊的闭包

1.最简单的闭包

let  a = {
      print("hello")
}
// 执行闭包
a()

2.带参数的闭包
在闭包中参数、返回值、实现的代码都写在{} 中，要用一个关键字 'in' 来分隔定义和实现

// {形参列表 -> 返回值类型 in 实现代码}
let b = {(x: Int) -> () in
      print(x)
}
b(100)
let c = { (x: Int) -> Int in
     return x + 250
}
print(c(111))


func loadData(completion: @escaping ([String])->()) -> () {
        // 将任务添加到队列，指定执行任务的函数
        DispatchQueue.global().async {
            print("耗时操作 \(Thread.current)")
            
            let json = ["头条","八卦","娱乐"];
            
            DispatchQueue.main.async(execute: { 
                print("主线程更新 UI \(Thread.current)")
                
                // 回调 -> 执行 闭包（通过参数传递）
                completion(json)
            })  
        }  
    }

loadData { (result) in
            print("获取新闻数据 \(result)")
        }

闭包的应用场景

• 异步执行完成回调
• 控制器间回调
• 自定义视图回调

循环引用
接触循环引用，需要打断链条
方法1：OC的方法

// 细节 weak 只能修饰var,不能修饰let
weak var weakSelf = self
loadData{
              // 细节：解包有两种方式的解包1：？可选解包，如果self已经释放，不会像对象发送getter的消息，更加安全；2：！强行解包，如果self已经被释放，强行解包会导致崩溃
              print(weakSelf?.view)
}

方法2：Swift的推荐方法

// [weak self] 表示{}中的所有self都是弱引用，需要注意解包
loadData { [weak self] in
          print(self?.view)
}

方法3:不推荐使用

// [unowned self]表示{}中的所有self都是assign的，不会强引用，但是，如果对象释放，指针地址不会变化，如果对象释放，继续调用，就会出现野指针
loadData { [unowned self] in
          print(self.view)
}