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 Program
About Functions

調用函數

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

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

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

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

100
200

參數和返回值

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 運行上面的程序，得到以下結果：

40
45
120

不帶參數的函數

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

語法

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 運行上面的程序，得到以下結果

1
2
3

外部參數名稱

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

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 運行上面的程序，得到以下結果

125

參數可變型參數

當我們想定義具有多個數量參數的函數, 那麼我們可以聲明成員爲 「可變參數」 的參數。參數可以被指定爲可變參數由(...)的參數名稱之後。

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 運行上面的程序，得到以下結果

4
3
5
4.5
3.1
5.6
Swift
Enumerations
Closures

常量，變量和 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 運行上面的程序，得到以下結果

2
6

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

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

在這裏，函數聲明爲字符串數據類型。

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

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

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

Swift Functions
Types 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: 129
Result: 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