字符串字面量

你可以在代码里使用一段预定义的字符串值作为字符串字面量。字符串字面量是由一对双引号包裹着的具有固定顺序的字符集。

let someString = "Some string literal value"

多行字符串字面量

如果你需要一个字符串是跨越多行的，那就使用多行字符串字面量 —— 由一对三个双引号包裹着的具有固定顺序的文本字符集

let quotation = """
The White Rabbit put on his spectacles.  "Where shall I begin,
please your Majesty?" he asked.

"Begin at the beginning," the King said gravely, "and go on
till you come to the end; then stop."
"""

字符串字面量的特殊字符

字符串字面量可以包含以下特殊字符

• 转义字符\0(空字符)、\(反斜线)、\t(水平制表符)、\n(换行符)、\r(回车符)、"(双引号)、'(单引号)。
• Unicode 标量，写成\u{n}(u为小写)，其中n为任意一到八位十六进制数且可用的 Unicode 位码。

初始化空字符串

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

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

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

if emptyString.isEmpty {
  print("Nothing to see here")
}

字符串可变性

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

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

字符串是值类型

Swift 的String类型是值类型。 如果您创建了一个新的字符串，那么当其进行常量、变量赋值操作，或在函数/方法中传递时，会进行值拷贝,Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值。 很明显无论该值来自于哪里，都是您独自拥有的。 您可以确信传递的字符串不会被修改，除非你自己去修改它。

使用字符

您可通过for-in循环来遍历字符串，获取字符串中每一个字符的值：

    for character in "Dog!🐶" {
      print(character)
  }
  // D
  // o
  // g
  // !
  // 🐶

连接字符串和字符

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

  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!"
```
>注意：

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

字符串插值

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

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

访问和修改字符串

• 每一个String值都有一个关联的索引(index)类型，String.Index，它对应着字符串中的每一个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
  

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

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

插入和删除

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

  var welcome = "hello"
  welcome.insert("!", at: welcome.endIndex)
  // welcome 变量现在等于 "hello!"
  
  welcome.insert(contentsOf:" there", 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 中。

子字符串

当你从字符串中获取一个子字符串 —— 例如，使用下标或者 prefix(_:) 之类的方法 —— 就可以得到一个 SubString 的实例，而非另外一个 String。Swift 里的 SubString 绝大部分函数都跟 String 一样，意味着你可以使用同样的方式去操作 SubString 和 String。然而，跟 String 不同的是，你只有在短时间内需要操作字符串时，才会使用 SubString。当你需要长时间保存结果时，就把 SubString 转化为 String 的实例：

  let greeting = "Hello, world!"
  let index = greeting.index(of: ",") ?? greeting.endIndex
  let beginning = greeting[..<index]
  // beginning 的值为 "Hello"
  
  // 把结果转化为 String 以便长期存储。
  let newString = String(beginning)

比较字符串

字符串/字符相等

字符串/字符可以用等于操作符(==)和不等于操作符(!=)，详细描述在比较运算符：

  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"

前缀/后缀相等

通过调用字符串的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"
]

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

字符串的 Unicode 表示形式

for codeUnit in dogString.utf8 {
   print("\(codeUnit) ", terminator: "")
}
print("")
// 68 111 103 226 128 188 240 159 144 182

for codeUnit in dogString.utf16 {
   print("\(codeUnit) ", terminator: "")
}
print("")
// 68 111 103 8252 55357 56374

for scalar in dogString.unicodeScalars {
   print("\(scalar.value) ", terminator: "")
}
print("")
// 68 111 103 8252 128054

for scalar in dogString.unicodeScalars {
   print("\(scalar) ")
}
// D
// o
// g
// ‼
// 🐶