Swift Learning (5) - Strings and Characters (Fully Ver.)

let someString = "Some string literal value"  // 字符串字面量初始化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 til you come to the end; then stop."
    """
print(quotation)
---
output: 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 til you come to the end; then stop."

let singleLineString = "These are the same."
let multiLineString = """
These are the same.
"""
print("单行字符串：\(singleLineString)")
print("多行字符串：\(multiLineString)")
---
output: 单行字符串：These are the same.
多行字符串：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."
"""
print("使用了换行符的quotation：\(softWrappedQuotation)")
---
output: 使用了换行符的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 lineBreaks = """

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

"""
print(lineBreaks)
---
output: 
This string starts with a line break.
It also ends with a line break.

let linesWithIndentation = """
    This line doesn't begin with whitespace.
        This line begins with four spaces.
    This line doesn't begin with whitespace.
    """  // 关闭引号前的空白字符串有4个空格
print(linesWithIndentation)
---
output: This line doesn't begin with whitespace.
    This line begins with four spaces.
This line doesn't begin with whitespace.

let wiseWords = "\"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
print(wiseWords)
print(dollarSign, terminator: " ")
print(blackHeart, terminator: " ")
print(sparklingHeart)
---
output: "Imagination is more important than knowledge." - Einstein
$ ♥ 💖

let threeDoubleQuotes = """
    Escaping the first quote \"""
    Escaping all three quotes \"\"\"
    """
print(threeDoubleQuotes)
---
output: Escaping the first quote """
Escaping all three quotes """

let threeMoreDoubleQuotationMarks = #"""
Here are three more double quotes: """
Good! Good!
"""#
print(threeMoreDoubleQuotationMarks)
---
output: Here are three more double quotes: """
Good! Good!

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

if emptyString.isEmpty {
    print("Nothing to see here.")  // 打印输出“Nothing to see here.”
}
---
output: Nothing to see here.

var variableString = "Horse"
variableString += " and carriage"  // variableString现在为“Horse and carriage”
print(variableString)

let constantString = "Highlander"
//constantString += " and another Hignlander"  // 若取消这行注释，编译器会报错：Left side of mutating operator isn't mutable: 'constantString' is a 'let' constant
print(constantString)
---
output: Horse and carriage
Highlander

for character in "Dog!🐶" {
    print(character)
}
// 另外，通过标明一个`Character`类型并用字符字面量进行赋值，可以建立一个独立的字符常量或变量。
let exclamationMark: Character = "!"
// 字符串可以通过传递一个值类型为`Character`的数组作为自变量来初始化。
let catCharacters: [Character] = ["c", "a", "t", "!", "🐱"]
let catString = String(catCharacters)
print(catString)  // 打印"cat!🐱"
---
output: D
o
g
!
🐶
cat!🐱

let string1 = "hello"
let string2 = " jensen"
var welcome = string1 + string2  // welcome现在等于“hello jensen”
print(welcome)
---
output: hello jensen

var instruction = "look over"
instruction += string2  // instruction现在等于“look over jensen”
print(instruction)
---
output: look over jensen

let questionMark: Character = "?"
welcome.append(questionMark)  // welcome现在等于“hello jensen?”
print(welcome)
---
output: hello jensen?

let badStart = """
    one
    two
    """
let end = """
    three
    """
print(badStart + end)  // 打印两行：one\ntwothree

let goodStart = """
    one
    two
    
    """
print(goodStart + end)  // 打印三行：one\ntwo\nthree
---
output: one
twothree
one
two
three

let multiplier = 3
let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"  // message是“3 times 2.5 is 7.5”
print(message)
---
output: 3 times 2.5 is 7.5

print(#"Write an interpolated string in Swift using \(multiplier)."#)  // 打印“Write an interpolated string in Swift using \(multiplier).”
---
output: Write an interpolated string in Swift using \(multiplier).

print(#"6 times 7 is \#(6 * 7)"#)  // 打印“6 times 7 is 42”
---
output: 6 times 7 is 42

let eAcute: Character = "\u{E9}"  // é 代表一个单一的Swift的Character值，同时代表了一个可扩展的字形群，该字形群包含一个单一的标量
let combinedEAcute = "\u{65}\u{301}"  // é 代表一个可扩展的字形群，该字形群包含两个标量
print("eAcute is \(eAcute) and combinedEAcute is \(combinedEAcute)")
---
output: eAcute is é and combinedEAcute is é

let precomposed: Character = "\u{D55C}"  // 한
let decomposed: Character = "\u{1112}\u{1161}\u{11AB}"  // ᄒ, ᅡ, ᆫ
print("precomposed的值是\(precomposed)，decomposed的值是\(decomposed)")
---
output: precomposed的值是한，decomposed的值是한

let enclosedEAcute: Character = "\u{E9}\u{20DD}"  // enclosedEAcute是é⃝
print(enclosedEAcute)
---
output: é⃝

let regionalIndicatorForHK: Character = "\u{1F1ED}\u{1F1F0}"  //HK
print(regionalIndicatorForHK)  //  regionalIndicatorForHK是🇭🇰
---
output: 🇭🇰

let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐫"
print("unusualMenagerie has \(unusualMenagerie.count) characters.")  // 打印输出“unusualMenagerie has 40 characters.”
---
output: unusualMenagerie has 40 characters.

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

word += "\u{301}"
print("The number of characters in \(word) is \(word.count).")  // 打印输出”The number of characters in café is 4.“
---
output: The number of characters in cafe is 4.
The number of characters in café is 4.

let greeting = "Jensen Jon!"
print("greeting's first character is \(greeting[greeting.startIndex]).")  // J
print("The character before greeting's endIndex is \(greeting[greeting.index(before: greeting.endIndex)])")  // !
print("The character after greeting's startIndex is \(greeting[greeting.index(after: greeting.startIndex)])")  // e
print("The character with a offset of 7 from greeting's startIndex is \(greeting[greeting.index(greeting.startIndex, offsetBy: 7)])")  // J
---
output: greeting's first character is J.
The character before greeting's endIndex is !
The character after greeting's startIndex is e
The character with a offset of 7 from greeting's startIndex is J

//greeting[greeting.endIndex]  // 若取消注释，运行时系统会报错：Fatal error: String index is out of bounds
//greeting.index(after: greeting.endIndex)  // 若取消注释，运行时系统会报错：Fatal error: String index is out of bounds

for index in greeting.indices {
    print("\(greeting[index])", terminator: " ")  // 打印输出“J e n s e n   J o n !”
}
print("")
---
output: J e n s e n   J o n ! 

var friendlyGreeting = "hello"
friendlyGreeting.insert("!", at: friendlyGreeting.endIndex)  // friendlyGreeting变量现在等于“hello!”

friendlyGreeting.insert(contentsOf: " there", at: friendlyGreeting.index(before: friendlyGreeting.endIndex))  // friendlyGreeting变量现在等于“hello there!”

friendlyGreeting.remove(at: friendlyGreeting.index(before: friendlyGreeting.endIndex))  // friendlyGreeting变量现在等于“hello there”

let range = friendlyGreeting.index(friendlyGreeting.endIndex, offsetBy: -6)..<friendlyGreeting.endIndex
friendlyGreeting.removeSubrange(range)  // friendlyGreeting变量现在等于“hello”
print(friendlyGreeting)
---
output: hello

let niceGreeting = "Hello, Jensen!"
let index = niceGreeting.firstIndex(of: ",") ?? niceGreeting.endIndex
let beginning = greeting[..<index]  // beginning的值是“Hello”
// 把结果转化为String以便长期存储。
let newString = String(beginning)
print("newString is \(newString).")
---
output: newString is Jense.

let aQuotation = "We're a lot alike, you and I."
let sameQuotation = "We're a lot alike, you and I."
if aQuotation == sameQuotation {
    print("These two strings are considered equal.")  // 打印输出“These two strings are considered equal.”
}
---
output: These two strings are considered equal.

let eAcuteQuestion = "Voluez-vous un caf\u{E9}?"
let combinedEAcuteQuestion = "Voluez-vous un caf\u{65}\u{301}?"

if eAcuteQuestion == combinedEAcuteQuestion {
    print("These two strings are considered equal.")  // 打印输出“These two strings are considered equal.”
}
---
output: These two strings are considered equal.

let latinCapitialLetterA: Character = "\u{41}"
let cyrillicCapitalLetterA: Character = "\u{410}"

if latinCapitialLetterA != cyrillicCapitalLetterA {
    print("These two characters are not equivalent.")  // 打印输出“These two characters are not equivalent.”
}
---
output: These two characters are not equivalent.

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.")
---
output: There are 5 scenes in Act 1.

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")
---
output: 6 mansion scenes; 2 cell scenes

let dogString = "Dog‼🐶"

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

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

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

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