Swift 第三课时

Swift Lession 03

• 字符串和字符
  • 逐字的字符串
  • 初始化一个空串
  • 字符串的可变性
  • String 是数据类型
  • 字符工作模式
  • 串联字符串和字符
  • 字符串插入
  • Unicode
    • 纯粹的 Unicode(Unicode Scalars)
    • 特殊的字符在字符串中
    • 扩展的字形串
  • 统计字符串
  • 访问和修改字符串
    • 字符索引
    • 插入和删除字
  • 比较字符串
    • 字符串和字符相等
    • 前缀和后缀相等
  • 字符串的Unicode表现形式

字符串和字符

一个字符串是一连串的字符租车，例如：”hello, world”
Swift的字符串相当于 String 类型。

小提示

Swift 的 String 类型是 Foundation的 NSString 类的桥梁
任意的 String 类型运行在 Foundation 上时，可以调用 NSString 的可使用的API。

逐字的字符串

字符串是一连串固定的字符组成被一对双引号 ""包围。

let someString = "Some string literal value"

初始化一个空串

var emptyString = ""                // empty string literal
var anotherEmptyString = String()   // initializer syntax
// 判断一个字符串是否为空
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"
// 编译出错，let 申明的是不可变对象

String 是数据类型

在 swift 中 String 是一种数据类型，如果你创建一个String值，这个值被拷贝通过一个函数或方法，或当它被分配给一个常量或者变量，一个新的String值将会被创建，它不在是原先的String版本了。

字符工作模式

字符串可以转换成字符数组。

for character in "Dog!🐶".characters {
    print(character)
}
// 分别打印
// D  o  g  !  🐶

如果你想创建一个单独的字符，可以显示的声明。

let exclamationMark: Character = "!"

字符串可以通过初始化传递一个字符数组来创建。

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

串联字符串和字符

字符串可以被相加使用操作符+来创建一个新的字符串。

let string1 = "Hello"
let string2 = " there"
var welcome = string1 + string2
// welcome 现在是 "Hello there"

// 也可以使用 `+=`
var instruction = "look over"
instruction += string2
// instruction 现在是 "look over there"

// 可以通过 `String` 的 `append()` 方法来添加一个 `Character`
let exclamationMark: Character = "!"
welcome.append(exclamationMark)
// welocme 现在是 "Hello there!"

字符串插入

字符串插入是一种构建一个由常量，变量，字符或者表达式组合的字符串。

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

这个表达式写在圆括号内部，但是这个表达式不能包含保留的反斜杠(\)

Unicode

Unicode 是一个国际化的标准编码

纯粹的 Unicode(Unicode Scalars)

Swift 本地String类型是基于纯粹的Unicode值。

特殊的字符在字符串中

字符串能够包含以下的特殊字符：

• \0(空字符串)， \\(反斜杠), \t(横向制表符), \n(换行符), \r(回车符), \"(双引号), \'(单引号)
• 一个纯粹的 Unicode值，写作 \u{n}，在这里n是一个1到8位的16进制数字。

let wiseWords = "\"Imagination is more important than knowledge\" - Einstein"

let dollarSign = "\u{24}"          // $
let blackHeart = "\u{2665}"        // ♥
let sparklingHeart = "\u{1F496}"   // 💖

扩展的字形串

let eAcute: Character = "\u{E9}"        // é

统计字符串

从一个字符串中取得字符的总数，使用String的character属性里的count属性。

let unusnalMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪"
print("unusnalMenagerie has \(unusnalMenagerie.character.count) characters")
// unusnalMenagerie has 40 characters

访问和修改字符串

你访问和修改一个字符串通过它们自由的方法和属性，或者使用下标语法。

字符索引

每个String值都和index类型有联系。String.Index, 相当于每个字符在字符串中的位置。
使用startIndex属性去访问字符串中的第一个位置的字符。
使用endIndex属性去访问字符中的最后一个字符。
这个endIndex属性不是一个有效参数对于一个字符串小标。
如果一个字符串为空 startIndex和endIndex是相同的。

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

// 使用`characters`属性的`indices`属性创建一个`Range`
for index in greeting.characters.indices {
    print("\(greeting[index])", terminator:"")
}
// prints "G u t e n  T a g ! "

插入和删除字

插入一个字符在指定的位置，使用insert(_:atIndex:)方法。
插入一个字符串在指定的位置，使用insertContentsOf(_:at:)方法。

var welcome = "hello"
welcome.insert("!", atIndex: welcome.endIndex)
//  welcome 现在是 hello!
welcome.insertContentsOf(" there".characters, at: welcome.endIndex.predecessor())
// welcome 现在是 hello there!

删除一个指定位置的字符，使用removeAtIndex(_:)方法。
删除一个子串，使用RemoveRange(_:)方法。

welcome.removeAtIndex(welcome.endIndex.predecessor())
// welcome 现在是 hello there
let range = welcome.endIndex.advancedBy(-6) ..< welcome.endIndex
welcome.removeRange(range)
// welcome 现在是 hello

比较字符串

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("equal")
}
// equal

前缀和后缀相等

检验一个字符串的前缀和后缀，使用 hasPrefix(_:) 和 hasSuffix(_:)方法，它们都返回一个 Boolean 值。

let remeoAndJulet = [
    "Act 1 Scene 1: Verona, A public place",
    "Act 1 Scene 2: Capulet's mansion",
    "Act 1 Scene 3: A rrom in Capulet's mansion",
    "Act 1 Scene 4: A street outside Capulets 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
var mansionCount = 0
var cellCount = 0
for scene in remeoAndJuliet {
    if scene.hasPrefix("Act 1") {
        act1SceneCount += 1
    }
    if scene.hasSuffix("Capulet's mansion") {
        mansionCount += 1
    }
    if scene.hasSuffix("Friar Lawrence's cell") {
        cellCount += 1
    }
}
print("There are \(act1SceneCount) scenes in Act 1")
// print  "There are 5 scenes in Act 1"
print("\(mansionCount) mansion scenes; \(cellCount) cell scenes")
// print  "6 mansion scenes; 2 cell scenes"

字符串的Unicode表现形式

一般有三种Unicode表现形式。

• 一批UTF-8字符集。
• 一批UTF-16字符集。
• 一批UTF-32字符集。

let dogString = "Dog!!🐶"
// utf8
for codeUnit in dogString.utf8 {
    print("\(codeUnit) ", terminator: "")
}
// 68 111 103 33 33 240 159 144 182 

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

// utf32 又称 unicodeScalars
for scalar in dogString.unicodeScalars {
    print("\(scalar.value) ", terminator: "")
}
// 68 111 103 8252 128054 
// utf32 又称 unicodeScalars
for scalar in dogString.unicodeScalars {
    print("\(scalar) ", terminator: "")
}
// D o g !! 🐶