Swift - 函式

函式是一組組織在一起執行特定任務的語句。Swift 函式可以像簡單的 C 函式一樣簡單，也可以像 Objective C 語言函式一樣複雜。它允許我們在函式呼叫中傳遞區域性和全域性引數值。此外，我們可以在另一個函式內部定義一個函式，以將它的功能封裝在另一個函式內部。

函式在程式碼結構、模組化和提高程式碼可讀性方面發揮著重要作用。它們還提供各種功能，例如引數標籤、預設引數值、可變引數和多個返回值。

Swift 中的函式定義

在 Swift 中，函式由“func”關鍵字定義。當新定義函式時，它可以將一個或多個值作為輸入“引數”傳遞給函式，並且它將在主體中處理函式並將值作為輸出“返回值”傳遞迴函式。

每個函式都有一個函式名稱，用於描述函式執行的任務。要使用函式，您需要“呼叫”該函式及其名稱，並傳遞與函式引數型別匹配的輸入值（稱為引數）。函式引數也稱為“元組”。

函式的引數必須始終按照函式引數列表中的順序提供，返回值後跟 ->。

語法

以下是建立函式的語法：

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

示例

Swift 程式演示如何建立函式。

// Function with return type
func student(name: String) -> String {
   return name
}

print(student(name: "First Program"))
print(student(name:"About Functions"))

輸出

它將產生以下輸出：

First Program
About Functions

在 Swift 中呼叫函式

呼叫函式意味著執行函式內部的一組語句。我們可以透過函式的名稱來呼叫函式，並且在呼叫時必須提供所有引數（如果可用）。

讓我們假設我們定義了一個名為“display”的函式，例如，考慮一個函式名稱為“display”的函式，首先用引數“no1”（它持有整數資料型別）初始化。

然後將引數“no1”賦值給引數“a”，此後“a”將指向相同的資料型別整數。現在引數“a”被返回到函式。此處，display() 函式將儲存整數值並在每次呼叫函式時返回整數值。

語法

以下是呼叫函式的語法：

funcName(parameters)

示例

Swift 程式演示如何呼叫函式。

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

// Calling function
print(display(no1: 100))
print(display(no1: 200))

輸出

它將產生以下輸出：

100
200

Swift 中的函式引數型別

引數是在函式宣告中指定的變數，用於在呼叫函式時獲取輸入。或者它們允許我們在呼叫時將值傳遞給函式，並對這些值執行操作。它們始終在函式內部指定，並帶標籤、型別和值（如果可用）。Swift 函式支援以下型別的引數：

常規引數
可變引數
輸入輸出引數

讓我們詳細討論所有型別的引數。

常規引數

常規引數是函式中最常用的引數。它們允許我們根據指定的值執行基本操作。一個函式可以有一個或多個常規引數。每個常規引數都有其引數標籤和顯式型別，並且它們之間用逗號分隔。

我們還可以指定常規引數中的預設值，這意味著如果我們在呼叫該函式時省略該引數，則將使用該引數中存在的預設值。

語法

以下是常規引數的語法：

func funcname(name1: Type, name2:Type = defualtValue) -> returntype {
   Statement
   return value
}

示例

Swift 程式演示如何建立具有常規引數的函式。

// Creating function with regular parameters and default value
func Sum(num1: Int, num2: Int = 2) -> Int {
   var result = 0
   result = num1 + num2
   return result
}

// Calling function 
print("Sum 1:", Sum(num1: 10))
print("Sum 2:", Sum(num1: 20, num2: 12))

輸出

它將產生以下輸出：

Sum 1: 12
Sum 2: 32

可變引數

Swift 提供了一種名為可變引數的特殊型別的引數。可變引數允許我們在函式中接受多個相同型別的輸入值。當我們想要在函式內部傳遞任意數量的相同型別的值而不指定值的精確數量時，此引數很有用。

單個函式可以包含多個可變引數，並且在第一個可變引數之後，下一個可變引數必須包含引數標籤以進行區分。傳遞到可變引數中的值在函式中可用作陣列。可變引數不被標記為 inout。

語法

以下是可變引數的語法：

func funcname(_name1: Type…, name2:Type…, name3: Type…) -> returntype
{
   Statement
   return value
}

示例

Swift 程式演示如何建立具有可變引數的函式。

// Creating function with variadic parameter 
func Product(_ num: Int...) -> Int {

   var result = 1
   for x in num{
      result *= x
   }
   return result
}

// Calling function and passing multiple values of the same type
print("Product:", Product(10, 20, 30))

輸出

它將產生以下輸出：

Product: 6000

輸入輸出引數

Swift 中的輸入輸出引數提供了一種功能，即使在函式呼叫後修改了引數值，也能保留引數值。在函式引數定義的開頭，宣告“inout”關鍵字以保留成員值。

它派生關鍵字“inout”，因為它的值被“傳入”函式，並且它的值被函式體訪問和修改，並且它被“傳出”函式以修改原始引數。輸入輸出引數不包含預設值。

變數僅作為輸入輸出引數的引數傳遞，因為它們的值僅在函式內部和外部被修改。因此，無需將字串和字面量宣告為輸入輸出引數。“&”變數名前面的符號表示我們將引數傳遞給輸入輸出引數。

語法

以下是輸入輸出引數的語法：

func funcname(_name1: inout Type, _name2: inout Type) -> returntype
{
   Statement
   return value
}

示例

Swift 程式演示如何建立具有輸入輸出引數的函式。

// Function to swap two values
func swap(_ x: inout Int, _ y: inout Int) {
   let temp = x
   x = y
   y = temp
}

var p = 15
var q = 10

print("Before swapping: p = \(p), q = \(q)")

swap(&p, &q)

print("After swapping: p = \(p), q = \(q)")

輸出

它將產生以下輸出：

Before swapping: p = 15, q = 10
After swapping: p = 10, q = 15

Swift 中的函式引數標籤和引數名稱

函式可以為其引數和引數指定標籤和名稱。這些標籤和名稱為引數和引數提供了清晰且描述性的上下文。引數名稱用於函式宣告中，而引數標籤用於呼叫函式時。

預設情況下，引數標籤和引數名稱相同，但多個引數可以具有相同或唯一的引數標籤。引數的名稱應唯一，以便函式可以輕鬆區分它們。我們還可以透過在引數名稱前放置下劃線（_）來省略引數標籤。

語法

以下是引數標籤和引數名稱的語法：

// Parameter name With argument label
func funcname(argumentLabel parameterName: Type, parameterName: Type) -> returntype {
   Statement
   return value
}
funcname(name1:value, name2: value)

// Parameter name without argument label
func funcname(_name1: Type, _name2: Type) -> returntype {
   Statement
   return value
}
funcname(value1, value2)

示例

Swift 程式演示如何在函式中指定引數名稱和引數標籤。

// Function 1 with parameter names and argument label
func pow(firstArg a: Int, secondArg b: Int) -> Int {
   var res = a
   for _ in 1..<b {
      res = res * a
   }
   return res
}
print("Power:", pow(firstArg:5, secondArg:3))

// Function 2 with parameter names and without argument label
func product(_ a: Int,  b: Int) -> Int {
   let res = a * b
   return res
}
print("Product:", product(5, b:3))

輸出

它將產生以下輸出：

Power: 125
Product: 15

Swift 中的引數和返回值

Swift 提供靈活的函式引數及其返回值，從簡單到複雜的值。我們可以建立各種形式的函式，例如：

帶引數的函式
不帶引數的函式
帶返回值型別的函式
不帶返回值型別的函式
帶可選返回值型別的函式

讓我們詳細討論所有形式的函式。

帶引數的函式

透過將引數值傳遞到函式體來訪問函式。我們可以在函式內部傳遞單個或多個引數值，並且每個引數都有自己的標籤，以便編譯器可以識別哪個對應於哪個引數。

語法

以下是帶引數的函式的語法：

func funcname(para1: Type, para2: Type) -> datatype {
   return datatype
}

示例

Swift 程式建立帶引數的函式。

// Function with two parameters
func mult(no1: Int, no2: Int) -> Int {
   return no1 * no2
}

// Calling function
print(mult(no1: 2, no2: 20))
print(mult(no1: 3, no2: 15))
print(mult(no1: 4, no2: 30))

輸出

它將產生以下輸出：

40
45
120

無引數的函式

我們也可以定義沒有任何引數的函式。當我們想要封裝一段不依賴任何外部輸入的程式碼塊時，此類函式非常有用。

語法

以下是無引數函式的語法：

func funcname() -> datatype {
   return datatype
}

示例

Swift 程式建立無引數的函式。

// Function without parameters
func votersname() -> String {
   return "Alice"
}

// Calling function
print(votersname())

輸出

它將產生以下輸出：

Alice

帶返回值的函式

函式也用於將字串、整數和浮點數資料型別值作為返回值型別返回。它可以返回單個或多個值。如果函式返回多個值，則它將使用元組返回多個值。

語法

以下是帶返回值函式的語法：

func funcname(para1: Type, para2: Type) -> datatype {
   return datatype
}

示例

Swift 程式建立返回值的函式。

// Function to find out the largest and smallest number in a given array 
func ls(array: [Int]) -> (large: Int, small: Int) { 
   var lar = array[0]
   var sma = array[0]
   
   // Comparing value with its previous value
   for i in array[1..<array.count] 
   {
   
      // If the value is lesser than the previous one it is stored in 'sma' argument
      if i < sma {
         sma = i
      }
      // Otherwise it is stored in 'lar' argument
      else if i > lar {
         lar = i
      }
   }
   
   // Returning multiple values using tuple
   return (lar, sma)
}

let num = ls(array: [40, 12, -5, 78, 98])
print("Largest number is: \(num.large) and smallest number is: \(num.small)")

輸出

它將產生以下輸出：

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

無返回值的函式

某些函式可能在函式內部宣告引數，但沒有任何返回值。

語法

以下是無返回值函式的語法：

func funcname(para1: Type, para2: Type){
   return datatype
}

示例

Swift 程式建立不返回值的函式。

// Function with parameters but no return type
func sum(a: Int, b: Int) {
   let a = a + b
   let b = a - b
   print(a, b)
}

sum(a: 20, b: 10)
sum(a: 40, b: 10)
sum(a: 24, b: 6)

輸出

它將產生以下輸出：

30 20
50 40
30 24

帶可選返回值型別的函式

Swift 引入了“可選”功能，透過引入安全措施來解決問題。“可選”用於檢查“nil”或垃圾值，從而節省了大量除錯時間，並使程式碼對使用者高效且易讀。

例如，我們宣告函式值返回值型別為整數，但當函式返回字串值或 nil 值時會發生什麼？在這種情況下，編譯器將返回錯誤值。“可選”是為了解決這些問題而引入的。

可選函式將採用兩種形式“值”和“nil”。我們將使用關鍵保留字元“？”來提及“可選”，以檢查元組是返回值還是 nil 值。

示例

Swift 程式建立返回可選型別的函式。

// Function with optional return type
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(array: [8, -6, 2, 109, 3, 71]) {
   print("min is \(bounds.min) and max is \(bounds.max)")
}

輸出

它將產生以下輸出：

min is -6 and max is 109

函式型別

在 Swift 中，函式型別用於表示函式的型別以及其引數型別和返回值型別。函式型別允許我們以型別安全的方式建立、傳遞和使用函式作為變數或引數。引數型別表示將儲存在函式中的引數的型別，而返回值型別表示函式將返回的值的型別。

示例

Swift 程式演示函式型別。

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

輸出

它將產生以下輸出：

2
6

將函式賦值給變數

Swift 函式是一等公民。因此，我們允許將函式分配給變數，就像我們將值分配給變數一樣。將函式分配給變數後，該變數將儲存該函式的引用。

語法

以下是將函式賦值給變數的語法：

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

這裡 sum 是一個具有整數變數 'a' 和 'b' 的函式名，現在將其宣告為函式名 addition 的變數。此後，addition 和 sum 函式都具有相同數量的引數，宣告為整數資料型別，並且還返回整數作為引用。

示例

Swift 程式演示如何將函式賦值給變數。

// Function
func sum(a: Int, b: Int) -> Int {
   return a + b
}

// Assigning a function to a variable
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

輸出

它將產生以下輸出：

Result: 129

函式型別作為引數型別

在 Swift 中，我們可以在另一個函式中使用函式型別作為引數型別，這意味著我們可以將函式作為引數傳遞到另一個函式中。

示例

Swift 程式演示如何將函式作為引數傳遞到另一個函式中。

// Function type is (Int, Int) -> Int
func add(_ x: Int, _ y: Int) -> Int {
   return x + y
}

// Function type as a parameter
func Display(_ myOperation: (Int, Int) -> Int, _ p: Int, _ q: Int) -> Int {
   return myOperation(p, q)
}

// Passing function as an argument
let sum = Display(add, 5, 7)

print("Sum: \(sum)")

輸出

它將產生以下輸出：

Sum: 12

函式型別作為返回值型別

在 Swift 中，我們可以在另一個函式中使用函式型別作為返回值型別，這意味著一個函式可以從另一個函式返回。

示例

Swift 程式演示函式如何返回另一個函式。

// Function type is (Int, Int) -> Int
func add(_ x: Int, _ y: Int) -> Int {
   return x + y
}

// Display() function will return add() function
func Display()->(Int, Int) -> Int {
   return add
}

let myFunc = Display()
let result = myFunc(9, 2)

print("Sum: \(result)")

輸出

它將產生以下輸出：

Sum: 11

列印頁面