Swift 学习笔记 (函数)

函数

函数是一个独立的代码块，用来执行特定的任务。Swift中的函数与Object-C中的函数一样，但是声明与书写的方式不太一样，现在我们就通过几个例子介绍一下Swift中的函数。简单的来说，他与JS中的函数声明有些相像,但是如果有返回值的时候，他们返回值的书写方式又有不同。

先来说一个简单的例子

//greet 函数的名称
//personName:函数的形式参数，可以为多个 用逗号隔开
//->String 函数的返回值类型 如果没有可以不写
func greet(personName:String) ->String {
    let greeting = "hello:" + personName + "!"
    print(greeting)
    return greeting;
}

//函数的调用
greet(personName: "tian")

函数的形式参数和返回值

在Swift中，函数的形式参数和返回值非常灵活，你可以定义从一个简单的只有一个未命名形式参数的工具函数到那种具有形象的参数名称和不同的形式参数选项的复杂函数之间的任何函数。

无形式参数的函数

函数没有要求必须输入一个参数，或者函数内部不需要接受外部的变量就可以完成特定的功能，例子

//无形式参数的函数
func sayHelloWorld()->String {
    return "Hello World"
}
print(sayHelloWorld());

函数的定义仍然需要在名字后边加一个圆括号，即使它不接受形式参数也得这样做。当函数被调用的时候也要在函数的名字后边加一个空的圆括号。

多形式参数的函数

func greet(personName:String) ->String {
    let greeting = "hello:" + personName + "!"
    print(greeting)
    return greeting;
}
//函数的调用
greet(personName: "tian")
//多形式参数的函数
/*
 函数可以输入多个形式参数 可以卸载寒暑后面的圆括号内 用逗号分隔
 */
func greetAgain(person:String) -> String {
    return "Hello one more time"
}

func secondGreet(person:String,alreadGreeted:Bool) -> String {
    if alreadGreeted {
        return greetAgain(person:person);
    }else {
        return greet(personName: person)
    }
}

//调用函数
secondGreet(person: "tian", alreadGreeted: false)

无返回值的函数

//无返回值的函数
/*
 函数定义中没有要求必须有一个返回类型 下面是另一个版本的greet函数
 */
func thirdGreet(person:String) {
    print("Hello,\(person)")
}

thirdGreet(person: "tian")

因为没有反悔值，函数在定义的时候就不用写(->)或者返回类型

//我们在调用函数的时候 也可以忽略函数的返回值
func printAndCount(string:String) ->Int {
    print(string)
    return string.characters.count
}
func printWithoutCounting(string:String) {
    let _ = printAndCount(string: "tianfeng")
}

printAndCount(string: "liantian");
printWithoutCounting(string: "swift")

注意：返回值可以被忽略 但是如果一个函数需要返回值的时候就必须返回，如果一个函数有定义返回类型，没有反回值的话就不会运行到函数的末尾，会报编译时的错误

多返回值的函数

为了让函数返回多个值作为一个复合的返回值，你可以使用元组类型作为返回类型。

func minMax(array:[Int]) ->(min:Int, max:Int) {
//    var currentMin = array[0]
//    var currentMax = array[0]
//
//    for value in array {
//        if value < currentMin {
//            currentMin = value;
//        }else if (value > currentMax) {
//            currentMax = value
//        }
//    }
//    return (currentMin,currentMax);
    return (array.min()!,array.max()!)
}

let minAndMax = minMax(array: [,,,,])
print("\(minAndMax.min) and \(minAndMax.max)")

可选元组返回类型

如果元组在函数的返回类型中可能没有值，你可以用一个可选元组返回类型来说明整个元组可能是nil。下面就是一个例子：

func minMax(array:[Int]) -> (min:Int,max:Int)? {

    if array.isEmpty {
        return nil
    }

    return (array.min()!,array.max()!)
}

//由于是可选类型 所以在调用的时候 返回的可能为nil 我们就需要对返回值进行解包处理
if let bounds = minMax(array: [,-,,,]) {
    print("\(bounds.min) and \(bounds.max)")
}

---

函数的实际参数标签和形式参数名

每一个函数的形式参数都包含实际参数标签和形式参数名。实际参数标签用在调用函数的时候，在调用函数的时候每一个实际参数前面都要写实际参数标签，形式参数名用在函数的实现中。默认情况下，形式参数适用它们的形式参数作为实际参数标签。

func someFunction(firstParameterName:Int?,secondParameterName:Int?) {

    guard let x = firstParameterName,
          let y = secondParameterName
    else {
        return
    }
    print((x + y));
}

someFunction(firstParameterName: , secondParameterName: )

左右的形式参数必须有唯一的名字。尽管有可能多个形式参数拥有相同的实际参数标签，唯一的实际参数标签有助于让你的代码更加易读。

指定实际参数标签

在提供的形式参数名之前写实际参数标签 用空格分开

func someFunction(实际参数 parameterName:Int) {
    print("传进来的参数是:\(parameterName)")
}
someFunction(实际参数: )

省略实际参数标签

//省略实际参数标签
func someFunction1(_ firstParameterName: Int, secondParameterName: Int) {

}
someFunction1(, secondParameterName: )

默认形式参数值

你可以通过在行驶参数类型后给形式参数赋值来给函数的任意形式参数定义一个默认值，如果定义了默认值，您就可以在调用函数的时候省略这个形式参数

func haveValueFunction(a:Int = ,b:Int) ->Int {
    return b * a
}

print(haveValueFunction(b: ))
//虽然有了默认值，但是如果你想改变 还是可以改变的
print(haveValueFunction(a: , b: ))

可变形式参数

一个可变形式参数可以接受零或者多个特定类型的值。当调用函数的时候你可以利用可变形式参数来声明形式参数可以被传入值的数量是可变的。可以通过在形式参数的类型名称后边插入三个点符号（ ...）来书写可变形式参数。

传入到可变参数中的值在函数的主体中被当作是对应类型的数组。举个栗子，一个可变参数的名字是 numbers类型是 Double...在函数的主体中它会被当作名字是 numbers 类型是 [Double]的常量数组。

func arithmeticMean(numbers:Double...) ->Double {
    var total:Double = ;
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
arithmeticMean(numbers: ,,,,,)

输入输出形式参数

可变的形式参数职能在函数的内部做出改变，如果你想函数能够修改一个形式参数的值，而且你想这些改变在函数结束之后依然有效，那么就需要将形式参数定义为输入输出形式参数。

在形式参数定义开始的时候天际一个inout关键字可以定义一个输入输出的形式参数。输入输出的形式参数有一个能输入给函数的值，函数能对其进行改变。还能输出到函数外边替换原来的值。

//输入输出形式参数

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temp = a
    a = b
    b = temp
}

var c =  ,b =
swap(&c, &b);
c//
b//

---

函数类型

每一个函数都有一个特定的函数类型 它由形式参数类型 返回类型组成。

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

func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
    return a * b
}

上边的栗子定义了两个简单的数学函数 addTwoInts和 multiplyTwoInts 。这两个函数每个传入两个 Int值，返回一个 Int值，就是函数经过数学运算得出的结果。

这两个函数的类型都是 (Int, Int) -> Int 。也读作：
“有两个形式参数的函数类型，它们都是 Int类型，并且返回一个 Int类型的值。”

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

这个函数的类型是 () -> Void，或者 “一个没有形式参数的函数，返回 Void。”

使用函数类型

你可以像使用 Swift 中的其他类型一样使用函数类型。例如，你可以给一个常量或变量定义一个函数类型，并且为变量指定一个相应的函数。

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

“定义一个叫做 mathFunction的变量，它的类型是‘一个能接受两个 Int值的函数，并返回一个 Int值。’将这个新的变量指向 addTwoInts函数。”
这个 addTwoInts(_:_:)函数和 mathFunction函数有相同的类型，所以这个赋值是可以通过 Swift 的类型检查的。

mathFunction(,)

函数类型作为返回类型

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

func choseStepFunction(backwards:Bool) -> (Int)->Int {
    return backwards ? stepForward : stepBackWard
}

var currentValue =
let moveNearerToZero = choseStepFunction(backwards: currentValue > )
while currentValue !=  {
    currentValue = moveNearerToZero(currentValue)
}

内嵌函数

上面所说的所有的函数都是全局函数都是在全局的范围内进行定义的。你也可以在函数的内部定义另一个函数，这就是内嵌函数。

内嵌函数默认情况下在外部是被隐藏起来的，但却仍然可以通过包裹它们的函数来调用它们。包裹的函数也可以返回他内部的一个内嵌函数来在另外的范围里使用。

func chooseStepFunction(backward:Bool) ->(Int)->(Int) {
    func stepForward(input:Int)->Int{
        return input +
    }
    func stepBackWard(input:Int) ->Int {
        return input -
    }
    return backward ? stepBackWard : stepForward
}

var currentValue = -
let moveNearerToZero = chooseStepFunction(backward: currentValue > )
while currentValue !=  {
    currentValue = moveNearerToZero(currentValue)
}

以上就是swift中关于函数的部分了，比较基础，以后遇见复杂的会在回来更新。