Swift 3.png

• 1 .字符串字面量 String

在Swift中字符串字面量是由双引号" " 包裹着的

let someString = "Some string literal value"

像我们在 Swift 3 学习 01 中讲述的那样，Swift 会推断该常量为String类型

• 2 .初始化空字符串
• • 2.1 初始化

创建一个空字符串的两种方式

//（1）可以将空的字符串字面量赋值给变量
var emptyString = "" // empty string literal
//（2）初始化一个新的String实例
var anotherEmptyString = String() // initializer syntax
// these two strings are both empty, and are equivalent to each other

• • 2.2 判断空字符串

用isEmpty 属性来判断该字符串是否为空,返回值为 Bool

var emptyString = ""
if emptyString.isEmpty {
print("Nothing to see here")
}
// Prints "Nothing to see here"

• 3 .字符串可变性

在 Objective-C 中，需要通过选择两个不同的类(NSString和NSMutableString)来指定字符串是否可以被修改。而在Swift中用 let 声明常量来保证其不会被修改，用 var声明变量来对其进行修改。

//可变的字符串
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

3.0.png

• 4 .字符串是值类型

Swift 的 String 类型是值类型。 如果创建了一个新的字符串，那么当其进行常量、变量赋值操作，或在函数/方法中传递时，会进行值拷贝。
这样做的好处是，你可以确信传递的字符串不会被修改，除非你自己去修改它。
在 Objective-C 中,你可能面临着值被 '别人' 修改的风险，比如下面的 a .你并没有去直接修改ta.

NSString * a;
NSMutableString * b = [@"111111" mutableCopy];
 a = b;
 [b appendString:@"222222"];
 NSLog(@"a = %@",a); //a = 111111222222

在Swift中，无论怎样都不会将你的 a 修改 ，除非你直接对 a 进行修改。

var a : String;
var b = "111111"
a = b;
b = b.appending("222222");
print("a = \\(a)\\n")          //输出的 a = 111111

• 5 . 使用字符 Character
• • 5.1 获取字符串的字符

通过for-in循环来遍历字符串中的characters属性来获取每一个字符的值.

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

• • 5.2 声明一个字符

通过Character 关键字声明一个字符

let exclamationMark2: Character = "!"

必须要用Character声明才能得到一个字符，否则会被Swift推断为String类型。

5.2.png

• • 5.3 用字符数组初始化一个字符串

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

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

• 6 .连接字符串和字符 + 、 +=、append()

你可以不追加String或Character到现有的Character变量，因为一个Character值必须只包含一个字符。

• • 6.1 +

字符串可以通过加法运算符（+）相加在一起（或称“连接”）创建一个新的字符串,在前面的文章提及过。

let string1 = "hello"
let string2 = " there"
var welcome = string1 + string2
// welcome now equals "hello there"

• • 6.2 +=

可以通过加法赋值运算符 (+=) 将一个字符串添加到一个已经存在字符串变量上

var instruction = "look over"
instruction += string2
// instruction now equals "look over there

• • 6.3 append()

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

let exclamationMark: Character = "!"
welcome.append(exclamationMark)
// welcome now equals "hello there!"

• 7 .字符串插值 \\(a)

Swift提供便利的方式在字符串中插入一些值。a可以是常量、变量、字面量和表达式。 插入的字符串字面量的每一项都在以反斜线为前缀的圆括号中 即 \\(a)

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

在上述代码中 \\(multiplier) 做为整体插入到字符串中，在系统读取时会将对应的值插入该位置。

• 8 .Unicode

Unicode 是一个国际标准，用于文本的编码和表示。Swift 的String和Character类型是完全兼容 Unicode 标准的。

• • 8.1 Unicode 标量

Swift 的String类型是基于 Unicode 标量 建立的。 Unicode 标量是对应字符或者修饰符的唯一的21位数字，例如U+0061表示小写的拉丁字母("a")，U+1F425表示小鸡表情("")。
Unicode 码位的范围是U+0000到U+D7FF或者U+E000到U+10FFFF。Unicode 标量不包括 Unicode 代理项(surrogate pair) 码位，其码位范围是U+D800到U+DFFF。

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

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

• 9 .计算字符数量 count

使用字符串的 characters 属性的 count 属性获取字符数量。

let unusualMenagerie = "Koala , Snail , Penguin , Dromedary "  //只占一个字符。
print("unusualMenagerie has \\(unusualMenagerie.characters.count) characters")
// Prints "unusualMenagerie has 40 characters"

• 10 .可扩展的字形群集

每一个 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转换成了é。
简单而言 e (U+0065) + U+0301 --> é(U+00E9)，eAcute和combinedEAcute等价

let eAcute: Character = "\\u{E9}" // é
let combinedEAcute: Character = "\\u{65}\\u{301}" // e followed by ́
// eAcute is é, combinedEAcute is é

再比如在韩文中，下面的precomposed和decomposed等价

let precomposed: Character = "\\u{D55C}" // 한
let decomposed: Character = "\\u{1112}\\u{1161}\\u{11AB}" // ᄒ, ᅡ, ᆫ
// precomposed is 한, decomposed is 한

再比如地域性指示符号的 Unicode 标量可以组合成一个单一的Character值

let regionalIndicatorForUS: Character = "\\u{1F1FA}\\u{1F1F8}"
// regionalIndicatorForUS is 

• 11 .计算字符数量 count

通过characters属性count属性获取字符数量， Swift 中的字符在一个字符串中并不一定占用相同的内存空间数量。另外需要注意的是通过characters属性返回的字符数量并不总是与包含相同字符的NSString的length属性相同。NSString的length属性是利用 UTF-16 表示的十六位代码单元数字，而不是 Unicode 可扩展的字符群集。当一个Swift的String值 被NSString的length属性访问时，字符数量和字符串长度是不一样的。

let unusualMenagerie = "Koala , Snail , Penguin , Dromedary "
print("unusualMenagerie has \\(unusualMenagerie.characters.count) characters")   
// Prints "unusualMenagerie has 40 characters"
//下面的代码作为字符串算长度
var  str : NSString;
str = unusualMenagerie as NSString ;
print("str.length = \\(str.length)");    //str.length = 44

• 12 . 字符串索引

每一个String值都有一个关联的索引(index)类型，String.Index，它对应着字符串中的每一个Character的位置。
前面提到，不同的字符可能会占用不同数量的内存空间，所以要知道Character的确定位置，就必须从String开头遍历每一个 Unicode 标量直到结尾。因为整数(integer)是内存空间的概念，不同的字符可能会占用不同数量的内存空间，Swift 的字符串不能用整数(integer)做索引。
使用startIndex属性可以获取一个String的第一个Character的索引。使用endIndex属性可以获取最后一个Character的后一个位置的索引。因此，endIndex属性不能作为一个字符串的有效下标。如果String是空串，startIndex和endIndex是相等的。
通过调用 String 的 index(before:) 或 index(after:)方法，可以立即得到前面或后面的一个索引。您还可以通过调用index(_:offsetBy:)方法来获取对应偏移量的索引，这种方式可以避免多次调用index(before:) 或 index(after:) 方法。

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

试图获取越界索引对应的 Character，将引发一个运行时错误
fatal error: Can't form a Character from an empty String

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

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

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

• 13 .插入

调用insert(_:atIndex:)方法可以在一个字符串的指定索引插入一个字符，调用 insert(contentsOf:at:) 方法可以在一个字符串的指定索引插入一段字符串。（用在遵循Collection协议的类型）

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

• 14 .删除

调用 remove(at:) 方法可以在一个字符串的指定索引删除一个字符，调用 removeSubrange(_:) 方法可以在一个字符串的指定索引删除一个子字符串。（用在遵循RangeReplaceableCollection协议的类型）

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"

• 15 .比较字符串

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

• • 15.1 字符串/字符相等

字符串/字符可以用等于操作符(==)和不等于操作符(!=)

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"

如果两个字符串（或者两个字符）的可扩展的字形群集是标准相等的，那就认为它们是相等的。在这个情况下，即使可扩展的字形群集是有不同的 Unicode 标量构成的，只要它们有同样的语言意义和外观，就认为它们标准相等。
像上面提到的 e (U+0065) + U+0301 --> é(U+00E9)
这两个字符群集都是表示字符é的有效方式，所以它们被认为是标准相等。

// "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，或者A)。两个字符看着是一样的，但却有不同的语言意义：

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

• • 15.2 前缀/后缀相等

通过调用字符串的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(_:),如下统计由Act 1开头的字符串

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(_:),如下统计由Capulet's mansion结尾的字符串

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"

• 16 .字符串的 Unicode 表示形式

UTF-8 : 通过遍历String的utf8属性来访问它的UTF-8表示
UTF-16 : 通过遍历String的utf16属性来访问它的UTF-16表示

UTF-32: 遍历String值的unicodeScalars属性来访问它的 Unicode 标量表示

let dogString = "Dog"
//UTF-8
for codeUnit in dogString.utf8 {
print("\\(codeUnit) ", terminator: "")
}
print("")
//UTF-16
for codeUnit in dogString.utf16 {
print("\\(codeUnit) ", terminator: "")
}
print("")
//UTF-32
for scalar in dogString.unicodeScalars {
print("\\(scalar.value) ", terminator: "")
}
print("")

Character | UTF-8 Code Unit | UTF-16 Code Unit |UTF-32 Code Unit |Position
----|------|----|----|----|---
D(U+0044) | 68|68|68|0
o(U+006F )| 111|111|111|1
g(U+0067)| 103|103|103|2

还是直接上图吧，官方图哈哈

UTF8_2x.png

UTF16_2x.png

UnicodeScalar_2x.png

以上只是一些简单的概念说(fan)明(yi)，如有错误请指正，谢谢。Swift 3 学习 ，后续会不断更新。
如果你觉得我的文章对你有帮助请点喜欢哦，也可以关注我，每周至少一篇技术更新。
或者关注 我的专题 每周至少5篇高质量文章收录，多谢支持。

一起学习，一起进步