文章目录：
（1）字符串字面量
（2）初始化空字符串
（3）字符串可变性
（4）使用字符
（5）连接字符串和字符
（6）字符串插值
（7）计算字符数量
（8）访问和修改字符串
（9）比较字符串

（1）字符串字面量

let someString = "Some string literal value"

（2）初始化空字符串

要创建一个空字符串作为初始值，可以将空的字符串字面量赋值给变量，也可以初始化一个新的 String 实例:

var emptyString = "" // 空字符串字面量 
var anotherEmptyString = String() // 初始化方法
// 两个字符串均为空并等价。

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

if emptyString.isEmpty {
    print("Nothing to see here")
}
// 打印输出:"Nothing to see here"

（3）字符串可变性

可以通过将一个特定字符串分配给一个变量来对其进行修改，或者分配给一个常量来保证其不会被修改:

var variableString = "Horse"
variableString += " and carriage"
// variableString 现在为 "Horse and carriage"
let constantString = "Highlander"
constantString += " and another Highlander"
// 这会报告一个编译错误 (compile-time error) - 常量字符串不可以被修改。

（4）使用字符

可以通过 for-in 循环来遍历字符串中的 characters 属性来获取每一个字符的值:

for character in "Dog!?".characters {
    print(character)
}
// D
// o
// g
// !
// ?

（5）连接字符串和字符

1）字符串可以通过加法运算符( + )相加在一起(或称“连接”)创建一个新的字符串。

2）可以通过加法赋值运算符 ( += ) 将一个字符串添加到一个已经存在字符串变量上。

3）可以用 append() 方法将一个字符附加到一个字符串变量的尾部。

注意:
 不能将一个字符串或者字符添加到一个已经存在的字符变量上，因为字符变量只能包含一个字符。

（6）字符串插值

字符串插值是一种构建新字符串的方式，可以在其中包含常量、变量、字面量和表达式。 插入的字符串字面量 的每一项都在以反斜线为前缀的圆括号中:

let multiplier = 3
let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)" 
// message 是 "3 times 2.5 is 7.5"

注意:
插值字符串中写在括号中的表达式不能包含非转义反斜杠 ( \ )，并且不能包含回车或换行符。不过，插值字符串可以包含其他字面量。

（7）计算字符数量

如果想要获得一个字符串中 Character 值的数量，可以使用字符串的 characters 属性的 count 属性:

let unusualMenagerie = "Koala ?, Snail ?, Penguin ?, Dromedary ?" 
print("unusualMenagerie has \(unusualMenagerie.characters.count) characters")
// 打印输出 "unusualMenagerie has 40 characters"

注意在 Swift 中，使用可拓展的字符群作为 Character 值来连接或改变字符串时，并不一定会更改字符串的字 符数量。

1. 可扩展的字符群 可以组成一个或者多个 Unicode 标量。
2. NSString 的length 属性是利用 UTF-16 表示的十六位代码单元数字，而不是 Unicode 可扩展的字符群集。

（8）访问和修改字符串

可以通过字符串的属性和方法来访问和修改它，也可以用下标语法完成。

1. 字符串索引

每一个 String 值都有一个关联的索引(index)类型，String.Index ，它对应着字符串中的每一个 Character 的位置。
因为不同的字符可能会占用不同数量的内存空间，所以要知道 Character 的确定位置，就必须从 String 开头遍历每一个 Unicode 标量直到结尾。因此，Swift 的字符串不能用整数(integer)做索引。
使用 StartIndex 属性可以获取一个 String 的第一个 Character 的索引。使用 endIndex 属性可以获取最后一个 Character 的后一个位置的索引。因此，endIndex 属性不能作为一个字符串的有效下标。如果 String 是空串，StartIndex 和 endIndex 是相等的。
通过调用 String 的 index(before:) 或 index(after:) 方法，可以立即得到前面或后面的一个索引。您还 可以通过调用 index(_:offsetBy:) 方法来获取对应偏移量的索引，这种方式可以避免多次调用 index(befor e:) 或 index(after:) 方法。
可以使用下标语法来访问 String 特定索引的 Character 。

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

获取越界索引对应的 Character ，将引发一个运行时错误。

greeting[greeting.endIndex] // error
 greeting.index(after: endIndex) // error

使用 characters 属性的 indices 属性会创建一个包含全部索引的范围(Range)，用来在一个字符串中访问单 个字符。

for index in greeting.characters.indices {
    print("\(greeting[index]) ", terminator: "")
}
// 打印输出 "G u t e n T a g ! "

注意:
可以使用 startIndex 和 endIndex 属性或者 index(before:) 、 index(after:) 和 index(_:offsetB y:) 方法在任意一个确认的并遵循 Collection 协议的类型里面，如上文所示是使用在 String 中，您也可 以使用在 Array 、 Dictionary 和 Set 中。

2. 插入和删除

调用 insert(_:at:) 方法可以在一个字符串的指定索引插入一个字符，调用 insert(contentsOf:at:) 方法可以在一个字符串的指定索引插入一个段字符串。

var welcome = "hello"
welcome.insert("!", at: welcome.endIndex) 
// welcome 变量现在等于 "hello!"
welcome.insert(contentsOf:" there".characters, at: welcome.index(before: welcome.endIndex))
// welcome 变量现在等于 "hello there!"

调用 remove(at:) 方法可以在一个字符串的指定索引删除一个字符，调用 removeSubrange(_:) 方法可以在一 个字符串的指定索引删除一个子字符串。

welcome.remove(at: welcome.index(before: welcome.endIndex)) 
// welcome 现在等于 "hello there"
let range = welcome.index(welcome.endIndex, offsetBy: -6)..<welcome.endIndex welcome.removeSubrange(range)
// welcome 现在等于 "hello"

注意: 可以使用 insert(_:at:) 、 insert(contentsOf:at:) 、 remove(at:) 和 removeSubrange(_:) 方法，在任意一个确认的并遵循 RangeReplaceableCollection 协议的类型里面，不仅可以使用在 String 中，也可以使用在 Array、Dictionary 和 Set 中。

（9）比较字符串

Swift 提供了三种方式来比较文本值:字符串字符相等、前缀相等和后缀相等。

1. 字符串/字符相等

字符串/字符可以用等于操作符( == )和不等于操作符( != )

let quotation = "We're a lot alike, you and I."
let sameQuotation = "We're a lot alike, you and I."
if quotation == sameQuotation {
    print("These two strings are considered equal")
}
// 打印输出 "These two strings are considered equal"

2. 前缀/后缀相等

通过调用字符串的 hasPrefix(:) / hasSuffix(:) 方法来检查字符串是否拥有特定前缀/后缀，两个方法均接收一 个 String 类型的参数，并返回一个布尔值。
下面的例子以一个字符串数组表示莎士比亚话剧《罗密欧与朱丽叶》中前两场的场景位置:

let romeoAndJuliet = [
     "Act 1 Scene 1: Verona, A public place",
     "Act 1 Scene 2: Capulet's mansion",
     "Act 1 Scene 3: A room in Capulet's mansion",
     "Act 1 Scene 4: A street outside Capulet's mansion",
     "Act 1 Scene 5: The Great Hall in Capulet's mansion",
     "Act 2 Scene 1: Outside Capulet's mansion",
     "Act 2 Scene 2: Capulet's orchard",
     "Act 2 Scene 3: Outside Friar Lawrence's cell",
     "Act 2 Scene 4: A street in Verona",
     "Act 2 Scene 5: Capulet's mansion",
     "Act 2 Scene 6: Friar Lawrence's cell"
]

可以调用 hasPrefix(_:) 方法来计算话剧中第一幕的场景数:

var act1SceneCount = 0
 for scene in romeoAndJuliet {
     if scene.hasPrefix("Act 1 ") {
         act1SceneCount += 1
} }
print("There are \(act1SceneCount) scenes in Act 1")
// 打印输出 "There are 5 scenes in Act 1"

相似地，可以用 hasSuffix(_:) 方法来计算发生在不同地方的场景数:

var mansionCount = 0
 var cellCount = 0
 for scene in romeoAndJuliet {
     if scene.hasSuffix("Capulet's mansion") {
         mansionCount += 1
     } else if scene.hasSuffix("Friar Lawrence's cell") {
         cellCount += 1
} }
print("\(mansionCount) mansion scenes; \(cellCount) cell scenes") 
// 打印输出 "6 mansion scenes; 2 cell scenes"

注意:
hasPrefix(_:) 和 hasSuffix(_:) 方法都是在每个字符串中逐字符比较其可扩展的字符群 是否标准相等