Swift2.0語言教程之函式的返回值與函式型別

Swift2.0中函式的返回值

根據是否具有返回值，函式可以分為無返回值函式和有返回值函式。以下將會對這兩種函式型別進行講解。

Swift2.0中具有一個返回值的函式

開發者希望在函式中返回某一資料型別的值，必須要在函式宣告定義時為函式設定一個返回的資料型別，並使用return語句進行返回。其中，return語句的一般表示形式如下：

return 表示式

其中，表示式可以是符合Swift標準的任意表示式。而具有返回值的函式宣告定義形式如下：

func 函式名(引數列表)->返回值型別{
語句
return 表示式
}

其中，返回的表示式型別必須和函式的返回值型別一致。

【示例7-13】以下程式碼計算某一數值範圍的長度，並返回輸出。程式碼如下：

import Foundation
func range(start:Int,end:Int)->Int{
return end-start
}
let a=range(0, end: 10)
print(a)

在程式碼中，指定函式的返回值型別為Int，而return表示式為end-start。執行結果如下所示：

10

Swift2.0中具有多個返回值的函式

在Swift中，函式不僅可以返回一個返回值，還可以返回多個，這時就需要使用到元組型別。其語法形式如下：

func count(引數列表) -> (返回值1:資料型別, 返回值2:資料型別, 返回值3:資料型別,…) {
……
return (返回值1,返回值2,返回值3,…)
}

【示例7-14】下面就獲取在一個字串中得母音、子音以及其它的個數。程式碼如下：

import Foundation
func count(string: String) -> (vowels: Int, consonants: Int, others: Int) {
var vowels = 0, consonants = 0, others = 0
for character in string.characters {
switch String(character).lowercaseString {
case "a", "e", "i", "o", "u":
++vowels
case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
"n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
++consonants
default:
++others
}
}
return (vowels, consonants, others)
}
let str="Hello Swift!"
let number=count(str)
print("\(number.vowels)母音\n\(number.consonants)子音\n\(number.others)其它")

執行結果如下所示：

3母音
7子音
2其它

在具有多個返回值的函式需要注意以下2點：

1.返回值個數一致

在->後面的返回值型別的個數要和return中的返回值個數一致，否則程式就會出現錯誤。如以下的程式碼，將示例7-14中的程式碼做了修改：

func count(string: String) -> (vowels: Int, consonants: Int, others: Int) {
var vowels = 0, consonants = 0, others = 0
…
return (vowels, consonants)
}

在此程式碼中可以知道，->後面的返回值型別有3個，但是return中得返回值有2個，它們的個數不一樣，導致程式出現以下的錯誤：

Tuple types '(@lvalue Int, @lvalue Int)' and '(vowels: Int, consonants: Int, others: Int)' have a different number of elements (2 vs. 3)

2.返回值順序

在->後面的返回值型別要和return中的返回值型別的順序一致，否則程式就會出現錯誤。如以下的程式碼，將示例7-14中的程式碼做了修改：

func count(string: String) -> (vowels: Int, consonants: Int, others: Int) {
var vowels = 0, consonants = 0, others = 0
…
return (vowels,others,consonants)
}

在此程式碼中，->後面的返回值為(vowels: Int, consonants: Int, others: Int)，return中的返回值為(vowels,others,consonants)由於它們的資料型別相同都是整型，所以在改變它們的位置後，程式不會出現錯誤。執行結構如下：

3母音
2子音
7其它

Swift2.0中無返回值

函式除了有有返回值型別外，還有沒有返回值的型別。在第7.2、7.3、7.4節中所講的都是沒有返回值的函式型別。沒有返回值的型別不需要定義返回值型別，並且也不需要出現return語句。如果出現return語句，反而會造成程式錯誤。例如以下的程式碼，它的功能是輸出某一數字。

import Foundation
func printaa(a:Int){
return a
}
let num=9
let number=printaa(num)
print(number)

在此函式中，它是沒有返回值的，但是在函式中又使用了renturn語句返回了a的值，所以導致程式出現了以下的錯誤資訊：

'Int' is not convertible to '()'

Swift2.0中函式型別

在Swift中，每一個函式都是一個特定的型別，這種型別被稱為函式型別。它由引數型別和返回值型別構成。例如以下程式碼就是一個具有引數型別和返回值型別的函式：

func add(a: Int, b: Int) -> Int {
return a + b
}

在該程式碼中，定義了一個實現加法運算的數學函式add。此函式接受了兩個Int整型的引數，執行相應的數學運算後，返回一個Int整型值作為結果。這個函式的型別就是(Int,Int)->Int，程式設計師可以理解為函式型別有兩個Int整型引數，並返回一個Int整型值。在Swift除了有具有引數列表和返回值型別的函式外，還有不帶引數和返回值型別的函式，如以下程式碼是一個不帶引數和返回值的函式：

func printHelloWorld(){
print("Hello,World")
}

函式printHelloWorld()的型別是()->()。由於函式沒有引數，返回void，所以該型別在Swift中相當於一個空元組，也可以簡化為()。

Swift2.0中使用函式型別

作為一種型別，程式設計師可以像任何其他型別一樣使用函式型別。基本語法如下：

let/var 常量名/變數名:函式型別=函式名
或者
let/var 常量名/變數名=函式名

【示例7-15】以下將使用一個mathFunction變數引用函式add。程式碼如下：

import Foundation
func add(a: Int, b: Int) -> Int {
return a + b
}
var mathFunction: (Int, Int) -> Int = add
print(mathFunction(2,8))

在程式碼中定義了一個mathFunction變數，並將該變數的型別設定為函式型別。它接受了兩個Int整型值，並返回了一個Int整型值。使用這個新的變數mathFunction來引用add函式的功能。執行結果如下所示：

10

由於Swift具有自動推斷型別的能力，所以可以在宣告變數後直接賦值，不需要單個為變數去宣告型別，所以以上的為變數賦值的程式碼可以改寫為：

var mathFunction = add

如果不同函式具有相同的函式型別，這時把它們賦值給同一個變數。例如，在以上的程式碼中在新增一個函式：

func multiply(a:Int,b:Int)->Int{
return a*b
}

由於mathFunction變數和multiply的型別匹配，所以可以直接賦值，並輸出，程式碼如下：

mathFunction=multiply
print(mathFunction(3,8))

程式碼如下所示：

10
24

Swift2.0中使用函式型別作為引數型別

開發者可以使用函式型別作為另一個函式的引數型別。例如以下程式碼，它的功能是讓個數進行相加或者相乘，然後輸出。程式碼如下：

import Foundation
//兩數相加
func add(a: Int, b: Int) -> Int {
return a + b
}
//兩數相乘
func multiply(a:Int,b:Int)->Int{
return a*b
}
//輸出結果
func printresult(fun:(Int,Int)->Int,a:Int,b:Int){
print(fun(a,b))
}
printresult(add, a: 3, b: 2)
printresult(multiply, a: 3, b: 2)

在此程式碼中定義了三個函式。第三個函式printresult中，有三個引數：第一個引數為fun，型別為(Int,Int)->Int，開發者可以傳入任何這種型別的函式；第二個引數和第三個引數分別為a和b，它們的型別都是Int型，這兩個值是函式的輸入值。當第一次呼叫printresult函式時，它傳入了add函式和3、5兩個整數。這時，它又會呼叫函式add，將3、5作為函式add的輸入值，並輸出結果。第二此呼叫也類似，printresult會呼叫multiply函式。最後的執行結果如下所示：

5
6

Swift2.0中使用函式型別作為返回值型別

函式型別不僅可以被用作引數外，還可以被用作返回值型別。此時需要在->後面寫入一個完整的函式型別，其語法形式如下：

func 函式名(引數列表) -> 函式型別 {
…
}

【示例7-16】以下程式碼輸出透過給定的值，出現一系列的值；如果給定的值大於0輸出從這個數開始到0之間的數；如果是負數，一直輸出比這個是小1的數。程式碼如下：

import Foundation
//返回一個比輸入值大1得值
func stepForward(input: Int) -> Int {
return input + 1
}
//返回一個比輸入值小1得值
func stepBackward(input: Int) -> Int {
return input - 1
}
//選擇返回哪個函式
func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
return backwards ? stepBackward : stepForward
}
var currentValue = 5
let moveNearerToZero = chooseStepFunction(currentValue>0)
while currentValue != 0 {
print("\(currentValue)... ")
currentValue = moveNearerToZero(currentValue)
}

在此程式碼中定義了3個函式。第三個函式chooseStepFunction的返回值型別是(Int)->Int。執行結果如下所示：

5...
4...
3...
2...
1...
Swift2.0中的標準函式

函式除了可以根據引數列表的有無分為無參函式和有參函式，還可以從定義角度分為使用者自定義函式和標準函式兩種。以上的示例都是使用者自定函式。Swift提供了74個標準函式，這些函式都可以直接去使用，不需要進行定義。本節將針對常用的標準函式進行詳細的講解。

Swift2.0中絕對值函式abs()

abs()函式的功能是求數值的絕對值。其語法形式如下：

abs(數值)

函式的返回值是一個零或者正數。

【示例7-17】以下將使用abs()函式獲取-10、10、0、-1.233、1.233的絕對值。程式碼如下：

import Foundation
//求整數的絕對值
let value1=abs(-10)
let value2=abs(10)
let value3=abs(0)
//求浮點數的絕對值
let value4=abs(-1.233)
let value5=abs(1.233)
print("value1=\(value1)")
print("value2=\(value2)")
print("value3=\(value3)")
print("value4=\(value4)")
print("value5=\(value5)")

在此程式碼中，正數的絕對值是它本身；負數的絕對值為正數；0的絕對值還為0。執行結果如下：

value1=10
value2=10
value3=0
value4=1.233
value5=1.233

注意：abs()中的引數必須是數值，不可以是數值以外的東西，如字元、字串等。如以下的程式碼，將獲取字串"aaa"的絕對值。程式碼如下：

import Foundation
let value1=abs("aaa")
print("value1=\(value1)")

由於abs()的引數為字串導致程式出現了以下錯誤：

Cannot find an overload for 'abs' that accepts an argument list of type '(String)'

Swift2.0中最大值函式max()/最小值min()

在程式設計中，經常需要計算幾個引數的最大值或者最小值，此時可以使用標準函式中的max()和min()函式實現。以下是對這兩個函式的詳細講解。

1.獲取最大值

max()函式可以獲取幾個引數的最大值。其語法形式如下：

max(引數1,引數2,引數3,…)

其中，引數可以是數值，也可以是字串或字元。

【示例7-18】以下將使用max()函式，依次獲取1.9和10的最大值，13.8、20、88.88的最大值以及字串"Hello"、"Swift"、"Zone"的最大值。程式碼如下：

import Foundation
let maxValue1=max(1.9,10)
let maxValue2=max(13.8,20,88.88)
let maxValue3=max("Hello","Swift","Zone")
print("maxValue1=\(maxValue1)")
print("maxValue2=\(maxValue2)")
print("maxValue3=\(maxValue3)")

在對字串進行比較時，是對字串中的字元進行比較。首先會判斷3個字元的首字元哪個大。如果找到最大的字元，就以此字元開頭的字串為最大值；如果判斷的3個首字元相同，那麼在進行第二個字元的比較，以此類推。執行結果如下：

maxValue1=10.0
maxValue2=88.88
maxValue3=Zone

2.獲取最小值

min()函式可以獲取幾個引數的最小值。其語法形式如下：

min(引數1,引數2,引數3,…)

其中，引數同樣可以是數值、字串或字元。

【示例7-19】以下將使用min()函式，獲取1.9和10的最小值，獲取13.8、20、88.88的最小值，字串"Swift"、"Hello"、"iOS"的最小值。程式碼如下：

import Foundation
let minValue1=min(1.9,10)
let minValue2=min(13.8,20,88.88)
let minValue3=min("Swift","Hello","iOS")
print("minValue1=\(minValue1)")
print("minValue2=\(minValue2)")
print("minValue3=\(minValue3)")

執行結果如下：

minValue1=1.9
minValue2=13.8
minValue3=Hello

注意：在使用max()、min()時如果是數值，比較的引數都是數值。如果是字元或者字串，比較的引數也是字元或者字串。不可以在一個函式中同時比較數值和字串、字元。以下的程式碼將比較1.9、10和字串"Hello"的最小值。程式碼如下：

import Foundation
let minValue=min(1.9,10,"Hello")
println("minValue=\(minValue)")

在此程式碼中，由於min()函式對數值和字串進行比較，導致程式出現了以下的錯誤：

Cannot find an overload for 'min' that accepts an argument list of type '(Double, Int, String)'

Swift2.0中序列的最大值函式maxElement()/最小值函式minElement()

在一個序列中，往往需要獲取元素的最大值或者最小值。此時可以使用maxElement()和minElement()函式。以下是對這兩個函式的詳細講解。

1.序列的最大值

maxElement()函式獲取一個序列中最大值的元素。其語法形式如下：

序列.maxElement()

其中，序列可以是數值，也可以是一個範圍。

【示例7-20】下面使用maxElement()函式獲取序列sequence1、sequence2和範圍1...100中最大值的元素。程式碼如下：

import Foundation
let sequence1=[9,8,2,3]
let sequence2=["Ad","Ab","Ac"]
let maxValue1=sequence1.maxElement()!
print("maxValue1=\(maxValue1)")
let maxValue2=(1...100).maxElement()!
print("maxValue2=\(maxValue2)")
let maxValue3=sequence2.maxElement()!
print("maxValue3=\(maxValue3)")

其中，字串構成的序列sequence2的判斷方式與函式max()相同，都是依次比較字串的字母大小。執行結果如下：

maxValue1=9
maxValue2=100
maxValue3=Ad

2.序列的最小值

minElement()函式可以獲取一個序列中最小值的元素。其語法形式如下：

序列.minElement()

其中，序列可以是數值，也可以是一個範圍。

【示例7-21】以下將使用minElement()函式獲取序列sequence1、sequence2和範圍1...100中最小值的元素。程式碼如下：

import Foundation
let sequence1=[9,8,2,3]
let sequence2=["Ad","Ab","Ac"]
let minValue1=sequence1.minElement()!
print("minValue1=\(minValue1)")
let minValue2=(1...100).minElement()!
print("minValue2=\(minValue2)")
let minValue3=sequence2.minElement()!
print("minValue3=\(minValue3)")

執行結果如下：

minValue1=2
minValue2=1
minValue3=Ab

Swift2.0中判斷序列是否包含指定元素函式contains()

contains()函式可以判斷一個序列中是否包含指定的元素。其語法形式如下：

序列.contains(元素)

其中，函式的返回值型別為布林型別。當返回true時，表示表達序列中包含指定的元素；當返回false時，表示不包含。

【示例7-22】以下程式碼使用contains()函式函式判斷序列languages中是否包含元素"Swift"和"Java"。程式碼如下：

import Foundation
var languages = ["Swift", "Objective-C","C"]
//判斷在languages陣列中是否包含"Swift"字串
if languages.contains("Swift") == true {
print("languages序列中包含元素“Swift”")
}else{
print("languages序列中不包含元素“Swift”")
}
//判斷在languages陣列中是否包含"Java"字串
if languages.contains("Java") == true {
print("languages序列中包含元素“Java”")
}else{
print("languages序列中不包含元素“Java”")
}

在此程式碼languages中"Swift"、"Objective-C"、"C"這三個元素，但是沒有"Java"元素。執行結果如下：

languages序列中包含元素“Swift”
languages序列中不包含元素“Java”

在比較的時候，會區分字母的大小寫。所以，不同大小寫的字串是不同的。

Swift2.0序列排序函式sortInPlace()

在程式設計中，經常需要對序列中元素的進行排序。此時可以使用Swift中的sortInPlace()函式來實現。其語法形式如下：

序列.sortInPlace()

其中，序列是指陣列。

【示例7-23】以下將使用sort()函式對languages和value陣列進行排序。程式碼如下：

import Foundation
var languages = ["Swift", "Objective-C","C"]
print("排序前:languages=\(languages)")
languages.sortInPlace()
print("排序後:languages=\(languages)")

執行結果如下：

排序前:languages=[Swift, Objective-C, C]
排序後:languages=[C, Objective-C, Swift]

Swift2.0序列倒序函式reverse()

reverse()函式可以將序列中元素的倒序排列。其語法形式如下：

序列.reverse()

其中，序列是指陣列。

【示例7-24】以下將使用reverse 函式對序列languages和value進行倒序排列。程式碼如下：

import Foundation
var languages = ["Swift", "Objective-C","C"]
print("languages=\(languages)")
print("倒序輸出：")
for i in Array(languages.reverse()){
print(i)
}
var value = [1,8,4,10]
print("value=\(value)")
print("倒序輸出：")
for i in Array(value.reverse()){
print(i)
}

執行結果如下：

languages=[Swift, Objective-C, C]

倒序輸出：

C
Objective-C
Swift
value=[1, 8, 4, 10]

倒序輸出：

10
4
8
1

本文選自：Swift2.0語言快速入門v3.0 大學霸內部資料，轉載請註明出處，尊重技術尊重IT人！

Swift2.0語言教程之函式的返回值與函式型別