函数
是一种特殊的闭包
// 无参无返回值的三种写法
func a() -> Void { ... }
func a() -> () { ... }
func a() { ... } //最简
// 有参数无返回值
func square(a: Int, b: Int) -> Int { return a * b }
// 有参数有返回值
func square(a: Int, b: Int) { ... } //最简
内部函数
在函数体内部定义的函数，调用需在声明后
func result() {
func sum(a: Int, b: Int) -> Int {
return a + b
}
//在内部函数声明的下面调用
print(sum(a: 20, b: 80))
}
外部参数及忽略
提供外部参数能增强函数的可读性，同时也能够让函数在内部使用参数更加简单
忽略外部参数用 “_” 表示
// frist/second表示外部参数，a标识函数的内部参数只能够在函数的内部使用
func sum(first a: Int, second b: Int) -> Int {
return a + b
}
sum(first: 10, second: 20);
// 忽略外部参数 “_”
func sum(_ a: Int, _ b: Int) -> Int {
return a + b
}
sum(10, 20);
函数小技巧
多返回值：元组类型
oc 中使用输出参数实现
使用元组来让一个函数返回多个值。该元组的元素可以用名称或数字来表示。
func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
var min = scores[0]
var max = scores[0]
var sum = 0
for score in scores {
if score > max {
max = score
} else if score < min {
min = score
}
sum += score
}
return (min, max, sum)
}
//let statistics: (min: Int, max: Int, sum: Int)
let statistics = calculateStatistics(scores:[5, 3, 100, 3, 9])
//或者print(statistics.2) 该元组的元素可以用名称或数字来表示
print(statistics)
不确定参数
oc 中使用 va_list 等宏实现
参数个数可变：函数可以带有可变个数的参数，这些参数在函数内表现为数组的形式
func nameFunc(names: String...) {
for name in names {
print(name, terminator: " ")
}
}
nameFunc(names: "zhangsan", "lisi", "wangwu")
// Prints "zhangsan lisi wangwu "
闭包
closure：Swift 中的 block
闭包是一个封闭的结构: 闭包的参数，返回值、需要执行的代码片段 都应该在闭包的内部
函数和闭包都是引用类型：无论你将函数或闭包赋值给一个常量还是变量，你实际上都是将常量或变量的值设置为对应函数或闭包的引用
// block
void(^callback)(NSString *) = ^(NSString *str) {
// code
}
// closure
let closure = { (str: String) -> () in
// code
}
写法
一般左边不写，参数类型和返回值类型在闭包内标明即可
- 无参无返回值
// 完整形式 左右都有 标明闭包类型
let closure:() -> () = { () -> () in
print("最简单的闭包完整形式")
}
// 简化：左边不写，右边标明闭包类型，返回值为空时，写（）和 Void 一样
let closure = { () -> Void in
print("返回值为空时")
}
// 最简形式
let closure = {
print("最简形式")
}
- 有参无返回值
let closure = { (a: Int, b: Int) in
print("\(a) + \(b) = \(a+b)")
}
- 有参有返回值
let closure = { (a: Int, b: Int) -> (String) in
return "\(a+b)"
}
尾随闭包
当函数的最后一个参数是闭包的时候，函数的参数的 '()' 可提前关闭。
如果函数只有闭包这一个参数, '()' 可以省略，如果闭包类型是无参无返回值，"() -> () in" 也可以省略。
是在调用函数的时候可以省略，而不是声明的时候
bug：如果写出来的闭包函数报错，可以在声明的时候把返回值写上，调用成功后再删除
func loadData(name: String, completed: (Int) -> ()) {
completed((name as NSString).length)
}
loadData(name: "abc") { (count) in
print("name's count = " + "\(count)")
}
//Prints "name's count = 3"
func cFunc(closure: () -> ()) {
closure()
}
cFunc {
// code
}
@escaping
逃逸闭包：当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸。当你定义接受闭包作为参数的函数时，你可以在参数名之前标注 @escaping，⽤来指明这个闭包是允许“逃逸”出这个函数的
@escaping：标识该闭包可以逃离当前的“语境”，写在闭包类型声明之前，闭包作为函数的参数是默认不可逃逸的。
@escaping 语境：
-
闭包在 async 需要逃逸、sync 不需要逃逸
-
闭包被引用，需要逃逸。
循环引用
方法一：[weak self] (推荐)
self 是可选项，如果 self 已经被释放，则为 nil
// 类似 OC 中：__weak typeof(self) weakSelf;
// 如果 self 已经被释放，则为 nil
loadData { [weak self] in
print("\(self?.view)")
}
方法二： [unowned self] （不推荐）
self 不是可选项，如果 self 已经被释放，则出现野指针访问
// 类似 OC 中：__unsafe_unretained typeof(self) weakSelf;
// 如果 self 已经被释放，则出现野指针访问
loadData { [unowned self] in
print("\(self.view)")
}
方法三：与 OC 类似
weak var weakSelf = self
loadData() {
print("\(weakSelf?.view)")
}
网络请求试写
func request(urlStr: String, compeletd:@escaping (Bool, Any) -> Void) {
guard let url = URL(string: urlStr) else {
return
}
DispatchQueue.global().async {
URLSession.shared.dataTask(with: url) { (data, _, error) in
if error != nil {
DispatchQueue.main.async {
compeletd(false, error!)
}
} else {
let json = try? JSONSerialization.jsonObject(with: data!, options: .mutableContainers)
DispatchQueue.main.async {
compeletd(true, json!)
}
}
}.resume()
}
}
