String是例如"hello, world"，"albatross"這樣的有序的Character（字符）類型的值的集合。通過String類型來表示。
一個String的內容可以用變量的方式讀取，它包括一個Character值的集合。
創建和操作字符串的語法與 C 語言中字符串操作相似，輕量并且易讀。
字符串連接操作只需要簡單地通過+符號將兩個字符串相連即可。與 Swift 中其他值一樣，能否更改字符串的值，取決于其被定義為常量還是變量。也可以在字符串內插過程中使用字符串插入常量、變量、字面量表達成更長的字符串，這樣可以很容易的創建自定義的字符串值，進行展示、存儲以及打印。
盡管語法簡易，但String類型是一種快速、現代化的字符串實現。
每一個字符串都是由編碼無關的 Unicode 字符組成，并支持訪問字符的多種 Unicode 表示形式（representations）。
注意：
Swift 的String類型與 FoundationNSString類進行了無縫橋接。就像AnyObject類型中提到的一樣，在使用 Cocoa 中的 Foundation 框架時，可以將創建的任何字符串的值轉換成NSString，并調用任意的NSStringAPI。也可以在任意要求傳入NSString實例作為參數的 API 中用String類型的值代替。
字符串字面量（String Literals）
可以在代碼中包含一段預定義的字符串值作為字符串字面量。字符串字面量是由雙引號 ("") 包裹著的具有固定順序的文本字符集。
字符串字面量可以用于為常量和變量提供初始值：
let someString = "Some string literal value"
注意someString常量通過字符串字面量進行初始化，Swift 會推斷該常量為String類型。
初始化空字符串 (Initializing an Empty String)
要創建一個空字符串作為初始值，可以將空的字符串字面量賦值給變量，也可以初始化一個新的String實例：
var emptyString = "" // 空字符串字面量
var anotherEmptyString = String() // 初始化方法
// 兩個字符串均為空并等價。
可以通過檢查其Boolean類型的isEmpty屬性來判斷該字符串是否為空：
if emptyString.isEmpty {
print("Nothing to see here")
}
// 打印輸出："Nothing to see here"
字符串可變性 (String Mutability)
可以通過將一個特定字符串分配給一個變量來對其進行修改，或者分配給一個常量來保證其不會被修改：
var variableString = "Horse"
variableString += " and carriage"
// variableString 現在為 "Horse and carriage"
let constantString = "Highlander"
constantString += " and another Highlander"
// 這會報告一個編譯錯誤 (compile-time error) - 常量字符串不可以被修改。
注意：
在 Objective-C 和 Cocoa 中，需要通過選擇兩個不同的類(NSString和NSMutableString)來指定字符串是否可以被修改。
字符串是值類型（Strings Are Value Types）
Swift 的String類型是值類型。
如果創建了一個新的字符串，那么當其進行常量、變量賦值操作，或在函數/方法中傳遞時，會進行值拷貝。
任何情況下，都會對已有字符串值創建新副本，并對該新副本進行傳遞或賦值操作。
Swift 默認字符串拷貝的方式保證了在函數/方法中傳遞的是字符串的值。
很明顯無論該值來自于哪里，都是獨自擁有的。
可以確信傳遞的字符串不會被修改，除非自己去修改它。
在實際編譯時，Swift 編譯器會優化字符串的使用，使實際的復制只發生在絕對必要的情況下，這意味著將字符串作為值類型的同時可以獲得極高的性能。
使用字符（Working with Characters）
可通過for-in循環來遍歷字符串中的characters屬性來獲取每一個字符的值：
for character in "Dog!??".characters {
print(character)
}
// D
// o
// g
// !
// ??
另外，通過標明一個Character類型并用字符字面量進行賦值，可以建立一個獨立的字符常量或變量：
let exclamationMark: Character = "!"
字符串可以通過傳入一個值類型為Character的數組作為自變量來初始化：
let catCharacters: [Character] = ["C", "a", "t", "!", "??"]
let catString = String(catCharacters)
print(catString)
// 打印輸出："Cat!??"
連接字符串和字符 (Concatenating Strings and Characters)
字符串可以通過加法運算符（+）相加在一起（或稱“連接”）創建一個新的字符串：
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"
在上面的例子中，multiplier作為\(multiplier)被插入到一個字符串常量量中。
當創建字符串執行插值計算時此占位符會被替換為multiplier實際的值。
multiplier的值也作為字符串中后面表達式的一部分。
該表達式計算Double(multiplier) * 2.5的值并將結果 (7.5) 插入到字符串中。
在這個例子中，表達式寫為\(Double(multiplier) * 2.5)并包含在字符串字面量中。
注意：
插值字符串中寫在括號中的表達式不能包含非轉義反斜杠 (\\)，并且不能包含回車或換行符。不過，插值字符串可以包含其他字面量。
Unicode
Unicode 是一個國際標準，用于文本的編碼和表示。
可以用標準格式表示來自任意語言幾乎所有的字符，并能夠對文本文件或網頁這樣的外部資源中的字符進行讀寫操作。
Swift 的String和Character類型是完全兼容 Unicode 標準的。
Unicode 標量（Unicode Scalars）
Swift 的String類型是基于 Unicode 標量 建立的。
Unicode 標量是對應字符或者修飾符的唯一的21位數字，例如U+0061表示小寫的拉丁字母(LATIN SMALL LETTER A)("a")，U+1F425表示小雞表情(FRONT-FACING BABY CHICK) ("??")。
注意：
Unicode 碼位(code poing) 的范圍是U+0000到U+D7FF或者U+E000到U+10FFFF。Unicode 標量不包括 Unicode 代理項(surrogate pair) 碼位，其碼位范圍是U+D800到U+DFFF。
注意不是所有的21位 Unicode 標量都代表一個字符，因為有一些標量是留作未來分配的。已經代表一個典型字符的標量都有自己的名字，例如上面例子中的LATIN SMALL LETTER A和FRONT-FACING BABY CHICK。
字符串字面量的特殊字符 (Special Characters in String Literals)
字符串字面量可以包含以下特殊字符：
- 轉義字符
\0(空字符)、\\\\(反斜線)、\t(水平制表符)、\n(換行符)、\r(回車符)、\"(雙引號)、\'(單引號)。 - Unicode 標量，寫成
\u{n}(u為小寫)，其中n為任意一到八位十六進制數且可用的 Unicode 位碼。
下面的代碼為各種特殊字符的使用示例。
wiseWords常量包含了兩個雙引號。
dollarSign、blackHeart和sparklingHeart常量演示了三種不同格式的 Unicode 標量：
let wiseWords = "\"Imagination is more important than knowledge\" - Einstein"
// "Imageination is more important than knowledge" - Enistein
let dollarSign = "\u{24}" // $, Unicode 標量 U+0024
let blackHeart = "\u{2665}" // ?, Unicode 標量 U+2665
let sparklingHeart = "\u{1F496}" // ??, Unicode 標量 U+1F496
可擴展的字形群集(Extended Grapheme Clusters)
每一個 Swift 的Character類型代表一個可擴展的字形群。
一個可擴展的字形群是一個或多個可生成人類可讀的字符 Unicode 標量的有序排列。
舉個例子，字母é可以用單一的 Unicode 標量é(LATIN SMALL LETTER E WITH ACUTE, 或者U+00E9)來表示。然而一個標準的字母e(LATIN SMALL LETTER E或者U+0065) 加上一個急促重音(COMBINING ACTUE ACCENT)的標量(U+0301)，這樣一對標量就表示了同樣的字母é。
這個急促重音的標量形象的將e轉換成了é。
在這兩種情況中，字母é代表了一個單一的 Swift 的Character值，同時代表了一個可擴展的字形群。
在第一種情況，這個字形群包含一個單一標量；而在第二種情況，它是包含兩個標量的字形群：
let eAcute: Character = "\u{E9}" // é
let combinedEAcute: Character = "\u{65}\u{301}" // e 后面加上 ?
// eAcute 是 é, combinedEAcute 是 é
可擴展的字符群集是一個靈活的方法，用許多復雜的腳本字符表示單一的Character值。
例如，來自朝鮮語字母表的韓語音節能表示為組合或分解的有序排列。
在 Swift 都會表示為同一個單一的Character值：
let precomposed: Character = "\u{D55C}" // ?
let decomposed: Character = "\u{1112}\u{1161}\u{11AB}" // ?, ?, ?
// precomposed 是 ?, decomposed 是 ?
可拓展的字符群集可以使包圍記號(例如COMBINING ENCLOSING CIRCLE或者U+20DD)的標量包圍其他 Unicode 標量，作為一個單一的Character值：
let enclosedEAcute: Character = "\u{E9}\u{20DD}"
// enclosedEAcute 是 é?
局部的指示符號的 Unicode 標量可以組合成一個單一的Character值，例如REGIONAL INDICATOR SYMBOL LETTER U(U+1F1FA)和REGIONAL INDICATOR SYMBOL LETTER S(U+1F1F8)：
let regionalIndicatorForUS: Character = "\u{1F1FA}\u{1F1F8}"
// regionalIndicatorForUS 是 ????
計算字符數量 (Counting Characters)
如果想要獲得一個字符串中Character值的數量，可以使用字符串的characters屬性的count屬性：
let unusualMenagerie = "Koala ??, Snail ??, Penguin ??, Dromedary ??"
print("unusualMenagerie has \(unusualMenagerie.characters.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.characters.count)")
// 打印輸出 "the number of characters in cafe is 4"
word += "\u{301}" // COMBINING ACUTE ACCENT, U+0301
print("the number of characters in \(word) is \(word.characters.count)")
// 打印輸出 "the number of characters in café is 4"
注意：
可擴展的字符群集可以組成一個或者多個 Unicode 標量。這意味著不同的字符以及相同字符的不同表示方式可能需要不同數量的內存空間來存儲。所以 Swift 中的字符在一個字符串中并不一定占用相同的內存空間數量。因此在沒有獲取字符串的可擴展的字符群的范圍時候，就不能計算出字符串的字符數量。如果正在處理一個長字符串，需要注意characters屬性必須遍歷全部的 Unicode 標量，來確定字符串的字符數量。
另外需要注意的是通過
characters屬性返回的字符數量并不總是與包含相同字符的NSString的length屬性相同。NSString的length屬性是利用 UTF-16 表示的十六位代碼單元數字，而不是 Unicode 可擴展的字符群集。作為佐證，當一個NSString的length屬性被一個Swift的String值訪問時，實際上是調用了utf16Count。
訪問和修改字符串 (Accessing and Modifying a String)
可以通字符串的屬性和方法來訪問和讀取它，當然也可以用下標語法完成。
字符串索引 (String Indices)
每一個String值都有一個關聯的索引(index)類型，String.Index，它對應著字符串中的每一個Character的位置。
前面提到，不同的字符可能會占用不同數量的內存空間，所以要知道Character的確定位置，就必須從String開頭遍歷每一個 Unicode 標量直到結尾。因此，Swift 的字符串不能用整數(integer)做索引。
使用startIndex屬性可以獲取一個String的第一個Character的索引。使用endIndex屬性可以獲取最后一個Character的后一個位置的索引。因此，endIndex屬性不能作為一個字符串的有效下標。如果String是空串，startIndex和endIndex是相等的。
通過調用String.Index的predecessor()方法，可以立即得到前面一個索引，調用successor()方法可以立即得到后面一個索引。任何一個String的索引都可以通過鎖鏈作用的這些方法來獲取另一個索引，也可以調用advancedBy(_:)方法來獲取。但如果嘗試獲取出界的字符串索引，就會拋出一個運行時錯誤。
可以使用下標語法來訪問String特定索引的Character。
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"
比較字符串 (Comparing Strings)
Swift 提供了三種方式來比較文本值：字符串字符相等、前綴相等和后綴相等。
字符串/字符相等 (String and Character Equality)
字符串/字符可以用等于操作符(==)和不等于操作符(!=)：
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"
注意：
在 Swift 中，字符串和字符并不區分區域。
前綴/后綴相等 (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(_:)方法都是在每個字符串中逐字符比較其可擴展的字符群集是否標準相等。
字符串的 Unicode 表示形式（Unicode Representations of Strings）
當一個 Unicode 字符串被寫進文本文件或者其他儲存時，字符串中的 Unicode 標量會用 Unicode 定義的幾種編碼格式編碼。每一個字符串中的小塊編碼都被稱為代碼單元。這些包括 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 表示：
<table style='text-align:center'>
<tr height="77">
<td>Character</td>
<td>D
U+0044</td>
<td>o
U+006F</td>
<td>g
U+0067</td>
<td colspan="3">?
U+203C</td>
<td colspan="4">??
U+1F436</td>
</tr>
<tr height="77">
<td height="77">UTF-8
Code Unit</td>
<td>68</td>
<td>111</td>
<td>103</td>
<td>226</td>
<td>128</td>
<td>188</td>
<td>240</td>
<td>159</td>
<td>144</td>
<td>182</td>
</tr>
<tr>
<td height="77">Position</td>
<td>0</td>
<td>1</td>
<td>2</td>
<td>3</td>
<td>4</td>
<td>5</td>
<td>6</td>
<td>7</td>
<td>8</td>
<td>9</td>
</tr>
</table>
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 表示：
<table style='text-align:center'>
<tr height="77">
<td>Character</td>
<td>D
U+0044</td>
<td>o
U+006F</td>
<td>g
U+0067</td>
<td>?
U+203C</td>
<td colspan="2">??
U+1F436</td>
</tr>
<tr height="77">
<td height="77">UTF-16
Code Unit</td>
<td>68</td>
<td>111</td>
<td>103</td>
<td>8252</td>
<td>55357</td>
<td>56374</td>
</tr>
<tr>
<td height="77">Position</td>
<td>0</td>
<td>1</td>
<td>2</td>
<td>3</td>
<td>4</td>
<td>5</td>
</tr>
</table>
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 標量表示 (Unicode Scalars Representation)
可以通過遍歷String值的unicodeScalars屬性來訪問它的 Unicode 標量表示。
其為UnicodeScalarView類型的屬性，UnicodeScalarView是UnicodeScalar的集合。
UnicodeScalar是21位的 Unicode 代碼點。
每一個UnicodeScalar擁有一個value屬性，可以返回對應的21位數值，用UInt32來表示：
<table style='text-align:center'>
<tr height="77">
<td>Character</td>
<td>D
U+0044</td>
<td>o
U+006F</td>
<td>g
U+0067</td>
<td>?
U+203C</td>
<td>??
U+1F436</td>
</tr>
<tr height="77">
<td height="77">UTF-16
Code Unit</td>
<td>68</td>
<td>111</td>
<td>103</td>
<td>8252</td>
<td>128054</td>
</tr>
<tr>
<td height="77">Position</td>
<td>0</td>
<td>1</td>
<td>2</td>
<td>3</td>
<td>4</td>
</tr>
</table>
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
// ?
// ??
