本條目從函數出發,一路談到閉包、類、屬性、構造方法、下標腳本與繼承,並特別著墨於 Swift 與 Objective-C 在這些主題上的關鍵差異。
函數是完成獨立任務的程式碼區塊。Swift 的函數不僅能像 C 語言那樣作為參數與回傳值,還支援巢狀定義,並提供參數預設值、可變參數與輸入輸出參數等能力。
// 沒有回傳值時可省略箭頭,或寫成 Void、空元組 ()(Void 的本質就是空元組)
func sum(num1: Int, num2: Int) -> Int {
return num1 + num2
}
sum(1, 2)
語法形式雖有差異,本質與其他語言並無不同。真正值得留意的是 Swift 明確區分了「局部參數名」(形式參數)與「外部參數名」,這在很大程度上照顧了 Objective-C 開發者的閱讀習慣。
/**
* 函數參數名分為局部參數名與外部參數名
*/
func split(string a: String, seperator b: Character) -> [String] {
return split(a, maxSplit: Int.max, allowEmptySlices: false, isSeparator: { $0 == b })
}
// 設定了外部參數名,呼叫時就必須帶上,可讀性大幅提升
split(string: "hello,world,!", seperator: ",") // ["hello", "world", "!"]
// 在局部參數名前加 #,可讓外部參數名與局部參數名同名
func split2(#string: String, #seperator: Character) -> [String] {
return split(string, maxSplit: Int.max, allowEmptySlices: false, isSeparator: { $0 == seperator })
}
split2(string: "hello,world,!", seperator: ",")
// 有預設值時,參數名預設同時作為外部參數名
func split3(#string: String, seperator: Character = ",") -> [String] {
return split(string, maxSplit: Int.max, allowEmptySlices: false, isSeparator: { $0 == seperator })
}
split3(string: "hello,world,!", seperator: ",") // ["hello", "world", "!"]
split3(string: "hello world !", seperator: " ") // ["hello", "world", "!"]
// 用 _ 取消外部參數名
func split4(string: String, _ seperator: Character = ",") -> [String] {
return split(string, maxSplit: Int.max, allowEmptySlices: false, isSeparator: { $0 == seperator })
}
split4("hello,world,!", ",") // ["hello", "world", "!"]
/**
* 可變參數:一個函數最多一個,且必須是最後一個參數
* strings 在函數內部是 [String],對外部則是不定個數的 String
*/
func joinStr(seperator: Character = ",", strings: String...) -> String {
var result: String = ""
for var i = 0; i < strings.count; i++ {
if i != 0 {
result.append(seperator)
}
result += strings[i]
}
return result
}
joinStr(seperator: " ", "hello", "world", "!") // "hello world !"
/**
* 函數參數預設是常量,無法直接修改;加上 var 可視為區域變數
* 但此變數只在函數內部有效,函數結束即消失(C 語言的參數預設是變數)
*/
func sum2(var num1: Int, num2: Int) -> Int {
num1 = num1 + num2
return num1
}
sum2(1, 2) // 3
/**
* 輸入輸出參數:可在函數內部修改外部變數(呼叫時不可傳入常量或字面值)
* 以下 swap 僅為示範,實務請直接使用 Swift 的全域 swap 函數
*/
func swap(inout a: Int, inout b: Int) {
a = a + b
b = a - b
a = a - b
}
var a = 1, b = 2
swap(&a, &b) // 呼叫時加上 &
print("a=\(a), b=\(b)") // a=2, b=1
函數本身也是一種類型,既能當參數也能當回傳值:
var sum3 = sum // 型別推斷為 (Int, Int) -> Int,不同函數型別之間不能直接賦值
sum3(1, 2) // 3
// 函數作為回傳值
func fn() -> (Int, Int) -> Int {
// 巢狀函數
func minus(a: Int, b: Int) -> Int {
return a - b
}
return minus
}
var minus = fn()
// 函數作為參數
func caculate(num1: Int, num2: Int, fn: (Int, Int) -> Int) -> Int {
return fn(num1, num2)
}
caculate(1, 2, sum) // 3
caculate(1, 2, minus) // -1
Swift 的閉包相當於 Objective-C 的 Block,也近似 C#、Java 的 lambda。它的核心特徵是能捕獲並保存上下文中的常量或變數引用——即使這些變數在原作用域中已銷毀,區塊內仍可存取。嚴格說,全域函數與巢狀函數也是閉包:前者不捕獲任何變數,後者則會捕獲所在函數的變數。但我們平常所說的閉包,多指沒有名稱的閉包表達式(匿名閉包),其形式為:
{ ( parameters ) -> returnType in
statements
}
下面的例子展示閉包表達式如何被逐層簡化,也順帶體現了 Swift 語法的簡潔取向:
func sum(num1: Int, num2: Int) -> Int { return num1 + num2 }
func minus(num1: Int, num2: Int) -> Int { return num1 - num2 }
func caculate(num1: Int, num2: Int, fn: (Int, Int) -> Int) -> Int { return fn(num1, num2) }
var (a, b) = (1, 2)
caculate(a, b, sum) // 3
caculate(a, b, minus) // -1
// 以閉包表達式取代具名函數
caculate(a, b, { (num1: Int, num2: Int) -> Int in
return num1 - num2
}) // -1
// 依上下文推斷型別;單一表達式的閉包可省略 return
caculate(a, b, { num1, num2 in
num1 - num2
}) // -1
// 使用參數名縮寫 $0...$n,並省略 in
caculate(a, b, { $0 - $1 }) // -1
若函數的最後一個參數是閉包,可以把它移到呼叫的括號之外,這種寫法稱為「尾隨閉包」;若它是唯一的參數,連括號都能省:
// 尾隨閉包
caculate(a, b) { $0 - $1 } // -1
閉包之所以叫「閉包」,就在於它會把作用域內的常量或變數「閉合包裹」起來:
func add() -> () -> Int {
var total = 0
var step = 1
func fn() -> Int {
total += step
return total
}
return fn
}
// fn 捕獲了 total 與 step
var a = add()
a() // 1
a() // 2 —— 說明 a 保存了 total 的副本,否則結果仍會是 1
var b = add()
b() // 1 —— 說明 a 與 b 各自持有獨立的副本,否則結果會是 3
var c = b
c() // 2 —— 說明閉包是參考型別(函數亦然),否則結果會是 1
Swift 會自動決定捕獲時採取值拷貝還是參考拷貝,被捕獲變數的記憶體管理也由 runtime 負責;當 a 不再被使用,fn 所捕獲的變數便會一併釋放。
// Swift 的類不必繼承任何基底類,此時它本身就是一個基底類
class Person {
var name: String
var height = 0.0
// 若不自行撰寫構造方法,系統會自動提供無參數構造方法
init(name: String) {
self.name = name
}
func showMessage() {
print("name=\(name), height=\(height)")
}
// 解構方法,類似 Objective-C 的 dealloc;沒有括號、沒有參數、無法直接呼叫
deinit {
print("deinit...")
}
}
var p = Person(name: "Kenhin")
p.height = 172.0
p.showMessage() // name=Kenhin, height=172.0
// 類是引用型別
var p2 = p
p2.name = "Kaoru"
print(p.name) // Kaoru
if p === p2 { // === 表示「等價」,指向同一個物件
print("p === p2")
}
由此可歸納幾點:Swift 的類不必繼承基底類(這點與通常必須繼承 NSObject 的 Objective-C 不同);屬性的宣告形式近似其他語言的成員變數;未自訂構造方法時系統會補一個無參數版本;解構方法沒有括號與參數,也不能自行呼叫。
Swift 的屬性分兩類:儲存屬性(可用於類與結構體)與計算屬性(可用於類、結構體與列舉)。Swift 並不強調「成員變數」這個概念。儲存屬性在概念與寫法上更像其他語言的成員變數,但多了讀寫控制、屬性監視與懶載入等能力。
class Account {
var balance: Double = 0.0
}
class Person {
var firstName: String
var lastName: String
let age: Int
// 計算屬性:只實作 get 即為唯讀屬性
var fullName: String {
get {
return firstName + "." + lastName
}
set {
// newValue 代表即將賦入的新值,也可自訂名稱
let array = split(newValue, maxSplit: Int.max,
allowEmptySlices: false, isSeparator: { $0 == "." })
if array.count == 2 {
firstName = array[0]
lastName = array[1]
}
}
}
// 唯讀屬性可簡寫為:
// var fullName: String { return firstName + "." + lastName }
// 懶載入:首次存取時才計算初始值,型別不限於物件
lazy var account = Account()
init(firstName: String, lastName: String, age: Int) {
self.firstName = firstName
self.lastName = lastName
self.age = age
}
func showMessage() {
print("name=\(self.fullName)")
}
}
var p = Person(firstName: "Kenshin", lastName: "Cui", age: 29)
p.fullName = "Kaoru.Sun"
p.account.balance = 10
p.showMessage()
幾項重點:
lazy 屬性必須有初始值,且必須是變數(常量在構造完成前就已經定下值)。var 還是 let 宣告,這個值可以在宣告時指定,也可以在構造方法中指定。計算屬性的變化可以直接寫在 setter 裡監視;儲存屬性則做不到,因為它沒有 setter。為此 Swift 另外提供了 willSet 與 didSet,通稱「屬性監視器」。
class Account {
// 注意:設定預設值 0.0 時不會觸發監視器
var balance: Double = 0.0 {
willSet {
// newValue 可自訂名稱;在監視器中存取屬性不會造成循環呼叫
// 此處修改 balance 並不會生效
print("willSet, newValue=\(newValue), value=\(self.balance)")
}
didSet {
// oldValue 可自訂名稱;此處修改 balance 會成為最終結果
print("didSet, oldValue=\(oldValue), value=\(self.balance)")
}
}
}
class Person {
var firstName: String
var lastName: String
let age: Int
var fullName: String {
get {
return firstName + "." + lastName
}
set {
// 計算屬性的監視直接寫在 set 中即可
let array = split(newValue, maxSplit: Int.max,
allowEmptySlices: false, isSeparator: { $0 == "." })
if array.count == 2 {
firstName = array[0]
lastName = array[1]
}
}
}
lazy var account = Account()
init(firstName: String, lastName: String, age: Int) {
self.firstName = firstName
self.lastName = lastName
self.age = age
}
// 型別屬性
static var skin: Array<String> {
return ["yellow", "white", "black"]
}
}
var p = Person(firstName: "Kenshin", lastName: "Cui", age: 29)
p.account.balance = 1.0
print("p.account.balance=\(p.account.balance)") // 3.0(didSet 中的修改生效)
for color in Person.skin {
print(color)
}
監視器的幾個規則:
willSet 與 didSet 預設帶有 newValue 與 oldValue 參數,名稱同樣可自訂。didSet 中修改屬性值會成為最終值,willSet 中則無法改動。方法就是與特定型別關聯的函數。Objective-C 中函數必須是 C 函數、方法則必須是 Objective-C 方法;而在 Swift 裡,方法除了用於類,也能用於結構體與列舉。這裡著重看構造方法。
class Person {
var name: String
var height: Double
var age = 0
// 指定構造方法
init(name: String, height: Double, age: Int) {
self.name = name
self.height = height
self.age = age
}
// 便利構造方法:透過呼叫指定構造方法並提供預設值來簡化建立流程
convenience init(name: String) {
self.init(name: name, height: 0.0, age: 0)
}
func modifyInfoWithAge(age: Int, height: Double) {
self.age = age
self.height = height
}
// 型別方法
class func showClassName() {
print("Class name is \"Person\"")
}
deinit {
print("deinit...")
}
}
var p = Person(name: "kenshin") // 透過便利構造方法建立
關於參數名的預設行為,函數與方法不同:函數只有帶預設值的參數同時是外部參數,其餘皆為局部參數;而方法(構造與解構方法除外)預設第一個參數是局部參數,從第二個參數起同時是局部與外部參數——這與 Objective-C 的呼叫風格頗為相似。此外,構造方法的所有參數預設同時是外部與局部參數。
構造方法分兩類:指定構造方法是主力,負責把全部儲存屬性初始化完成;便利構造方法是輔助,透過呼叫指定構造方法並提供預設值來減少重複程式碼。每個類至少要有一個指定構造方法。
下標腳本是存取集合元素的快捷語法,例如 a[0]、a[1]。它以 subscript 關鍵字定義,宣告形式像方法,讀寫實作則像屬性。
class Record {
var store: [String: String]
init(data: [String: String]) {
self.store = data
}
// 以索引存取(也可只實作 getter 做成唯讀)
subscript(index: Int) -> String {
get {
let key = sorted(Array(self.store.keys))[index]
return self.store[key]!
}
set {
let key = sorted(Array(self.store.keys))[index]
self.store[key] = newValue
}
}
// 下標腳本重載:以鍵存取
subscript(key: String) -> String {
get {
return store[key]!
}
set {
store[key] = newValue
}
}
}
var r = Record(data: ["name": "kenshin", "sex": "male"])
print("r[0]=\(r[0])") // r[0]=kenshin
r["sex"] = "female"
print(r[1]) // female
與 Objective-C 相同,Swift 也是單繼承(可實作多個協議,協議寫在後面)。子類可以呼叫父類的屬性與方法、覆寫方法、加上屬性監視器,甚至把唯讀屬性覆寫成可讀寫。
class Person {
var firstName: String, lastName: String
var age: Int = 0
var fullName: String {
get {
return firstName + " " + lastName
}
}
init(firstName: String, lastName: String) {
self.firstName = firstName
self.lastName = lastName
}
func showMessage() {
print("name=\(fullName), age=\(age)")
}
// final 宣告後子類無法覆寫
final func sayHello() {
print("hello world.")
}
}
class Student: Person {
// 覆寫屬性監視器
override var firstName: String {
willSet {
print("oldValue=\(firstName)")
}
didSet {
print("newValue=\(firstName)")
}
}
var score: Double
// 子類的指定構造方法必須呼叫父類構造方法,
// 且必須在子類儲存屬性初始化之後
init(firstName: String, lastName: String, score: Double) {
self.score = score
super.init(firstName: firstName, lastName: lastName)
}
convenience init() {
self.init(firstName: "", lastName: "", score: 0)
}
// 把唯讀屬性覆寫為可讀寫
override var fullName: String {
get {
return super.fullName
}
set {
let array = split(newValue, maxSplit: Int.max,
allowEmptySlices: false, isSeparator: { $0 == "." })
if array.count == 2 {
firstName = array[0]
lastName = array[1]
}
}
}
override func showMessage() {
print("name=\(fullName), age=\(age), score=\(score)")
}
}
var p = Student()
p.firstName = "kenshin"
Objective-C 的 init 其實並不安全:無法保證只被呼叫一次,而且在 init 中存取屬性也可能出問題,這些都只能依靠文件約定,編譯期發現不了,出錯偵測是被動的。Swift 給構造方法加了硬性規定——構造方法執行完成前,必須保證所有儲存屬性都有值;這條規則在整個繼承鏈上都必須成立,於是衍生出以下約束:
註:本文範例採用早期 Swift 語法(如 println、var 參數、Array<String>),用以保留原始教學脈絡;實際開發請對照當前 Swift 版本調整。