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)

总结

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

巴特西

Swift 1