Swift心得筆記之函數。本站提示廣大學習愛好者：（Swift心得筆記之函數）文章只能為提供參考，不一定能成為您想要的結果。以下是Swift心得筆記之函數正文
參數
內部變量名
普通情形下你可以不指定內部變量名，直接挪用函數：
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 live in \(location) too. When is your \(age + 1)th birthday?")
}
}
let myFunClass = MyFunClass()
myFunClass.helloWithName("Mr. Roboto", 5, "San Francisco")
假如你思念在 OC 中界說函數名的方法，可以持續如許界說，好比 helloWithName 這類，隱蔽第一個函數的內部名：
class MyFunClass {
func helloWithName(name: String, age: Int, location: String) {
println("Hello \(name). I live in \(location) too. When is your \(age + 1)th birthday?")
}
}
let myFunClass = MyFunClass()
myFunClass.helloWithName("Mr. Roboto", age: 5, location: "San Francisco")
假如你其實不想要內部變量名，那末可以用 _ 來取代：
struct Celsius {
var temperatureInCelsius: Double
init(fromFahrenheit fahrenheit: Double) {
temperatureInCelsius = (fahrenheit - 32.0) / 1.8
}
init(fromKelvin kelvin: Double) {
temperatureInCelsius = kelvin - 273.15
}
init(_ celsius: Double) {
temperatureInCelsius = celsius
}
}
let boilingPointOfWater = Celsius(fromFahrenheit: 212.0)
// boilingPointOfWater.temperatureInCelsius 是 100.0
let freezingPointOfWater = Celsius(fromKelvin: 273.15)
// freezingPointOfWater.temperatureInCelsius 是 0.0
let 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 + 4
add(value1: 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, 2,4,5) // (2+2) + (4+2) + (5+2) = 17
常量和變量參數
默許參數是常量，沒法在函數體中轉變參數值。我們可以 var 一個新的值就行操作，也能夠直接在函數界說中加上 var 防止在函數體中界說新的變量。
好比這一個右對齊函數：
func alignRight(var string: String, count: Int, pad: Character) -> String {
let amountToPad = 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 paddedString = alignRight(originalString, 10, "-") // "-----hello"
輸出輸入參數 (inout)
在函數體中對變量參數停止的修正其實不會轉變參數值自己，好比看這個例子：
func add(var v1:Int) -> Int {
return ++v1
}
var a = 1
add(a) // 2
a // 1
假如想經由過程函數修正原始值須要 inout ，然則如許是毛病的：
func add(inout v1:Int) -> Int {
return ++v1
}
var a = 1
add(a) // 2
a // 1
在傳入的時刻，須要加上 & 標志：
func add(inout v1:Int) -> Int {
return ++v1
}
var a = 1
add(&a) // 2
a // 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. Roboto
name2 // Mr. Potato
var number1 = 2
var number2 = 5
valueSwap(&number1, &number2) // 交流數字
number1 // 5
number2 // 2
函數類型
在 Swift 中，函數翻身把歌頌，終究成了一等國民，和其他類型等量齊觀。
變量
我們可以界說一個變量，這個變量的類型是函數類型：
func addTwoInts(a: Int, b: Int) -> Int {
return a + b
}
let anotherMathFunction = addTwoInts
anotherMathFunction(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, 3, 5) // 將參數2和參數3作為參數傳給參數1的函數
前往值
函數也是可以作為成果前往的。好比前往的值是一個參數為 Int 前往值為 Int 的函數，就是如許界說：func foo() -> (Int) -> Int。可以看上面這個詳細的例子：
func stepForward(input: Int) -> Int {
return input + 1
}
func stepBackward(input: Int) -> Int {
return input - 1
}
func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
return backwards ? stepBackward : stepForward
}
var currentValue = 3
let moveNearerToZero = chooseStepFunction(currentValue > 0) // 依據參數前往 stepForward 或 stepBackward
println("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
// 假如沒有 typealias 則須要如許：
// func luckyNumberForName(name: String, #lotteryHandler: (String, Int) -> String) -> String {
func luckyNumberForName(name: String, #lotteryHandler: lotteryOutputHandler) -> String {
let luckyNumber = Int(arc4random() % 100)
return lotteryHandler(name, luckyNumber)
}
luckyNumberForName("Mr. Roboto", lotteryHandler: {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.helloWithName
helloWithNameFunc(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"
以上所述就是本文的全體內容了，願望年夜家可以或許愛好。
