Swift 字面量/运算符/条件语句/字符串/数组/字典
1. Swift 字面量
所谓字面量，就是指像特定的数字，字符串或者是布尔值这样，能够直接了当地指出自己的类型并为变量进行赋值的值。
比如在下面：
let aNumber = 3
let aString = "Hello"
let aBool = true
1.1 字符串型字面量
字符串型字面量由被包在双引号中的一串字符组成，形式如下：
"characters"
字符串型字面量中不能包含未转义的双引号 （"）、未转义的反斜线（\）、回车符或换行符。
| 转义字符 | 含义 |
|---|
\0 | 空字符 | \\ | 反斜线 \ | \b | 退格(BS) ，将当前位置移到前一列 | \f | 换页(FF)，将当前位置移到下页开头 | \n | 换行符 | \r | 回车符 | \t | 水平制表符 | \v | 垂直制表符 | \' | 单引号 | \" | 双引号 | \000 | 1到3位八进制数所代表的任意字符 | \xhh... | 1到2位十六进制所代表的任意字符 |
2. Swift 运算符
2.1 区间运算符
Swift 提供了两个区间的运算符。
| 运算符 | 描述 | 实例 |
|---|
| 闭区间运算符 | 闭区间运算符（a…b）定义一个包含从a到b(包括a和b)的所有值的区间，b必须大于等于a。 ? 闭区间运算符在迭代一个区间的所有值时是非常有用的，如在for-in循环中。 | 1…5 区间值为 1, 2, 3, 4 和 5 | | 半开区间运算符 | 半开区间（a…<b）定义一个从a到b但不包括b的区间。 之所以称为半开区间，是因为该区间包含第一个值而不包括最后的值。 | 1…< 5 区间值为 1, 2, 3, 和 4 |
以下为区间运算的简单实例：
import Cocoa
print("闭区间运算符:")
for index in 1...5 {
print("\(index) * 5 = \(index * 5)")
}
print("半开区间运算符:")
for index in 1..<5 {
print("\(index) * 5 = \(index * 5)")
}
以上程序执行结果为：
闭区间运算符:
1 * 5 = 5
2 * 5 = 10
3 * 5 = 15
4 * 5 = 20
5 * 5 = 25
半开区间运算符:
1 * 5 = 5
2 * 5 = 10
3 * 5 = 15
4 * 5 = 20
3. Swift 条件语句
3.1 Swift switch 语句
Swift 语言中 switch 语句的语法：
switch expression {
case expression1 :
statement(s)
fallthrough
case expression2, expression3 :
statement(s)
fallthrough
default :
statement(s);
}
一般在 switch 语句中不使用 fallthrough 语句。
这里我们需要注意 case 语句中如果没有使用 fallthrough 语句，则在执行当前的 case 语句后，switch 会终止，控制流将跳转到 switch 语句后的下一行。
如果使用了fallthrough 语句，则会继续执行之后的 case 或 default 语句，不论条件是否满足都会执行。
注意：在大多数语言中，switch 语句块中，case 要紧跟 break，否则 case 之后的语句会顺序运行，而在 Swift 语言中，默认是不会执行下去的，switch 也会终止。如果你想在 Swift 中让 case 之后的语句会按顺序继续运行，则需要使用 fallthrough 语句。
实例1
以下实例没有使用 fallthrough 语句：
import Cocoa
var index = 10
switch index {
case 100 :
print( "index 的值为 100")
case 10,15 :
print( "index 的值为 10 或 15")
case 5 :
print( "index 的值为 5")
default :
print( "默认 case")
}
当上面的代码被编译执行时，它会产生下列结果：
index 的值为 10 或 15
实例2
以下实例使用 fallthrough 语句：
import Cocoa
var index = 10
switch index {
case 100 :
print( "index 的值为 100")
fallthrough
case 10,15 :
print( "index 的值为 10 或 15")
fallthrough
case 5 :
print( "index 的值为 5")
default :
print( "默认 case")
}
当上面的代码被编译执行时，它会产生下列结果：
index 的值为 10 或 15
index 的值为 5
4. Swift 字符串
4.1 空字符串
可以使用空的字符串字面量赋值给变量或初始化一个String类的实例来初始值一个空的字符串。 我们可以使用字符串属性 isEmpty 来判断字符串是否为空：
import Cocoa
var stringA = ""
if stringA.isEmpty {
print( "stringA 是空的" )
} else {
print( "stringA 不是空的" )
}
let stringB = String()
if stringB.isEmpty {
print( "stringB 是空的" )
} else {
print( "stringB 不是空的" )
}
以上程序执行输出结果为：
stringA 是空的
stringB 是空的
4.2 字符串中插入值
字符串插值是一种构建新字符串的方式，可以在其中包含常量、变量、字面量和表达式。 您插入的字符串字面量的每一项都在以反斜线为前缀的圆括号中：
import Cocoa
var varA = 20
let constA = 100
var varC:Float = 20.0
var stringA = "\(varA) 乘于 \(constA) 等于 \(varC * 100)"
print( stringA )
以上程序执行输出结果为：
20 乘于 100 等于 2000.0
4.3 字符串长度
字符串长度使用 String.count 属性来计算，实例如下：
Swift 3 版本使用的是 String.characters.count
import Cocoa
var varA = "www.runoob.com"
print( "\(varA), 长度为 \(varA.count)" )
以上程序执行输出结果为：
www.runoob.com, 长度为 14
5. Swift 数组
Swift 数组使用有序列表存储同一类型的多个值。相同的值可以多次出现在一个数组的不同位置中。
Swift 数组会强制检测元素的类型，如果类型不同则会报错，Swift 数组应该遵循像 Array<Element> 这样的形式，其中 Element 是这个数组中唯一允许存在的数据类型。
如果创建一个数组，并赋值给一个变量，则创建的集合就是可以修改的。这意味着在创建数组后，可以通过添加、删除、修改的方式改变数组里的项目。如果将一个数组赋值给常量，数组就不可更改，并且数组的大小和内容都不可以修改。
5.1 创建数组
我们可以使用构造语法来创建一个由特定数据类型构成的空数组：
var someArray = [SomeType]()
以下是创建一个初始化大小数组的语法：
var someArray = [SomeType](repeating: InitialValue, count: NumbeOfElements)
以下实例创建了一个类型为 Int ，数量为 3，初始值为 0 的空数组：
var someInts = [Int](repeating: 0, count: 3)
以下实例创建了含有三个元素的数组：
var someInts:[Int] = [10, 20, 30]
5.2 访问数组
我们可以根据数组的索引来访问数组的元素，语法如下：
var someVar = someArray[index]
index 索引从 0 开始，即索引 0 对应第一个元素，索引 1 对应第二个元素，以此类推。
我们可以通过以下实例来学习如何创建，初始化，访问数组：
import Cocoa
var someInts = [Int](repeating: 10, count: 3)
var someVar = someInts[0]
print( "第一个元素的值 \(someVar)" )
print( "第二个元素的值 \(someInts[1])" )
print( "第三个元素的值 \(someInts[2])" )
以上程序执行输出结果为：
第一个元素的值 10
第二个元素的值 10
第三个元素的值 10
5.3 修改数组
你可以使用 append() 方法或者赋值运算符 += 在数组末尾添加元素，如下所示，我们初始化一个数组，并向其添加元素：
import Cocoa
var someInts = [Int]()
someInts.append(20)
someInts.append(30)
someInts += [40]
var someVar = someInts[0]
print( "第一个元素的值 \(someVar)" )
print( "第二个元素的值 \(someInts[1])" )
print( "第三个元素的值 \(someInts[2])" )
以上程序执行输出结果为：
第一个元素的值 20
第二个元素的值 30
第三个元素的值 40
我们也可以通过索引修改数组元素的值：
import Cocoa
var someInts = [Int]()
someInts.append(20)
someInts.append(30)
someInts += [40]
someInts[2] = 50
var someVar = someInts[0]
print( "第一个元素的值 \(someVar)" )
print( "第二个元素的值 \(someInts[1])" )
print( "第三个元素的值 \(someInts[2])" )
以上程序执行输出结果为：
第一个元素的值 20
第二个元素的值 30
第三个元素的值 50
5.4 遍历数组
我们可以使用 for-in 循环来遍历所有数组中的数据项：
import Cocoa
var someStrs = [String]()
someStrs.append("Apple")
someStrs.append("Amazon")
someStrs.append("Runoob")
someStrs += ["Google"]
for item in someStrs {
print(item)
}
以上程序执行输出结果为：
Apple
Amazon
Runoob
Google
如果我们同时需要每个数据项的值和索引值，可以使用 String 的 enumerate() 方法来进行数组遍历。实例如下：
import Cocoa
var someStrs = [String]()
someStrs.append("Apple")
someStrs.append("Amazon")
someStrs.append("Runoob")
someStrs += ["Google"]
for (index, item) in someStrs.enumerated() {
print("在 index = \(index) 位置上的值为 \(item)")
}
以上程序执行输出结果为：
在 index = 0 位置上的值为 Apple
在 index = 1 位置上的值为 Amazon
在 index = 2 位置上的值为 Runoob
在 index = 3 位置上的值为 Google
5.5 合并数组
我们可以使用加法操作符（+）来合并两种已存在的相同类型数组。新数组的数据类型会从两个数组的数据类型中推断出来：
import Cocoa
var intsA = [Int](repeating: 2, count:2)
var intsB = [Int](repeating: 1, count:3)
var intsC = intsA + intsB
for item in intsC {
print(item)
}
以上程序执行输出结果为：
2
2
1
1
1
5.6 count 属性
我们可以使用 count 属性来计算数组元素个数：
import Cocoa
var intsA = [Int](count:2, repeatedValue: 2)
var intsB = [Int](count:3, repeatedValue: 1)
var intsC = intsA + intsB
print("intsA 元素个数为 \(intsA.count)")
print("intsB 元素个数为 \(intsB.count)")
print("intsC 元素个数为 \(intsC.count)")
以上程序执行输出结果为：
intsA 元素个数为 2
intsB 元素个数为 3
intsC 元素个数为 5
5.7 isEmpty 属性
我们可以通过只读属性 isEmpty 来判断数组是否为空，返回布尔值：
import Cocoa
var intsA = [Int](count:2, repeatedValue: 2)
var intsB = [Int](count:3, repeatedValue: 1)
var intsC = [Int]()
print("intsA.isEmpty = \(intsA.isEmpty)")
print("intsB.isEmpty = \(intsB.isEmpty)")
print("intsC.isEmpty = \(intsC.isEmpty)")
以上程序执行输出结果为：
intsA.isEmpty = false
intsB.isEmpty = false
intsC.isEmpty = true
6. Swift 字典
Swift 字典用来存储无序的相同类型数据的集合，Swift 字典会强制检测元素的类型，如果类型不同则会报错。
Swift 字典每个值（value）都关联唯一的键（key），键作为字典中的这个值数据的标识符。
和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典，这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。
Swift 字典的 key 没有类型限制，可以是整型或字符串，但必须是唯一的。
如果创建一个字典，并赋值给一个变量，则创建的字典就是可以修改的。这意味着在创建字典后，可以通过添加、删除、修改的方式改变字典里的项目。如果将一个字典赋值给常量，字典就不可修改，并且字典的大小和内容都不可以修改。
6.1 创建字典
我们可以使用以下语法来创建一个特定类型的空字典：
var someDict = [KeyType: ValueType]()
下是创建一个空字典，键的类型为 Int，值的类型为 String 的简单语法：
var someDict = [Int: String]()
以下为创建一个字典的实例：
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
6.2 访问字典
我们可以根据字典的索引来访问数组的元素，语法如下：
var someVar = someDict[key]
我们可以通过以下实例来学习如何创建，初始化，访问字典:
import Cocoa
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someVar = someDict[1]
print( "key = 1 的值为 \(someVar)" )
print( "key = 2 的值为 \(someDict[2])" )
print( "key = 3 的值为 \(someDict[3])" )
以上程序执行输出结果为：
key = 1 的值为 Optional("One")
key = 2 的值为 Optional("Two")
key = 3 的值为 Optional("Three")
6.3 修改字典
我们可以使用 updateValue(forKey:) 增加或更新字典的内容。如果 key 不存在，则添加值，如果存在则修改 key 对应的值。updateValue(_:forKey:) 方法返回 Optional 值。实例如下：
import Cocoa
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var oldVal = someDict.updateValue("One 新的值", forKey: 1)
var someVar = someDict[1]
print( "key = 1 旧的值 \(oldVal)" )
print( "key = 1 的值为 \(someVar)" )
print( "key = 2 的值为 \(someDict[2])" )
print( "key = 3 的值为 \(someDict[3])" )
以上程序执行输出结果为：
key = 1 旧的值 Optional("One")
key = 1 的值为 Optional("One 新的值")
key = 2 的值为 Optional("Two")
key = 3 的值为 Optional("Three")
你也可以通过指定的 key 来修改字典的值，如下所示：
import Cocoa
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var oldVal = someDict[1]
someDict[1] = "One 新的值"
var someVar = someDict[1]
print( "key = 1 旧的值 \(oldVal)" )
print( "key = 1 的值为 \(someVar)" )
print( "key = 2 的值为 \(someDict[2])" )
print( "key = 3 的值为 \(someDict[3])" )
以上程序执行输出结果为：
key = 1 旧的值 Optional("One")
key = 1 的值为 Optional("One 新的值")
key = 2 的值为 Optional("Two")
key = 3 的值为 Optional("Three")
6.4 移除 Key-Value 对
我们可以使用 removeValueForKey() 方法来移除字典 key-value 对。如果 key 存在该方法返回移除的值，如果不存在返回 nil 。实例如下：
import Cocoa
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var removedValue = someDict.removeValue(forKey: 2)
print( "key = 1 的值为 \(someDict[1])" )
print( "key = 2 的值为 \(someDict[2])" )
print( "key = 3 的值为 \(someDict[3])" )
以上程序执行输出结果为：
key = 1 的值为 Optional("One")
key = 2 的值为 nil
key = 3 的值为 Optional("Three")
你也可以通过指定键的值为 nil 来移除 key-value（键-值）对。实例如下:
import Cocoa
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
someDict[2] = nil
print( "key = 1 的值为 \(someDict[1])" )
print( "key = 2 的值为 \(someDict[2])" )
print( "key = 3 的值为 \(someDict[3])" )
以上程序执行输出结果为：
key = 1 的值为 Optional("One")
key = 2 的值为 nil
key = 3 的值为 Optional("Three")
6.5 遍历字典
我们可以使用 for-in 循环来遍历某个字典中的键值对。实例如下:
import Cocoa
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
for (key, value) in someDict {
print("字典 key \(key) - 字典 value \(value)")
}
以上程序执行输出结果为：
字典 key 2 - 字典 value Two
字典 key 3 - 字典 value Three
字典 key 1 - 字典 value One
我们也可以使用 enumerate() 方法来进行字典遍历，返回的是字典的索引及 (key, value) 对，实例如下:
import Cocoa
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
for (key, value) in someDict.enumerated() {
print("字典 key \(key) - 字典 (key, value) 对 \(value)")
}
以上程序执行输出结果为：
字典 key 0 - 字典 (key, value) 对 (2, "Two")
字典 key 1 - 字典 (key, value) 对 (3, "Three")
字典 key 2 - 字典 (key, value) 对 (1, "One")
6.6 字典转换为数组
你可以提取字典的键值(key-value)对，并转换为独立的数组。实例如下：
import Cocoa
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
let dictKeys = [Int](someDict.keys)
let dictValues = [String](someDict.values)
print("输出字典的键(key)")
for (key) in dictKeys {
print("\(key)")
}
print("输出字典的值(value)")
for (value) in dictValues {
print("\(value)")
}
以上程序执行输出结果为：
输出字典的键(key)
2
3
1
输出字典的值(value)
Two
Three
One
6.7 count 属性
我们可以使用只读的 count 属性来计算字典有多少个键值对：
import Cocoa
var someDict1:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someDict2:[Int:String] = [4:"Four", 5:"Five"]
print("someDict1 含有 \(someDict1.count) 个键值对")
print("someDict2 含有 \(someDict2.count) 个键值对")
以上程序执行输出结果为：
someDict1 含有 3 个键值对
someDict2 含有 2 个键值对
6.8 isEmpty 属性
我们可以通过只读属性 isEmpty 来判断字典是否为空，返回布尔值:
import Cocoa
var someDict1:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someDict2:[Int:String] = [4:"Four", 5:"Five"]
var someDict3:[Int:String] = [Int:String]()
print("someDict1 = \(someDict1.isEmpty)")
print("someDict2 = \(someDict2.isEmpty)")
print("someDict3 = \(someDict3.isEmpty)")
以上程序执行输出结果为：
someDict1 = false
someDict2 = false
someDict3 = true
|