swift语言学习-8. 函数

swift 8 函数

更好排版：https://www.zybuluo.com/phper/note/65623

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

go!

函数的申明和调用

函数的申明

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

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

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

  
  
  
  

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

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

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

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

我们再举个例子：

  
  
  
  

   
   
   
   
func sayWord(name: String, country: String) -> String {
   
   
   
   
 let word = "Word, " + name + "!" + " I'm from " + country
   
   
   
   
 return word
   
   
   
   
}
  
  
  
  

上面这个例子就定义了另外一个函数，总共就有2个参数，一个是String类型的名字叫name，一个是也是String类型名字叫country，同样也是返回String类型。

函数的调用

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

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

  
  
  
  

   
   
   
   
sayHello("yangyi")
   
   
   
   
sayWord("yangyi", "china")
  
  
  
  

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

  
  
  
  

   
   
   
   
println(sayHello("yangyi"))
   
   
   
   
println(sayWord("yangyi", "china"))
  
  
  
  

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

函数的参数与返回值

多个参数

上面在讲到函数申明的时候，已经稍微提到了。对个参数的情况，和其他的语言类似，用,隔开：

  
  
  
  

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

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

无参数

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

  
  
  
  

   
   
   
   
func sayHello() -> String {
   
   
   
   
 return "hello"
   
   
   
   
}
   
   
   
   
//调用并打印函数
   
   
   
   
println(sayHello())
   
   
   
   
//输出：hello
  
  
  
  

无返回值

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

  
  
  
  

   
   
   
   
func sayHello() {
   
   
   
   
 print("hello")
   
   
   
   
}
   
   
   
   
//调用无参数也无返回值的函数
   
   
   
   
sayHello()
  
  
  
  

多个返回值

一般现代的语言，返回值只有一个，要想多了，要么就封装到一个数组当中返回，基本就一个返回值，swift可以允许有多个返回值，但是也是借助于元组 封装给一个返回。 
我们举例看下如何使用,手册上的一个例子：

  
  
  
  

   
   
   
   
func count(string: String) -> (vowels: Int, consonants: Int, others: Int) {
   
   
   
   
 var vowels = 0, consonants = 0, others = 0
   
   
   
   
 for character in string {
   
   
   
   
 switch String(character).lowercaseString {
   
   
   
   
 case "a", "e", "i", "o", "u":
   
   
   
   
 ++vowels
   
   
   
   
 case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
   
   
   
   
 "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
   
   
   
   
 ++consonants
   
   
   
   
 default:
   
   
   
   
 ++others
   
   
   
   
 }
   
   
   
   
 }
   
   
   
   
 return (vowels, consonants, others)
   
   
   
   
}
  
  
  
  

上面的例子返回一个3个Int 原始的元祖，记得用()包起来，return 的时候，也一样得用元祖()包起来返回。

函数参数名称

外部函数参数名字

我们在写一个函数的时候，使用的参数叫局部参数，只在这个函数内部使用，在调用这个函数的时候，可以不用这个参数名字，一般的语言都是这样，比如：

  
  
  
  

   
   
   
   
//定义了2个局部参数name和country
   
   
   
   
func sayWord(name: String, country: String) -> String {
   
   
   
   
 let word = "Word, " + name + "!" + " I'm from " + country
   
   
   
   
 return word
   
   
   
   
}
   
   
   
   
//调用时，只需要传入对应参数的值就可以了
   
   
   
   
sayHello("yangyi", "china");
  
  
  
  

那么，很显然的“yangyi”就对应于name参数，“china”对应于country参数。

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

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

  
  
  
  

   
   
   
   
func sayWord(yourname name: String, yourcountry country: String) -> String {
   
   
   
   
 let word = "Word, " + name + "!" + " I'm from " + country
   
   
   
   
 return word
   
   
   
   
}
  
  
  
  

那么如何调用有外部参数的函数呢？很简单，同样把它的外部参数名+":就可以了：

  
  
  
  

   
   
   
   
sayHello(yourname: "yangyi", yourcountry: "china")
  
  
  
  

ps: 我个人感觉这个功能有点鸡肋，没啥用。

简写外部参数名

上面的外部参数名的书写有点蛋疼，太长了。有啥简单点的写法吗？有，当然有，那就是用#号来代替外部参数名。内参前面加个#就可以了，实际上就是外部参数名和内部参数名一样的一个简写。

还是这个例子，我们用简写试试：

  
  
  
  

   
   
   
   
func sayWord(#name: String, #country: String) -> String {
   
   
   
   
 let word = "Word, " + name + "!" + " I'm from " + country
   
   
   
   
 return word
   
   
   
   
}
  
  
  
  

这样其实就定义了name 和 country 2个外部参数名，和内部参数名一样而已。

那么调用还是一样：

  
  
  
  

   
   
   
   
sayHello(name: "yangyi", country: "china")
  
  
  
  

默认参数值

和其他语言中一样，参数是可以有默认值的，这样在调用合格函数时，如果没传，就会用默认值显示。

  
  
  
  

   
   
   
   
func sayWord(#name: String, #country: String = "china") -> String {
   
   
   
   
 let word = "Word, " + name + "!" + " I'm from " + country
   
   
   
   
 return word
   
   
   
   
}
  
  
  
  

如果，我们不传递这个country参数，那么默认就是china了

  
  
  
  

   
   
   
   
sayHello(name: "yangyi")
  
  
  
  

默认值参数的外部参数名

是啥意思呢？就是说swift会自动给有默认值的参数，加上一个外部参数名，和它自己的内参名字一样，就像使用了#效果一样，不用你额外写。

  
  
  
  

   
   
   
   
func sayWord(name: String, country: String = "china") -> String {
   
   
   
   
 let word = "Word, " + name + "!" + " I'm from " + country
   
   
   
   
 return word
   
   
   
   
}
  
  
  
  

上面的参数country 没用使用# ，也就是说没有使用外部参数，但是，它有默认值china，所以swift自动给它加了个外部参数，名字也叫country，所以我们可以这样调用：

  
  
  
  

   
   
   
   
sayHello("yangyi", country: "USA")
  
  
  
  

当然，你这样原始调用当然也是可以的：

  
  
  
  

   
   
   
   
sayHello("yangyi", "USA")
   
   
   
   
sayHello("yangyi")
  
  
  
  

可变参数

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

是通过在变量类型名后面加入（...）的方式来定义可变参数。

看这个例子

  
  
  
  

   
   
   
   
func arithmeticMean(numbers: Double...) -> Double {
   
   
   
   
 var total: Double = 0
   
   
   
   
 for number in numbers {
   
   
   
   
 total += number
   
   
   
   
 }
   
   
   
   
 return total / Double(numbers.count)
   
   
   
   
}
   
   
   
   
arithmeticMean(1, 2, 3, 4, 5)
   
   
   
   
// returns 3.0
   
   
   
   
arithmeticMean(3, 8, 19)
   
   
   
   
// returns 10.0
  
  
  
  

可以看书这个得到的参数就是个数组类型，可以for 循环，可以用count属性求大小。很好用。

常量参数和变量参数

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

  
  
  
  

   
   
   
   
func sayWord(name: String) -> String {
   
   
   
   
 name = name + "hello"
   
   
   
   
 return name
   
   
   
   
}
  
  
  
  

你这样子是会报错的：“cannot assign to 'let' value 'name'”，也是就是说不能给name常量重新复制。

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

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

  
  
  
  

   
   
   
   
func sayWord(var name: String) -> String {
   
   
   
   
 name = name + "hello"
   
   
   
   
 return name
   
   
   
   
}
  
  
  
  

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

输入输出参数

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

  
  
  
  

   
   
   
   
func sayWord(inout name: String) -> String {
   
   
   
   
 name = "hello" + name
   
   
   
   
 return name
   
   
   
   
}
   
   
   
   
var myNme = "yangyi";
   
   
   
   
satHello(&myname);
   
   
   
   
println(myName);
   
   
   
   
//输出：hello yangyi
  
  
  
  

改变了变量的值。

函数类型

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

  
  
  
  

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

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

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

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

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

使用函数类型

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

先定义函数addTwoInts

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

再赋值：

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

(Int, Int) -> Int 作为一个类型合在一起，就像前面说过的定义原始的变量字符串String一样：

var myapp: String = "iphone"

这个可以读作：

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

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

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

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

函数类型作为参数类型

你可以用(Int, Int) -> Int这样的函数类型作为另一个函数的参数类型。这样你可以将函数的一部分实现交由给函数的调用者。

看这个例子：

func printMathResult(mathFunction: (Int, Int) -> Int, a: Int, b: Int) {
    println("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// prints "Result: 8”

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

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

函数类型作为返回类型

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

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 函数：

  
  
  
  

   
   
   
   
func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
   
   
   
   
 func stepForward(input: Int) -> Int { return input + 1 }
   
   
   
   
 func stepBackward(input: Int) -> Int { return input - 1 }
   
   
   
   
 return backwards ? stepBackward : stepForward
   
   
   
   
}
   
   
   
   
var currentValue = -4
   
   
   
   
let moveNearerToZero = chooseStepFunction(currentValue < 0)
   
   
   
   
// moveNearerToZero now refers to the nested stepForward() function
   
   
   
   
while currentValue != 0 {
   
   
   
   
 println("\(currentValue)... ")
   
   
   
   
 currentValue = moveNearerToZero(currentValue)
   
   
   
   
}
   
   
   
   
println("zero!")
   
   
   
   
// -4...
   
   
   
   
// -3...
   
   
   
   
// -2...
   
   
   
   
// -1...
   
   
   
   
// zero!