Swift 1

Swift 中函数使用指南

关于Swift中的各种函数的使用的总结

前言

时间久了，好多东西我们就会慢慢忘记，在这里总结一下Swift中函数的使用原则，把大部分的函数使用技巧用代码示例来做了演示，但是如果想提高，还是要多多思考才行

1.参数名

函数默认会带参数名，如果不想显示参数名，可以使用下划线_。

func createFamily(motherName: String, fatherName: String, babyName: String)  -> String {
    return motherName + fatherName + babyName
}

createFamily(motherName: "妈妈", fatherName: "爸爸", babyName: "bao'b")

2.多参数函数

多参数函数的使用，整个函数都是可以自定义的，实现非常灵活。（也叫可变参数）

func sum(numbers: Int...) -> Int {
    var total: Int = 0
    for number in numbers {
        total += number
    }
    return total
}

sum(numbers: 1, 2, 3, 4, 5, 6)

3.可变参数

注意，在最新的swift中，已经不允许在参数中使用var了，可以使用下边的这个值传递的方式实现

func factorial(number: Int) -> Int {
    var number = number
    var res: Int = 1
    while number > 1 {
        res = res * number
        number = number - 1
    }
    return res
}

var number: Int = 4
let b = factorial(number: number)

通过a: inout 这种方式可以在函数内修改参数的值，但是在使用中还是要加入&，目的是访问参数的指针地址

func swap(a: inout Int, b: inout Int) {
    let temp = a
    a = b
    b = temp
}

var a = 10
var c = 20
swap(&a, &c)
print("a: \(a), b: \(c)")

4.函数的高级用法

1.函数本身也是一种类型

func sayHello() -> Void { // 该函数的类型为() -> ()

}
// 该函数的类型为(Dictionary<String, String>) -> (Int, Int)
func count(kids: Dictionary<String, String>) ->
    (girls: Int, boys: Int) {
    return (1, 2)
}

2.函数作为变量,这也验证了函数类型和函数作为值来进行赋值

var countFunc: (Dictionary<String, String>) -> (Int, Int) = count

let kids: Dictionary<String, String> = ["123" : "456"]
print(countFunc(kids))

3.函数类型作为返回值

// 这个示例是这样的，我们根据用户的输入("吃""喝")来选择不同的函数进行打印
typealias NoParameterFunc = (() -> ()) // 可以为一个类型起一个别名
func eat() -> Void {
    print("吃了一块饼干")
}
func drink() -> Void {
    print("喝了一杯水")
}

func doSomethingWithIdentifier(identifier: String) -> (NoParameterFunc)? {
    switch identifier {
    case "吃":
        return eat  //因为我们返回的是一个函数类型，所以使用eat，要是使用eat()就返回一个函数了
    case "喝":
    return drink
    default:
        return nil
    }
}

let doSomething = doSomethingWithIdentifier(identifier: "吃")
if  let doSomething = doSomething {
    doSomething() //调用函数
}

4.嵌套函数

// 函数内部依然可以有函数，我们队上边的例子进行改造,结果一样
func anotherDoSomethingWithIdentifier(identifier: String) -> (NoParameterFunc)? {

    func eat1() -> Void {
        print("吃了一块饼干")
    }
    func drink1() -> Void {
        print("喝了一杯水")
    }
    switch identifier {
    case "吃":
        return eat1  //因为我们返回的是一个函数类型，所以使用eat，要是使用eat()就返回一个函数了
    case "喝":
        return drink1
    default:
        return nil
    }
}

5.柯里化函数

在swift3.0中已经被移除，原因是使用场景不多，且使语言变得复杂，大家了解下就好了

func add(a: Int, b: Int, c: Int) -> Int {
    return a + b + c
}

let d = add(a: 1, b: 2, c: 3)

// swift3.0中支持的柯里化
func addCur(a: Int) -> (_ b: Int) -> (_ c: Int) -> Int {
    return {
        (_ b: Int) -> (_ c: Int) -> Int  in
        return {
            (_ c: Int) -> Int in
            return a + b + c
        }
    }
}

6.闭包

func compare(l1: Int, l2: Int) -> Bool {
    return l1 > l2
}

let numbers = [2, 3, 6, 8, 1]
let sortedNumbers = numbers.sorted(by: { (l1: Int, l2: Int) -> Bool in return l1 > l2})
print(sortedNumbers)

let sortedNumbers1 = numbers.sorted(by: { (l1, l2) in l1 > l2})
print(sortedNumbers1)

let sortedNumbers2 = numbers.sorted(by: { $0 > $1})
print(sortedNumbers2)

let sortedNumbers3 = numbers.sorted(by: >)
print(sortedNumbers3)

// 尾闭包函数
// 当函数中的参数中使用了闭包，而且闭包内部很复杂，且闭包是最后一个参数时，才能使用尾闭包
let sortedNumbers4 = numbers.sorted() { // 同样是上边的例子，我们可以使用尾闭包，好处是增加代码的阅读性
    $0 < $1
}
print(sortedNumbers4)

总结

基本上掌握了这些函数的使用，在开发中也就够用了，要进阶，可以多了解函数响应式编程。