今天，我们将研究Swift String操作。
此外，我们将在Swift 4的介绍中讨论Strings的更改。

Swift 字符串

Swift中的String是" Character"类型的值的有序集合。

与数组类似，用var定义的字符串是可变的，而用let关键字定义的字符串是不可变的。

Swift 4的变化：现在字符串符合集合协议。
因此，字符串就是集合。
适用于集合的诸如reversed()，indexOf()等方法现在也可以直接与Swift字符串一起使用，而无需使用字符。

Swift String初始化

在Swift中有很多初始化字符串的方法。

//initializing an empty string
var empty = ""            //Empty String
var anotherEmpty = String()       //Another way to initialize an empty string

var str = "Hello, playground" //String literal
var intToString = String(10) //returns "10", this can be used to convert any type to string
var boolToString = String(false) //returns "false"

//initialise a string using repeating values.
let char = "a"
let string = String(repeating: char, count: 5) //prints "aaaaa"
let newChar = "ab"
let newString = String(repeating: newChar, count: 5) //prints : "ababababab"

字符串文字是由双引号(")括起来的一系列字符。

Swift String空字符串检查

要检查字符串是否为空，我们调用函数" isEmpty"，如下所示。

var empty = ""
var boolToString = String(false) //returns "false"

if empty.isEmpty
{
 print("string is empty")
}

if !boolToString.isEmpty
{
 print("string is not empty")
}

附加字符串

可以使用append()函数或者+ =运算符将字符串和字符附加到字符串上，如下所示。

var myString =  "Hello"
myString += " World" //returns "Hello World"
myString.append("!") //returns "Hello World!"
print(myString) //prints "Hello World!\n"

字符串插值

字符串插值是一种通过混合使用常量和变量来构造新的String值的方法。
插入字符串文字中的每个项目都用一对括号括起来，并以反斜杠()为前缀，如下所示：

let multiplier = 2
let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)" //prints "2 times 2.5 is 5.0"

遍历字符串

使用" for-in"循环以下列方式遍历String以获取Swift 3中的每个字符：

//using characters property
for character in myString.characters
{
 print(character)
}

//using indices property.
for character in myString.characters.indices
{
 print(myString[character])
}
//using enumerated() func
for (index,character) in myString.characters.enumerated()
{
 print(character)
}
//prints:
H
e
l
l
o
 
W
o
r
l
d
!

enumerated()：返回一个对对(n，x)的序列，其中n代表一个从零开始的连续整数，x代表该序列的一个元素。

Swift 4中的更改：在Swift 4中不推荐使用characters。

快速检索字符4。

for character in myString {
  print(character)
}

快速字符串长度

字符串的长度按以下方式获取。

let myString = "Too many characters here!"
print(myString.characters.count) //prints 25

连续的属性，例如characters和count被用来获取字符串的长度。

在Swift 4中：要获取Swift String的长度，我们只需要调用myString.count。

多行字符串文字

在Swift 4中，以下是使用三引号定义多行字符串文字的方法：

let multiLineString = """
Line 1
Line 2 goes here
Line 3 goes here
"""

Swift 4编译器默认在每行末尾添加新行。
为了防止这种默认行为，我们需要使用反斜杠()。

let multiLineString = """
Line 1
Line 2 goes here, \
Line 3 goes here
"""
print(multiLineString)
//Prints
//Line 1
//Line 2 goes here, Line 3 goes here

字符串比较

Swift String没有其他语言一样的"等于"方法。
它使用==和！=检查值

var stringA = "string"
var stringB = "string"
var stringC = "new string"
stringA == stringB //prints true
stringB != stringC //prints true

Swift中字符串的重要功能

Swift提供了许多强大的功能，可用于对String执行操作。
这些功能的最好之处在于它们具有很高的可读性。

转换为大写和小写

var myString = "Hello World!"
myString.lowercased() returns "hello world!"
myString.uppercased() //returns "HELLO WORLD!"

前缀和后缀

myString.hasPrefix("Hello") //returns true
myString.hasPrefix("hello") //returns false
myString.hasSuffix("!") //returns true

//Alternative approach
String(myString.characters.prefix(2)) //returns "He"
String(myString.characters.suffix(3)) //returns "ld!"

'prefix(maxLength)和'suffix(maxLength)返回一个子字符串，该子字符串根据输入的数字分别具有前n个和后n个字符。

字符串开始和结束索引

var myString = "Hello World!"
myString.startIndex //returns 0
myString.endIndex //returns 12

从字符串中插入和删除字符

myString.insert("!", at: myString.endIndex) //"Hello World!!"
myString.insert("!", at: myString.startIndex) //"!Hello World!!"
myString.remove(at: myString.startIndex) //returns "!"
print(myString) //"Hello World!!\n"

注意：at：期望使用String.Index类型的参数。
诠释将不起作用(Atleast在Swift 3中不适用)

插入多个字符/子字符串

myString.insert(contentsOf: "Hey".characters, at: myString.endIndex) //returns "Hello World!Hey"

检索其他索引

var myString = "Hello World!"
let startIndexPlusTwo = myString.index(myString.startIndex, offsetBy: 2)
let endIndexMinusFour = myString.index(myString.endIndex, offsetBy: -4)
myString[startIndexPlusTwo] //returns "l"
myString[endIndexMinusFour] //returns "r"
myString[myString.index(before: startIndexPlusTwo)] //returns "e"
myString[myString.index(after: startIndexPlusTwo)] //returns "l"

startIndexPlusTwo和endIndexMinusFour的类型为String.Index。
myString []内部只能接受String.Index类型。
不是Int。

字符索引

var myString = "Hello World!"
myString.characters.index(of: "o") //returns 4
myString.characters.index(of: "f") //returns nil

index(of :)返回第一个匹配字符的索引

Swift String子字符串

我们可以按如下方式检索索引之间的子字符串。

var myString = "Hello World!"
let startIndexPlusTwo = myString.index(myString.startIndex, offsetBy: 2) 
let endIndexMinusFour = myString.index(myString.endIndex, offsetBy: -4)
myString[startIndexPlusTwo..<myString.endIndex] //returns "llo World!"
myString[myString.startIndex..<startIndexPlusTwo] //returns "He"

//Alternate approach
myString.substring(to: startIndexPlusTwo) //returns "He"
myString.substring(from: startIndexPlusTwo) //returns "llo World!"
myString.substring(with: startIndexPlusTwo..<endIndexMinusFour) //"llo Wo"
var mySubString = String(myString.characters.suffix(from: startIndexPlusTwo)) //returns "llo World!"

substring(to :)将子字符串从startIndex返回到索引集。
substring(from :)返回从索引集到结束索引的子字符串。
substring(with :)返回输入的索引范围之间的子字符串。

搜索子字符串

使用子函数range(of :)搜索子字符串。
此函数返回一个可选类型，该类型是Range？类型的索引范围，因此我们需要将其解包才能使用该范围。

if let myRange = myString.range(of: "Hello"){
myString[myRange] //returns "Hello"
}
else{
 print("No such substring exists")
}
//In case when the substring doesn't exist
if let myRange = myString.range(of: "Hlo"){
myString[myRange]
}
else{
 print("No such substring exists") //this is printed
}

从Swift字符串中替换/删除子字符串

函数replaceSubrange和removeSubrange用于替换字符串中的子字符串，如下所示。

var myString = "Hello World!"
//replacing
if let myRange = myString.range(of: "Hello"){
myString.replaceSubrange(myRange, with: "Bye") //returns "Bye World!"
}
else{
 print("No such substring exists")
}

//removing
if let myRange = myString.range(of: "Hello "){
myString.removeSubrange(myRange) //returns "World!"
}
else{
 print("No such substring exists")
}

Swift String分割

为了分割字符串，我们使用函数components(separatedBy：)。
该函数需要一个字符或者字符串类型的参数，如下所示：

var myString = "Hello How You Doing ?"
var stringArray = myString.components(separatedBy: " ") //returns ["Hello", "How", "You", "Doing", "?"]
for string in stringArray
{
  print(string)
}
//prints:
Hello
How
You
Doing
?

Swift 4中的变化：Swift 4与String一起也将Substring作为类型。

子串作为一种类型

作为字符串的子序列的子字符串现在也是一种类型。
因此，当我们在Swift 4中分割字符串时，我们得到一个Substring类型的数组。
每个元素都是Substring类型，如下所示。

var myString = "Hello How You Doing ?"
var substrings = myString.split(separator: " ")
type(of: substrings) //Array<Substring>.Type
type(of: substrings.first!) //Substring.Type
var newStringFromSub = String(substrings.first!) //"Hello"

注意：type是一个函数，它返回传递的参数的类型。