本頁包含內容： 集合的可變性 陣列 集合 集合操作 字典 Swift 語言提供Arrays、Sets和Dictionaries三種基本的集合型別用來儲存集合資料。陣列（Arrays）是有序資料的集。集合（Sets）是無序無重複資料的集。字典（Dictionaries）是無序的鍵值對的集。

Swift 語言中的Arrays、Sets和Dictionaries中儲存的資料值型別必須明確。這意味著我們不能把不正確的資料型別插入其中。同時這也說明我們完全可以對取回值的型別非常自信。

注意： Swift 的Arrays、Sets和Dictionaries型別被實現為泛型集合。更多關於泛型型別和集合，參見 泛型章節。

集合的可變性 如果建立一個Arrays、Sets或Dictionaries並且把它分配成一個變數，這個集合將會是可變的。這意味著我們可以在建立之後新增更多或移除已存在的資料項，或者改變集合中的資料項。如果我們把Arrays、Sets或Dictionaries分配成常量，那麼它就是不可變的，它的大小和內容都不能被改變。

注意： 在我們不需要改變集合的時候建立不可變集合是很好的實踐。如此 Swift 編譯器可以優化我們建立的集合。

陣列(Arrays) 陣列使用有序列表儲存同一型別的多個值。相同的值可以多次出現在一個數組的不同位置中。

注意: Swift 的Array型別被橋接到Foundation中的NSArray類。 更多關於在Foundation和Cocoa中使用Array的資訊，參見 Using Swift with Cocoa and Obejective-C(Swift 3.0.1) 中使用 Cocoa 資料型別部分。

陣列的簡單語法 寫 Swift 陣列應該遵循像Array這樣的形式，其中Element是這個陣列中唯一允許存在的資料型別。我們也可以使用像[Element]這樣的簡單語法。儘管兩種形式在功能上是一樣的，但是推薦較短的那種，而且在本文中都會使用這種形式來使用陣列。

建立一個空陣列 我們可以使用構造語法來建立一個由特定資料型別構成的空陣列：

var someInts = Int print(“someInts is of type [Int] with (someInts.count) items.”) // 列印 “someInts is of type [Int] with 0 items.” 注意，通過建構函式的型別，someInts的值型別被推斷為[Int]。

或者，如果程式碼上下文中已經提供了型別資訊，例如一個函式引數或者一個已經定義好型別的常量或者變數，我們可以使用空陣列語句建立一個空陣列，它的寫法很簡單：[]（一對空方括號）：

someInts.append(3) // someInts 現在包含一個 Int 值 someInts = [] // someInts 現在是空陣列，但是仍然是 [Int] 型別的。

建立一個帶有預設值的陣列 Swift 中的Array型別還提供一個可以建立特定大小並且所有資料都被預設的構造方法。我們可以把準備加入新陣列的資料項數量（count）和適當型別的初始值（repeating）傳入陣列建構函式：

var threeDoubles = Array(repeating: 0.0, count: 3) // threeDoubles 是一種 [Double] 陣列，等價於 [0.0, 0.0, 0.0]

通過兩個陣列相加建立一個數組 我們可以使用加法操作符（+）來組合兩種已存在的相同型別陣列。新陣列的資料型別會被從兩個陣列的資料型別中推斷出來：

var anotherThreeDoubles = Array(repeating: 2.5, count: 3) // anotherThreeDoubles 被推斷為 [Double]，等價於 [2.5, 2.5, 2.5]

var sixDoubles = threeDoubles + anotherThreeDoubles // sixDoubles 被推斷為 [Double]，等價於 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

用陣列字面量構造陣列 我們可以使用陣列字面量來進行陣列構造，這是一種用一個或者多個數值構造陣列的簡單方法。陣列字面量是一系列由逗號分割並由方括號包含的數值：

[value 1, value 2, value 3]。

下面這個例子建立了一個叫做shoppingList並且儲存String的陣列：

var shoppingList: [String] = [“Eggs”, “Milk”] // shoppingList 已經被構造並且擁有兩個初始項。 shoppingList變數被宣告為“字串值型別的陣列“，記作[String]。 因為這個陣列被規定只有String一種資料結構，所以只有String型別可以在其中被存取。 在這裡，shoppingList陣列由兩個String值（“Eggs” 和"Milk"）構造，並且由陣列字面量定義。

注意： shoppingList陣列被宣告為變數（var關鍵字建立）而不是常量（let建立）是因為以後可能會有更多的資料項被插入其中。

在這個例子中，字面量僅僅包含兩個String值。匹配了該陣列的變數宣告（只能包含String的陣列），所以這個字面量的分配過程可以作為用兩個初始項來構造shoppingList的一種方式。

由於 Swift 的型別推斷機制，當我們用字面量構造只擁有相同型別值陣列的時候，我們不必把陣列的型別定義清楚。 shoppingList的構造也可以這樣寫：

var shoppingList = [“Eggs”, “Milk”] 因為所有陣列字面量中的值都是相同的型別，Swift 可以推斷出[String]是shoppingList中變數的正確型別。

訪問和修改陣列 我們可以通過陣列的方法和屬性來訪問和修改陣列，或者使用下標語法。

可以使用陣列的只讀屬性count來獲取陣列中的資料項數量：

print(“The shopping list contains (shoppingList.count) items.”) // 輸出 “The shopping list contains 2 items.”（這個陣列有2個項） 使用布林屬性isEmpty作為一個縮寫形式去檢查count屬性是否為0：

if shoppingList.isEmpty { print(“The shopping list is empty.”) } else { print(“The shopping list is not empty.”) } // 列印 “The shopping list is not empty.”（shoppinglist 不是空的） 也可以使用append(_:)方法在陣列後面新增新的資料項：

shoppingList.append(“Flour”) // shoppingList 現在有3個數據項，有人在攤煎餅 除此之外，使用加法賦值運算子（+=）也可以直接在陣列後面新增一個或多個擁有相同型別的資料項：

shoppingList += [“Baking Powder”] // shoppingList 現在有四項了 shoppingList += [“Chocolate Spread”, “Cheese”, “Butter”] // shoppingList 現在有七項了 可以直接使用下標語法來獲取陣列中的資料項，把我們需要的資料項的索引值放在直接放在陣列名稱的方括號中：

var firstItem = shoppingList[0] // 第一項是 “Eggs” 注意： 第一項在陣列中的索引值是0而不是1。 Swift 中的陣列索引總是從零開始。

我們也可以用下標來改變某個已有索引值對應的資料值：

shoppingList[0] = “Six eggs” // 其中的第一項現在是 “Six eggs” 而不是 “Eggs” 還可以利用下標來一次改變一系列資料值，即使新資料和原有資料的數量是不一樣的。下面的例子把"Chocolate Spread"，“Cheese”，和"Butter"替換為"Bananas"和 “Apples”：

shoppingList[4…6] = [“Bananas”, “Apples”] // shoppingList 現在有6項 注意： 不可以用下標訪問的形式去在陣列尾部新增新項。

呼叫陣列的insert(_:at:)方法來在某個具體索引值之前新增資料項：

shoppingList.insert(“Maple Syrup”, at: 0) // shoppingList 現在有7項 // “Maple Syrup” 現在是這個列表中的第一項 這次insert(_:at:)方法呼叫把值為"Maple Syrup"的新資料項插入列表的最開始位置，並且使用0作為索引值。

類似的我們可以使用remove(at:)方法來移除陣列中的某一項。這個方法把陣列在特定索引值中儲存的資料項移除並且返回這個被移除的資料項（我們不需要的時候就可以無視它）：

let mapleSyrup = shoppingList.remove(at: 0) // 索引值為0的資料項被移除 // shoppingList 現在只有6項，而且不包括 Maple Syrup // mapleSyrup 常量的值等於被移除資料項的值 “Maple Syrup” 注意： 如果我們試著對索引越界的資料進行檢索或者設定新值的操作，會引發一個執行期錯誤。我們可以使用索引值和陣列的count屬性進行比較來在使用某個索引之前先檢驗是否有效。除了當count等於 0 時（說明這是個空陣列），最大索引值一直是count - 1，因為陣列都是零起索引。

資料項被移除後陣列中的空出項會被自動填補，所以現在索引值為0的資料項的值再次等於"Six eggs"：

firstItem = shoppingList[0] // firstItem 現在等於 “Six eggs” 如果我們只想把陣列中的最後一項移除，可以使用removeLast()方法而不是remove(at:)方法來避免我們需要獲取陣列的count屬性。就像後者一樣，前者也會返回被移除的資料項：

let apples = shoppingList.removeLast() // 陣列的最後一項被移除了 // shoppingList 現在只有5項，不包括 Apples // apples 常量的值現在等於 “Apples” 字串

陣列的遍歷 我們可以使用for-in迴圈來遍歷所有陣列中的資料項：

for item in shoppingList { print(item) } // Six eggs // Milk // Flour // Baking Powder // Bananas 如果我們同時需要每個資料項的值和索引值，可以使用enumerated()方法來進行陣列遍歷。enumerated()返回一個由每一個數據項索引值和資料值組成的元組。我們可以把這個元組分解成臨時常量或者變數來進行遍歷：

for (index, value) in shoppingList. enumerated() { print(“Item (String(index + 1)): (value)”) } // Item 1: Six eggs // Item 2: Milk // Item 3: Flour // Item 4: Baking Powder // Item 5: Bananas 更多關於for-in迴圈的介紹請參見for 迴圈。

集合（Sets） 集合(Set)用來儲存相同型別並且沒有確定順序的值。當集合元素順序不重要時或者希望確保每個元素只出現一次時可以使用集合而不是陣列。

注意： Swift的Set型別被橋接到Foundation中的NSSet類。 關於使用Foundation和Cocoa中Set的知識，參見 Using Swift with Cocoa and Obejective-C(Swift 3.0.1) 中使用 Cocoa 資料型別部分。

集合型別的雜湊值 一個型別為了儲存在集合中，該型別必須是可雜湊化的–也就是說，該型別必須提供一個方法來計算它的雜湊值。一個雜湊值是Int型別的，相等的物件雜湊值必須相同，比如a==b,因此必須a.hashValue == b.hashValue。

Swift 的所有基本型別(比如String,Int,Double和Bool)預設都是可雜湊化的，可以作為集合的值的型別或者字典的鍵的型別。沒有關聯值的列舉成員值(在列舉有講述)預設也是可雜湊化的。

注意： 你可以使用你自定義的型別作為集合的值的型別或者是字典的鍵的型別，但你需要使你的自定義型別符合 Swift 標準庫中的Hashable協議。符合Hashable協議的型別需要提供一個型別為Int的可讀屬性hashValue。由型別的hashValue屬性返回的值不需要在同一程式的不同執行週期或者不同程式之間保持相同。

因為Hashable協議符合Equatable協議，所以遵循該協議的型別也必須提供一個"是否相等"運算子()的實現。這個Equatable協議要求任何符合實現的例項間都是一種相等的關係。也就是說，對於a,b,c三個值來說，==的實現必須滿足下面三種情況：

a == a(自反性) a == b意味著b == a(對稱性) a == b && b == c意味著a == c(傳遞性) 關於遵循協議的更多資訊，請看協議。

集合型別語法 Swift 中的Set型別被寫為Set，這裡的Element表示Set中允許儲存的型別，和陣列不同的是，集合沒有等價的簡化形式。

建立和構造一個空的集合 你可以通過構造器語法建立一個特定型別的空集合：

var letters = Set() print(“letters is of type Set with (letters.count) items.”) // 列印 “letters is of type Set with 0 items.” 注意： 通過構造器，這裡的letters變數的型別被推斷為Set。

此外，如果上下文提供了型別資訊，比如作為函式的引數或者已知型別的變數或常量，我們可以通過一個空的陣列字面量建立一個空的Set：

letters.insert(“a”) // letters 現在含有1個 Character 型別的值 letters = [] // letters 現在是一個空的 Set, 但是它依然是 Set 型別

用陣列字面量建立集合 你可以使用陣列字面量來構造集合，並且可以使用簡化形式寫一個或者多個值作為集合元素。

下面的例子建立一個稱之為favoriteGenres的集合來儲存String型別的值：

var favoriteGenres: Set = [“Rock”, “Classical”, “Hip hop”] // favoriteGenres 被構造成含有三個初始值的集合 這個favoriteGenres變數被宣告為“一個String值的集合”，寫為Set。由於這個特定的集合含有指定String型別的值，所以它只允許儲存String型別值。這裡的favoriteGenres變數有三個String型別的初始值(“Rock”，“Classical"和"Hip hop”)，並以陣列字面量的方式出現。

注意： favoriteGenres被宣告為一個變數(擁有var標示符)而不是一個常量(擁有let標示符),因為它裡面的元素將會在下面的例子中被增加或者移除。

一個Set型別不能從陣列字面量中被單獨推斷出來，因此Set型別必須顯式宣告。然而，由於 Swift 的型別推斷功能，如果你想使用一個數組字面量構造一個Set並且該陣列字面量中的所有元素型別相同，那麼你無須寫出Set的具體型別。favoriteGenres的構造形式可以採用簡化的方式代替：

var favoriteGenres: Set = [“Rock”, “Classical”, “Hip hop”] 由於陣列字面量中的所有元素型別相同，Swift 可以推斷出Set作為favoriteGenres變數的正確型別。

訪問和修改一個集合 你可以通過Set的屬性和方法來訪問和修改一個Set。

為了找出一個Set中元素的數量，可以使用其只讀屬性count：

print(“I have (favoriteGenres.count) favorite music genres.”) // 列印 “I have 3 favorite music genres.” 使用布林屬性isEmpty作為一個縮寫形式去檢查count屬性是否為0：

if favoriteGenres.isEmpty { print(“As far as music goes, I’m not picky.”) } else { print(“I have particular music preferences.”) } // 列印 “I have particular music preferences.” 你可以通過呼叫Set的insert(_:)方法來新增一個新元素：

favoriteGenres.insert(“Jazz”) // favoriteGenres 現在包含4個元素 你可以通過呼叫Set的remove(_:)方法去刪除一個元素，如果該值是該Set的一個元素則刪除該元素並且返回被刪除的元素值，否則如果該Set不包含該值，則返回nil。另外，Set中的所有元素可以通過它的removeAll()方法刪除。

if let removedGenre = favoriteGenres.remove(“Rock”) { print("(removedGenre)? I’m over it.") } else { print(“I never much cared for that.”) } // 列印 “Rock? I’m over it.” 使用contains(_:)方法去檢查Set中是否包含一個特定的值：

if favoriteGenres.contains(“Funk”) { print(“I get up on the good foot.”) } else { print(“It’s too funky in here.”) } // 列印 “It’s too funky in here.”

遍歷一個集合 你可以在一個for-in迴圈中遍歷一個Set中的所有值。

for genre in favoriteGenres { print("(genre)") } // Classical // Jazz // Hip hop 更多關於for-in迴圈的資訊，參見For 迴圈。

Swift 的Set型別沒有確定的順序，為了按照特定順序來遍歷一個Set中的值可以使用sorted()方法，它將返回一個有序陣列，這個陣列的元素排列順序由操作符’<'對元素進行比較的結果來確定.

for genre in favoriteGenres.sorted() { print("(genre)") } // prints “Classical” // prints “Hip hop” // prints "Jazz

集合操作 你可以高效地完成Set的一些基本操作，比如把兩個集合組合到一起，判斷兩個集合共有元素，或者判斷兩個集合是否全包含，部分包含或者不相交。

基本集合操作 下面的插圖描述了兩個集合-a和b-以及通過陰影部分的區域顯示集合各種操作的結果。

使用intersection(:)方法根據兩個集合中都包含的值建立的一個新的集合。 使用symmetricDifference(:)方法根據在一個集合中但不在兩個集合中的值建立一個新的集合。 使用union(:)方法根據兩個集合的值建立一個新的集合。 使用subtracting(:)方法根據不在該集合中的值建立一個新的集合。 let oddDigits: Set = [1, 3, 5, 7, 9] let evenDigits: Set = [0, 2, 4, 6, 8] let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]

oddDigits.union(evenDigits).sorted() // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] oddDigits. intersection(evenDigits).sorted() // [] oddDigits.subtracting(singleDigitPrimeNumbers).sorted() // [1, 9] oddDigits. symmetricDifference(singleDigitPrimeNumbers).sorted() // [1, 2, 9]

集合成員關係和相等 下面的插圖描述了三個集合-a,b和c,以及通過重疊區域表述集合間共享的元素。集合a是集合b的父集合，因為a包含了b中所有的元素，相反的，集合b是集合a的子集合，因為屬於b的元素也被a包含。集合b和集合c彼此不關聯，因為它們之間沒有共同的元素。

使用“是否相等”運算子(==)來判斷兩個集合是否包含全部相同的值。 使用isSubset(of:)方法來判斷一個集合中的值是否也被包含在另外一個集合中。 使用isSuperset(of:)方法來判斷一個集合中包含另一個集合中所有的值。 使用isStrictSubset(of:)或者isStrictSuperset(of:)方法來判斷一個集合是否是另外一個集合的子集合或者父集合並且兩個集合並不相等。 使用isDisjoint(with:)方法來判斷兩個集合是否不含有相同的值(是否沒有交集)。 let houseAnimals: Set = [“?”, “?”] let farmAnimals: Set = [“?”, “?”, “?”, “?”, “?”] let cityAnimals: Set = [“?”, “?”]

houseAnimals.isSubset(of: farmAnimals) // true farmAnimals.isSuperset(of: houseAnimals) // true farmAnimals.isDisjoint(with: cityAnimals) // true

字典 字典是一種儲存多個相同型別的值的容器。每個值（value）都關聯唯一的鍵（key），鍵作為字典中的這個值資料的識別符號。和陣列中的資料項不同，字典中的資料項並沒有具體順序。我們在需要通過識別符號（鍵）訪問資料的時候使用字典，這種方法很大程度上和我們在現實世界中使用字典查字義的方法一樣。

注意： Swift 的Dictionary型別被橋接到Foundation的NSDictionary類。 更多關於在Foundation和Cocoa中使用Dictionary型別的資訊，參見 Using Swift with Cocoa and Obejective-C(Swift 3.0.1) 中使用 Cocoa 資料型別部分。

字典型別簡化語法 Swift 的字典使用Dictionary<Key, Value>定義，其中Key是字典中鍵的資料型別，Value是字典中對應於這些鍵所儲存值的資料型別。

注意： 一個字典的Key型別必須遵循Hashable協議，就像Set的值型別。

我們也可以用[Key: Value]這樣簡化的形式去建立一個字典型別。雖然這兩種形式功能上相同，但是後者是首選，並且這本指導書涉及到字典型別時通篇採用後者。

建立一個空字典 我們可以像陣列一樣使用構造語法建立一個擁有確定型別的空字典：

var namesOfIntegers = Int: String // namesOfIntegers 是一個空的 [Int: String] 字典 這個例子建立了一個[Int: String]型別的空字典來儲存整數的英語命名。它的鍵是Int型，值是String型。

如果上下文已經提供了型別資訊，我們可以使用空字典字面量來建立一個空字典，記作[:]（中括號中放一個冒號）：

namesOfIntegers[16] = “sixteen” // namesOfIntegers 現在包含一個鍵值對 namesOfIntegers = [:] // namesOfIntegers 又成為了一個 [Int: String] 型別的空字典

用字典字面量建立字典 我們可以使用字典字面量來構造字典，這和我們剛才介紹過的陣列字面量擁有相似語法。字典字面量是一種將一個或多個鍵值對寫作Dictionary集合的快捷途徑。

一個鍵值對是一個key和一個value的結合體。在字典字面量中，每一個鍵值對的鍵和值都由冒號分割。這些鍵值對構成一個列表，其中這些鍵值對由方括號包含、由逗號分割：

[key 1: value 1, key 2: value 2, key 3: value 3] 下面的例子建立了一個儲存國際機場名稱的字典。在這個字典中鍵是三個字母的國際航空運輸相關程式碼，值是機場名稱：

var airports: [String: String] = [“YYZ”: “Toronto Pearson”, “DUB”: “Dublin”] airports字典被宣告為一種[String: String]型別，這意味著這個字典的鍵和值都是String型別。

注意： airports字典被宣告為變數（用var關鍵字）而不是常量（let關鍵字）因為後來更多的機場資訊會被新增到這個示例字典中。

airports字典使用字典字面量初始化，包含兩個鍵值對。第一對的鍵是YYZ，值是Toronto Pearson。第二對的鍵是DUB，值是Dublin。

這個字典語句包含了兩個String: String型別的鍵值對。它們對應airports變數宣告的型別（一個只有String鍵和String值的字典）所以這個字典字面量的任務是構造擁有兩個初始資料項的airport字典。

和陣列一樣，我們在用字典字面量構造字典時，如果它的鍵和值都有各自一致的型別，那麼就不必寫出字典的型別。 airports字典也可以用這種簡短方式定義：

var airports = [“YYZ”: “Toronto Pearson”, “DUB”: “Dublin”] 因為這個語句中所有的鍵和值都各自擁有相同的資料型別，Swift 可以推斷出Dictionary<String, String>是airports字典的正確型別。

訪問和修改字典 我們可以通過字典的方法和屬性來訪問和修改字典，或者通過使用下標語法。

和陣列一樣，我們可以通過字典的只讀屬性count來獲取某個字典的資料項數量：

print(“The dictionary of airports contains (airports.count) items.”) // 列印 “The dictionary of airports contains 2 items.”（這個字典有兩個資料項） 使用布林屬性isEmpty作為一個縮寫形式去檢查count屬性是否為0：

if airports.isEmpty { print(“The airports dictionary is empty.”) } else { print(“The airports dictionary is not empty.”) } // 列印 “The airports dictionary is not empty.” 我們也可以在字典中使用下標語法來新增新的資料項。可以使用一個恰當型別的鍵作為下標索引，並且分配恰當型別的新值：

airports[“LHR”] = “London” // airports 字典現在有三個資料項 我們也可以使用下標語法來改變特定鍵對應的值：

airports[“LHR”] = “London Heathrow” // "LHR"對應的值 被改為 "London Heathrow 作為另一種下標方法，字典的updateValue(:forKey:)方法可以設定或者更新特定鍵對應的值。就像上面所示的下標示例，updateValue(:forKey:)方法在這個鍵不存在對應值的時候會設定新值或者在存在時更新已存在的值。和上面的下標方法不同的，updateValue(_:forKey:)這個方法返回更新值之前的原值。這樣使得我們可以檢查更新是否成功。

updateValue(_:forKey:)方法會返回對應值的型別的可選值。舉例來說：對於儲存String值的字典，這個函式會返回一個String?或者“可選 String”型別的值。

如果有值存在於更新前，則這個可選值包含了舊值，否則它將會是nil。

if let oldValue = airports.updateValue(“Dublin Airport”, forKey: “DUB”) { print(“The old value for DUB was (oldValue).”) } // 輸出 “The old value for DUB was Dublin.” 我們也可以使用下標語法來在字典中檢索特定鍵對應的值。因為有可能請求的鍵沒有對應的值存在，字典的下標訪問會返回對應值的型別的可選值。如果這個字典包含請求鍵所對應的值，下標會返回一個包含這個存在值的可選值，否則將返回nil：

if let airportName = airports[“DUB”] { print(“The name of the airport is (airportName).”) } else { print(“That airport is not in the airports dictionary.”) } // 列印 “The name of the airport is Dublin Airport.” 我們還可以使用下標語法來通過給某個鍵的對應值賦值為nil來從字典裡移除一個鍵值對：

airports[“APL”] = “Apple Internation” // “Apple Internation” 不是真的 APL 機場, 刪除它 airports[“APL”] = nil // APL 現在被移除了 此外，removeValue(forKey:)方法也可以用來在字典中移除鍵值對。這個方法在鍵值對存在的情況下會移除該鍵值對並且返回被移除的值或者在沒有值的情況下返回nil：

if let removedValue = airports. removeValue(forKey: “DUB”) { print(“The removed airport’s name is (removedValue).”) } else { print(“The airports dictionary does not contain a value for DUB.”) } // prints “The removed airport’s name is Dublin Airport.”

字典遍歷 我們可以使用for-in迴圈來遍歷某個字典中的鍵值對。每一個字典中的資料項都以(key, value)元組形式返回，並且我們可以使用臨時常量或者變數來分解這些元組：

for (airportCode, airportName) in airports { print("(airportCode): (airportName)") } // YYZ: Toronto Pearson // LHR: London Heathrow 更多關於for-in迴圈的資訊，參見For 迴圈。

通過訪問keys或者values屬性，我們也可以遍歷字典的鍵或者值：

for airportCode in airports.keys { print(“Airport code: (airportCode)”) } // Airport code: YYZ // Airport code: LHR

for airportName in airports.values { print(“Airport name: (airportName)”) } // Airport name: Toronto Pearson // Airport name: London Heathrow 如果我們只是需要使用某個字典的鍵集合或者值集合來作為某個接受Array例項的 API 的引數，可以直接使用keys或者values屬性構造一個新陣列：

let airportCodes = String // airportCodes 是 [“YYZ”, “LHR”]

let airportNames = String // airportNames 是 [“Toronto Pearson”, “London Heathrow”] Swift 的字典型別是無序集合型別。為了以特定的順序遍歷字典的鍵或值，可以對字典的keys或values屬性使用sorted()方法。