【4858.com】Swift中的集合类型,集合类型

By admin in 4858.com on 2019年4月19日

那壹局地的重大内容是斯威夫特中的Collections

那一有的的关键内容是斯威夫特中的Collections

集合类型 (Collection Types)

自从苹果2014年发布Swift,到现行反革命已经两年多了,而Swift也来到了叁.一版本。二零一八年应用工作之余,共花了七个多月的小时把官方的斯维夫特编制程序指南看完。未来打点一下笔记,回看一下在先的文化。有亟待的校友能够去看合法文书档案>>。


斯维夫特提供了三种集合类型:数组(Array)、集合(Set)、字典(Dictionary)。Array是有各类的值的成团;Set是多少个唯一的值的冬辰集聚;Dictionary是严节的键值对聚集。

注意:Swift的ArraySetDictionary都属于泛型集合。

Swift提供ArraysSetsDictionaries三种基本的联谊类型用来囤积集合数据。

咱俩精晓Java中的Collection基本上是每二个Java程序猿接触到的第1个重要的知识点。

咱俩领略Java中的Collection基本上是每三个Java程序猿接触到的首先个重点的知识点。

数组 (Array)

数组只可以存款和储蓄一样类其余值。同样的值能够出现在数组的例外地方中。

1. 数组

数组使用有类别表存款和储蓄同一种类的多少个值,同样的值能够频仍涌出。

在Swift中也不例外,斯维夫特中的Collection有八个:数组(Array),字典(Dictionary)和汇集(set)

在Swift中也不例外,Swift中的Collection有多少个:数组(Array),字典(Dictionary)和集合(set)

数组类型的笔记语法 (Array Type Shorthand Syntax)

3个数组的品类是那般写的:Array<Element>Element是数组成分值的项目,也足以简写成:[Element]

一.一 创设三个空数组

var someInts = [Int]()

一、数组

一、数组

成立八个空数组 (Creating an Empty Array)
var someInt = [Int]()
print("someInts is of type [Int] with \(someInts.count) items.")
// Prints "someInts is of type [Int] with 0 items."

someInt被推断为[Int]类型。

一经上下文已经提供了数组的项目,空素组还足以写成[]

someInt.append(3)
// someInts now contains 1 value of type Int
someInt = []
// someInts is now an empty array, but is still of type [Int]

1.二 创制多少个暗含私下认可值得数组

var threeDoubles = Array(repeating: 0.0, count: 3)
// 等价于[0.0, 0,0, 0.0]

数组的开创方法,请参见其它壹篇小说Swift三中数组创立方法,那里要说的是Swift中某些数组的特色:

数组的创导方法,请参见别的壹篇小说斯维夫特叁中数组成立方法,那里要说的是Swift中部分数组的风味:

始建3个有暗中认可值的数组 (Creating an Array with a Default Value)
var threeDoubles = Array(repeating: 0.0, count: 3)
// threeDoubles is of type [Double], and equals [0.0, 0.0, 0.0]

一.三 通过多个数组相加创制三个数组

var anotherThreeDoubles = Array(repeating: 2.5, count: 3)
var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles被推断为[Double]

1、向数组中添澳成分:

1、向数组中添比索素:

通过合并多个数组来创造数组 (Creating an Array by Adding Two Arrays Together)
let anotherThreeDoubles = Array(repeating: 2.5, count: 3)
// anotherThreeDoubles is of type [Double], and equals [2.5, 2.5, 2.5]

var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles is inferred as [Double], and equals [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

一.四 用数组字面量构造数组

var shoppingList:[String] = ["Eggs", "Milk"]
// shoppingList已经被构造并且拥有两个初始项

鉴于Swift的门类臆度机制,当大家用字面量构造只具备同等档次值数组的时候,能够省却数组的品种:

var shoppingList = ["Eggs", "Milk"]

向数组中添卢比素除了能够选用append方法,使用+也是能够的:

向数组中添日币素除了可以接纳append方法,使用+也是足以的:

用字面值创立数组 (Creating an Array with an Array Literal)
var shoppingLis = ["Eggs", "Milk"]
// shoppingList has been initialized with two initial items

一.伍 访问和修改数组

  • count:获取数组中的元素数目
  • isEmpty:检查count是否为0
  • append(_:):在数组后面增多新的多寡
  • insert(_:at:):在某些具体索引值在此以前拉长数据项
  • remove(at:):移除数组中的某1项
  • removeLast():移除数组的末尾壹项

+=运算符能够平素在数组前面增添3个或多少个同连串的数码项:

shoppingList += ["Baking Powder"]
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]

笔者们能够因此下标获取或转移有些已有索引值对应的数据。
还是能够利用下标来3遍变动1雨后玉兰片的数据值:

shoppingList[4..<6] = ["Bananas", "Apples"]
var numbers = [1,2,3,4,5]
numbers.append(8)
numbers+[8]
var numbers = [1,2,3,4,5]
numbers.append(8)
numbers+[8]
走访和更改数组 (Accessing and Modifying an Array)

赢得数组的个数:

print("The shopping list contains \(shoppingList.count) items.")
// Prints "The shopping list contains 2 items."

判别数组成分的个数是或不是为0:

if shoppingList.isEmpty {
    print("The shopping list is empty.")
} else {
    print("The shopping list is not empty.")
}

日增一个要素:

shoppingList.append("Flour")
// shoppingList now contains 3 items, and someone is making pancakes

行使加法赋值运算符增加越多元素:

shoppingList += ["Baking Powder"]
// shoppingList now contains 4 items
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// shoppingList now contains 7 items

【4858.com】Swift中的集合类型,集合类型。选用下标获取元素:

var firstItem = shoppingList[0]
// firstItem is equal to "Eggs"

改动成分:

shoppingList[0] = "Six eggs"
// the first item in the list is now equal to "Six eggs" rather than "Eggs"

选拔下标三回性改变多个因素,甚至要退换的要素个数能够不对等新数组的个数:

shoppintList[4...6] = ["Bananas", "Apples"]
// 用两个替换三个

在特定的职位插入元素:

shoppingList.insert("Maple syrup", at: 0)
// shoppingList now contains 7 items
// "Maple Syrup" is now the first item in the list

删除特定岗位的成分,并且再次回到被删除的因素:

let mapleSyrup = shoppingList.remove(at: 0)
// the item that was at index 0 has just been removed
// shoppingList now contains 6 items, and no Maple Syrup
// the mapleSyrup constant is now equal to the removed "Maple Syrup" string

除去最终1个成分:

let apples = shoppingList.removeLast()
// the last item in the array has just been removed
// shoppingList now contains 5 items, and no apples
// the apples constant is now equal to the removed "Apples" string

一.6 数组的遍历

大家得以用for-in巡回遍历全数数组中的数据项。
假诺我们同时需求各类数据项的值和索引值,能够选拔enumerated()方法。enumerated()回到1个由每贰个数目项索引值和数据值组成的元组:

for (index, value) in shoppingList.enumerated() {
    print("Item \(String(index + 1)): \(value)")
}

都以能够的。

都以足以的。

遍历整个数组 (Iterating Over an Array)

使用for-in遍历:

for item in shoppingList {
    print(item)
}
// Six eggs
// Milk
// Flour
// Baking Powder
// Bananas

使用enumerated()措施遍历,这么些法子再次回到包涵索引和目录对应的要素的多元组:

for (index, value) in shoppingList.enumerated() {
    print("Item \(index + 1): \(value)")
}
// Item 1: Six eggs
// Item 2: Milk
// Item 3: Flour
// Item 4: Baking Powder
// Item 5: Bananas

2. 集合

集结用来囤积同样档次并且未有规定顺序的值,集合内的因素不能够再次。

2、多少个数组相等

二、多个数组相等

集合 (Sets)

聚拢中无顺序地囤积了同样档次的值,并且个中的每3个值都以唯一的。在要素的依次不重要依旧供给每二个要素都亟需唯一的时候,能够利用集合,而不用数组。

2.壹 集合类型的哈希值

存款和储蓄在集聚中的类型必须是可哈希化的,Swift的有所大旨类型(比如String,Int,DoubleBool)私下认可皆以可哈希化的,未有涉嫌值额枚举成员值暗中同意也是可哈希化的。

您能够接纳自定义的类别作为集合的值的体系或字典的键的种类,但供给使自定义类型符合Swift标准库中的Hashable协议。符合Hashable切磋的项目供给提供3个门类为Int的可读属性hashValue

在Java和C/C++中判别四个数组相等是相比较复杂的,不过在Swift中却很有益:

在Java和C/C++中剖断五个数组相等是比较复杂的,可是在斯威夫特中却很有益于:

聚拢类型的哈希值 (Hash Values for Set Types)

相会里面的要素类型必须hashable,也正是说,那么些成分类型必须提供一个办法来测算他协调的哈希值。八个哈希值是1个用来推断多个目的是或不是等于的Int花色的整数。例如,假设a == b4858.com,,那么a.hashValue == b.hashValue

具备Swift的主干类型(例如StringIntDoubleBool)私下认可都以hashable的,都能够当做集合的值类型或许字典的键类型。未有关联值的枚举值暗中认可也是hashable的。

咱俩能够自定义类型,并且遵照Hashable说道,作为集合可能字典键的值类型。自定义的项目必须提供一个能读取的Int品种的性质,并取名叫hashValue。在区别的次第依旧同贰个程序运行数13遍中,不必要每回hashValue属性再次回到的值都至极。

因为Hashable说道遵循Equatable商事,所以大家自定义的档次还亟需提供二个对等运算符(==)的实现。Equatable磋商须要每3个==的兑现是三个等价关系。也正是说,==的落到实处必须满意上面三个标准化:

  • a == a (自反性)
  • a == b,说明b == a (对称性)
  • a == b && b == c,说明 a == c (传递性)

二.2 集合类型语法

var numbers = [1,2,3,4,5]
var oneToFive = [1,2,3,4,5]
numbers == oneToFive
var numbers = [1,2,3,4,5]
var oneToFive = [1,2,3,4,5]
numbers == oneToFive
聚拢类型语法 (Set Type Syntax)

使用Set<Element>来设置集合类型,Element是会师存款和储蓄的成分类型。

2.二.一 成立和协会叁个空的集聚

var letters = Set<Character>()

本条再次来到值正是true,直接用==即可举办推断了。

本条重回值便是true,直接用==就足以举办剖断了。

创办和伊始化1个空集合 (Creating and Initializing an Empty Set)
var letters = Set<Character>()
print("letters is of type Set<Character> with \(letters.count) items.")
// Prints "letters is of type Set<Character> with 0 items."

letters被测度为Set<Character>类型。

同等地,就算上下文提供了聚众的类型音讯,能够采取[]来创设三个空的成团:

letters.insert("a")
// letters now contains 1 value of type Character
letters = []
// letters is now an empty set, but is still of type Set<Character>

二.2.二 用数组字面量创立集合

var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]

二、字典和聚集

二、字典和集纳

行使数组字面值来创设贰个集合 (Creating a Set with an Array Literal)
var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
// favoriteGenres has been initialized with three initial items

集合的花色无法通过数组的字面值来推论,所以Set的品类必须旗帜显著宣称。不过因为斯维夫特的类型推测,假使用三个饱含一样体系字面值的数组来初叶化集合,大家得以不写集合的品种。例如:

var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]

因为数组的满贯字面值都以同样档次,所以Swfit能估计出Set<String>favoriteGenres的正确类型。

2.二.3 访问和修改1个集合

  • count:返回Set7月素的多少
  • isEmpty:检查count是否为0
  • insert(_:):增添三个新因素
  • remove(_:):删除2个成分(倘使Set不包蕴该值,重返nil)
  • removeAll():删除全数因素
  • contains(_:):检查Set中是还是不是含有3个一定的值

对字典和集合来讲最重要的是开创方法,别的的在法定文书档案都得以查到(当然创造方法也是能够查到的)

对字典和集纳来讲最根本的是创造方法,其余的在合法文档都得以查到(当然创立方法也是足以查到的)

走访和修改集合 (Accessing and Modifying a Set)

使用count天性获取集合成分个数:

print("I have \(favoriteGenres.count) favorite music genres.")
// Prints "I have 3 favorite music genres."

使用isEmpty品质判别集合瓜月素的个数是还是不是为0:

if favoriteGenres.isEmpty {
    print("As far as music goes, I'm not picky.")
} else {
    print("I have particular music preferences.")
}
// Prints "I have particular music preferences."

使用insert(_:)艺术添法郎素:

favoriteGenres.insert("Jazz")
// favoriteGenres now contains 4 items

使用remove(_:)删去贰个因素,并赶回被删去的要素,要是成分不存在,重返nil;使用removeAll()去除全部要素:

if let removedGenre = favoriteGenres.remove("Rock") {
    print("\(removedGenre)? I'm over it.")
} else {
    print("I never much cared for that.")
}
// Prints "Rock? I'm over it."

看清是不是包括某些成分:

if favoriteGenres.contains("Funk") {
    print("I get up on the good foot.")
} else {
    print("It's too funky in here.")
}
// Prints "It's too funky in here."

二.2.肆 遍历1个会见

使用for-in遍历一个汇聚。
Swift的Set连串未有规定的各种,为了依照一定的逐条来遍历四个Set中的值能够用sorted()情势,它将回到2个不改变数组,那么些数组的因素排列顺序又操作符<对成分进行相比的结果来分明。

for genre in favoriteGenres.sorted() {
    print("genre")
}
// 按顺序打印"Classical", "Hip hop", "Jazz"

字典的创导:

字典的开创:

遍历整个集合 (Iterating Over a Set)
for genre in favoriteGenres {
    print("\(genre)")
}
// Jazz
// Hip hop
// Classical

斯维夫特的集合类型未有概念顺序,大家得以使用sorted()办法来排序,那几个办法应用<运算符将成分从小到大排列:

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

二.三 集合操作

var dic = ["apple" : "苹果", "bag" : "包"]
var dic = ["apple" : "苹果", "bag" : "包"]

实施集合操作 (Performing Set Operations)

2.三.一 基本集合操作

  • intersection(_:):依据三个集聚中都蕴含的值创立2个新的汇集
  • symmetricDifference(_:):依照在1个集合中但不在七个汇集中的值创设四个新集合
  • 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]

集合的创办:

会晤的成立:

宗旨集合操作 (Fundamental Set Operations)

下图是聚众ab实行了区别的方法之后,得出的结果图:

4858.com 1

Fundamental Set Operations

  • 使用intersection(_:)情势赢得多个集聚共有的因素,并用这几个同样的要素创设叁个新的聚集
  • 使用symmetricDifference(_:)艺术获得除了多个汇聚共有的要素外的富有因素,并用这么些同样的成分创立二个新的集纳
  • 使用union(_:)主意获得八个聚众的有着因素,并用这么些同样的要素创设三个新的汇聚
  • 使用subtracting(_:)方法减去与钦定集合一样的要素后余下的成分,并用剩下的成分创立1个新的聚众

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]

二.三.二 集合成员涉及和卓殊

  • ==:判定多少个聚众是不是等于
  • isSubset(of:):剖断二个会面中的值是不是也被含有在另一个相会中
  • isStrictSubset(of:)/isStrictSuperset(of:):判断二个集结是不是是另1个集结的子集合/父集合并且五个集聚不对等
  • isDisjoint(with:):判定那七个聚众是或不是有搅和

let houseAnimals: Set = ["dog", "cat"]
let farmAnimals: Set = ["cow", "chicken", "sheep", "dog", "cat"]
let cityAnimals: Set = ["bird", "mouse"]

houseAnimals.isSubset(of: farmAnimals)
// true

farmAnimals.isSuperset(of: houseAnimals)
// true

farmAnimals.isDisjoint(with: cityAnimals)
// ture
var letters = Set<Character>()
var setColors:Set<String> = ["红色","白色","洋红色","黄色"]
var letters = Set<Character>()
var setColors:Set<String> = ["红色","白色","洋红色","黄色"]
集结关系和11分性 (Set Membership and Equality)

下图演示了多个集聚:abc,重叠区域代表有同1的因素。集合a是集合b的父集合,因为a包含了b的具有因素;相反,ba的子集合。集合b和集合c互不相交,因为他俩平昔分歧样的成分。

4858.com 2

Set Membership and Equality

  • 行使“是还是不是等于”运算符 (==)来判定多个聚众的享有因素是或不是等于
  • 使用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

3. 字典

字典是一种存款和储蓄八个同样档次的值得容器,字典中的数据项尚未实际顺序。

 

 

Dictionaries (字典)

字典是一个冬天聚集中千篇1律类别的键和一样类其他值的关联。每2个值关联着二个唯1的键。

三.1 创立一个空字典

var namesOfIntegers = [Int: String]()

亟待小心的是:

供给注意的是:

字典类型速记语法 (Dictionary Type Shorthand Syntax)

使用Dictionary<Key, Value>来指定字典的类别。

注意:字典的Key类型必须比照Hashable商量,就像集合的值同样。

还可以是用简单的格局[Key: Value]来钦赐字典的类型.

三.二 用字典字面量创立字典

var airports: [String: String] = ["XYZ": "Toronto Pearson", "DUB": "Dublin"]

var airports = ["XYZ": "Toronto Pearson", "DUB": "Dublin"]

数组:有序的

数组:有序的

创造贰个空字典 (Creating an Empty Dictionary)
var namesOfIntegers = [Int: String]()
// namesOfIntegers is an empty [Int: String] dictionary

只要上下文已经提供了类型消息,能够选用[:]来创制二个空字典:

namesOfIntegers[16] = "sixteen"
// namesOfIntegers now contains 1 key-value pair
namesOfIntegers = [:]
// namesOfIntegers is once again an empty dictionary of type [Int: String]

三.叁 访问和退换字典

同数组和聚集同样,字典同样有着countisEmpty属性。
大家得以在字典中应用下表语法增多新的数码项,或许转移特定键对应的值。

airports["LHR"] = "London"
airports["LHR"] = "London Heathrow"

updateValue(_:forKey:)富有同等的成效,不一致的是,这一个艺术重返更新值以前的原值,即对应值的门类的可选值。

if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") {
    print("The old value for DUB was \(oldValue)")
}
// 输出 "The old value for DUB was Dublin

我们也得以利用下标语法在字典中检索特定键对应的值。

if let airportName = airports["DUB"] {
    print("The name of the airports is \(airportName)")
} else {
    print("That airport is not in the airports dictionary")
}
// 打印 "The name of the airports is Dublin Airport"

我们还足以动用下标语法通过给有个别键的对应值赋值为nil来从字典里移除1个键值对:

airports["APL"] = "Apple Internation"
airports["APL"] = nil

removeValue(forKey:)办法也得以用来移除键值对,再次回到被移除的值可能在并未有值得景况下重临nil

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

聚拢:冬季的、唯1的、可以实行联谊操作(交并补),可以落成高效寻觅

汇聚:冬辰的、唯1的、能够进行联谊操作(交并补),可以兑现长足搜索

选择字典字面值来创立字典 (Creating a Dictionary with a Dictionary Literal)
var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]

三.4 字典遍历

除了for-in魔幻遍历,大家也可以通过拜访keys或者values品质,遍历字典的键或许值:

斯维夫特的字典类型是严节集聚类型,为了以特定的相继遍历字典的键或值,能够对字典的keysvalues脾气使用sorted()方法。

字典:键值对

字典:键值对

做客和更改字典 (Accessing and Modifying Dictionary)

获得字典键值对的个数:

print("The airports dictionary contains \(airports.count) items.")
// Prints "The airports dictionary contains 2 items."

看清字典中键值对的个数是或不是为0:

if airports.isEmpty {
    print("The airports dictionary is empty.")
} else {
    print("The airports dictionary is not empty.")
}
// Prints "The airports dictionary is not empty."

行使下标语法增多新的键值对:

airports["LHR"] = "London Heathrow"
// the value for "LHR" has been changed to "London Heathrow"

还能使用updateValue(_:forKey:)艺术来设置或更新七个键一见如旧的值,并回到1个可选类型的值。借使那一个键不设有,那么就增多一个新的键值对,并赶回nil;若是那几个键存在,那么就创新那些键对应的值,并再次回到此前的旧值。那足以让大家检查键对应的值是或不是更新成功。

if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") {
    print("The old value for DUB was \(oldValue).")
}
// Prints "The old value for DUB was Dublin."

动用下标语法来获取键对应的值:

if let airportName = airports["DUB"] {
    print("The name of the airport is \(airportName).")
} else {
    print("That airport is not in the airports dictionary.")
}
// Prints "The name of the airport is Dublin Airport."

使用下标语法并把键对应的值设置为nil来删除贰个键值对:

airports["APL"] = "Apple International"
// "Apple International" is not the real airport for APL, so delete it
airports["APL"] = nil
// APL has now been removed from the dictionary

别的,还是能行使removeValue(forKey:)办法来删除3个键值对,假诺存在,重回键对应的值;假诺不存在,再次来到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."
遍历整个字典 (Iterating Over a Dictionary)
for (airportCode, airportName) in airports {
    print("\(airportCode): \(airportName)")
}
// YYZ: Toronto Pearson
// LHR: London Heathrow

使用keysvalues天性来遍历字典的全体键和全体值:

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

借使要运用字典的全体键和具有值,能够使用数组的API来创制:

let airportCodes = [String](airports.keys)
// airportCodes is ["YYZ", "LHR"]

let airportNames = [String](airports.values)
// airportNames is ["Toronto Pearson", "London Heathrow"]

斯维夫特的字典类型未有概念顺序,为了遍历经过排序的全数键和持有值,需求采纳keysvalues属性的sorted()方法。


第陆有的完。下个部分:【Swift 3.1】05 – 控制流 (Control Flow)


设若有不当的地点,欢迎指正!谢谢!

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有