Swift基础（二）字符串和字符

字符串

• 字符串的本质是字符序列，由若干个字符组成。

创建字符串

// 使用字符串字面量
var stringA = "Hello, World!"
print( stringA )

// String 实例化
var stringB = String("Hello, World!")
print( stringB )

// 空字符串
var stringC = ""
// 实例化 String 类来创建空字符串
let stringD = String()

if stringC.isEmpty {
   print( "stringA 是空的" )
} else {
   print( "stringA 不是空的" )
}

多行字符串

//多行符号（"""）要占一行 
let moreLineString = """
你看看我
我是一个多行字符串
我说“我是多行字符串”
"""

// 单行多行比较
let  stringA1 = "我是单行字符串"
let  stringA2 = """
我是多行字符串
"""

字符串可变性

// 符串可变性
// stringA 可被修改
var stringA3 = "今天天气不错："
stringA3 += "晴空万里"
print( stringA3 )

// stringB 不能修改
let stringB1 = "今天天气不错："
stringB1 += "晴空万里"
print( stringB1 )

字符串插值

// 字符串插值*是一种构建新字符串的方式，可以在其中包含常量、变量、字面量和表达式。字符串字面量和多行字符串字面量都可以使用字符串插值。 
//格式 \()
let  π = 3.14159
print("我是打印的数据\(π)")

计算字符串中字符数量

//计算字符串中字符数量
let stringA4 = "hello"
print("这是\(stringA4)的count = \(stringA4.count)")

字符

使用字符

// 通过 `for-in` 循环来遍历字符串，获取字符串中每一个字符的值
for character in "Dog!🐶" {
    print(character)
}

//标明一个 `Character` 类型并用字符字面量进行赋值，可以建立一个独立的字符常量或变量
let exclamationMark: Character = "!"

//字符串可以通过传递一个值类型为 `Character` 的数组作为自变量来初始化
let catCharacters: [Character] = ["C", "a", "t", "!", "🐱"]
let catString = String(catCharacters)
print(catString)

连接字符串和字符

// 字符串可以通过加法运算符（+）相加在一起 创建一个新的字符串：
let string1 = "hello"
let string2 = " there"
var welcome = string1 + string2

//使用加法赋值运算符（+=）将一个字符串添加到一个已经存在字符串变量
var lock = "look over"
lock += string2

// 使用append() 方法将一个字符附加到一个字符串变量的尾部 字符变量只能包含一个字符
let appendString: Character = "!"
welcome.append(appendString)

//多行字符串字面量来拼接字符串
let badStart = """
one
two
"""
let end = """
three
"""
print(badStart + end)

访问和修改字符串

字符串索引

//不同的字符可能会占用不同数量的内存空间，所以Swift 的字符串不能用整数（integer）做索引。

// 使用 startIndex 属性可以获取一个 String 的第一个 Character 的索引
let hei = "hei!"
hei[hei.startIndex]
//使用 endIndex 属性可以获取最后一个 Character 的后一个位置的索引(会报错字符串索引越界)
hei[hei.endIndex]

//String 提供了 index(before:) 或 index(after:) 方法，可以立即得到前面或后面的一个索引。
hei[hei.index(before: hei.endIndex)]
hei[hei.index(after: hei.startIndex)]

// 调用 index(_:offsetBy:) 方法来获取对应偏移量的索引
let index = hei.index(hei.startIndex, offsetBy: 0)
hei[index]

插入和删除

// 插入和删除
// 调用 insert(_:at:) 方法可以在一个字符串的指定索引插入一个字符
var helloString = "hello"
helloString.insert("!", at: helloString.endIndex)

// 调用 insert(contentsOf:at:) 方法可以在一个字符串的指定索引插入一个段字符串
helloString.insert(contentsOf:" there", at: helloString.index(before: helloString.endIndex))

// 调用 remove(at:) 方法可以在一个字符串的指定索引删除一个字符
helloString.remove(at: helloString.index(before: helloString.endIndex))

// 调用 removeSubrange(_:) 方法可以在一个字符串的指定索引删除一个子字符串 ???
let range = helloString.index(helloString.endIndex, offsetBy: 0)..<helloString.endIndex
helloString.removeSubrange(range)

比较字符串

// 字符串/字符可以用等于操作符（==）和不等于操作符（!=）
let one1 = "We're a lot ali  ke, you and I."
let one2 = "We're a lot alike, you and I."
if one1 == one2 {
    print("equal")
}else{
    print("no equal")
}

// 调用字符串的 hasPrefix(_:)/hasSuffix(_:) 方法来检查字符串是否拥有特定前缀/后缀，两个方法均接收一个 String 类型的参数，并返回一个布尔值。

// hasPrefix(_:)
let stringArray = [
    "string1 one",
    "string1 one",
    "string1 one",
    "string1 one",
    "string1 one",
    "string1 one",
    "string2 two",
    "string2 two",
    "string2 two",
    "string2 two",
    "string2 two",
]

var numCount = 0
for start in stringArray {
    if start.hasPrefix("string1") {
        numCount += 1
    }
}
print("start.hasPrefix.count == \(numCount)")

// hasSuffix(_:)
var oneCount = 0
var twoCount = 0
for string in stringArray {
    if string.hasSuffix("one") {
        oneCount += 1
    } else if string.hasSuffix("two") {
        twoCount += 1
    }
}
print("string.hasSuffix.oneCount == \(oneCount) == string.hasSuffix.twoCount == \(twoCount)")