Swift学习笔记之函数

概述参数 外部变量名 一般情况下你可以不指定外部变量名，直接调用函数： func helloWithName(name: String, age: Int, location: String) { println("Hello \(name). I live in \(location) too. When is your \(age + 1)th birthday?") } 参数 外部变量名

一般情况下你可以不指定外部变量名，直接调用函数：

func helloWithname(name: String,age: Int,location: String) {        println("Hello \(name). I live in \(location) too. When is your \(age + 1)th birthday?")    }helloWithname("Mr. Roboto",5,"San Francisco")

但是在类（或者结构，枚举）中的时候，会自动分配外部变量名（第一个除外），这个时候如果还想直接调用就会报错了：

class MyFunClass {    func helloWithname(name:String,age:Int,location:    String){        println("Hello \(name).I love in \(location) too.When is your \(age + 1)th birthday?")    }}let myFunClass = MyFunClass()myFunClass.helloWithname("Mr.Roboto","San Franciso")

如果你实在不想要外部变量，那么可以用_来代替：

struct Celsius {    var temperatureInCelsius: Double    init(fromFathrenheit fahrenheit:Double) {        temperatureInCelsius = (fathrenheit - 32.0)/1.8    }    init(fromKelvin Kelvin:Double) {        temperatureInCelsius = kevin - 273.15    }    init(_ celsius: Double) {        temperatureInCelsius = celsius    }}let boilingPointOfWater = Celsius(fromFahrenheit:212.0)//boilingPointOfWater. temperatureInCelsius 是 100.0let freezingPointOfWater = Celsius(fromKelvin: 273.15)//freezingPointOfWater.temperatureInCelsius 是 0.0let bodyTemperature = Celsius(37.0)//bodyTemperature.temperatureInCelsius 是 37.0

对外部参数名的娴熟应用于极好的抽象初始化过程。可以看看 json-swift library 中的应用。

默认参数值

可以在函数定义里写上函数的默认值，这样在调用的时候可以不传这个值：

func add(value1 v1:Int,value2 p1:Int = 2)->Int{    return v1+p1}add(value1: 2,value2: 4)    //2 +4add(value: 1)   //1+2

如果你没有提供外部参数名，设置默认参数值会自动提供默认参数名。

可变参数

可变参数 (Variadic Parameters) 可以接受一个以上的参数值。比如计算平均值：

func arithmeticmean(numbers: Double..) -> Double {    var total: Double = 0    for number in numbers { //numbers is [Double]       total +=number    }    return total //Double(numbers.count)}arithmeticmean(1,2,3,4,5)arithmeticmean(3,8,19)

如果不止一个参数，需要把可变参数放在最后，否则会报错。应该这样：

func sumAddValue(addValue:Int=0,numbers:Int...)-> Int {    var sum = 0    for number in numbers {     //numbers ===[Int]        sum +=number + addValue    }    return sum}sumAddValue(addValue:2,5) //(2+2) +(4+2) +(5+2) =17

常量和变量参数

默认参数是常量，无法在函数体中改变参数值。我们可以var一个新的值就行 *** 作，也可以直接在函数定义中加上var避免在函数体中定义新的变量。
比如这一个右对齐函数：

func alignRight(var string:String,count:Int,pad: Character) ->String {    let amountopad = count - countElements(String)    if amounttopad < 1 {        return string    }    let padString = String(Pad)    for _ in 1...amounttopad {        string = padString +string    }    return string}let originalString = "hello"let paddenString = alignRight(originalString,10,"-")//"------Hello"

输入输出参数（inout）

在函数体中对应变量参数进行的修改并不会改变参数值本身，比如看这个例子：

func add(var v1:Int) -> Int {    return ++v1}var a = 1adda)       //2a           //1

如果想通过函数修改原始值需要 inout,但是这样错误的：

func add(inout v1:Int) -> Int {    return ++v1}var a = 1 add(a)  //2a           //1

在传入的时候，需要加上& 标记

func add(inout v1:Int) -> Int {    return ++v1}var a = 1 add(a)  //2a           //1

泛型参数类型

在此借用一下 objc.io 中的例子来演示泛型参数类型的使用：

//交换两个值的函数func valueSwap<T>(inout value1: T,inout value2: T) {    let oldValue1 = value1    value1 = value2    value2 = oldValue1}var name1 = "Mr.Potato"var name2 = "Mr.Roboto"valueSwap(&name1,&name2)        //交换字符串name1   //Mr.Robotoname2   //Mr.Potatovar number1 = 2 var number2 = 5valueSwap(&number1,&number2)       //交换数字number1 //5number2 //2

函数类型

在 Swift 中，函数翻身把歌唱，终于成了一等公民，和其他类型平起平坐。

变量

我们可以定义一个变量，这个变量的类型是函数类型：

func addTwoInts(a: Int,b: Int) -> Int {    return a + b}let anotherMathFunction = addTwoIntsanotherMathFunction(1,2)        //3

参数

函数既然是类型的一种，那么显然也是可以作为参数传递的：

func addTwoInts(a: Int,b: Int) -> Int {    return a+b}func printMathResult(mathFunction: (Int,Int) -> Int,a: Int,b: Int) { println("Result: \(mathFunction(a,b))") } printMathResult(addTwoInts,5) //将参数2和参数3作为参数传给参数1的函数

返回值

函数也是可以作为结果返回的。比如返回的值是一个参数为 Int 返回值为 Int 的函数，就是这样定义：func foo() -> (Int) ->Int.可以看下面这个具体的例子：

func stepForward(input: Int) -> Int {    return input + 1}func stepBcakward(input: Int) ->Int {    return input - 1}func chooseStepFunctin(backwards: Bool) -> (Int) -> Int {    return backwards ? stepBackward : stepForward}var currentValue = 3 let moveNearerToZero = chooseStepFunction(currentValue > 0) //根据参数返回 stepForward 或 stepBackwardprintln("Counting to zero:")while currentValue != 0 {    println("\(currentValue)... ")    currentValue = moveNearerToZero(currentValue)}println("zero!")//3...//2...//1...//zero!

别名

用多了会发现现在一大串 ()-> 中文穿插各种 ()-> 是一个非常蛋疼的事情。我们可以用 typealias 定义函数别名，其功能和 OC 中的typedef 以及 shell 中的alias 的作用基本是一样的。举个例子来看下：

import Foundation typealias lotteryOutputHandler = (String,Int) -> String //如果没有 typelias 则需要这样：//func luckyNumberForname(name: String,#lotteryHandler: (String,Int)-> String) -> Stringfunc luckyNumberForname(name: String,#lotteryHandler: lotterOutputHandler) -> String {    let luckyNumber = Int(arc4random()%100)    return lotteryHandler(name,luckyNumber)}luckyNumberForname("Mr.Roboto",lotterHandler: {name,number in return " \ (name)'s' lucky number is \(number)"})//Mr.Roboto's lucky number is 33

嵌套

但是其实并不是所有的函数都需要在外面的，有时候我们定义一个新的函数只是为了封装一层。并不是为了复用。这时候可以吧函数嵌套进去，比如前面这个例子：

func chooseStepFunction(backwards: Bool) -> (Int) -> Int {        func stepForward(input: Int) -> Int { return input + 1 }        func stepBackward(input: Int) -> Int { return input - 1 }        return backwards ? stepBackward : stepForward    }    var currentValue = -4    let moveNearerToZero = chooseStepFunction(currentValue < 0)    // moveNearerToZero Now refers to the nested stepForward() function    while currentValue != 0 {        println("\(currentValue)... ")        currentValue = moveNearerToZero(currentValue)    }    println("zero!")    // -4...    // -3...    // -2...    // -1...    // zero!

柯里化（currying）

柯里化背后的基本想法是，函数可以局部应用，意思时一些参数值可以在函数调用之前被指定或者绑定。这个部分函数的调用会返回一个新的函数。
这个具体内容可以参见 Swift 方法的多面性 中 柯里化部分的内容。我们可以这样调用

class MyHelloWorldClass {    func helloWithname(name: String)->String {        return "hello,\(name)"    }}let myHelloWorldClassInstance = MyHelloWorldClass()let helloWithnameFunc = MyHelloWorldClass.helloWithnamehhelloWithnameFunc(myHelloWorldClassInstance)("Mr.Roboto) //hello,Mr.Roboto

多返回值

在Swift 中我们可以利用 tuple 返回多个返回值。比如下面这个例子，返回所有数字范围：

func findRangeFromNumbers(numbers: Int...) -> (min: Int,max: Int) {        var maxValue = numbers.reduce(Int.min,{ max($0,$1) })        var minValue = numbers.reduce(Int.max,{ min($0,$1) })         return (minValue,maxValue)    }    findRangeFromNumbers(1,234,555,345,423)    // (1,555)而返回值未必都是有值的，我们也可以返回可选类型的结果：    import Foundation    func componentsFromUrlString(urlString: String) -> (host: String?,path: String?) {        let url = NSURL(string: urlString)        return (url?.host,url?.path)    }    let urlComponents = componentsFromUrlString("http://why/233;param?foo=1&baa=2#fragment")    switch (urlComponents.host,urlComponents.path) {    case let (.Some(host),.Some(path)):        println("host \(host) and path \(path)")    case let (.Some(host),.None):        println("only host \(host)")    case let (.None,.Some(path)):        println("only path \(path)")    case let (.None,.None):        println("This is not a url!")    }    // "host why and path /233/param"

References Functions Swift Functions Swift 方法的多面性 Instance Methods are Curried Functions in Swift 总结

以上是内存溢出为你收集整理的Swift学习笔记之函数全部内容，希望文章能够帮你解决Swift学习笔记之函数所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。