Swift 04.Functions

函数的基本构造

基本结构

func 函数名 (形参名:形参类型) ->返回值 {实现代码}

如果没有参数,那么也必须把参数的括号带上

如果有多个形参,那么必须以逗号 , 隔开

如果没有返回值,那么可以省略 也可以以->Void 和 () 代替

你可以在形名前指定外部参数名,中间以空格分隔.

注意: 如果你提供了外部参数名,那么函数在被调用时,必须使用外部参数名。

第一个参数默认忽略其外部参数名称,明确写下划线是多余的

如果你不想为第二个及后续的参数设置参数名,用一个下划线(_)代替一个明确地参数名.

func someFunction(firstParameterName: Int, _ secondParameterName: Int) {
}
someFunction(, )

函数的基本类型

有参数有返回值函数

func 函数名 (形参名:形参类型) ->返回值 {实现代码}

func myName(name:String,age:Int) ->String {
    return (name + "\(age)")
}

调用定义好的函数

let nema = myName("xiaoming", age: )

print(nema)

func 函数名 (外部参数名 形参名:形参类型) ->返回值 {实现代码}

func myName1(na name:String,num age:Int) ->String {
    return (name + "\(age)")
}

调用定义好的函数

let nema1 = myName1(na: "xiaohong", num: )

print(nema1)

无参数 有返回值 函数

func 函数名() ->返回值  !哪怕函数没有参数 也一样要加()

func myNum() ->String{
    return "无参数 有返回值"
}
let num = myNum()
print(num)

无参数无返回值函数

func 函数名()  !返回值可以省略

func myReturn(){
    print("无参数无返回值")
}
myReturn()

->()来标识无返回值

func myRetu()->(){
    print("无参无返回值")
}
myRetu()

->Void来标识无返回值

func myRetu1()->Void{
    print("无参无返回值")
}

myRetu1()

有参数 无返回值函数

func 函数名(形参:形参类型)

func myPargam(name:String,age:Int){
    print(name + "\(age)")
}

myPargam("xiaowang", age: )

可变参数

最多可以有一个可变参数函数,和它必须出现在参数列表中,为了避免歧义在调用函数有多个参数。

如果 你的函数有一个或多个参数有默认值,还有一个可变的参数,将可变参写在参数列表的最后。

func arithmeticMean(numbers: Double...) -> Double {

    var total: Double = 

    for number in numbers {

        total += number }

    print(numbers)

    return total / Double(numbers.count)

}

let dou = arithmeticMean(,,,)

print(dou)

通过在参数名前加关键字 var 来定义变量参数:

对变量参数所进行的修改在函数调用结束后便消失了,并且对于函数体外是不可见的。变量参数仅仅存 在于函数调用的生命周期中。

func alignRight(var string: String, totalLength: Int, pad: Character) -> String {

    let amountToPad = totalLength - string.characters.count

    if amountToPad <  {

        return string

    }

    let padString = String(pad)

    for _ in ...amountToPad {

        string = padString + string

    }

    return string

}

let originalString = "hello"

let paddedString = alignRight(originalString, totalLength: , pad: "-")

输入输出参数

/*

*你只能将变量作为输入输出参数

*当 传入的参数作为输入输出参数时,需要在参数前加 & 符,表示这个值可以被函数修改。

*/

func swapTwoInts(inout a: Int, inout _ b: Int) {

    let temporaryA = a

    a = b

    b = temporaryA

}

var someInt = 

var anotherInt = 

swapTwoInts(&someInt, &anotherInt)

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

输入输出参数和返回值是不一样的。上面的 swapTwoInts 函数并没有定义任何返回值,但仍然修改了 someInt 和 anotherInt 的值。输入输出参数是函数对函数体外产生影响的另一种方式。

默认参数值

你可以在函数体中为每个参数定义 默认值(Deafult Values) 。当默认值被定义后,调用这个函数时可以忽略这个 参数。

func someFunction(parameterWithDefault: Int = ) {

    // function body goes here

    // if no arguments are passed to the function call, 

    // value of parameterWithDefault is 42

    print(parameterWithDefault)

}

someFunction()

// parameterWithDefault is 6 

someFunction()

// parameterWithDefault is 12

使用函数类型

在 Swift 中,使用函数类型就像使用其他类型一样。例如,你可以定义一个类型为函数的常量或变量,并将函数 赋值给它:

addTwoInts 和 mathFunction 有同样的类型,所以这个赋值过程在 Swift 类型检查中是允许的。

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

    return a+b

}

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

let a = mathFunction(,)

print("Result:\(a) \(mathFunction(2, 3))")

作为参数的函数

在 Swift 中，函数可以被用来当做变量传递。比如，一个函数可以含有一个函数类型的参数

func luckyNumberForName(name: String,lotteryHandl lotteryHandler: (String, Int) -> String) -> String {

    let luckyNumber = Int(arc4random() % )

    return lotteryHandler(name, luckyNumber)

}

func defaultLotteryHandler(name: String, luckyNumber: Int) -> String {

    return "\(name), your lucky number is \(luckyNumber)"

}

luckyNumberForName("Mr. Roboto", lotteryHandl: defaultLotteryHandler)

// Mr. Roboto, your lucky number is 38

注意下只有函数的引用被传入 — 在本例中是 defaultLotteryHandler。这个函数之后是否执行是由接收的函数决定。

实例方法也可以用类似的方法传入：

func luckyNumberForName(name: String, lotteryHandl lotteryHandler: (String, Int) -> String) -> String {

    let luckyNumber = Int(arc4random() % )

    return lotteryHandler(name, luckyNumber)

}

class FunLottery {
    func defaultLotteryHandler(name: String, luckyNumber: Int) -> String {

        return "\(name), your lucky number is \(luckyNumber)"

    }
}

let funLottery = FunLottery()

luckyNumberForName("Mr. Roboto", lotteryHandl: funLottery.defaultLotteryHandler)

// Mr. Roboto, your lucky number is 38

为了让你的函数定义更具可读性，可以考虑为你函数的类型创建别名 (类似于 Objective-C 中的 typedef)：

typealias lotteryOutputHandler = (String, Int) -> String

func luckyNumberForName(name: String, lotteryHandl lotteryHandler: lotteryOutputHandler) -> String {

    let luckyNumber = Int(arc4random() % )

    return lotteryHandler(name, luckyNumber)

}

你也可以使用不包含参数名的函数 (类似于 Objective-C 中的 blocks)：

func luckyNumberForName(name: String, lotteryHandl lotteryHandler: (String, Int) -> String) -> String {

    let luckyNumber = Int(arc4random() % )

    return lotteryHandler(name, luckyNumber)

}

luckyNumberForName("Mr. Roboto", lotteryHandl: {name, number in

    return "\(name)'s' lucky number is \(number)"

})

// Mr. Roboto's lucky number is 74

在 Objective-C 中，使用 blocks 作为参数是异步操作是操作结束时的回调和错误处理的常见方式，这一方式在 Swift 中得到了很好的延续。