字符串是例如 "hello, world" ， "albatross" 这样的有序的Character (字符)类型的值的集合。通过String 类型来表示。 一个 String 的内容可以用许多方式读取，包括作为一个 Character值的集合。
Swift 的 String 类型与FoundationNSString 类进行了无缝桥接。Foundation 也可以对String进行扩 展，暴露在 NSString 中定义的方法。 这意味着，如果你在 String 中调用这些 NSString的方法，将不用进行 转换。`

字符串字面量

字符串字面量是由双引号 ( "" ) 包裹着的具 有固定顺序的文本字符 。 字符串字面量可以用于为常量和变量提供初始值:

let someString = "Some string literal value"

注意 someString 常量通过字符串字面量进行初始化，Swift 会推断该常量为 String 类型。

初始化空字符串

要创建一个空字符串作为初始值，可以将空的字符串字面量赋值给变量，也可以初始化一个新的 String实例:

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

您可以通过检查其 Bool类型的 isEmpty 属性来判断该字符串是否为空:

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

字符串可变性

您可以通过将一个特定字符串分配给一个变量来对其进行修改，或者分配给一个常量来保证其不会被修改:

var variableString = "Horse"
variableString += " and carriage"
// variableString 现在为 "Horse and carriage"
let constantString = "Highlander"
constantString += " and another Highlander"
// 这会报告一个编译错误 (compile-time error) - 常量字符串不可以被修改。

字符串是值类型

Swift 的String类型是值类型。 如果您创建了一个新的字符串，那么当其进行常量、变量赋值操作，或在函数/ 方法中传递时，会进行值拷贝。 任何情况下，都会对已有字符串值创建新副本，并对该新副本进行传递或赋值操作,这一点和OC有很大不同。

Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值。 很明显无论该值来自于哪里，都是您 独自拥有的。 您可以确信传递的字符串不会被修改，除非你自己去修改它。

使用字符

可以通过forin 来遍历字符串

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

连接字符串和字符

字符串可以通过加法运算符( + )相加在一起(或称“连接”)创建一个新的字符串:

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

注意: 您不能将一个字符串或者字符添加到一个已经存在的字符变量上，因为字符变量只能包含一个字符。

字符串插值

字符串插值是一种构建新字符串的方式，可以在其中包含常量、变量、字面量和表达式。 您插入的字符串字面量 的每一项都在以反斜线为前缀的圆括号中:

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

在上面的例子中，multiplier 作为\(multiplier)被插入到一个字符串常量量中。 当创建字符串执行插值计算 时此占位符会被替换为 multiplier 实际的值。multiplier的值也作为字符串中后面表达式的一部分。 该表达式计算 Double(multiplier) * 2.5的值并将结果( 7.5 ) 插入到字符串中。 在这个例子中，表达式写为\(Double(multiplier) * 2.5) 并包含在字符串字面量中。

计算字符数量

如果想要获得一个字符串中 Character值的数量，可以使用字符串的 characters 属性的 count 属性:

let unusualMenagerie = "Koala ?, Snail ?, Penguin ?, Dromedary ?" 

print("unusualMenagerie has \(unusualMenagerie.characters.count) characters") 
// 打印输出 "unusualMenagerie has 40 characters"

访问和修改字符串

你可以通过字符串的属性和方法来访问和修改它，当然也可以用下标语法完成。

字符串索引
每一个 值都有一个关联的索引(index)类型，String.index ，它对应着字符串中的每一个 Character 的位置。
前面提到，不同的字符可能会占用不同数量的内存空间，所以要知道 的确定位置，就必须从 开 头遍历每一个 Unicode 标量直到结尾。因此，Swift的字符串不能用整数(integer)做索引。

使用 startIndex属性可以获取一个 String的第一个Character 的索引。使用endIndex 属性可以获取最后一个 Character的后一个位置的索引。因此，endIndex 属性不能作为一个字符串的有效下标。如果 String是空串，startIndex和 endIndex` 是相等的.

通过调用 String 的 index(before:)或 index(after:) 方法，可以立即得到前面或后面的一个索引。您还 可以通过调用 index(_:offsetBy:)方法来获取对应偏移量的索引，这种方式可以避免多次调用 index(befor e:) 或 index(after:)方法。

你可以使用下标语法来访问 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

试图获取越界索引对应的Character，将引发一个运行时错误。

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

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

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

插入和删除

调用insert(_:at:) 方法可以在一个字符串的指定索引插入一个字符，调用 insert(contentsOf:at:) 方法可 以在一个字符串的指定索引插入一个段字符串。

var welcome = "hello"
welcome.insert("!", at: welcome.endIndex) // welcome 变量现在等于 "hello!"
welcome.insert(contentsOf:" there".characters, at: welcome.index(before: welcome.endIndex)) // welcome 变量现在等于 "hello there!"

调用remove(at:) 方法可以在一个字符串的指定索引删除一个字符，调用 removeSubrange(_:)方法可以在一 个字符串的指定索引删除一个子字符串。

welcome.remove(at: welcome.index(before: welcome.endIndex)) 
// welcome 现在等于 "hello there"
let range = welcome.index(welcome.endIndex, offsetBy: -6)..<welcome.endIndex welcome.removeSubrange(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("These two strings are considered equal")
}
// 打印输出 "These two strings are considered equal"

通过调用字符串的 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"
]

var act1SceneCount = 0
 for scene in romeoAndJuliet {
     if scene.hasPrefix("Act 1 ") {
         act1SceneCount += 1
} }
print("There are \(act1SceneCount) scenes in Act 1") // 打印输出 "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")
 // 打印输出 "6 mansion scenes; 2 cell scenes"