一個字符串 是一系列字符的集合，例如hello, world和albatross。Swift的字符串是String類型。可以通過不同訪問字符串的內(nèi)容，例如作為Character值的集合。
Swift的String和Character類型提供了一個快速的，兼容Unicode的方式處理文本內(nèi)容。字符串創(chuàng)建和操作的語法是輕量級的，易讀的，同C語言的語法類似。連接兩個字符串只需要通過+運(yùn)算符便可完成，像Swift的其它類型一樣，字符串的可變性取決于它是一個常量還是一個變量。可以將常量，變量，字面量和表達(dá)式插入到一個更長的字符串中，這個過程稱為字符串插值。這使得創(chuàng)建一個自定義的字符串來進(jìn)行展示，存儲和打印變得簡單。
盡管語法簡潔，但是Swift的String類型卻是一個快速，現(xiàn)代的字符串實(shí)現(xiàn)。每一個字符都是由獨(dú)立編碼的Unicode字符組成，并且提供了以不同的Unicode表現(xiàn)形式訪問這些Unicode字符的方式。
注意
Swift的String類型與Foundation框架的NSString類進(jìn)行了橋接。Foundation框架同樣擴(kuò)展了String來暴露NSString的方法。這意味著如果你引入了Foundation框架，可以在String上直接調(diào)用NSString的方法而無需轉(zhuǎn)換。
更多關(guān)于結(jié)合Foundation和Cocoa使用String的內(nèi)容，詳見Using Swift with Cocoa and Objective-C (Swift 3.0.1)的Working with Cocoa Data Types。
目錄
- 字符串字面量
- 初始化一個空字符串
- 字符串可變性
- 字符串是值類型
- 使用字符
- 連接字符串和字符
- 字符串插值
- Unicode
- 字符統(tǒng)計
- 字符串訪問和修改
- 字符串比較
- 字符串的Unicode表示
字符串字面量
可以在代碼中包括預(yù)定義的String值作為字符串字面量。一個字符串字面量是被引號("")包圍的一段固定序列的文本字符。
使用字符串字面量作為一個常量或者變量的初始值：
let someString = "Some string literal value"
注意，Swift將someString推斷為String類型，因?yàn)樗怀跏蓟癁橐粋€字符串字面量。
注意
更多關(guān)于在字符串字面量使用特殊字符的信息，詳見Special Characters in String Literals。
初始化一個空字符串
想創(chuàng)建一個空的String值變量作為創(chuàng)建一個更長的字符串的起點(diǎn)，可以賦值為一個空的字符串字面量，或者使用初始化語法初始化一個新的String實(shí)例：
var emptyString = "" // empty string literal
var anotherEmptyString = String() // initializer syntax
// these two strings are both empty, and are equivalent to each other
可以通過檢查字符串的isEmpty布爾屬性來判斷一個String的值是否為空。
if emptyString.isEmpty {
print("Nothing to see here")
}
// Prints "Nothing to see here"
字符串可變性
一個指定的字符串是否可變?nèi)Q于它被賦值為一個常量還是變量：
var variableString = "Horse"
variableString += " and carriage"
// variableString is now "Horse and carriage"
let constantString = "Highlander"
constantString += " and another Highlander"
// this reports a compile-time error - a constant string cannot be modified
注意
在OC與Cocoa中，通過選擇使用NSString或者NSMutableString來決定一個字符串是否可變，這種處理方式和Swift是不同的。
字符串是值類型
Swift的String類型是一個值類型。創(chuàng)建一個新的String值，當(dāng)它被傳遞到一個函數(shù)或者方法，或者被賦值給一個常量或則變量時，它的值是被復(fù)制的。在每種情況下，都創(chuàng)建了一個已知值的副本，然后這個副本被傳遞或者賦值，而不是原始的值。值類型會在結(jié)構(gòu)體和枚舉是值類型介紹。
String這種默認(rèn)的值拷貝行為確保了當(dāng)一個函數(shù)或者方法傳入了一個String值時，你清晰的知道你擁有這個確切的String值，而無需考慮它的來源。你可以很自信的認(rèn)為你傳入的String值不會被修改，除非你自己修改了它。
實(shí)際上，Swift的編譯器會最優(yōu)化字符串的使用，所以實(shí)際的拷貝只會發(fā)生在絕對必要時。這意味著當(dāng)把一個字符串作為值類型處理時總能獲取到最優(yōu)的性能。
使用字符
可以通過在for-in循環(huán)中遍歷一個字符串的characters屬性來獲取它的每一個Character值。
for character in "Dog!??".characters {
print(character)
}
// D
// o
// g
// !
// ??
for-in循環(huán)在for-in循環(huán)介紹
同樣的，通過為一個單字符的字符串字面量標(biāo)注一個Character型的類型注釋來創(chuàng)建一個單獨(dú)的Character常量或者變量：
let exclamationMark: Character = "!"
可以通過將一個由Character值組成的數(shù)組當(dāng)成參數(shù)傳入String的初始化方法中來構(gòu)造一個String值：
let catCharacters: [Character] = ["C", "a", "t", "!", "??"]
let catString = String(catCharacters)
print(catString)
// Prints "Cat!??"
連接字符串和字符
String值可以通過加號運(yùn)算符(+)相加來創(chuàng)建一個新的String值：
let string1 = "hello"
let string2 = " there"
var welcome = string1 + string2
// welcome now equals "hello there"
同樣可以使用加等于運(yùn)算符(+=)拼接一個String值：
var instruction = "look over"
instruction += string2
// instruction now equals "look over there"
可以通過使用String類型的append()方法拼接一個Character值：
let exclamationMark: Character = "!"
welcome.append(exclamationMark)
// welcome now equals "hello there!"
注意
不能向一個Character變量拼接String或者Character，因?yàn)橐粋€Character值只能包含一個字符。
字符串插值
字符串插值 是一種通過將常量，變量，字面量和表達(dá)式的值混合包含進(jìn)一個字符串字面量來構(gòu)建一個新的String值的方式。每一個插入到字符串字面量的元素都被包裝進(jìn)前綴為一個反斜杠的一對圓括號中：
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)的形式被插入到字符串字面量中。當(dāng)使用字符串插值創(chuàng)建一個實(shí)際的字符時，此占位符會被替換為multiplier實(shí)際的值。
multiplier的值稍后也會作為這個字符串中一個更大的表達(dá)式的一部分。這個表達(dá)式計算Double(multiplier) * 2.5的值并將結(jié)果(7.5)插入這個字符串。此例中，這個表達(dá)式被寫成\(Double(multiplier) * 2.5)包含進(jìn)這個字符串字面量中。
注意
一個插值字符串中，圓括號內(nèi)的表達(dá)式不能包含非轉(zhuǎn)義的反斜杠(\\)，回車或者換行。但是可以包含其它字符串字面量。
Unicode
Unicode 是一個在不同文字系統(tǒng)下用于文本的編碼，表示和處理的國際標(biāo)準(zhǔn)。它以一種標(biāo)準(zhǔn)的形式允許你幾乎可以描述任何語言的任何字符，并且可以對文本文件或者網(wǎng)頁這樣的外部數(shù)據(jù)源進(jìn)行讀寫操作。Swift的String和Character類型是完全兼容Unicode的。
Unicode標(biāo)量
實(shí)際上，Swift的String類型是基于Unicode標(biāo)量 值建立的。一個Unicode標(biāo)量是一個字符或者標(biāo)識符唯一的21位數(shù)字，例如U+0061代表小寫的拉丁字母a，U+1F425代表小雞表情??。
注意
一個Unicode標(biāo)量是范圍U+0000到U+D7FF或者U+E000到U+10FFFF的任何碼位。Unicode標(biāo)量不包含范圍為U+D800到U+DFFF的Unicode代理項(xiàng)碼位。
注意并不是所有的21位Unicode碼位都分配給了字符--一些標(biāo)量是留作未來分配的。分配給字符的標(biāo)量通常都有一個名字，例如例子中的小寫拉丁字母a和小雞符號??。
字符串字面量的特殊字符
字符串字面量可以包含以下特殊字符
- 轉(zhuǎn)義特殊字符
\0(空字符)，\\\\(反斜線)，\t(制表符)，\n(換行符)，\r(回車符)，\"(雙引號)，\'(單引號) - 一個任意的寫成
\u{n}的Unicode標(biāo)量，n是一個1-8位的16進(jìn)制數(shù)，它等于一個合法的Unicode碼位。
以下四個例子的代碼展示了這些特殊字符。wiseWords常量包含兩個轉(zhuǎn)義的雙引號字符，dollarSign，blackHeart和sparklingHeart常量展示了Unicode標(biāo)量格式：
let wiseWords = "\"Imagination is more important than knowledge\" - Einstein"
// "Imagination is more important than knowledge" - Einstein
let dollarSign = "\u{24}" // $, Unicode scalar U+0024
let blackHeart = "\u{2665}" // ?, Unicode scalar U+2665
let sparklingHeart = "\u{1F496}" // ??, Unicode scalar U+1F496
可擴(kuò)展的字符簇
每一個Swift的Character類型實(shí)例都代表了一個單獨(dú)的可擴(kuò)展的字符簇。一個可擴(kuò)展的字符簇是一個由一個或多個Unicode標(biāo)量組成的序列，這些標(biāo)量提供了人類可以讀懂的字符。
舉個例子，字母é可以被表示為單獨(dú)的Unicode標(biāo)量é(二聲的小寫拉丁字母e)。但是它同樣也可以被表示為一對標(biāo)量--一個標(biāo)準(zhǔn)的字母e(小寫的拉丁字母e或者U+0065)和一個二聲標(biāo)量(U+0301)。這個二聲標(biāo)量形象的應(yīng)用在了它前面的標(biāo)量，當(dāng)一個可識別Unicode的文本渲染系統(tǒng)渲染它的時候，將e轉(zhuǎn)化為了é。
下面的兩個例子中，字母é被表示為一個單獨(dú)的SwiftCharacter值，這個值代表了一個可擴(kuò)展的字符簇。第一個例子中，這個簇包含了一個單獨(dú)的標(biāo)量；第二個例子中，包含了兩個標(biāo)量：
let eAcute: Character = "\u{E9}" // é
let combinedEAcute: Character = "\u{65}\u{301}" // e followed by ?
// eAcute is é, combinedEAcute is é
可擴(kuò)展的字符簇可以靈活地將許多復(fù)雜的腳本字符表現(xiàn)為一個單獨(dú)的Character值。例如，韓語字母表的韓語音節(jié)既可以表示為組合的也可以表示為分解的序列。這些表現(xiàn)方式在Swift中都代表了一個單獨(dú)的Character值：
let precomposed: Character = "\u{D55C}" // ?
let decomposed: Character = "\u{1112}\u{1161}\u{11AB}" // ?, ?, ?
// precomposed is ?, decomposed is ?
可擴(kuò)展的字符簇可以使用包圍標(biāo)記(例如COMBINING ENCLOSING CIRCLE或者U+20DD)將其它Unicode標(biāo)量包圍起來作為一個單獨(dú)的Character值的一部分：
let enclosedEAcute: Character = "\u{E9}\u{20DD}"
// enclosedEAcute is é?
代表區(qū)域指示符號的Unicode標(biāo)量可以組合成一對來表示一個單獨(dú)的Character值，例如REGIONAL INDICATOR SYMBOL LETTER U(U+1F1FA)和REGIONAL INDICATOR SYMBOL LETTER S(U+1F1F8)的組合：
let regionalIndicatorForUS: Character = "\u{1F1FA}\u{1F1F8}"
// regionalIndicatorForUS is ????
字符統(tǒng)計
如果想要獲取一個字符串中Character值的數(shù)量，使用字符串的Character屬性的count屬性：
let unusualMenagerie = "Koala ??, Snail ??, Penguin ??, Dromedary ??"
print("unusualMenagerie has \(unusualMenagerie.characters.count) characters")
// Prints "unusualMenagerie has 40 characters"
注意在Swift中，使用可擴(kuò)展的字符簇作為Character值意味著字符串的連接或者修改并不一定會影響字符串的字符數(shù)量。
例如，如果使用四個字符長度的單詞cafe初始化一個新的字符串，然后在尾部拼接一個COMBINING ACUTE ACCENT (U+0301)，結(jié)果仍然是含有4個字符，第四個字符是é而不是e：
var word = "cafe"
print("the number of characters in \(word) is \(word.characters.count)")
// Prints "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)")
// Prints "the number of characters in café is 4"
注意
可擴(kuò)展的字符簇可以由多個Unicode標(biāo)量構(gòu)成。這意味著不同的字符以及相同字符的不同表示方式可以請求不同的存儲空間。因此Swift的字符在一個字符串中并不一定占據(jù)相同的存儲空間。所以在沒有遍歷整個字符串確定它的可擴(kuò)展的字符簇邊界時是不能計算字符的數(shù)量的。如果處理一個特別長的字符值，需要注意Character屬性必須遍歷整個字符串的所有Unicode標(biāo)量才能確定字符的數(shù)量。
通過Character屬性返回的字符數(shù)量并不總是和包含相同字符的通過NSString的length屬性返回的長度相同。NSString的長度是基于字符串在UTF-16表示方式下16位碼元的數(shù)量而不是Unicode可擴(kuò)展字符簇的數(shù)量。
訪問和修改字符串
可以通過方法，屬性或者下標(biāo)語法訪問和修改一個字符串。
字符串索引
每一個String值都有一個關(guān)聯(lián)的索引類型 (String.Index)，它與字符的位置一一對應(yīng)。
前面提到，不同的字符可以請求不同的存儲空間，所以為了確定一個指定位置的Character，必須從String的頭部或者尾部遍歷每個Unicode標(biāo)量。因此，Swift的字符串不能被整型值索引。
使用startIndex屬性訪問一個String的首個Character。endIndex屬性是String中的最后一個值之后的位置。因此endIndex屬性屬性不是一個字符串下標(biāo)的合法值。如果一個String為空，startIndex和endIndex相同。
使用String的index(before:)和index(after:)方法訪問一個給定索引的前一個或后一個索引。使用index(_:offsetBy:)訪問一個距離給定索引較遠(yuǎn)的索引，而不是多次調(diào)用另外兩個方法。
使用下標(biāo)語法訪問一個指定的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
試圖訪問一個字符串范圍之外的索引或者索引對應(yīng)的Character會觸發(fā)運(yùn)行時錯誤。
greeting[greeting.endIndex] // Error
greeting.index(after: greeting.endIndex) // Error
使用Character屬性的indices屬性訪問字符串中字符的所有索引。
for index in greeting.characters.indices {
print("\(greeting[index]) ", terminator: "")
}
// Prints "G u t e n T a g ! "
注意
可以在任何遵循Collection協(xié)議的類型上使用startIndex和endIndex屬性，index(before:)，index(after:)和index(_:offsetBy:)方法。這些類型包括在這介紹的String，也包括集合類型如Array，Dictionary，Set。
插入和刪除
使用insert(_:at:)方法在字符串的指定位置插入一個單獨(dú)的字符，使用insert(contentsOf:at:)方法在字符串的指定位置插入另一個字符串的內(nèi)容。
var welcome = "hello"
welcome.insert("!", at: welcome.endIndex)
// welcome now equals "hello!"
welcome.insert(contentsOf: " there".characters, at: welcome.index(before: welcome.endIndex))
// welcome now equals "hello there!"
使用remove(at:)方法在字符串的指定位置刪除一個單獨(dú)的字符，使用removeSubrange(_:)方法在字符串的指定范圍刪除一個子串：
welcome.remove(at: welcome.index(before: welcome.endIndex))
// welcome now equals "hello there"
let range = welcome.index(welcome.endIndex, offsetBy: -6)..<welcome.endIndex
welcome.removeSubrange(range)
// welcome now equals "hello"
注意
可以在任何遵循RangeReplaceableCollection協(xié)議的類型上使用insert(_:at:)，insert(contentsOf:at:)，remove(at:)，removeSubrange(_:)方法。這些類型包括在這介紹的String，也包括集合類型如Array，Dictionary，Set。
比較字符串
Swift提供了三種方式比較文本值：字符串和字符相等，前綴相等，后綴相等。
字符串和字符相等
使用等于運(yùn)算符(==)和不等于運(yùn)算符(!=)檢查字符串和字符的等同性：
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")
}
// Prints "These two strings are considered equal"
如果兩個String值或者兩個Character值的可擴(kuò)展的字符簇是相等的那么它們兩個就認(rèn)為是相等的。如果可擴(kuò)展的字符簇有同樣的語義和外觀就認(rèn)為它們是相等的，即使它們實(shí)際上是由不同的Unicode標(biāo)量構(gòu)成。
例如，LATIN SMALL LETTER E WITH ACUTE(U+00E9)等于LATIN SMALL LETTER E(U+0065)加上COMBINING ACUTE ACCENT(U+0301)。這些可擴(kuò)展的字符簇都是合法的方式代表字符é，所以它們被認(rèn)為是相等的。
// "Voulez-vous un café?" using LATIN SMALL LETTER E WITH ACUTE
let eAcuteQuestion = "Voulez-vous un caf\u{E9}?"
// "Voulez-vous un café?" using 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")
}
// Prints "These two strings are considered equal"
相反的，英語中使用的LATIN CAPITAL LETTER A(U+0041或者A)與俄語中的CYRILLIC CAPITAL LETTER A(U+0410或者А)是不相等的。這兩個字符只是視覺上相似，但沒有相同的語義：
let latinCapitalLetterA: Character = "\u{41}"
let cyrillicCapitalLetterA: Character = "\u{0410}"
if latinCapitalLetterA != cyrillicCapitalLetterA {
print("These two characters are not equivalent.")
}
// Prints "These two characters are not equivalent."
注意
Swift的字符串和字符比較并不區(qū)分地域。
前綴和后綴相等
使用字符串的hasPrefix(_:)和hasSuffix(_:)方法檢測一個字符串是有有一個指定的字符前綴或者后綴，這兩個方法都使用一個單獨(dú)的String類型參數(shù)并返回一個布爾值。
下面的例子使用一個字符串?dāng)?shù)組表示莎士比亞的戲劇<<羅密歐與朱麗葉>>前兩場的場地：
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"
]
可以對romeoAndJuliet數(shù)組使用hasPrefix(_:)方法計算這部劇第一場的場景數(shù)量：
var act1SceneCount = 0
for scene in romeoAndJuliet {
if scene.hasPrefix("Act 1 ") {
act1SceneCount += 1
}
}
print("There are \(act1SceneCount) scenes in Act 1")
// Prints "There are 5 scenes in Act 1"
同樣的，使用hasSuffix(_:)方法計算發(fā)生在Capulet’s mansion或Friar Lawrence’s cell附近的場景的數(shù)量：
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")
// Prints "6 mansion scenes; 2 cell scenes"
注意
hasPrefix(_:)和hasSuffix(_:)方法在每個字符串的可擴(kuò)展字符簇之間執(zhí)行逐字符的等同性比較，詳見字符和字符串。
字符串的Unicode表示
當(dāng)向一個文本文件或者一些其它儲存器寫入一個Unicode字符串時，字符串的Unicode標(biāo)量會使用Unicode定義的幾種編碼格式編碼。每種格式都會將字符串編碼進(jìn)小的塊，也就是碼元。這些包括UTF-8編碼格式(將字符串編碼成8位的碼元)，UTF-16編碼格式(將字符串編碼成16位的碼元)，UTF-32編碼格式(將字符串編碼成32位的碼元)。
Swift提供了幾種不同的方式訪問字符串的Unicode表現(xiàn)形式。可以使用for-in聲明遍歷字符串來以可擴(kuò)展的字符簇的形式訪問它的每個Character值。詳見使用字符串。
同樣可以以另外三種Unicode兼容的表現(xiàn)形式訪問一個String值：
- UTF-8碼源的集合(通過
utf8屬性訪問) - UTF-16碼源的集合(通過
utf16屬性訪問) - 21位Unicode標(biāo)量值的集合，等于字符串的UTF-32編碼格式(通過
unicodeScalars屬性訪問)
下面的字符串由字符D，o，g，?(DOUBLE EXCLAMATION MARK，或者Unicode標(biāo)量U+203C)和??字符(DOG FACE或者Unicode標(biāo)量U+1F436)構(gòu)成，下面的例子展示了這個字符串的不同表現(xiàn)方式：
let dogString = "Dog???"
UTF-8表現(xiàn)方式
可以通過遍歷字符串的utf8屬性來訪問一個字符串的UTF-8形式。這個屬性是String.UTF8View類型的，這個類型是一個無符號8位值(UInt8)的集合，它的每個字節(jié)都是UTF-8的表現(xiàn)方式：
for codeUnit in dogString.utf8 {
print("\(codeUnit) ", terminator: "")
}
print("")
// Prints "68 111 103 226 128 188 240 159 144 182 "
上例中，前3個十進(jìn)制codeUnit值(68, 111, 103)代表了字符D，o和g，這些字符的UTF-8形式和它們的ASCII形式是一樣的。接下來的3個十進(jìn)制codeUnit值(226, 128, 188)是字符DOUBLE EXCLAMATION MARK的三位UTF-8形式。最后的的4個十進(jìn)制codeUnit值(240, 159, 144, 182)是字符DOG FACE的四位UTF-8形式。
UTF-16表現(xiàn)方式
可以通過遍歷字符串的utf16屬性來訪問一個字符串的UTF-16形式。這個屬性是String.UTF16View類型的，這個類型是一個無符號16位值(UInt16)的集合，它的每個字節(jié)都是UTF-16的表現(xiàn)方式：
for codeUnit in dogString.utf16 {
print("\(codeUnit) ", terminator: "")
}
print("")
// Prints "68 111 103 8252 55357 56374 "
同樣的，前3個codeUnit值(68, 111, 103)代表了字符D，o和g，這些字符的UTF-16碼元和它們的UTF-8形式有同樣的值(因?yàn)檫@些Unicode標(biāo)量代表ASCII字符)。
第四個codeUnit值(8252)是一個等同于16進(jìn)制值203C的十進(jìn)制值，它代表了字符DOUBLE EXCLAMATION MARK的Unicode標(biāo)量U+203C。這個字符可以被表示成一個單獨(dú)的UTF-16碼元。
第五和第六個codeUnit值 (55357和56374) 是字符DOG FACE的 UTF-16 表示。這些值為U+D83D(十進(jìn)制值為55357)的高代理值，和U+DC36(十進(jìn)制值為56374)的低代理值。
Unicode標(biāo)量表示
可以通過遍歷字符串的unicodeScalars屬性來訪問字符串的Unicode標(biāo)量形式。這個屬性是UnicodeScalarView類型的，這個類型是一個UnicodeScalar類型值的集合。
每個unicodeScalars有一個value屬性返回這個標(biāo)量的21位值，用UInt32表示：
for scalar in dogString.unicodeScalars {
print("\(scalar.value) ", terminator: "")
}
print("")
// Prints "68 111 103 8252 128054 "
前三個UnicodeScalar值(68，111，103)的value屬性仍然代表字符D、o和g。
第四個codeUnit值(8252)仍然是一個等于十六進(jìn)制203C的十進(jìn)制值。它代表了DOUBLE EXCLAMATION MARK字符的Unicode標(biāo)量U+203C。
第五個UnicodeScalar值的value屬性，128054，是一個十六進(jìn)制1F436的十進(jìn)制表示。其等同于DOG FACE的Unicode標(biāo)量U+1F436。
作為查詢它們的value屬性的一種替代方法，每個UnicodeScalar值也可以用來構(gòu)建一個新的String值，例如字符串插值：
for scalar in dogString.unicodeScalars {
print("\(scalar) ")
}
// D
// o
// g
// ?
// ??
上一篇：Swift-基礎(chǔ)運(yùn)算符
下一篇：Swift-集合類型
