博客

1.函数的定义和调用

func greet(person: String) -> String {
//    函数名   传入值   传入值类型  返回值类型
    let greeting = "Hello" + person
    return greeting
}
print( greet(person: "Anna") )   //调用

2.函数的参数与返回值

(1)无参函数

func sayHello() -> String {
    return "hello!"
}
print( sayHello() )

(2)多参函数

func greet(person: String, alreadyGreeted: Bool) -> String {
    if alreadyGreeted {
        return greetAgain(person: person)
    }else {
        return greet(personn: person)
    }
}

(3)无返回值

func greet(person: String) {
    print("Hello, \(person)")
}
greet(person: "Dave")

(4)多重返回值

func minMax(array: [Int]) -> (min: Int, max: Int) {
    //业务代码
    return (a, b)
}

(5)可选元组返回类型(元组可以是nil)

func minMax(array: [Int]) -> (min: Int, max: Int)? {
    //业务代码
    return (a, b)
}

(6)隐式返回的函数

func greeting(for person: String) -> String {
    "Hello " + person
}
print(greeting(for: "Dave")

任一可以被写成一行return的函数，return(x) + for。

调用的时候： 方法名(for: 参数)

3.参数标签和参数名称

(1)指定参数标签

func greet(from hometown: String) -> String {
    return "from \(hometown)."
}
print( greet(from: "Beijing") )

(2)忽略参数标签

func some(_ a: Int, b: Int) {
    //代码
}
som(1, b: 2)

(3)默认参数值

func some(a: Int, b: Int = 12) {
    //代码
}
some(a: 3, b: 6)   //b用6
some(a: 3)   //b用12

(4)可变参数

一个可变参数可接受0个或多个值。

func arith(_ numbers: Double ...) -> {
    //代码
}
arith(1, 2, 3, 4, 5)

(5)输入输出参数(&)

函数参数默认为常量，不可修改。如果要修改，则要把参数设置为输入输出参数。

func swap(_a: inout Int, _b: inout Int) {
    //代码
}
swap(&5, &7)

4.函数类型

//类型： (Int, Int) -> Int
func add(_ a: Int, _ b: Int) -> Int {
　　return a + b
}
//类型： () -> Void
func printHello() {
    print("H")
}

(1)使用函数类型

var 变量: (Int, Int) -> Int = add
变量(2, 3)    //调用

(2)函数类型作为参数类型

func printMath(_ mathFunction: (Int, Int) -> Int, a: Int, b: Int) {
    print( mathFunction(a, b) )
}
printMath(add, 3, 5)

(3)函数类型作为返回类型

func choose(back: Bool) -> (Int) -> Int{
    return add
}
let move = choose(back: true)

5.嵌套函数

把函数定义到别的函数体中，对外界不可见，但可以被他们的外围函数调用。

func addMul(a: Int, b: Int, c: Int) -> Int {
    func add(d: Int, e: Int) -> Int { return d + e }
    func mul(f: Int, g: Int) -> Int { return f * g }
    return mul(a, add(b, c))
}
print(addMul(1, 2, 3))