Swift5.1 函数

Swift5.1 函数笔记

import UIKit

var str = "Hello, playground"


//func 函数名(形参: 参数类型) -> 返回值 {
//    函数体
//}

///函数参数和返回值

    //无参数有返回值函数
    func sayHelloWorld() -> String {
         return "Hello , world"
    }

    //多参数有返回值函数
    func greet(person: String, alreadyGreeted: Bool) -> String{
        return "hello, world"
    }

    //无返回值函数
    //严格地说，即使没有明确定义返回值，该 greet(Person：) 函数仍然返回一个值。没有明确定义返回类型的函数的返回一个 Void 类型特殊值，该值为一个空元组，写成 ()。
    func greet(person: String) {
        print("hello,world")
    }

    //多重返回值函数 （直接返回元组） + 可选元组返回类型
    func minMax(array: [Int]) -> (min: Int, max: Int)? {
        guard !array.isEmpty else { return nil}
        //求最大值和最小值
        var currentMin = array[0]
        var currentMax = array[0]
        
        for value in array[1..<array.count] {
            if value < currentMin {
                currentMin = value
            }else if value > currentMax{
                currentMax = value
            }
        }
        return (currentMax,currentMin)
    }

    if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
        print("min is \(bounds.min) and max is \(bounds.max)")
    }
    
    //隐式返回函数
    func greeting(for person: String) -> String {
       "Hello ," + person + "!"
    }
print(greeting(for: "wei"))
    
/// 函数参数标签和参数名称
//    每个函数参数都有一个参数标签（argument label）以及一个参数名称（parameter name）。参数标签在调用函数的时候使用；调用的时候需要将函数的参数标签写在对应的参数前面。参数名称在函数的实现中使用。默认情况下，函数参数使用参数名称来作为它们的参数标签。
//指定参数标签
func someFunction(argumentLabel parameterName: Int) {
    //argumentLabel 参数标签. 调用函数的时候使用
    //parameterName 参数名称. 在函数内部实现中使用
}

//忽略参数标签
//下划线（_）来代替一个明确的参数标签
func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
    
}

//默认参数值
func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
    
}

someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault = 6
someFunction(parameterWithoutDefault: 4) // parameterWithDefault = 12


//可变参数 。。。
func arithmeticMean(_ number: Double...) -> Double {
    var total: Double = 0
    for number in number {
        total += number
    }
    return total / Double(number.count)
}


//输入输出参数 （函数内部可以修改变量的值）
//定义一个输入输出参数时，在参数定义前加 inout 关键字。一个 输入输出参数有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值

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

var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)

print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")


///函数类型

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

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

//(Int, Int) -> Int 这个函数类型有两个 Int 型的参数并返回一个 Int 型的值
//这个函数的类型是：() -> Void，或者叫“没有参数，并返回 Void 类型的函数”。
// 使用函数类型

//定义一个叫做 mathFunction 的变量，类型是‘一个有两个 Int 型的参数并返回一个 Int 型的值的函数’，并让这个新变量指向 addTwoInts 函数
var mathFunction: (Int, Int) -> Int = addTwoInts
print(mathFunction(2,3))


//函数类型作为参数

func printMathResult(_ mathFunction: (Int, Int) -> Int , _ a: Int , _ b: Int) {
    print(mathFunction(a,b))
}

printMathResult(addTwoInts, 3, 5) //8


//函数类型作为返回类型
// 在返回箭头（->）后写一个完整的函数类型

func stepForward(_ input: Int) -> Int {
    print(3)
    return input + 1
}

func setpBackward(_ input: Int) -> Int {
    print(2)
    return input - 1
}

func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    print("1")
    return backward ? setpBackward : stepForward
}

var currentValue = 3
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)

while currentValue != 0 {
    print("\(currentValue)...")
    currentValue = moveNearerToZero(currentValue)
}

print("Zero !")


/// 嵌套函数

func chooseStepFunctions(backward: Bool) -> (Int) -> Int {
    func stepForward(input: Int) -> Int { return input + 1 }
    func stepBackward(input: Int) -> Int { return input - 1 }
    return backward ? stepBackward : stepForward
}

参考:

SwiftGG-函数
官方文档 Functions