Swift語言中的函數學習教程

函數是一個組織在一起語句集合，以執行特定任務。Swift 函數類似于簡單 C 函數以及復雜的 Objective C 語言函數。它使我們能夠通過函數調用內部的局部和全局參數值。像其他任何語言一樣 swift 函數也遵循相同的步驟。

函數聲明：它告訴編譯器有關的函數的名稱，返回類型和參數。

函數定義：它提供函數的實際主體。

Swift 函數包含參數類型和返回類型。

函數定義
在Swift 語言中函數是由 “func” 關鍵字來定義。當一個新定義函數時，它可能需要一個或幾個值作為函數輸入作為“參數” ，它將被處理在函數體中并傳回值作為 '返回類型' 輸出。

每個函數都有一個函數名，它描述了函數將執行的任務。要使用函數，需要調用其名字函數，并通過它的輸入值(稱為參數)匹配函數的參數類型。函數參數也被稱為“元組”。

函數的參數必須提供與函數參數列表的順序相同，并返回一個值在 -> 之后。

語法

復制代碼代碼如下:

		
		Syntax:
		func funcname(Parameters) -> returntype
		{
		   Statement1
		   Statement2
		    ---
		   Statement N
		   return parameters
		}

學生們的名字被聲明為函數“student” ，函數內部聲明字符串作為返回數據類型，當調用該函數將返回學生姓名。

復制代碼代碼如下:

		
		func student(name: String) -> String {
		   return name
		}
		println(student("First Program"))
		println(student("About Functions"))

當我們使用 playground 運行上面的程序，得到以下結果

First ProgramAbout Functions

調用函數
考慮下面的例子是一個用來顯示數字的“display”函數，首先用參數 “no1” 初始化且持整數數據類型。然后參數 “no1” 被分配給參數 “a”，指向相同的數據類型的整數。現在參數 a 被返回給函數。這里 display()函數將持有整數值，每調用函數一次，返回整數值。

復制代碼代碼如下:

func display(no1: Int) -> Int {
let a = no1
return a
}

println(display(100))
println(display(200))

當我們使用 playground 運行上面的程序，得到以下結果

參數和返回值
Swift 提供了靈活的函數參數和返回值，從簡單到復雜的值。類似于 C 和 Objective C 函數也可以有多種形式

帶參數的函數
函數是通過其參數值傳到函數體訪問。我們可以通過單一到多元的參數值作為元組傳到函數內部。

復制代碼代碼如下:

		
		func mult(no1: Int, no2: Int) -> Int {
		   return no1*no2
		}
		println(mult(2,20))
		println(mult(3,15))
		println(mult(4,30))

當我們使用 playground 運行上面的程序，得到以下結果：

不帶參數的函數
我們可能使用包含函數不帶任何參數。

語法

復制代碼代碼如下:

		
		func funcname() -> datatype {
		   return datatype
		}

以下是不帶參數函數的一個例子：

復制代碼代碼如下:

		
		func votersname() -> String {
		   return "Alice"
		}
		println(votersname()) 

當我們使用 playground 運行上面的程序，得到以下結果

Alice

函數帶返回值
函數也可用于返回字符串，整數和浮點數據類型值來作為返回類型。要找出數組函數 “ls” 的最大和最小的數，用large，small 整數數據類型聲明。

數組初始化為持有整數值。然后數組被處理并將數組中的每一個值讀出并寫其先前的值比較。當該值比前一個存儲在“small”的參數更小，否則存儲在 “large” 的參數值通過調用函數返回

復制代碼代碼如下:

		
		func ls(array: [Int]) -> (large: Int, small: Int) {
		   var lar = array[0]
		   var sma = array[0]
		   for i in array[1..<array.count] {
		      if i < sma {
		         sma = i
		      } else if i > lar {
		         lar = i
		      }
		   }
		   return (lar, sma)
		}
		let num = ls([40,12,-5,78,98])
		println("Largest number is: /(num.large) and smallest number is: /(num.small)")

當我們使用 playground 運行上面的程序，得到以下結果

Largest number is: 98 and smallest number is: -5

函數不帶返回值
某些函數可能在函數中聲明參數，但沒有任何返回值。下面的程序聲明 a 和 b 作為參數傳遞給 sum()函數。函數內部本身的參數 a 和 b 的值是通過調用所述函數通過調用 sum()，其值被打印從而不用返回相關值。

復制代碼代碼如下:

		
		func sum(a: Int, b: Int) {
		   let a = a + b
		   let b = a - b
		   println(a, b)
		}
		sum(20, 10)
		sum(40,10)
		sum(24,6)

當我們使用 playground 運行上面的程序，得到以下結果

(30, 20)(50, 40)(30, 24)

返回 Optional 類型的函數
Swift 推出 “optional” 特性以通過引入一個安全對策來消除問題。例如，考慮我們聲明函數值返回類型為整數，但當函數返回一個字符串值或任何一個零值，會怎么樣？在這種情況下，編譯器會返回錯誤值。 “optional” 引入以擺脫這些問題。

可選(Optional )功能將采取兩種形式 'value' 和 'nil'。我們會提到 'Optionals' 使用鍵保留字符 “?” 檢查元組是否返回一個值或零值。

復制代碼代碼如下:

		
		func minMax(array: [Int]) -> (min: Int, max: Int)? {
		    if array.isEmpty { return nil }
		    var currentMin = array[0]
		    var currentMax = array[0]
		    for value in array[1..<array.count] {
		        if value < currentMin {
		            currentMin = value
		        } else if value > currentMax {
		            currentMax = value
		        }
		    }
		    return (currentMin, currentMax)
		}
		if let bounds = minMax([8, -6, 2, 109, 3, 71]) {
		    println("min is /(bounds.min) and max is /(bounds.max)")
		}

當我們使用 playground 運行上面的程序，得到以下結果

min is -6 and max is 109

'Optionals'被用來檢查 'nil' 或垃圾值，從而消耗大量的時間調試，使代碼的效率和可讀性的用戶。

函數局部VS外部參數名稱局部參數名稱
局部參數名稱僅在函數內部訪問。

復制代碼代碼如下:

		
		func sample(number: Int) {
		   println(number)
		}

這里 func 示例參數數量被聲明為內部變量，因為它是由函數 sample() 內部訪問。在這里，“number” 被聲明為局部變量，但下面的語句引用變量可使用函數外部。

復制代碼代碼如下:

		
		func sample(number: Int) {
		   println(number)
		}
		sample(1)
		sample(2)
		sample(3)

當我們使用 playground 運行上面的程序，得到以下結果

外部參數名稱
外部參數名稱允許命名一個函數參數，使它們的目的更加明確。命名兩個函數的參數，然后調用該函數如下

復制代碼代碼如下:

		
		func pow(firstArg a: Int, secondArg b: Int) -> Int {
		   var res = a
		   for _ in 1..<b {
		      res = res * a
		   }
		   println(res)
		   return res
		}
		pow(firstArg:5, secondArg:3)

當我們使用 playground 運行上面的程序，得到以下結果

參數可變型參數
當我們想定義具有多個數量參數的函數, 那么我們可以聲明成員為 “可變參數” 的參數。參數可以被指定為可變參數由(...)的參數名稱之后。

復制代碼代碼如下:

		
		func vari<N>(members: N...){
		   for i in members {
		      println(i)
		   }
		}
		vari(4,3,5)
		vari(4.5, 3.1, 5.6)
		vari("Swift", "Enumerations", "Closures")

當我們使用 playground 運行上面的程序，得到以下結果

4354.53.15.6SwiftEnumerationsClosures

常量，變量和 I/O 參數
函數默認情況下，考慮參數'常量'，其中的用戶也可以聲明參數到函數作為變量。我們已經討論過 'let' 關鍵字用來聲明常量參數，可變參數的定義是使用 “var” 關鍵字。

I/O參數在 Swift 中提供保留參數值的功能，即使其值在函數調用修改之后。在函數參數定義“inout”關鍵字的開始聲明保留成員值。

它源于關鍵字“inout”，因為它的值傳遞 'in' 到函數并且它的值被訪問，并它的函數體修改，函數返回到“out” 來修改原來的參數。

因為單靠它的值在里面，函數外部修改變量僅作為參數傳遞 in-out 參數。因此，沒有必要聲明字符串、文本作為 in-out 參數。 '&' 在之前變量名是指傳遞的參數。

復制代碼代碼如下:

		
		func temp(inout a1: Int, inout b1: Int) {
		   let t = a1
		   a1 = b1
		   b1 = t
		}
		var no = 2
		var co = 10
		temp(&no, &co)
		println("Swapped values are /(no), /(co)")

當我們使用 playground 運行上面的程序，得到以下結果

Swapped values are 10, 2

函數類型及其用法
每個函數遵循指定的函數通過輸入參數，并輸出所期望的結果。

復制代碼代碼如下:

		
		func inputs(no1: Int, no2: Int) -> Int {
		   return no1/no2
		}

下面是一個例子：

復制代碼代碼如下:

		
		func inputs(no1: Int, no2: Int) -> Int {
		   return no1/no2
		}
		println(inputs(20,10))
		println(inputs(36,6))

當我們使用 playground 運行上面的程序，得到以下結果

在這里，函數有兩個參數 no1 和 no2 作為整數數據類型被初始化，它的返回類型也被聲明為'int'

復制代碼代碼如下:

		
		Func inputstr(name: String) -> String {
		   return name
		}

在這里，函數聲明為字符串數據類型。

函數也可能有無效(void)的數據類型來表示該函數將不返回任何東西。

復制代碼代碼如下:

		
		func inputstr() {
		   println("Swift Functions")
		   println("Types and its Usage")
		}
		inputstr()

當我們使用 playground 運行上面的程序，得到以下結果

Swift FunctionsTypes and its Usage

上述函數聲明為沒有參數并且函數的返回值為 void。

使用函數類型
函數首先傳遞整數，浮點數或字符串類型的參數，然后如下所述其被作為常數或變量傳遞到函數中。

復制代碼代碼如下:

var addition: (Int, Int) -> Int = sum

這里 'a'和 'b' 聲明作為 sum 函數的參數變量，在函數將這兩個整數相加并返回：

復制代碼代碼如下:

		
		func sum(a: Int, b: Int) -> Int {
		   return a + b
		}
		var addition: (Int, Int) -> Int = sum
		println("Result: /(addition(40, 89))")

當我們使用 playground 運行上面的程序，得到以下結果

Result: 129

函數類型作為參數類型和返回類型
我們也可以通過傳遞函數本身作為參數類型給另一個函數。

復制代碼代碼如下:

		
		func sum(a: Int, b: Int) -> Int {
		   return a + b
		}
		var addition: (Int, Int) -> Int = sum
		println("Result: /(addition(40, 89))")
		func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
		   println("Result: /(addition(a, b))")
		}
		another(sum, 10, 20)

當我們使用 playground 運行上面的程序，得到以下結果

Result: 129Result: 30

嵌套函數
嵌套函數通過調用內部函數來調用外部函數。

復制代碼代碼如下:

		
		 func calcDecrement(forDecrement total: Int) -> () -> Int {
		   var overallDecrement = 0
		   func decrementer() -> Int {
		      overallDecrement -= total
		      return overallDecrement
		   }
		   return decrementer
		}
		let decrem = calcDecrement(forDecrement: 30)
		println(decrem())

當我們使用 playground 運行上面的程序，得到以下結果：

-30

函數參數傳遞
函數的語法格式如下：
func 函數名(參數列表) -> 返回值類型 {
語句組
return 返回值
}
關鍵字是func。
多個參數列表之間可以用逗號（,）分隔，也可以沒有參數。
使用箭頭“->”指示返回值類型。返回值有單個值和多個值。如果函數沒有返回值，則“-> 返回值類型”部分可以省略。
如果函數有返回值，就需要在函數體最后使用return語句；如果沒有返回值，則函數體中可以省略return語句。
函數定義示例代碼如下：

復制代碼代碼如下:

		
		funcrectangleArea(width:Double, height:Double) -> Double {
		    let area = width * height
		    return area   
		} 
		print("320x480的長方形的面積:/(rectangleArea(320, height:480))") 

傳遞參數
介紹幾種不同形式的參數。
使用外部參數名
為每個參數提供一個可以在函數外部使用的名稱，稱為外部參數名，修改rectangleArea函數的定義如下：

復制代碼代碼如下:

		
		func rectangleArea(Wwidth:Double, H height:Double) -> Double {
		    let area = width * height
		    return area
		}

在局部參數名之前給一個“外部參數名”，用空格分隔。定義代碼中的W和H就是外部參數名。調用代碼如下：
print("320x480的長方形的面積:/(rectangleArea(W:320, H:480))")
如果我們提供了外部參數名，那么在函數調用時，必須使用外部參數名，所以W和H不能省略。

省略外部參數名
Swift 2.0提供省略外部參數名可能，在定義函數時，使用下劃線（_）表示外部參數名，示例代碼如下：

復制代碼代碼如下:

		
		funcrectangleArea(width:Double, _ height:Double) -> Double {
		    let area = width * height
		    return area
		}

這樣函數在調用時就可以省略外部參數名，代碼如下：
print("320x480的長方形的面積:/(rectangleArea(320, 480))")
在定義函數時第一個參數不需要使用下劃線（_），默認第一個參數名是省略的，其他參數名要想省略則需要使用下劃線（_）符號。

參數默認值
在定義函數的時候可以為參數設置一個默認值，當調用函數的時候可以忽略該參數?？聪旅娴囊粋€示例：

復制代碼代碼如下:

		
		func makecoffee(type :String = "卡布奇諾") -> String {
		    return "制作一杯/(type)咖啡。"
		}

在調用的時候，如果調用者沒有傳遞參數，則使用默認值。調用代碼如下：
let coffee1 = makecoffee("拿鐵")
let coffee2 = makecoffee()
最后輸出結果如下：

制作一杯拿鐵咖啡。制作一杯卡布奇諾咖啡。

可變參數
Swift中函數的參數個數可以變化，它可以接受不確定數量的輸入類型參數，它們具有相同的類型。我們可以通過在參數類型名后面加入（...）的方式來指示這是可變參數。
下面看一個示例：

復制代碼代碼如下:

		
		func sum(numbers:Double...) -> Double {
		    var total: Double = 0
		    for number in numbers {
		        total += number
		    }
		    return total
		}

下面是兩次調用sum函數代碼：

sum(100.0, 20, 30)sum(30, 80)

可以看到每次傳遞參數的個數是不同的。