Swift - 函数从入门到精通

基本函数定义

func sayHello(personName:String)->String{
    return personName
}
print(sayHello("Ali"))

多个参数的函数定义和调用（若要在外部进行该函数的调用，第一个参数不需要写名子，后面的参数需要写名字）

fun sayHello(psersonName:String,isChecked:Bool)->String{
    if isChecked{
        return psersonName
    }
    return "no"
}
sayHello("Ali", isChecked: true)

返回值为void的函数可以省略void

func sayHello1(personName:String)->(){
    print(personName)
}
sayHello1("Ali")

函数使用元组返回多个值

func minMax(arr:[Int]!)->(min:Int,max:Int){
    var min = arr.first!
    var max = arr.first!
    for value in arr{
        if value < min{
            min = value
        }
        if value > max{
            max = value
        }
    }
    return (min,max)
}
let result = minMax([1,2,3,4,5])


//参数的别名 （当使用别名后，第一个参数也需要写名字）
func call(to Person:String , and OtherPerson:String)->(){
    print("\(Person) and \(OtherPerson)")
}
call(to: "Qi", and: "Ali")

空的别名（调用参数的时候不需要写名字）

func call1(person:String,_ anotherPerson:String){
    print("\(person) and \(anotherPerson)")
}
print(call1("qi", "Ali"))

包含默认值得函数，如果没有赋值，使用默认值

func call2(person:String = "Tom",_ andotherPerson:String = "Jerry")->String{
    return "\(person)  and \(andotherPerson)"
}
call2()
call2("qi","Ali")

可变参数

func sum(num:Int...)->Int{
    var sum = 0
    for n in num{
        sum += n
    }
    return sum
}
sum(1)
sum(1,2,3,4)

所有传入的参数如果没有加Var标示， 默认为不可变

变量参数（当传入的参数需要在函数里改变的时候，需要使用，不会影响外部的变量）

func sayName(var personName:[String])->(){
    personName.append("Hello")
    print(personName)
}

var name = ["Ali"]
sayName(name)
print(name)

若要引用传递（即改变传入的参数影响外面的实参),需要使用关键字inout

交换两个变量的值

func swapTwoInts(inout a:Int, inout _ b:Int)->Void{
    (a,b) = (b,a)
}
var a = 3 , b = 5
swapTwoInts(&a,&b)
print("a=\(a),b=\(b)")

函数类型

//1.函数指针
//加法
func add(num1:Int, _ num2:Int)->Int{
    return num1 + num2
}
//乘法
func mul(num1:Int, _ num2:Int)->Int{
    return num1 * num2
}
//定义一个函数类型变量
var op:(Int, Int)->Int

//赋值和调用
op = add
print(op(3,5))
op = mul
print(op(3,5))

//2. 直接将函数类型作为参数
func cal(op:(Int,Int)->Int,_ num1:Int,_ num2:Int)->Int{
    return op(num1,num2)
}
//调用
print(cal(add, 3, 5))
print(cal(mul, 3, 5))


//3.函数类型作为返回值
func addOrMul(isAdd:Bool)->(Int,Int)->Int{
    return isAdd ?add :mul
}
//调用
print(addOrMul(true)(3,5))

嵌套函数

func addOrMul1(isAdd:Bool)->(Int, Int) ->Int{
    
    //加法
    func add1(num1:Int, _ num2:Int)->Int{return num1 + num2}
    
    //乘法
    func mul1(num1:Int, _ num2:Int)->Int{return num1 * num2}
    
    return isAdd ? add1 : mul1
}
调用
print(addOrMul1(false)(3,6))

复杂的函数返回值

func hello() ->() ->() ->() -> Void{
    func h1() -> () -> () -> Void{
        func h2() -> () -> Void{
            func h3() -> Void{
                print("Hello, world")
            }
            return h3
        }
        return h2
    }
    return h1
}

hello()()()()

柯里化（Currying）注：可能在后面的版本里会移除，建议不要使用

func hello1(i:Int)(_ j:Int) -> Int{
    return i + j
}

let h1 = hello1(5)
h1(6)
let h2 = hello1(5)(6)