swift从零开始-07-函数

函数

函数是执行特定任务的代码自包含块。给定一个函数名称标识，当执行器任务时就可以用这个标识来进行调用。swift中的每个函数都有一个类型，包括函数的参数类型和返回类型

函数的声明与调用

当你定义一个函数时，你可以为其定义一个或多个命名，定义类型值作为函数的输入（称为参数），当该函数完成时将传回输出定义的类型（称为它的返回值）
func sayHello(personName: String) -> String {
let welcom = "Hello," + personName + "!"
return welcom
}
print(sayHello("Kobe"))

函数的参数和返回值

1.多输入参数
函数可以有多个输入参数，把它们写到函数的括号内，并用都好隔开，并且每个参数的类型可以各不相同
func halfOpenRangeLength(start: Int, end: Int) -> Int {
return end - start
}
print(halfOpenRangeLength(10, end: 25))

2.无参函数
无参函数就是函数的输入参数个数为0个
func sayHelloWorld() -> String {
return "Hello,World!"
}
print(sayHelloWorld())

3.没有返回值的函数（其实是返回了一个void类型的特殊值）
func sayGoodNight(personName: String) {
print("good night,(personName).")
}
sayGoodNight("James")
4.多返回值函数
使用一个元组类型作为函数的返回类型返回一个有多个值组成的一个复合作为返回值
//下面这个例子计算字符串中元音、辅音、字符的数量
func count(string: String) -> (vowels: Int, consonants: Int, others: Int) {
var vowels = 0, consonants = 0, others = 0
for character in string.characters {
switch String(character).lowercaseString {
case "a", "e", "i", "o", "u":
vowels += 1
case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
"n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
consonants += 1
default:
others += 1
}
}
return (vowels, consonants, others)
}
let total = count("some people is rubbish!")
print("(total.vowels) vowels (total.consonants) consonants (total.others) others")
//需要注意的是在这一点上元组的成员不需要被命名在该该函数返回的元组中，因为他们的名字已经被指定为函数的返回类型的一部分。

函数参数名

1.内部参数名(这些参数名仅能在函数本身的主体内使用，在调用函数时，不能使用)
func someFunction(parameterName: Int) {
//
}
2.外部参数名
1）有时当你调用一个函数将每个参数进行命名是非常有用的，以表明你传递给函数的每个参数的目的
2）如果当用户函数调用你的函数时提供参数名称除了设置本地的参数名称外，也要为每个参数定义外部参数名称，写法是在本地参数名前面在写一个参数名，用空格分开
3）当调用函数时，外部参数名就会显示的在函数体内表示出来，这和其他语言（C,C++,OC）的方法一样，很方便知道每次参数传值的意义，我建议这么写，特别是在多人开发时很有用
func someFunction2(externalParameterName localPrameterName: Int) {
//
}
```
  func context(string s1: String, toString s2: String, withJoiner joiner: String) -> String {
      return s1 + joiner + s2;
  }

  print(context(string: "hello, welcome to ", toString: " world", withJoiner: "SPIREJ丶GG's"))
```
3.外部参数名速记
如果你想为一个函数参数提供一个外部参数名，然而本地参数名已经使用了一个合适的名称了，你不需要为该参数写相同的两次名称。取而代之的是，写一次名字，并用一个hash符号（＃）作为名称的前缀。这告诉Swift使用该名称同时作为本地参数名称和外部参数名称。
```
  //但是这个速记好像在2.0已经去掉了~~~~(>_<)~~~~
```
4.参数默认值
可以为任何参数设定默认值来作为函数的定义的一部分，如果默认值已经定义，调用函数时就可以省略该参数的传值
将使用默认值得参数放在函数的参数列表的末尾
func join(string s1: String, toString s2: String, withJoiner joiner: String = " ") -> String {
return s1 + joiner + s2;
}
//调用时就会出现下面两种函数：
//如果函数调用时没有给 joiner 提供值，就会使用默认值(" ")
//join(string: <#T##String#>, toString: <#T##String#>)
//如果调用时给 joiner 值，就会使用下面这个
//join(string: <#T##String#>, toString: <#T##String#>, withJoiner: <#T##String#>)

5.有默认值的外部名称参数
swift会自动的为有默认值的参数提供外部参数名，名称与内部参数名相同
func join2(s1: String, s2: String, joiner: String = " ") -> String {
return s1 + joiner + s2
}
```
  //join2(<#T##s1: String##String#>, s2: <#T##String#>, joiner: <#T##String#>)
```
6.可变参数
//一个可变参数的参数接受零个或多个指定类型的值
//写法：写可变参数的参数时，需要参数的类型名称后加上点字符（...）
//传递一个可变参数的参数的值时，函数体中是以提供适当类型的数组的形式存在。例如,一个可变参数的名称为numbers和类型为Double...在函数体内就作为名为numbers类型为Double[]的常量数组。
func arithmeticMean(numbers:Double...) -> Double {
var total: Double = 0
for number in numbers {
total += number
}
return total/Double(numbers.count)
}
```
  let result = arithmeticMean(1,2,3,4,5)
  print(result)
```
7.常量参数和变量参数
//函数参数的默认值都是常量
//有时函数有一个参数的值得变量副本是非常有用的。您可以通过指定一个或多个参数作为变量参数，而不是避免在函数内部为自己定义一个新的变量。
//在参数名称前用关键字var定义变量参数(目测在swift3.0中删除)

8.输入-输出参数
//可变参数，3.0移除，如果你想有一个函数来修改参数的值，并且想让这些变化坚持在函数调用结束后，可以定义输入-输出参数来代替
//通过在其参数定义的开始添加inout关键字写用来标明输入-输出参数
//只可以传递一个变量作为一个in-out参数
func swapTwoInts(inout a: Int, inout b: Int) -> (Int, Int) {
let temp = a
a = b
b = temp
return (a, b)
}
var someInt = 3
var anotherInt = 5
print(swapTwoInts(&someInt, b: &anotherInt))

函数类型

1.每一个函数都有特定的函数类型，可以充当参数类型和函数的返回类型
//例如：函数类型是 (Int, Int)->Int,解读为"这个函数类型，它有两个int型的参数，并返回一个int类型的值"
func addTwoInts(a: Int, b: Int) -> Int {
return a + b
}

2.函数类型为()->(),解读为"函数没有参数，并返回void"，函数不显示的支出一个返回值类型是void，在swift中相当于一个空元组，显示为()
func printGG(){
print("GG")
}

使用函数类型

在swift中可以像任何其他类型一样的使用函数类型，例如可以定义一个常量或者变量为一个函数类型，并指定适当的函数给该常量或变量
var mathFunction: (Int, Int)->Int = addTwoInts
//可以解读为”定义一个名为mathFunction的变量，该变量的类型为’一个函数，它接收连个int型参数，并返回一个int值‘，设置这个新的变量来引用名为addTwoInts函数功能“
//该addTwoInts函数具有与mathFunction变量相同的类型，所以通过swift的类型检查
//现在可以调用指定的函数名称为mathFunction：
print("result:(mathFunction(2,3))")
```
  //不同的函数相同的匹配类型也可以分配给相同的变量，也同样适用于非函数类型
  func multiplyTwoInts(a: Int, b: Int) -> Int {
      return a * b
  }
  mathFunction = multiplyTwoInts
  print("result:\(mathFunction(2,3))")

  //还是回到类型推断的问题上了，你为一个常量或变量分配一个函数时你可以快速推断成函数类型
  let anotherMathFunction = addTwoInts
  //anotherMathFunction的类型为(Int, Int)->Int
```
函数类型的参数
可以是一个函数类型作为另一个函数的参数类型
func printMathResult(hehe:(Int, Int)->Int,a: Int, b: Int) {
print("result:(hehe(a, b))")
}
printMathResult(addTwoInts, a: 3, b: 5)

函数类型的返回值
可以使用一个函数类型作为另一个函数的返回类型。写法：返回的函数-> 即返回箭头后立即写一个完整的函数类型就做到这点
func fa(input: Int) -> Int {
return input + 1
}
func fb(input: Int) -> Int {
return input - 1
}

  func fc(backwards: Bool) -> (Int)->Int {
      return backwards ? fa : fb
  }

  //这里 fc 函数 它的返回类型就是“函数类型(Int)->Int”
  var currentN = 3
  let textResult = fc(currentN < 0) //这里使用函数类型 textResult 的类型 (Int)->Int
  while currentN != 0 {
      print(currentN)
      currentN = textResult(currentN)
  }

嵌套函数

在其他函数中定义函数，被称为嵌套函数
嵌套函数默认对外界是隐藏的，但仍然可以调用和使用其内部函数，内部函数也可以返回一个嵌套函数，允许嵌套函数内的另一个范围内使用
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 {
print("(currentValue)... ")
currentValue = moveNearerToZero(currentValue)
}

全部频道

swift从零开始-07-函数

函数

函数的声明与调用

函数的参数和返回值

函数参数名

函数类型

使用函数类型

嵌套函数

参考资料