swift基础（二）

运算符

字符

集合类型

一、运算符

1.溢出运算符

在默认情况下，当向一个整数赋予超过它容量的值时，Swift 默认会报错，而不是生成一个无效的数。

swift 提供的三个溢出运算符来让系统支持整数溢出运算。这些运算符都是以 & 开头的：

溢出加法 &+

溢出减法 &-

溢出乘法 &*

如：

var unsignedOverflow = UInt8.max

// unsignedOverflow 等于 UInt8 所能容纳的最大整数 255

unsignedOverflow = unsignedOverflow &+ 1

// 此时 unsignedOverflow 等于 0

2.比较运算符

当元组中的值可以比较时，你也可以使用这些运算符来比较它们的大小。例如，因为 Int 和 String 类型的值可以比较，所以类型为 (Int, String) 的元组也可以被比较。相反，Bool 不能被比较，也意味着存有布尔类型的元组不能被比较。

比较元组大小会按照从左到右、逐值比较的方式，直到发现有两个值不等时停止。如果所有的值都相等，那么这一对元组我们就称它们是相等的。例如：

(1, "zebra")

// true，因为 1 小于 2

(3, "apple")

// true，因为 3 等于 3，但是 apple 小于 bird

(4, "dog") == (4, "dog")

// true，因为 4 等于 4，dog 等于 dog

3.空合运算符

空合运算符（a ?? b）将对可选类型 a 进行空判断，如果 a 包含一个值就进行解封，否则就返回一个默认值 b。表达式 a 必须是 Optional 类型。默认值 b 的类型必须要和 a 存储值的类型保持一致。

let defaultColorName = "red"

var userDefinedColorName: String? //默认值为 nil

var colorNameToUse = userDefinedColorName ?? defaultColorName

// userDefinedColorName 的值为空，所以 colorNameToUse 的值为 "red"

4.区间运算符

闭区间运算符（a...b）定义一个包含从 a 到 b（包括 a 和 b）的所有值的区间。a 的值不能超过 b。 ‌ 闭区间运算符在迭代一个区间的所有值时是非常有用的，如在 for-in 循环中：

for index in 1...5 {

print("\(index) * 5 = \(index * 5)")

}

半开区间运算符（a..

半开区间的实用性在于当你使用一个从 0 开始的列表（如数组）时，非常方便地从0数到列表的长度。

let names = ["Anna", "Alex", "Brian", "Jack"]

let count = names.count

for i in 0..

print("第 \(i + 1) 个人叫 \(names[i])")

}

二、字符串与字符

1.空字符串

var emptyString = ""

// 空字符串字面量

var anotherEmptyString = String()

// 初始化方法

// 两个字符串均为空并等价。

您可以通过检查其Bool类型的isEmpty属性来判断该字符串是否为空：

if emptyString.isEmpty {

print("Nothing to see here")

}

// 打印输出："Nothing to see here"

2.字符串是值类型

Swift 的String类型是值类型。 如果您创建了一个新的字符串，那么当其进行常量、变量赋值操作，或在函数/方法中传递时，会进行值拷贝。 任何情况下，都会对已有字符串值创建新副本，并对该新副本进行传递或赋值操作。

3.字符串插值

let multiplier = 3

let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"

// message 是 "3 times 2.5 is 7.5"

4.字符串索引

let greeting = "Guten Tag!"

greeting[greeting.startIndex]

// G

greeting[greeting.index(before: greeting.endIndex)]

// !

greeting[greeting.index(after: greeting.startIndex)]

// u

let index = greeting.index(greeting.startIndex, offsetBy: 7)

greeting[index]

// a

5.字符串插入、删除

使用 insert(_:at:)、insert(contentsOf:at:)、remove(at:) 和 removeSubrange(_:) 方法在任意一个确认的并遵循 RangeReplaceableCollection 协议的类型里面，如上文所示是使用在 String 中，您也可以使用在 Array、Dictionary 和 Set 中

三、集合类型

数组

1.构建空数组

var someInts = [Int]()

print("someInts is of type [Int] with \(someInts.count) items.")

// 打印 "someInts is of type [Int] with 0 items."

注意，通过构造函数的类型，someInts的值类型被推断为[Int]。

2.特定大小有默认值的数组

var threeDoubles = Array(repeating: 0.0, count: 3)

// threeDoubles 是一种 [Double] 数组，等价于 [0.0, 0.0, 0.0]

3.数组相加

使用加法操作符（+）来组合两种已存在的相同类型数组。

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]

4.不可以用下标访问的形式去在数组尾部添加新项。（越界）

5.数组遍历

for item in shoppingList {

print(item)

}

或

for (index, value) in shoppingList. enumerated() {

print("Item \(String(index + 1)): \(value)")

}

//enumerated()返回一个由每一个数据项索引值和数据值组成的元组。

集合

集合(Set)用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要时或者希望确保每个元素只出现一次时可以使用集合而不是数组。

1.集合哈希值

一个类型为了存储在集合中，该类型必须是可哈希化的--也就是说，该类型必须提供一个方法来计算它的哈希值。一个哈希值是Int类型的，相等的对象哈希值必须相同，比如a==b,因此必须a.hashValue == b.hashValue。

Swift 的所有基本类型(比如String,Int,Double和Bool)默认都是可哈希化的，可以作为集合的值的类型或者字典的键的类型。

注意：自定义的类型作为集合的值的类型或者是字典的键的类型，需要使你的自定义类型符合 Swift 标准库中的Hashable协议

2.构造集合

var letters = Set()

letters.insert("a")

// letters 现在含有1个 Character 类型的值

letters = []

// letters 现在是一个空的 Set, 但是它依然是 Set 类型

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

// favoriteGenres 被构造成含有三个初始值的集合

3.集合操作

使用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]

4.判断集合关系

使用“是否相等”运算符(==)来判断两个集合是否包含全部相同的值。

使用isSubset(of:)方法来判断一个集合中的值是否也被包含在另外一个集合中。

使用isSuperset(of:)方法来判断一个集合中包含另一个集合中所有的值。

使用isStrictSubset(of:)或者isStrictSuperset(of:)方法来判断一个集合是否是另外一个集合的子集合或者父集合并且两个集合并不相等。

使用isDisjoint(with:)方法来判断两个集合是否不含有相同的值(有没有交集)。

字典

1.创建字典

varnamesOfIntegers= [Int:String]()

namesOfIntegers[16] = "sixteen"

// namesOfIntegers 现在包含一个键值对

namesOfIntegers = [:]

// namesOfIntegers 又成为了一个 [Int: String] 类型的空字典

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

2.更新字典

字典的updateValue(_:forKey:)这个方法返回更新值之前的原值。这样使得我们可以检查更新是否成功。

如果有值存在于更新前，则这个可选值包含了旧值，否则它将会是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."

3.字典遍历

for (airportCode, airportName) in airports {

print("\(airportCode): \(airportName)")

}

for airportCode in airports.keys {

print("Airport code: \(airportCode)")

}

for airportName in airports.values {

print("Airport name: \(airportName)")

}

如果我们只是需要使用某个字典的键集合或者值集合来作为某个接受Array实例的 API 的参数，可以直接使用keys或者values属性构造一个新数组：

let airportCodes = [String](airports.keys)

let airportNames = [String](airports.values)