* 函數(shù)是用來完成特定任務(wù)的獨立的代碼塊。你給一個函數(shù)起一個合適的名字，用來標(biāo)識函數(shù)做什么，并且當(dāng)函數(shù)需要執(zhí)行的時候，這個名字會被用于“調(diào)用”函數(shù)
* 格式：
* func 函數(shù)名稱(參數(shù)名:參數(shù)類型, 參數(shù)名:參數(shù)類型...) -> 函數(shù)返回值 {函數(shù)實現(xiàn)部分}
*沒有參數(shù)沒有返回值*
* 可以寫為 ->Void
* 可以寫為 ->()
* 可以省略
* Void 它其實是一個空的元組（tuple），沒有任何元素，可以寫成()
func say() -> Void{
'' print("cool")
}
say() //調(diào)用方法
func say2() -> (){
'' print("cool")
}
say2() //調(diào)用方法
func say3(){
'' print("cool")
}
say3() //調(diào)用方法
*有參數(shù)沒有返回值*
* 內(nèi)部參數(shù): Swift2.0以前, 默認(rèn)情況下的參數(shù)都是內(nèi)部參數(shù)
*? Swift2.0開始, 默認(rèn)將第二個參數(shù)名稱作為外部參數(shù)
* 外部參數(shù)只能外部用, 函數(shù)內(nèi)部不能使用, 函數(shù)內(nèi)部只能使用內(nèi)部參數(shù)
* 忽略外部參數(shù): 在內(nèi)部參數(shù)前加‘ _?’
func sum(a: Int, b: Int){
'' print(a + b)
}
sum(10, b: 20)
func summ(a: Int, _ b: Int){
'' print(a + b)
}
summ(10, 20)
// xy外部參數(shù), ab內(nèi)部參數(shù)
// Swift2.0以前可以寫#
func sum2(x a: Int, y b: Int){
'' print(a + b)
}
sum2(x: 10, y: 20)
*默認(rèn)參數(shù)*
* 格式: func method(parameter: Int = 0){}
* 當(dāng)默認(rèn)值被定義后，調(diào)用這個函數(shù)時可以忽略這個參數(shù)
* 其它語言的默認(rèn)參數(shù)必須寫在最后面, Swift可以寫在任意位置
* 注意：
* 將帶有默認(rèn)值的參數(shù)放在函數(shù)參數(shù)列表的最后。這樣可以保證在函數(shù)調(diào)用時，非默認(rèn)參數(shù)的順序是一致的，同時使得相同的函數(shù)在不同情況下調(diào)用時顯得更為清晰。
func joinString(s1:String , jioner:String = "??",toString s2:String) ->String
{
'' return s1 + jioner + s2;
}
joinString("cool", jioner: "和", toString: "boy")
joinString("cool", toString: "boy")
*常量參數(shù)和變量參數(shù)（Constant and Variable Parameters)*
* 函數(shù)參數(shù)默認(rèn)是常量, 在函數(shù)內(nèi)部不能修改
* 如果想在函數(shù)中修改參數(shù), 必須在參數(shù)前加上var
* 注意：
* 對變量參數(shù)所進(jìn)行的修改在函數(shù)調(diào)用結(jié)束后便消失了，并且對于函數(shù)體外是不可見的。變量參數(shù)僅僅存在于函數(shù)調(diào)用的生命周期中
func swap(a:Int, b:Int)
{
'' print("交換前 a = \(a) b = \(b)")
'' let temp = a;
'' a = b; // 不能修改
'' b = temp;
'' print("交換后 a = \(a) b = \(b)")
}
func swap1(var a:Int, var b:Int)
{
'' print("交換前 a = \(a) b = \(b)")
'' let temp = a;
'' a = b;? // 可以修改, 但不會影響實參
'' b = temp;
'' print("交換后 a = \(a) b = \(b)")
}
var x = 10
var y = 20
print("交換前 a = \(x) b = \(y)")
swap1(x, b: y)
print("交換后 a = \(x) b = \(y)")
*輸入輸出參數(shù)（In-Out Parameters*
* 變量參數(shù)，正如上面所述，僅僅能在函數(shù)體內(nèi)被更改。如果你想要一個函數(shù)可以修改參數(shù)的值，并且想要在這些修改在函數(shù)調(diào)用結(jié)束后仍然存在，那么就應(yīng)該把這個參數(shù)定義為輸入輸出參數(shù)（In-Out Parameters)
* 定義一個輸入輸出參數(shù)時，在參數(shù)定義前加 inout 關(guān)鍵字
* 注意：
* 輸入輸出參數(shù)不能有默認(rèn)值，而且可變參數(shù)不能用 inout 標(biāo)記。如果你用 inout 標(biāo)記一個參數(shù)，這個參數(shù)不能被 var 或者 let 標(biāo)記。
func swap2(inout a:Int, inout b:Int)
{
'' let temp = a;
'' a = b;
'' b = temp;
}
var x1 = 10;
var y1 = 20;
print("交換前 a = \(x1) b = \(y1)")
swap2(&x1, b: &y1)
print("交換后 a = \(x1) b = \(y1)")
*可變參數(shù)（Variadic Parameters*
* 一個可變參數(shù)可以接收零個或多個值
* 如果沒有變參函數(shù) , 并且函數(shù)的參數(shù)個數(shù)又不確定那么只能寫多個方法或者用將函數(shù)參數(shù)改為集合
* 格式 func method(parameter: Int...){}
* 可變參數(shù)在函數(shù)中可以當(dāng)做一個數(shù)組
* 注意：
* 一個函數(shù)最多只能有一個可變參數(shù)
* 變參只能是同種類型的數(shù)據(jù)
* 變參必須指定數(shù)據(jù)類型
* 如果函數(shù)有一個或多個帶默認(rèn)值的參數(shù)，而且還有一個可變參數(shù)，那么把可變參數(shù)放在參數(shù)表的最后
func add(nums:Int..., other:Int) -> Int
{
'' var sum = 0;
'' for num in nums
'' {
''? ? sum += num
'' }
'' return sum + other
}
print(add(1, 2, 3, other: 9))// 會將9傳遞給第一個參數(shù), 后面的傳遞給nums
沒有參數(shù)有返回值
func getNumer() ->Int{
'' return 998
}
print(getNumer())
?有參數(shù)有返回值
func sum3(a: Int, b: Int) ->Int{
'' return a + b
}
print(sum3(10, b: 20))
嵌套函數(shù)
func showArray(array:\[Int])
{
'' // 嵌套函數(shù)
'' func printArray(arr:[Int])
'' {
''? ? for number in array
''? ? {
''? ? ? ? print("\(number), ")
''? ? }
'' }
'' printArray(array)
}
showArray(\[1, 3, 5, 7, 9])
* 函數(shù)類型（Function Types）*
* 函數(shù)類型作為參數(shù)類型（Function Types as Parameter Types）
* 函數(shù)類型作為返回類型（Function Types as Return Types）
* 嵌套函數(shù)（Nested Functions）
*提前退出*
* 像if語句一樣，guard的執(zhí)行取決于一個表達(dá)式的布爾值。我們可以使用guard語句來要求條件必須為真時，以執(zhí)行g(shù)uard語句后的代碼。
* 如果guard語句的條件被滿足，則在保護(hù)語句的封閉大括號結(jié)束后繼續(xù)執(zhí)行代碼
* 任何使用了可選綁定作為條件的一部分并被分配了值的變量或常量對于剩下的保護(hù)語句出現(xiàn)的代碼段是可用的
* 如果條件不被滿足，在else分支上的代碼就會被執(zhí)行。
* else這個分支必須轉(zhuǎn)移控制以退出guard語句出現(xiàn)的代碼段。它可以用控制轉(zhuǎn)移語句如return,break,continue或者throw做這件事
func divide(dividend: Double? , divisor: Double?) -> Double?
{
'' if dividend == .None {
''? ? return .None
'' }
''
'' if divisor == .None {
''? ? return .None
'' }
''
'' if divisor == 0 {
''? ? return .None
'' }
'' // 應(yīng)該盡量避免使用強制解包
'' return dividend! / divisor!
}
print(divide(10, divisor: 20))
func divide2(dividend: Double?, divisor: Double?) -> Double? {
'' // 嵌套太深
'' if let dividend = dividend
'' {
''? ? if let divisor = divisor
''? ? {
''? ? ? ? if divisor != 0
''? ? ? ? {
''? ? ? ? ? ? return dividend / divisor
''? ? ? ? }
''? ? }
'' }
'' return .None
}
print(divide2(10, divisor: 20))
func divide3(dividend: Double?, divisor: Double?) -> Double? {
'' guard let dividend = dividend else {
''? ? return .None
'' }
'' guard let divisor = divisor else {
''? ? return .None
'' }
'' guard divisor != 0 else {
''? ? return .None
'' }
'' return dividend / divisor
}
print(divide3(10, divisor: 20))
