[关闭]
@phper 2016-09-03T09:50:56.000000Z 字数 9890 阅读 848

swift 8. 函数

swift


今天这一篇学习swift中的函数。函数在任何一门语言中都占据着举足轻重的地位,半边江山都是它的。所以,这一节我会很仔细的学的。

go!

函数的申明和调用

函数的申明

什么是函数,这个就不用说了吧。有过其他任何一门语言基础的人都应该了解,就不过多解释啥是函数了,函数是一块封闭打包好的代码块,以供其他地方调用。那么swift中function 是如何申明的呢?

swift中申明函数使用的关键字是func 。我了个擦,你特么的用完整的function这几个字母会不会死啊!!!好吧,既然你学人家的东西,就只能跟着人家走了。

先举个例子来看如何申明一个函数的:

  1. func sayHello(personName: String) -> String {
  2. let greeting = "Hello, " + personName + "!"
  3. return greeting
  4. }

看,是不是觉得特别新奇,第一次见到这样子来写一个函数的。

func作为关键字前缀,用来申明这是一个函数。然后加上函数名(function name,用来描述这个函数是来干嘛的。紧接着是参数,参数必须是这个样子的:(参数名 :参数的类型)。可以有一个参数,也可以有多个,但都是这个样子书写的。返回值用箭头 -> 返回类型 这种方式来表示。

看明白了如何申明一个函数了吧,还是蛮简单的,相比其他语言中申明函数的方式,看完上面的之后,反而觉得这种方式还蛮清晰的。它很清晰定义描述了函数做什么,它期望接收什么和执行结束时它返回的结果是什么。

函数的调用

上面我们申明了2个函数sayHellosayWord,那么如何调用他们呢?这一点每个语言都是一样的,直接用函数名(参数)就可以了。

我们像这样子调用这2个函数

  1. var name = sayHello("yangyi")
  2. print(name)

那么我们也可以一次性的调用并将结果打印出来:

  1. print(sayHello("yangyi"))

值得注意的是:在你申明一个函数的参数是啥类型的时候,已经做了强制申明,所以在你调用这个函数传入的参数就一定是这个类型,不然会报错。

函数的参数与返回值

多个参数

一般函数,可以有一个参数,也可以有多个参数。和其他的语言一样,多个参数用,隔开

func funcName (参数名:参数的类型, 参数名:参数的类型...){

}

下面定义了一个三个参数的函数,用于获取个人的信息。

  1. func getInfo(name: String, country: String, age: Int) -> String {
  2. //有3个参数
  3. let info = "Hello, My name is " + name + "!" + " I'm from " + country + " I`m " + String(age) + " old now !"
  4. return info
  5. }
  6. //调用并打印
  7. print(getInfo("yangyi", country:"china", age:18))
  8. //输出:Hello, My name is yangyi! I'm from china I`m 18 old now !

上面这个例子我们用了3个参数,2个String 和 1 个Int来作为参数,你可能注意到我用String(age)来强制转换了,因为swift中是不允许String 和 Int 不同的类型想加的,必须转换成同类型的,才可以,否则直接报错。

你可能注意到了这行:

getInfo("yangyi", country:"china", age:18)

第一个参数直接传入yangyi,第二个和第三个参数,却必须要加上参数名,否则编辑器报错。为什么要这样呢?这是因为苹果认为,其余的参数必须得显示的传入参数的名字,更好的让开发者知道这个参数是干嘛的。不容易顺序出错。我们下面讲到内部参数和外部参数时,会继续深究。

无参数

作为一个函数,肯定是有无参的情况的,即没有参数输入,swift中的函数无参数输入和其他语言一样,括号()中留空就好了

  1. func sayHello() -> String {
  2. return "hello"
  3. }
  4. //调用并打印函数
  5. print(sayHello())
  6. //输出:hello

无返回值

swift中参数的返回值的类型是通过 ->返回值 这种形式来书写的,那一个函数没返回值咋搞呢?还不简单,直接把->返回值 去掉就可以了啊!哈哈哈哈哈哈哈哈~

  1. func sayHello() {
  2. print("hello")
  3. }
  4. //调用无参数也无返回值的函数
  5. sayHello()

多个返回值

一般现代的语言,返回值只有一个,要想返回多个值,要么是封装到一个数组当中返回,要么是对参数取值(&),再返回。所以基本就一个返回值。swift可以允许有多个返回值,借助于元组 类型返回。

元组在之前就讲过了,是()括号括起来的数据。所以。函数就变成这样了:

func funcName (string:String) -> (a:Int, b:Int) {

}

我们举例看下如何使用, 下面的一个简单的例子,用来查找一个数组中的最小值和最大值。

  1. //多个返回值
  2. func findMaxAndMin(numbers:[Int]) -> (min:Int, max:Int){
  3. var minValue = numbers[0]
  4. var maxValue = numbers[0]
  5. for number in numbers{
  6. minValue = min(minValue, number)
  7. maxValue = max(maxValue, number)
  8. }
  9. return (minValue, maxValue)
  10. }
  11. var scores:[Int] = [1,2,3,4,5,6]
  12. var result = (findMaxAndMin(scores))
  13. print("the min is \(result.min)") // 1
  14. print("the max is \(result.max)") // 6

上面的例子可能太过简陋,对于传入参数值没做判断,对返回值也没做处理,可能会引起一些错误,我们结合之前学到的一些知识点,对这个函数进行加强,会用到 array.isEmpty, if, guard,Optional,if let 可选型解包等知识。

  1. //多个返回值
  2. func findMaxAndMin(numbers:[Int]) -> (min:Int, max:Int)?{
  3. //判断是否为空,为空则返回nil
  4. if numbers.isEmpty{
  5. return nil
  6. }
  7. //保卫 不为空,否则返回nil
  8. guard !numbers.isEmpty else{
  9. return nil
  10. }
  11. //nil是可选型的标配,返回了nil,所以返回值也得加个?(min:Int, max:Int)?
  12. // 表示返回值是可选型的,可能返回nil。
  13. var minValue = numbers[0]
  14. var maxValue = numbers[0]
  15. for number in numbers{
  16. minValue = min(minValue, number)
  17. maxValue = max(maxValue, number)
  18. }
  19. return (minValue, maxValue)
  20. }
  21. var scores:[Int]? = [1,2,3,4,5,6]
  22. scores = scores ?? []; // 用 ?? 确保scores 一定不为nil
  23. if let result = findMaxAndMin(scores!){ // 强制解包,我们已经确定了scores不为nil
  24. print("the min is \(result.min)") // 1
  25. print("the max is \(result.max)") // 6
  26. }

函数参数名称

外部函数参数名

我们在写一个函数的时候,使用的参数叫内部参数,就是说在这个函数内部使用

  1. //定义了2个局部参数a和b
  2. func sayHelloTo(a: String, b: String) -> String {
  3. return "\(b), \(a)"
  4. }
  5. //调用时,只需要传入对应参数的值就可以了
  6. sayHelloTo("yangyi", b:"hello"); // hello ,yangyi

很显然,我并不是很清楚的知道参数a 和 b 是干嘛的。比较难以理解。

所以,现在出现了一种场景,就是我希望强制约束或者告诉调用者,我这几个参数是干嘛的?我想用用文字说明下,那么调用者就能一目了然的知道这几个参数是干嘛的。调用者调用时也必须带上这些参数名。

这就是外部参数名,来约束调用者。像这个样子约束,参数名前面空格加上外部参数名。还是刚才这个例子,如果我们要定义外部函数参数就可以这样:

  1. func sayHelloTo(name a: String, withWord b: String) -> String {
  2. return "\(b), \(a)"
  3. }
  4. //调用就加上外部参数名
  5. sayHelloTo(name:"yangyi", withWord:"hello")

这样的好处就是,我们很清晰的告诉外部调用者,我每个参数是干嘛的,而且在我们的函数内部,我们仍然可以使用我们自己定义的比较简单的名字。

由于我们的函数名字sayHelloTo To 这个动词 就已经很清楚的说明我们的对象了,所以,第一个参数,可以不用外部参数名,这样更加清晰明了:

  1. func sayHelloTo(a: String, withWord b: String) -> String {
  2. return "\(b), \(a)"
  3. }
  4. sayHelloTo("yangyi", withWord:"hello")

默认条件下,如果我们不去声明第二个,第三个....他们的外部参数,那么内部参数名就是外部参数名。

简写外部参数名

上面的外部参数名的书写有点蛋疼,太长了。而且有时候不但没有起到规范和提示的作用,反而还有点碍事。

比如这个例子:

  1. func mutiply(num1: Int, num2: Int) -> Int {
  2. return num1*num2
  3. }

上面定义了一个函数mutiply, 计算2个整型的值的乘积。

由于,第二个参数,没有加外部参数名,所以,它的内部参数就是外部参数,那么调用就得这样:

  1. mutiply(2, num2: 8) // 16

但是,这个函数其实足够简单,就是需要计算2个整型的乘积,这样一弄,调用者蛋疼的不行,估计会骂声一片,能不能省略掉第二个参数的外部名呢?答案是可以的。用 _ 。我们在 for元组中都用了这个小下划线符号,表示忽略。

  1. func mutiply(num1: Int, _ num2: Int) -> Int {
  2. return num1*num2
  3. }
  4. mutiply(2, 8) // 16

我们由此想到,系统提供给我们的函数,很多其实都是省略了外部参数名的,比如:
min(1,2)
max(3,6)

参数默认值

和其他语言中一样,一个参数是可以有默认值的,当这个参数不传,就会使用默认值。

像这样使用:

  1. func sayHiTo(name:String, withWord word:String = "Hi") -> String{
  2. return "\(word), \(name)"
  3. }
  4. sayHiTo("yangyi") // Hi, yangyi
  5. sayHiTo("yangyi", withWord: "hello") // hello, yangyi

我们用的最多的函数print其实,他有好几个参数,只是后面几个参数,有默认值,我们就可以不用传了:

print(items: Any..., separator: String = " ", terminator: String = "\r\n")

//separator 表示分隔符,就是同时输出几个字符,用什么隔开,默认是空格

//terminator 表示结束符,同时几个print输出时,用什么结束符,默认是\r\n换行
  1. print(00, 66)
  2. print(77, 88)
  3. print(12, 34, separator: "---", terminator: "!!!")
  4. print(56, 78,separator: "---", terminator: "....")

输出就是:

  1. 0 66
  2. 77 88
  3. 12---34!!!56---78....

可变参数

可变参数是一个好东西,在写一个函数时,可能有1个参数,可能有2个参数,可能有N个,也可能一个参数也没有。所以这样一来,内参就无法定义了。这个时候,可变参数就起到了很好的作用,很多语言中都有,swift中如何搞呢?

在变量类型名后面加入(...)来定义可变参数。

看这个例子

  1. func addMutil(numbers: Int...) -> Int {
  2. var total: Int = 0
  3. for number in numbers {
  4. total += number
  5. }
  6. return total
  7. }
  8. addMutil(1,2,3,4) // 10
  9. addMutil(1,2) // 3
  10. addMutil() // 0

常量参数和变量参数

其实,应该叫形参和实参才更靠谱,形参就是在定义函数时,用得参数名字,实参就是调用这个函数传递的参数。在swift中,形参其实是一个常量参数,是只能被用,不能被改,举个例子:

  1. func sayWord(name: String) -> String {
  2. name = name + "hello"
  3. return name
  4. }

你这样子是会报错的:
“annot assign to value: 'name' is a 'let' constant
也是就是说不能给name常量重新复制。

那有什么办法解决这个问题呢?我就是希望复用这个值,或者需求就是希望这这个参数值上做改动呢?

当有办法:在参数名前面空格加上var来申明这个一个变量参数。

  1. func sayWord(var name: String) -> String {
  2. name = name + "hello"
  3. return name
  4. }

这样就可以了。这样name 参数就变成一个变量参数了。可以改变自己的值了。

但是这样子其实只是改变了函数的返回值,并没有改变 name 这个字符串的值,只是我们偷懒在函数里复用了这个name值。

  1. func sayWord(var name: String) -> String {
  2. name = name + "hello"
  3. return name
  4. }
  5. var name = "yangyi"
  6. sayWord("yangyi") //返回yangyihello
  7. name //任然是 yangyi

但是,swift3中会取消 var 这种申明的方式。

输入输出参数

用var 什么一个变量参数,仅仅只能在函数体内被更改,而且在swift3中被改变了,那如果你想要一个函数可以修改参数的值,并且想要在这些修改在函数调用结束后仍然存在,那么就应该把这个参数定义为输入输出参数,用关键字inout标识。就是进去之后还会出来。调用的时候加上&,类似于C语言里的取地址运算。

  1. func sayWord(inout name: String) -> String {
  2. name = "hello" + name
  3. return name
  4. }
  5. var myname = "yangyi";
  6. satHello(&myname);
  7. print(myName); //输出:helloyangyi

这样就改变了变量的值。

再看一个例子,用元祖的交换2个变量的值。

  1. func swapTwoNum(inout num1: Int, inout _ num2: Int){
  2. (num1, num2) = (num2, num1)
  3. }
  4. var num1 = 1
  5. var num2 = 2
  6. swapTwoNum(&num1, &num2)
  7. print(num1) // 变成 2
  8. print(num2) // 变成 1

函数类型

每个函数都有特定的类型,由参数的类型和返回值的类型决定的。例如,下面的这个个函数:

  1. func sayHello(name: String, country: String) -> String {
  2. let info = "Hello, " + name + "!" + " I'm from " + country
  3. return info
  4. }

它的函数类似就是(String, String) -> String 可以读作“这个函数类型,它有两个 String型的参数并返回一个String 型的值。"

  1. func add (a:Int, _ b:Int) -> Int{
  2. return a + b
  3. }

add 函数的函数类型就是 (Int, Int) -> Int

下面是另一个例子,一个没有参数,也没有返回值的函数:

func printHelloWorld() {
    println("hello, world")
}

它是没有参数和返回的,那么它的函数类型就是() -> ()或者 Void->Void 没有指定返回类型的函数总返回 Void。在Swift中,Void 与空的元组是一样的。

使用函数类型

知道申明是函数类型之后,我们就可以使用它了,在 Swift 中,使用函数类型就像使用其他类型一样。例如,你可以定义一个类型为函数的常量或变量,并将函数赋值给它:

先定义函数addTwoInts

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

再赋值:

var mathFunction: (Int, Int) -> Int = add

(Int, Int) -> Int 作为一个类型合在一起,表示一个声明的是一个函数变量,这个函数变量有2个整型参数,返回值也是一个整型。

就像前面说过的定义原始的变量字符串String一样:

var myapp: String = "iphone"

这个可以读作:

“定义一个叫做 mathFunction 的变量,类型是‘一个有两个 Int 型的参数并返回一个 Int 型的值的函数’,并让这个新变量指向 add 函数”。

add 和 mathFunction 有同样的类型,所以这个赋值过程在 Swift 类型检查中是允许的。

所以现在可以这样调用 mathFuntion函数:

print("Result: \(mathFunction(2, 3))")
// print "Result: 5"

那么我们如何顶一个一个没有参数,也没有返回值的函数类型呢?

  1. func helloWord(){
  2. print( "hello word" )
  3. }
  4. //下面4种方式都是OK的。
  5. var anthorHelloWord1:()->() = helloWord
  6. var anthorHelloWord2:()->Void = helloWord
  7. var anthorHelloWord3:Void->() = helloWord
  8. var anthorHelloWord4:Void->Void = helloWord

函数类型作为参数类型

那么,你可能会疑惑了,这样蛋疼的申明一个函数类型,再赋给另一个变量,这样有啥意义呢。其实这样做,就是为了把函数当做一个参数传给给另一个函数。

看下面这个例子:

定义了一个函数:printMathResult ,第一个参数是个函数类型(Int, Int) -> Int,后面2个参数是2个整型。这样是将函数的一部分实现交由给函数的调用者。

看这个例子:

  1. func printMathResult(mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int){
  2. print("Result: \(mathFunction(a, b))")
  3. }
  4. printMathResult(mathFunction, 3, 5) // 8

这个函数第一个参数mathFunction 是一个(Int, Int) -> Int 类型的函数。在函数里直接打印这个函数调用。

这样,这个函数的实现就由这个函数参数来决定了。

再看另一个例子:

  1. var a1:[Int] = [1,3,2,4,5,7,6]
  2. a1.sort() //排序好了。[1,2,3,4,5,6,7]

sort函数其实是可以传一个函数类型的参数的。

a1.sort(isOrderedBefore: (Int, Int) -> Bool)

这个函数类型就是我们自定义排序规则,比如,我们想让大的数排在前面:

  1. func sortDesc(a:Int, b:Int)-> Bool{
  2. return a > b
  3. }
  4. a1.sort(sortDesc) // [7,6,5,4,3,2,1]

函数类型高阶函数

swift中的高阶函数,主要有这几个:map, filter, reduce。这3个函数,就是传入一个函数类型的变量。

array.map((Int) -> Int) 函数传入一个函数变量,数组的每一个值,都经过这个函数处理。

比如,我们希望改变数组中的每一个数组的值,都加2

  1. var array2 = [1,2,3,4,5]
  2. func plus2(num1:Int) -> Int{
  3. return num1 + 2
  4. }
  5. array2.map(plus2) //[3,4,5,6,7]

array.filter((Int) -> Bool) 过滤。函数传入一个函数变量,数组中的每一个值都会经过这个函数处理,并会过滤掉一部分值。

  1. func eg4(num1:Int) -> Bool{
  2. return num1 > 4
  3. }
  4. array2.filter(eg4) // [5]

array.reduce(Int, combine: (Int, Int) -> Int) 累计函数。用来累加或者累减。把会第一个Int参数,作为combine的第一个参数,数组的第1个元素作为combine的第二个参数,combine返回的值,继续作为combine的第一个参数,第二参数取数组的第2个元素。依次循环。知道遍历完数组,最后计算的结果就是返回值。

  1. var array2 = [1,2,3,4,5]
  2. func add (a:Int, _ b:Int) -> Int{
  3. return a + b
  4. }
  5. array2.reduce(0, combine: add) // 8
  6. array2.reduce(0, combine: +) // 8直接用+ 也是表示相加
  7. array2.reduce(0, combine: -) // -15 直接用+ 也是表示相加
  8. array2.reduce(0, combine: *) // 0 因为有元素是0 ,所以相乘永远是0

函数类型作为返回类型

函数类型同样可以作为返回值,因为它就被当做一种类型,和普通的类型一样,所以也是可以返回的。你需要做的是在返回箭头 -> 后写一个完整的函数类型。我们再看这个例子:

func stepForward(input: Int) -> Int {
    return input + 1
}
func stepBackward(input: Int) -> Int {
    return input - 1
}

上面分别定义了2个函数,函数类型都是 (Int) -> Int 类型的。一个是加1,一个是减1。

func chooseStepFunction(info: Bool) -> (Int) -> Int {
    return info ? stepForward : stepForward
}

再定义一个函数 chooseStepFunction 参数是一个bool值,返回值是 (Int) -> Int这样的函数类型。有bool来决定,到底返回哪一个、

所以,我们这样调用:

let moveNearerToZero = chooseStepFunction(3 > 0)
// moveNearerToZero ==函数 stepForward
moveNearerToZero(1) //输出结果是2

 let moveNearerToZero = chooseStepFunction(-3 > 0)
// moveNearerToZero ==函数 stepBackward
moveNearerToZero(1) //输出结果是0

嵌套函数

这章中你所见到的所有函数都叫全局函数(global functions),它们定义在全局域中。你也可以把函数定义在别的函数体中,称作嵌套函数(nested functions)。

默认情况下,嵌套函数是对外界不可见的,但是可以被他们封闭函数(enclosing function)来调用。一个封闭函数也可以返回它的某一个嵌套函数,使得这个函数可以在其他域中被使用。

你可以用返回嵌套函数的方式重写 chooseStepFunction 函数:

  1. func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
  2. func stepForward(input: Int) -> Int { return input + 1 }
  3. func stepBackward(input: Int) -> Int { return input - 1 }
  4. return backwards ? stepBackward : stepForward
  5. }
  6. var currentValue = -4
  7. let moveNearerToZero = chooseStepFunction(currentValue < 0)
  8. moveNearerToZero(1) // 0
  9. var currentValue = 8
  10. let moveNearerToZero = chooseStepFunction(currentValue < 0)
  11. moveNearerToZero(1) // 9
添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注