Swift函数

一.函数

1.函数定义

• 函数的定义
  • 格式 func 函数名(行参列表) -> 返回值 {代码实现}
  • 调用 let result = 函数名(参数1: 值1, 参数2: 值2...)

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

// Swift 1.0 `sum(10, 50)`
// Swift 2.0 `sum(10, y: 50)`
// SWift 3.0 `sum(x: 10, y: 50)`
print(sum(x: 10, y: 50))

2.函数的外部参数

• 外部参数

// MARK: - 函数的外部参数
// - 在形参名前再增加一个外部参数名，能够方便调用人员更好地理解函数的语义
func sum1(num1 x: Int, num2 y: Int) -> Int {
    return x + y
}

• 省略外部参数

// - 在形参前使用 `_`，表示外部参数能够省略，更适合其他语言的程序员的习惯
func sum2(_ x: Int, _ y: Int) -> Int {
    return x + y
}

3.函数的默认值

• 定义带默认值的函数

// MARK: - 函数的默认值
func sum3(x: Int = 20, y: Int = 30) -> Int {
    return x + y
}

• 调用带默认值的函数

说明：包含默认值的函数可以不用传递，并且可以任意组合

// 默认值
print(sum3())
print(sum3(x: 10, y: 20))
print(sum3(x: 1))
print(sum3(y: 1))

• 函数格式小结

  • 包含默认值的函数可以不用传递，并且可以任意组合
  • _ 可以忽略外部参数，与其他语言的函数风格更加类似
  • 外部参数 供外部调用使用，形参 在函数内部使用

4.没有返回值

• 没有返回值的函数，一共有三种写法
  • 省略
  • ()
  • Void

// MARK: - 没有返回值
/**
 Swift 中支持三种没有返回值的情况

 - 省略
 - ()
 - Void

 返回值的格式主要应用于闭包
 */
func demo1() {
    print(#function)
}

func demo2() -> () {
    print(#function)
}

func demo3() -> Void {
    print(#function)
}

二.闭包

OC 中 Block 概念回顾

• 闭包类似于 OC 中的 Block
  • 预先定义好的代码
  • 在需要时执行
  • 可以当作参数传递
  • 可以有返回值
  • 包含 self 时需要注意循环引用

1.闭包的定义

• 定义一个函数

//: 定义一个 sum 函数
func sum(x: Int, y: Int) -> Int {
    return x + y
}

// 定义一个指向函数的常量
// 在 Swift 中函数本身就可以当作参数被定义和传递
let sumFunc = sum

// 执行函数常量
print(sumFunc(x: 10, y: 30))

• 闭包的四步演练

// 1> 最简单的闭包
let myBlock1 = {
    print("hello block")
}

myBlock1()

// 2> 闭包的完整写法，闭包的所有内容都包含在 {} 中
// `in` 用于区分闭包的参数和实现代码
let myBlock2 = { () -> () in
    print("hello myBlock2")
}

myBlock2()

// 3> 带参数的闭包
let myBlock3 = { (x: Int, y: Int) -> () in
    print(x + y)
}
myBlock3(10, 20)

// 4> 带返回值的闭包
let myBlock4 = { (x: Int, y: Int) -> Int in
    return x + y
}

print(myBlock4(10, 50))

2.闭包使用

(1)GCD

• 异步加载数据

/// GCD 模拟异步加载数据
func loadData() -> () {

    // GCD 概念：将任务添加到队列，并且指定任务的执行函数
    // 翻译 -> `队列` 调度 `任务` 以 `同步/异步` 方式执行
    DispatchQueue.global().async {

        print("异步耗时加载数据 \(Thread.current())")

        let json = ["新闻1", "新闻2", "出大事了"]

        DispatchQueue.main.async(execute: {

            print("主线程回调 \(Thread.current()) \(json)")
        })
    }

    print("come here")
}

(2)添加回调闭包

/// GCD 模拟异步加载数据
func loadData(completion: @escaping ([String])->()) -> () {

    // GCD 概念：将任务添加到队列，并且指定任务的执行函数
    // 翻译 -> `队列` 调度 `任务` 以 `同步/异步` 方式执行
    DispatchQueue.global().async {

        print("异步耗时加载数据 \(Thread.current())")

        let json = ["新闻1", "新闻2", "出大事了"]

        DispatchQueue.main.async(execute: {

            print("主线程回调 \(Thread.current()) \(json)")

            completion(json)
        })
    }

    print("come here")
}

@escaping：逃逸性闭包，标示该闭包会在其他方法/闭包内部被执行

(3)尾随闭包

• 尾随闭包，如果闭包是最后一个参数，可以提前结束函数，最后一个参数直接使用 {} 闭包的方式传递

// 尾随闭包写法
// - 如果闭包是最后一个参数，函数可以提前结束，并且在末位直接追加 `{}` 闭包
// - 尾随闭包可以省略参数名
loadData { (result) in
    print("--- \(result)")
}

// 函数参数的写法
loadData(completion: {result in
    print("--- \(result)")
})