函數(shù)定義
/*
* 函數(shù)(參數(shù)默認(rèn)為常量搞挣，在函數(shù)體不能被修改。函數(shù)是引用類型畴蹭，后面會(huì)提到)
*/
func <#name#>(<#parameters#>) -> <#return type#> {
<#function body#>
}
/**
* 例子(有返回值，有參數(shù)函數(shù))
*/
func greetPerson(person: String) -> String {
return "Hello, " + person + "!"
}
print(greetPerson(person: "bluajack"))
// 打印 "Hello, bluajack!"
func greetAgain(person: String) -> String {
return "Hello again, " + person + "!"
}
print(greetAgain(person: "bluajack"))
// 打印 "Hello again, bluajack!"
無(wú)參數(shù)函數(shù)
/**
* 無(wú)參數(shù)函數(shù),下面()為空
*/
func sayHelloWorld() -> String {
return "hello, world"
}
print(sayHelloWorld())
// 打印 "hello, world"
多參數(shù)函數(shù)
/**
* 多參數(shù)函數(shù)，參數(shù)1 (person:String) 參數(shù)2（alreadyGreeted:Bool）
*/
func greet(person:String, alreadyGreeted:Bool) -> String {
if alreadyGreeted {
return greetAgain(person: person)
}else{
return greetPerson(person: person)
}
}
print(greet(person: "girl", alreadyGreeted: false))
// 打印 "Hello, girl!"
print(greet(person: "bluajack", alreadyGreeted: true))
// 打印 "Hello again, bluajack!"
無(wú)返回值函數(shù)
/**
* 無(wú)返回值函數(shù)
*/
func greet(person:String) {
print("Hello, \(person)!")
}
greet(person: "約嗎亿卤？")
// 打印 Hello, 約嗎驱敲？!
//嚴(yán)格上來(lái)說(shuō)，雖然沒有返回值被定義赐俗，greet(person:) 函數(shù)依然返回了值拉队。沒有定義返回類型的函數(shù)會(huì)返回一個(gè)特殊的Void值。它其實(shí)是一個(gè)空的元組（tuple）阻逮，沒有任何元素粱快，可以寫成()。
多重返回值函數(shù)
/**
* 多重返回值函數(shù)
* 用元組（tuple）類型讓多個(gè)值作為一個(gè)復(fù)合值從函數(shù)中返回叔扼。
*/
func getMinMax(array: [Int]) -> (min: Int, max: Int) {
var min = array[0]
var max = array[0]
for value in array[1..<array.count] {
if value < min {
min = value
} else if value > max {
max = value
}
}
return (min, max)
}
let myArray = getMinMax(array: [12,25,-4,69,88,250])
print("min is \(myArray.min) and max is \(myArray.max)")
//打印 "min is -4 and max is 250"
可選元組返回類型函數(shù)
/*
* 基于上面函數(shù)的完善(存在傳入數(shù)組為空的情況)
* 可選元組返回類型函數(shù)
*/
func MinMax(array: [Int]) -> (min: Int, max: Int)? {
if array.isEmpty { return nil }
var min = array[0]
var max = array[0]
for value in array[1..<array.count] {
if value < min {
min = value
} else if value > max {
max = value
}
}
return (min, max)
}
//這里注意了 ??為空合運(yùn)算符事哭，用來(lái)判斷可選類型，前提是左右兩邊類型相等
let myArray2 = MinMax(array: []) ?? (0,0)
print(myArray2.min,myArray2.max)
//打印 "0 0"
//可選元組類型如 (Int, Int)? 與元組包含可選類型如 (Int?, Int?) 是不同的.可選的元組類型瓜富，整個(gè)元組是可選的慷蠕，而不只是元組中的每個(gè)元素值
函數(shù)參數(shù)標(biāo)簽和參數(shù)名稱
/**
* 函數(shù)參數(shù)標(biāo)簽和參數(shù)名稱
在參數(shù)名稱前指定參數(shù)標(biāo)簽，中間用逗號(hào)隔開食呻。函數(shù)標(biāo)簽?zāi)軌蚴鼓愕拇a更具可讀性
func testFunction(參數(shù)標(biāo)簽 參數(shù)名稱:類型) -> <#return type#> {
<#function body#>
}
*/
//例子_指定參數(shù)標(biāo)簽(不指定參數(shù)標(biāo)簽時(shí)流炕，默認(rèn)，函數(shù)參數(shù)使用參數(shù)名稱來(lái)作為它們的參數(shù)標(biāo)簽)
func greet(person: String, from hometown: String) -> String {
return "Hello \(person)! Glad you could visit from \(hometown)."
}
print(greet(person: "bluajack", from: "jingzhou"))
// 打印 "Hello bluajack! Glad you could visit from jingzhou."
//例子_忽略參數(shù)標(biāo)簽(如果你不希望為某個(gè)參數(shù)添加一個(gè)標(biāo)簽仅胞，可以使用一個(gè)下劃線(_)來(lái)代替一個(gè)明確的參數(shù)標(biāo)簽)
func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
// 在函數(shù)體內(nèi)每辟，firstParameterName 和 secondParameterName 代表參數(shù)中的第一個(gè)和第二個(gè)參數(shù)值
}
someFunction(1, secondParameterName: 2)//如果一個(gè)參數(shù)有一個(gè)標(biāo)簽，那么在調(diào)用的時(shí)候必須使用標(biāo)簽來(lái)標(biāo)記這個(gè)參數(shù)
設(shè)定默認(rèn)參數(shù)值
/**
* 設(shè)定默認(rèn)參數(shù)值(當(dāng)給參數(shù)設(shè)定默認(rèn)值后干旧，調(diào)用這個(gè)函數(shù)可以忽略這個(gè)參數(shù)渠欺，當(dāng)然你不忽略，那就用你給的值好了啰)
*/
func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
// 如果你在調(diào)用時(shí)候不傳第二個(gè)參數(shù)椎眯，parameterWithDefault 會(huì)值為 12 傳入到函數(shù)體中挠将。
}
someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault = 6
someFunction(parameterWithoutDefault: 4) // parameterWithDefault = 12
/**
* 可變參數(shù)(方法：在變量類型后面加入(...)的方式定義可變參數(shù))”嗾可變參數(shù)的實(shí)參在函數(shù)體中變?yōu)榇祟愋偷囊粋€(gè)數(shù)組
*/
func calAverage(_ numbers: Double...) -> Double {
var total: Double = 0
for number in numbers {
total += number
}
return total / Double(numbers.count)
}
calAverage(1, 2, 3, 4, 5)
// 返回 3.0, 是這 5 個(gè)數(shù)的平均數(shù)舔稀。
calAverage(3, 8.25, 18.75)
// 返回 10.0, 是這 3 個(gè)數(shù)的平均數(shù)。
輸入輸出參數(shù)
/**
* 輸入輸出參數(shù)
* 開頭提到函數(shù)參數(shù)默認(rèn)是常量掌测。如果你想要一個(gè)函數(shù)可以修改參數(shù)的值内贮，并且想要在這些修改在函數(shù)調(diào)用結(jié)束后仍然存在，那么就應(yīng)該把這個(gè)參數(shù)定義為輸入輸出參數(shù)
* 定義一個(gè)輸入輸出參數(shù)時(shí)，在參數(shù)定義前加 inout 關(guān)鍵字夜郁。只能傳遞變量給輸入輸出參數(shù)什燕。不能傳入常量或者字面量，因?yàn)檫@些量是不能被修改的竞端。當(dāng)傳入的參數(shù)作為輸入輸出參數(shù)時(shí)屎即，需要在參數(shù)名前加 & 符，表示這個(gè)值可以被函數(shù)修改
* 我感覺這里有點(diǎn)類似于C語(yǔ)言中的函數(shù)中的指針參數(shù)事富，傳入地址技俐，改變對(duì)應(yīng)地址內(nèi)存放的變量。
*/
//take care : 輸入輸出參數(shù)不能有默認(rèn)值赵颅，而且可變參數(shù)不能用 inout 標(biāo)記
//例子
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
let temporaryA = a
a = b
b = temporaryA
}
var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
// 打印 "someInt is now 107, and anotherInt is now 3"
函數(shù)類型
/**
* 函數(shù)類型('函數(shù)的類型' 由函數(shù)的 '參數(shù)類型' 和 '返回類型' 組成)
*/
//例子
func addTwoInts(_ a: Int, _ b: Int) -> Int {
return a + b
}
func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
return a * b
}
//這兩個(gè)函數(shù)的類型是 (Int, Int) -> Int虽另，就是說(shuō)“這個(gè)函數(shù)類型有兩個(gè) Int 型的參數(shù)并返回一個(gè) Int 型的值暂刘〗让”
func printHelloWorld() {
print("hello, world")
}
//這個(gè)函數(shù)的類型是：() -> Void，或者叫“沒有參數(shù)谣拣，并返回 Void 類型的函數(shù)”
使用函數(shù)類型
/**
* 使用函數(shù)類型
*/
//定義---(”定義一個(gè)叫做 mathFunction 的變量募寨，類型是‘一個(gè)有兩個(gè) Int 型的參數(shù)并返回一個(gè) Int 型的值的函數(shù)’，并讓這個(gè)新變量指向 addTwoInts 函數(shù)”)
//這里的意思就是森缠，函數(shù)tm也可以被引用拔鹰。函數(shù)屬于引用類型
var mathFunction: (Int, Int) -> Int = addTwoInts
print("Result: \(mathFunction(2, 3))")
// Prints "Result: 5"
mathFunction = multiplyTwoInts
print("Result: \(mathFunction(2, 3))")
// Prints "Result: 6"
函數(shù)類型作為參數(shù)使用
/**
* 函數(shù)類型作為參數(shù)類型使用(用 (Int, Int) -> Int 這樣的函數(shù)類型作為另一個(gè)函數(shù)的參數(shù)類型)
*/ // 參數(shù)名稱 （參數(shù)類型，也就是函數(shù)類型）
func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
print("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// 打印 "Result: 8"
函數(shù)類型作為返回類型使用
/**
* 函數(shù)類型作為返回類型
*/
//先定義兩個(gè)簡(jiǎn)單函數(shù)((Int) -> Int)
func stepForward(_ input: Int) -> Int {
return input + 1
}
func stepBackward(_ input: Int) -> Int {
return input - 1
}
//本節(jié)例子------------------------------(下面就是把函數(shù)類型作為返回類型)
func chooseStepFunction(backward: Bool) -> (Int) -> Int {
return backward ? stepBackward : stepForward
}
//簡(jiǎn)單來(lái)說(shuō)贵涵，就是通過(guò)你傳入的bool值判斷返回哪個(gè)函數(shù)
var currentValue = 3
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
// moveNearerToZero 現(xiàn)在指向 stepBackward() 函數(shù)列肢。
嵌套函數(shù)
/**
* 函數(shù)嵌套函數(shù)(OC中方法中嵌套方法,當(dāng)然這里是不一樣的!)
* 被嵌套的函數(shù)對(duì)外界是不可見的，意思就是前面我的那些例子都是全局的函數(shù)宾茂，下面這個(gè)被嵌套的函數(shù)變成局部的啦瓷马！
* 如何在外界使用內(nèi)部的嵌套函數(shù)呢？跨晴？欧聘？
* 當(dāng)然是看下面例子吧。
*/
func chooseFunction(backward: Bool) -> (Int) -> Int {
func stepForward(input: Int) -> Int { return input + 1 }
func stepBackward(input: Int) -> Int { return input - 1 }
return backward ? stepBackward : stepForward
}
var value = -4
let choosedFunc = chooseFunction(backward: value > 0)
//這里定義常量引用作為返回值的被嵌套的函數(shù),后面的操作端盆，就不贅述了怀骤！
