字符串和字符

[TOC]

字符串是例如 "hello, world" ， "albatross" 这样的有序的 Character （字符）类型的值的集合。通过 String 类型来表示。一个 String 的内容可以用许多方式读取，包括作为一个 Character 值的集合。

Swift的 String 和 Character 类型提供了快速和兼容Unicode的方式供你的代码使用。创建和操作字符串的语法与C语言中字符串操作相似，轻量并且易读。字符串的连接操作只需要简单地通过 + 符号将两个字符串相连即可。与Swift中其他值一样，能否更改字符串的值，取决于其被定义为常量还是变量。你也可以在字符串内插过程中使用字符串插入常量、变量、字面量表达成更长的字符串，这样可以很容易的创建自定义的字符串，进行展示、存储以及打印。

尽管语法简易，但 String 类型是一种快速、现代化的字符串实现。每一个字符串DOI是由编码无关的 Unicode 字符组成，并支持访问字符的多种Unicode表示形式。

注意：Swift的 String 类型与Foundation的 NSString 类进行了无缝桥接。Foundation也可以对 String 进行扩展，暴露在 NSString 中定义的方法。这意味着，如果你在 String 中调用这些 NSString 的方法，将不用进行转换。

字符串字面量

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

字符串字面量可以用于为常量和变量提供初始值：

let someString = "Some string literal value"

注意 someString 常量通过字符串字面量进行初始化，Swift会推断该常量为 String 类型。

多行字符串字面量

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

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."
"""

一个多行字符串字面量包含了所有的在开启和关闭引号（ """ ）中的行。这个字符从开启引号（ """ ）之后第一行开始，到关闭引号（ """ ）之前为止。这就意味着字符串开启引号之后（ """ ）或者结束引号（ """ ）之前都没有换行符号。

下面两个字符串其实是一样的，虽然第二个使用了多行字符串的形式：

let singleLineString = "These are the same."
let multilineString = """
These are the same.
"""

如果你的代码之中，多行字符串字面量包含换行符的话，则多行字符串字面量中也会包含换行符。如果你想换行，以便加强代码的可读性，但是你又不想在你的多行字符串字面量中出现换行符的话，你可以用在行尾写一个反斜杠（ \ ）作为续航符。

let softWrappedQuotation = """
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."
"""

为了让一个多行字符串字面量开始和结束于换行符，请将换行写在第一行和最后一行，例如：

let lineBreaks = """

This string starts with a line break.
It also ends with a line break.

"""

一个多行字符串字面量能够缩进来匹配周围的代码。关闭引号（ """ ） 之前的空白字符串告诉Swift编译器其他各行多少字符串需要忽略。然而，如果你在某行的前面写的空白字符串超出了关闭引号（ """ ） 之前的空白字符串，则超出部分将被包含在多行字符串字面量中。

let linesWithIndentation = """
    This line doesn't begin whith whitespace.
        this line begins with four space.
    this line doesn't begin with whitespace.
    """

从上面的例子中，尽管整个多行字符串字面量都是缩进的，第一行和最后一行没有以空白字符开始。中间一行的缩进用空白字符串比关闭引号（ """ ）之前的空白字符多，所以，它的行首将有4个空格。

字符串字面量的特殊字符

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

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

下面的代码为各种特殊字符的使用示例。 wiseWords 常量包含了两个双引号。 dollarSign 、blackHeart 和 sparklingHeart 常量演示了三种不同格式的Unicode标量：

let wiseWords = "\"Imagination is more important than knowledge\" - Einstein"   
//  "Imagination is more important than knowledge" - Einstein
let dollarSign = "\u{24}" 
// $，Unicode 标量 U+0024
let blackHeart = "\u{2665}"
// ♥，Unicode 标量 U+2665
let sparklingHeart = "\u{1F496}"      
// 💖，Unicode 标量 U+1F496

由于多行字符串字面量使用了三个双引号，而不是一个，所以你可以在多行字符串字面量里直接使用双引号（ " ）而不必加上转义符（ \ ）。要在多行字符串字面量中使用 """ 的话，就需要使用至少一个转义符（ \ ）:

let threeDoubleQuotes = """
Escaping the first quote \"""
Escaping all three quotes \"\"\"
"""

初始化空字符串

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

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

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

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

字符串可变性

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

var variableString = "Horse"
variableString += " and carriage"
// variableString 现为 Horse and carriage

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

注意：在Objective-C和Cocoa中，你需要通过选择两个不同的类 NSSrting 和 NSMutableString 来指定字符串是否可以被修改。

字符串是值类型

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

Swift默认字符串拷贝的方式保证了在函数/方法中传递的字符串的值。很明显无论值来自哪里，都是你独自拥有的。你可以确信传递的字符串不会被修改，除非你自己去修改它。

在实际编译时，Swift编译器会优化字符串的使用，使实际的复制只发生在绝对必要的情况下，这意味着你将字符串作为值类型的同时可以获得极高的性能。

使用字符

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

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

另外，通过标明一个 Character 类型并用字符字面量赋值，可以建立一个独立的字符常量或变量：

let exclamationMark: Character = "!"

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

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

连接字符串和字符

字符串可以通过加法运算符（ + ）相加在一起，创建一个新的字符串：

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

你也可以通过加法赋值运算符（ += ）将一个字符串加到一个已经存在的字符串变量上：

var instruction = "look over"
instruction += string2
// instruction 现在等于 "look over three"

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

let exclamationMark: Character = "!"
welcome.append(exclamationMark)
// welcome 现在等于 "hello three!"

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

如果你需要使用多行字符串字面量来拼接字符串，并且你需要字符串每一行都以换行符结尾，包括最后一行：

let badStart = """
one
two
"""
let end = """
three
"""
print(badStart + end)
// 输出
// one
// twothree

let goodStart = """
one
two

"""
print(goodStatr + end) 
// 输出
// one
// two
// three

上面的代码，把 badStart 和 end 拼接起来的字符串非我们想要的结果。因为 badStart 最后一行没有换行符，它与 end 的第一行结合到了一起。相反的，goodStart 的每一行都以换行符结尾，所以它与 end 拼接的字符串总共有三行，正如我们期望的那样。

字符串插值

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

let multiplier = 3
let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
// message 现在等于 "3 times 2.5 is 7.5"

在上面的例子中，multiplier作为\(multiplier)被插入到一个字符串常量量中。 当创建字符串执行插值计算时此占位符会被替换为multiplier实际的值。

multiplier的值也作为字符串中后面表达式的一部分。 该表达式计算Double(multiplier) * 2.5的值并将结果 (7.5) 插入到字符串中。 在这个例子中，表达式写为\(Double(multiplier) * 2.5)并包含在字符串字面量中。

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

计算字符数量

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

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

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

例如，如果你用四个字符的单词 cafe 初始化一个新的字符串，然后添加一个 ``COMBINING ACTUE ACCENT（U+0301）作为字符串的结尾。最终这个字符串的字符数量仍然是4，因为第四个字符是é，而不是e` ：

var word = "cafe"
print("the number of characters in \(word) is \(word.count)")
// 打印输出 "the number of characters in cafe is 4"

word += "\u{301}"    // 拼接一个重音，U+0301

print("the number of characters in \(word) is \(word.count)")
// 打印输出 "the number of characters in café is 4"

注意： 可扩展的字符群集可以组成一个或者多个 Unicode 标量。这意味着不同的字符以及相同字符的不同表示方式可能需要不同数量的内存空间来存储。所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间数量。因此在没有获取字符串的可扩展的字符群的范围时候，就不能计算出字符串的字符数量。如果您正在处理一个长字符串，需要注意 count 属性必须遍历全部的 Unicode 标量，来确定字符串的字符数量。

另外需要注意的是通过 count 属性返回的字符数量并不总是与包含相同字符的 NSString 的 length 属性相同。 NSString 的 length 属性是利用 UTF-16 表示的十六位代码单元数字，而不是 Unicode 可扩展的字符群集。

访问和修改字符串

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

字符串索引

每一个 String 值都有一个关联的索引类型：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(before:) 或 index(after:) 方法。

你可以使用下标语法来访问 String 特定索引的 Character 。

let greeting = "Guten Tag!"
greeting[greeting.startIndex] // G
greeting[gerrting.index(before: greeting.endIndex)] // !
greeting[gerrtinf.index(after: greeting.startIndex)] // u
let index = greeting.index(greeting.startIndex, offsetBy: 7)
greeting[index] // a

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

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

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

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

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

插入和删除

调用 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 、Doctionary 和 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)

就像 String ，每一个 SubString 都会在内存里保存字符集。而 String 和 SubStrig 的区别在于性能优化上， SubString 可以重复原 String 的内存空间，或者另一个 SubString 的内存空间（ String 也有同样的优化，但如果两个 String 共享内存的话，它们就会相等）。这一优化意味着你在修改 String 和 SubString 之前都不需要消耗性能去复制内存。就像前面说的那样， SubString 不适合长期存储 - - 因为它重用了原 String 的内存空间，原 String 的内存空间必须保留直到它的 SubString 不再被使用为止。

上面的例子，greeting 是一个 String ，意味着它在内存里有一片空间保存字符集。而由于 beginning 是 greeting 的 SubString ，它重用了 greeting 的内存空间。相反，newString 是一个 String - - 它是使用 SubString 创建的，拥有一片自己的内存空间。下面的图展示了他们之间的关系：

图片

比较字符串

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

字符串/字符相等

字符串/字符相等可以用等于操作符（==）和不等于操作符（!=）：

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"

如果两个字符串（或者两个字符）的可扩展字形群集是标准相等的，那就认为它们是相等的。在这个情况下，即使可扩展的字形群集是由不同的Unicode标量构成，只要它们有同样的语言意义和外观，就认为它们标准相等。

例如，LATIN SMALL LETTER E WITH ACUTE(U+00E9)就是标准相等于LATIN SMALL LETTER E(U+0065)后面加上COMBINING ACUTE ACCENT(U+0301)。这两个字符群集都是表示字符é的有效方式，所以它们被认为是标准相等的：

// "Voulez-vous un café?" 使用 LATIN SMALL LETTER E WITH ACUTE
let eAcuteQuestion = "Voulez-vous un caf\u{E9}?"

// "Voulez-vous un café?" 使用 LATIN SMALL LETTER E and COMBINING ACUTE ACCENT
let combinedEAcuteQuestion = "Voulez-vous un caf\u{65}\u{301}?"

if eAcuteQuestion == combinedEAcuteQuestion {
    print("These two strings are considered equal")
}
// 打印输出 "These two strings are considered equal"

相反，英语中的LATIN CAPITAL LETTER A(U+0041，或者A)不等于俄语中的CYRILLIC CAPITAL LETTER A(U+0410，或者A)。两个字符看着是一样的，但却有不同的语言意义：

let latinCapitalLetterA: Character = "\u{41}"

let cyrillicCapitalLetterA: Character = "\u{0410}"

if latinCapitalLetterA != cyrillicCapitalLetterA {
    print("These two characters are not equivalent")
}
// 打印 "These two characters are not equivalent"

前缀/后缀相等

通过调用字符串的 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 secne.hasPrefix("Act 1") {
        act1SceneCount += 1
    }
}
print("There are \(act1SceneCount) secnes 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"

字符串的 Unicode 表示形式

当一个 Unicode 字符串被写进文本文件或者其他储存时，字符串中的 Unicode 标量会用 Unicode 定义的几种编码格式（encoding forms）编码。每一个字符串中的小块编码都被称代码单元（code units）。这些包括 UTF-8 编码格式（编码字符串为8位的代码单元）， UTF-16 编码格式（编码字符串位16位的代码单元），以及 UTF-32 编码格式（编码字符串32位的代码单元）。

Swift 提供了几种不同的方式来访问字符串的 Unicode 表示形式。 您可以利用for-in来对字符串进行遍历，从而以 Unicode 可扩展的字符群集的方式访问每一个Character值。

另外，能够以其他三种 Unicode 兼容的方式访问字符串的值：

• UTF-8 代码单元集合 (利用字符串的utf8属性进行访问)
• UTF-16 代码单元集合 (利用字符串的utf16属性进行访问)
• 21位的 Unicode 标量值集合，也就是字符串的 UTF-32 编码格式 (利用字符串的unicodeScalars属性进行访问)

下面由D,o,g,‼(DOUBLE EXCLAMATION MARK, Unicode 标量 U+203C)和🐶(DOG FACE，Unicode 标量为U+1F436)组成的字符串中的每一个字符代表着一种不同的表示：

let dogString = "Dog‼🐶"

UTF-8 表示

您可以通过遍历String的utf8属性来访问它的UTF-8表示。 其为String.UTF8View类型的属性，UTF8View是无符号8位 (UInt8) 值的集合，每一个UInt8值都是一个字符的 UTF-8 表示：

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

上面的例子中，前三个10进制codeUnit值 (68, 111, 103) 代表了字符D、o和 g，它们的 UTF-8 表示与 ASCII 表示相同。 接下来的三个10进制codeUnit值 (226, 128, 188) 是DOUBLE EXCLAMATION MARK的3字节 UTF-8 表示。 最后的四个codeUnit值 (240, 159, 144, 182) 是DOG FACE的4字节 UTF-8 表示。

UTF-16 表示

您可以通过遍历String的utf16属性来访问它的UTF-16表示。 其为String.UTF16View类型的属性，UTF16View是无符号16位 (UInt16) 值的集合，每一个UInt16都是一个字符的 UTF-16 表示：

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

同样，前三个codeUnit值 (68, 111, 103) 代表了字符D、o和g，它们的 UTF-16 代码单元和 UTF-8 完全相同（因为这些 Unicode 标量表示 ASCII 字符）。

第四个codeUnit值 (8252) 是一个等于十六进制203C的的十进制值。这个代表了DOUBLE EXCLAMATION MARK字符的 Unicode 标量值U+203C。这个字符在 UTF-16 中可以用一个代码单元表示。

第五和第六个codeUnit值 (55357和56374) 是DOG FACE字符的 UTF-16 表示。 第一个值为U+D83D(十进制值为55357)，第二个值为U+DC36(十进制值为56374)。

Unicode 标量表示

您可以通过遍历String值的unicodeScalars属性来访问它的 Unicode 标量表示。 其为UnicodeScalarView类型的属性，UnicodeScalarView是UnicodeScalar类型的值的集合。 UnicodeScalar是21位的 Unicode 代码点。

每一个UnicodeScalar拥有一个value属性，可以返回对应的21位数值，用UInt32来表示：

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

前三个UnicodeScalar值(68, 111, 103)的value属性仍然代表字符D、o和g。 第四个codeUnit值(8252)仍然是一个等于十六进制203C的十进制值。这个代表了DOUBLE EXCLAMATION MARK字符的 Unicode 标量U+203C。

第五个UnicodeScalar值的value属性，128054，是一个十六进制1F436的十进制表示。其等同于DOG FACE的 Unicode 标量U+1F436。

作为查询它们的value属性的一种替代方法，每个UnicodeScalar值也可以用来构建一个新的String值，比如在字符串插值中使用：

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