字符串可变性(String Mutability)

可以通过将一个特定字符串分配给一个变量来对其进行修改，或者分配给一个常量来保证其不会被修改：
<pre><code> var variableString = "Horse" variableString += " and carriage" // variableString 现在为 "Horse and carriage"</code></pre>
可通过for-in循环来遍历字符串中的characters属性来获取每一个字符的值：
for character in "Dog!🐶".characters {
print(character)
}
// D
// o
// g
// !
// 🐶

字符串可以通过传递一个值类型为Character的数组作为自变量来初始化：

let catCharacters: [Character] = ["C", "a", "t", "!", "🐱"]
let catString = String(catCharacters)
print(catString)
// 打印输出："Cat!🐱"

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

let string1 = "hello"
let string2 = " there"
var welcome = string1 + string2
// welcome 现在等于 "hello there"

也可以通过加法赋值运算符 (+=) 将一个字符串添加到一个已经存在字符串变量上：
var instruction = "look over"
instruction += string2
// instruction 现在等于 "look over there"
可以用append()方法将一个字符附加到一个字符串变量的尾部：
let exclamationMark: Character = "!"
welcome.append(exclamationMark)
// welcome 现在等于 "hello there!"

字符串插值 (String Interpolation)

字符串插值是一种构建新字符串的方式，可以在其中包含常量、变量、字面量和表达式。您插入的字符串字面量的每一项都在以反斜线为前缀的圆括号中：
```
let multiplier = 3
let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
// message is "3 times 2.5 is 7.5"
```

字符串索引 (String Indices)

每一个String值都有一个关联的索引(index)类型，String.Index，它对应着字符串中的每一个Character的位置。

使用startIndex属性可以获取一个String的第一个Character的索引。使用endIndex属性可以获取最后一个Character的后一个位置的索引。因此，endIndex属性不能作为一个字符串的有效下标。如果String是空串，startIndex和endIndex是相等的。

通过调用String.Index的predecessor()方法，可以立即得到前面一个索引，调用successor()方法可以立即得到后面一个索引。任何一个String的索引都可以通过锁链作用的这些方法来获取另一个索引，也可以调用advancedBy(_:)方法来获取。但如果尝试获取出界的字符串索引，就会抛出一个运行时错误:

  let greeting = "Guten Tag!"
  greeting[greeting.startIndex]
  // G
  greeting[greeting.endIndex.predecessor()]
  // !
  greeting[greeting.startIndex.successor()]
  // u
  let index = greeting.startIndex.advancedBy(7)
  greeting[index]
  // a

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

greeting[greeting.endIndex] // error
greeting.endIndex.successor() // error

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

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

插入和删除 (Inserting and Removing)

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

var welcome = "hello"
welcome.insert("!", atIndex: welcome.endIndex)
// welcome now 现在等于 "hello!"

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

welcome.insertContentsOf(" there".characters,at:welcome.endIndex.predecessor())
// welcome 现在等于 "hello there!"

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

welcome.removeAtIndex(welcome.endIndex.predecessor())
// welcome 现在等于 "hello there"

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

let range = welcome.endIndex.advancedBy(-6)..<welcome.endIndex
welcome.removeRange(range)
// welcome 现在等于 "hello"

前缀/后缀相等 (Prefix and Suffix Equality)

通过调用字符串的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
}
}
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
} else if scene.hasSuffix("Friar Lawrence's cell") {
++cellCount
}
}
print("(mansionCount) mansion scenes; (cellCount) cell scenes")
// 打印输出 "6 mansion scenes; 2 cell scenes"
注意： hasPrefix(:)和hasSuffix(:)方法都是在每个字符串中逐字符比较其可扩展的字符群集是否标准相等.