Swift函数与闭包-(函数)

Posted on Edited on In ,

Swift函数与闭包

函数

定义函数

swift的函数声明使用func关键字，当我们声明一个函数时，我们需要指定其返回值类型，并且在函数中按照指定的类型返回数据。

函数声明(Function)可以是在类class当中的，也可以独立在class外使用。当函数声明在类当中时，我们通常称其为方法(Method)。

下面这个函数是计算两个整形数据的值的：

1
2
3
4
5
func intAdder(x: Int, y:Int) -> Int {
    return x + y
}
let intNum = intAdder(10, y: 20)
print(intNum)

在这个函数当中，我们指定了它的参数名与参数类型(x:Int, y:Int)以及函数的返回值类型(->Int)。参数类型限定了传入参数的数据类型，而返回值则指定了返回的数据类型。在有返回值的时候，我们都是使用数据类型来指定返回类型的。在无需返回值的函数当中，我们可以指定返回值为Void或者省略返回值类型。

1
2
3
4
5
6
7
8
9
10
11
# Void
func sideEffectAdder(x:Int, y:Int) -> Void {
    print("Added value is \(x + y)")
}
sideEffectAdder(3, y:4) 

# leave it empty
func sideEffectAdderEmpty(x:Int, y:Int) {
    print("Added value is \(x + y)")
}
sideEffectAdder(3, y:4)

参数别名

swift允许我们为函数定义外部调用的别名。那intAdder这个方法来说明：

1
2
3
4
5
6
7
8
9
func intAdder(x: Int, y:Int) -> Int {
    return x + y
}
intAdder(10, y: 20)

func intAdder(first x: Int, second y:Int) -> Int {
    return x + y
}
intAdder(first: 10, second: 20)

上面两个同名的function可以并列存在（事实上，函数名相同的function如果外部参数名不一样，都可以在一起共存），只是我们调用的时候可以使用不同的参数名；

需要注意的是，一旦我们给函数定义了参数别名，在调用的时候一定要使用别名传参；

同时在多个参数的时候，我们可以指定某一个或者几个参数的参数别名，只需要在调用的时候使用参数别名就好。

默认情况下，swift对于多参数的调用除了第一个参数可以不写参数名，其后续的参数都是需要写参数名的。有的时候，对于参数的顺序我们并不是太care，或者我们并不想写后续参数名，我们可以使用_的方式作为别名来写函数：

1
2
3
4
5
func intAdder (x: Int, _ y:Int) -> Int {
    return x + y
}
let intNum5 = intAdder(10, 30)
print(intNum4)

不定长参数

有时候，我们传递的参数是不定个数的，这个时候我们可以使用...来指代，使用起来比较简单，直接在单参数后面加上...即可。

1
2
3
4
5
6
func sayHelloTo(names:String...)-> String{
    let names = names.joinWithSeparator(" and ")
    return("Hello to \(names)")
}
sayHelloTo("Jack") // Hello to Jack
sayHelloTo("Jack", "Jill") // Hello to Jack and Jill

...定义的参数列表有些类似于数组。使用的时候可以通过Array.joinWithSeparator来操作。

多参数时的不定长参数是可以在放置在参数的各个顺序的，当使用不定长参数时，不能使用_来省略参数名。当指定了多个不定长参数，我们只需要明确其参数名即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
func saySomethingToSomebody(thing: String, _ names:String...)-> String{
    let names = names.joinWithSeparator(" and ")
    return("Say \(thing) to \(names)")
}
saySomethingToSomebody("Morning", "Jack") // Say Morning to Jack
saySomethingToSomebody("Good night", "Jack", "Jill") // Say Good night to Jack and Jill

func saySomethingToSomebodySometimes(thing: String, names:String..., times: Int)-> String{
    let names = names.joinWithSeparator(" and ")
    return("Say \(thing) to \(names) \(times) times")
}
saySomethingToSomebodySometimes("Morning", names: "Jack", times: 100) // Say Morning to Jack 100 times
saySomethingToSomebodySometimes("Good night", names: "Jack", "Jill", times: 200) // Say Good night to Jack and Jill 200 times

可选型返回值

有时候，函数的逻辑不一定能返回特定类型的值，它还可能返回nil。对于这种情况，我们需要将函数的返回值类型定义成可选型。

1
2
3
4
5
6
7
8
9
10
11
func evenAdder(x:Int, _ y:Int) -> Int? {
    let even = (x % 2 == 0, y % 2 == 0)
    switch even{
    case (true, true):
        return (x + y)
    default:
        return nil
    }
}
evenAdder(2, 4) // {Some 6}
evenAdder(2, 3) // nil

多返回值[元祖]的函数

元组是swift当中的一种数据类型。函数也可以返回这种类型。

1
2
3
4
5
6
func postDataToServer() -> (status: Int, message: String) {
    return (200, "Success")
}
postDataToServer() //(.0 200, .1 "Success")
postDataToServer().status //200
postDataToServer().1 //"Success"

除了将元组类型写到返回值的地方，我们也可以通过typealias来声明一个元组作为返回值类型。

1
2
3
4
5
6
7
typealias Response = (status: Int, message: String)
func response() -> Response {
    return (200, "Success")
}
response()
response().status
response().1

返回值类型为函数的函数

函数是swift的头等公民，我们可以将函数赋值给一个变量，然后将这个变量作为其它函数的返回值类型。这一点正是swift函数式编程的一种体现。

swift当中的函数可以作为变量类型来操作，我们可以通过这种特性在任何地方使用函数作为数据类型。所以，我们也可以把函数当做函数的返回值类型：

1
2
3
4
5
6
7
8
9
func capitalize(s:String) -> String {
    return s.capitalizedString
}
capitalize("hello") // "Hello"

func applyToString(s:String, f:(String)->String) -> String {
    return(f(s))
}
applyToString("hello", f: capitalize) // "Hello"

swift当中有很多使用函数作为返回值类型的例子。比如map,reduce,sort等等。。。

1
["a", "b", "c"].map(capitalize) // ["A", "B", "C"]

###函数嵌套

在swift当中，我们可以使用嵌套函数。

1
2
3
4
5
6
7
8
9
10
func makeLogger() -> (String) -> String {
    func log(s:String) -> String {
        print(s)
        return(s)
    }
    return(log)
}

let myCustomLog = makeLogger()
myCustomLog("I am a message") // I am a message