Swift 字符串和字符(笔记)

print("Hello, World!")

/**********************字符串和字符*************************/

// 1, NSString是多个Characters 的集合

// 2, 字符串字面量(String Literals)

let someString = "Some string literal value"

// 3, 初始化空字符串

var emptyString = "" // 空字符串字面量

var anotherEmptyString = String() // 正常的初始化方法

// 两个字符串均为空并等价

if emptyString.isEmpty {

    print("\(emptyString) is empty")

}

// 打印结果 is empty

// 4, 字符串的可变性

var variableString = "Home"

variableString = "hourse"

print(variableString)

// 5, 字符串是值类型 (Strings Are Value Types)

// 也就是说,字符串在函数/方法传递中是拷贝一份过去,所以可以确保值在传递的时候不变

// 6, 使用字符

for character in "Dog".characters {

    print(character)

}

// 打印结果 D o g

// 直接声明一个 character

let exclamationMark:Character = "!"

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

let catCharacter:[Character] = ["C","a","t"]

let catString = String(catCharacter)

print(catString)

// 打印输出为 Cat

// 7, 连接字符串和字符

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

let string1 = "hello"

let string2 = " world"

var welecome = string1 + string2

print(welecome)

// 打印结果是 hello world

// 可以用 += 拼接在一个已有可变字符串的后面

var string3 = "fuck"

string3 += string2

print(string3)

// 可以用 .append()方法将字符附加到一个字符串变量的后面

// 只能用字符

let char:Character = "!"

welecome.append(char)

print(welecome)

// 打印结果  hello world!

// 8, 字符串插值( Srring Interpolation)

let multiplier = 3

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

print(message)

// 结果是 3 times 2.5 is 7.5

// 插值字符串中写在括号内的表达式不能包含非转业反斜杠(\),并且不能包含回车或换行符

// 差值字符串可以包含其他字面量

/*************************9, 标量 Unicode**********************/

// Unicode 是一个国际标准,用于文本的编辑和表示,它使您可以用标准格式表示出来自几乎所有的字符,并能够对文本文件和网页这样的外部资源中的字符进行读写操作

// String和 Charater 类型是完美兼容Unicode的

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

print(eAcute)

// 朝鲜语,可以根据语调组合

let precomposed:Character = "\u{D55C}"

print(precomposed)

// 可以组合

let decomposed:Character = "\u{1112}\u{1161}\u{11AB}"

print(decomposed)

// 包含记号

let enclosedEAcute:Character = "\u{E9}\u{20DD}"

print(enclosedEAcute)

// 局部指示符号的标量可以组合成单一的 character 值

let regionallndicatorForUS:Character = "\u{1F1FA}\u{1F1F8}"

print(regionallndicatorForUS) // 美国国旗

// 10, 计算字符数量

// 字符串, characters.count 属性

let unusualMenageris = "Koala,snail,Penguin,Dromedary"

print("unusualMenagerie has \(unusualMenageris.characters.count) characters")

// 打印输出结果unusualMenagerie has 29 characters

// swift 中,使用可扩展的字符串集做为 Character 值来连接或改变字符串时.并不一定会更改字符串的字符数量

// eg

var word = "cate"

print("the number of characters in \(word) is \(word.characters.count)")

// count 是 4

word += "\u{301}" // COMBINING ACUTE ACCENT, U+0301

print("the number of characters in \(word) is \(word.characters.count)")

// count 还是 4

// 它是把 e 换成了 é

// 下面这段话有待理解

// “注意： 可扩展的字符群集可以组成一个或者多个 Unicode 标量。这意味着不同的字符以及相同字符的不同表示方式可能需要不同数量的内存空间来存储。所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间数量。因此在没有获取字符串的可扩展的字符群的范围时候，就不能计算出字符串的字符数量。如果您正在处理一个长字符串，需要注“意characters属性必须遍历全部的 Unicode 标量，来确定字符串的字符数量。

// 另外需要注意的是通过characters属性返回的字符数量并不总是与包含相同字符的NSString的length属性相同。NSString的length属性是利用 UTF-16 表示的十六位代码单元数字，而不是 Unicode 可扩展的字符群集。作为佐证，当一个NSString的length属性被一个Swift的String值访问时，实际上是调用了utf16Count。

/********************* 11, 访问和修改字符串 **********************/

// 同过字符串的属性和方法来访问,或者用下标

let string11  = "I love my wife"

// 不同的字符串占用不同的内存空间,所以要知道 character 的确切位置,就必须从 string 开头遍历出没有个标量直到结尾

// 所以 swift 不能用整数(integer)做索引

// startIndex 获取 String 的第一个 character 的索引!是索引,不是 character

// endIndex 获取 String 的最后一个 character 的索引

// string.index 的 predecessor() 方法,可以得到前面的一个索引

// string.index 的 successor() 方法,可以得到后面一个索引

let character1 = string11.endIndex

print(character1)

// 任何一个 String 的索引可以通过锁链作用的这些方法获取另一个索引

// 调用 advancedBy(_:)方法 // 初始值往后推到这个方法给的个数

let greeting = "Guten tag!"

var character2 = greeting[greeting.startIndex]

print(character2) // G

character2 = greeting[greeting.endIndex.predecessor()]

print(character2) // !

character2 = greeting[greeting.startIndex.successor()]

print(character2) // u

character2 = greeting[greeting.startIndex.advancedBy(7)]

print(character2) // a

// 如果获取值越界,就会报错

// character属性的 indices 属性会创建一个包含全部索引的范围,用来在一个字符串中访问单个字符

for index in greeting.characters.indices {

    print("\(greeting[index])",terminator:"")

    if greeting[index] == greeting[greeting.endIndex.predecessor()]{

        print(terminator:"\n")

    }

}

// terminator:""作用是不换行!!!!!!!!!!!!!!!!

// 插入和删除

// 调用 insert(_:atIndex:)方法可以在一个字符串的指定索引插入一个"字符"

var welcome = "hello"

welcome.insert("!", atIndex: welcome.endIndex)

print(welcome) // hello!

// 调用 insertContentsOf(_:at:)方法可以在一个字符串的指定索引插入一个字符串

welcome.insertContentsOf("there".characters, at: welcome.endIndex.predecessor())

print(welcome) // hellorthere!

// 注意,insertContentsOf(_:at:)第一个冒号前面写要插入的字符串点上 characters

// 调用 removeAtIndex(_:)方法删除一个索引的一个字符

welcome.removeAtIndex(greeting.startIndex)

print(welcome) // ellothere!

// 调用 r

welcome.removeRange(welcome.endIndex.advancedBy(-6)..<welcome.endIndex)

print(welcome) //ello

// 比较字符串

// 字符串字符相等,前缀相等和后缀相等

// 没啥说的,上例子吧

let quotation = "We're a lot alike, you and I"

let someQuotation = "We're a lot alike, you and I"

if quotation == someQuotation {

    print("These two things are considered equal")

}

// swift 中,字符串和字符不区分区域

// 前缀和后缀比较 Prefix and Suffix

// 调用 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++

    }

}

print(act1SceneCount) // 5

var mansionCount = 0

var cellCount = 0

for scene in romeoAndJuliet {

    if scene.hasSuffix("cell") {

        cellCount++

    }

}

print(cellCount) // 2

// 字符串的 Unicode 表示形式 (不是太懂,没用过)

// 当一个 Unicode 被写进文本文件或者其他储存时,字符串中的 Unicode 标量会用 Unicode 定义的几种编码.每一个字符串中的小块编码被称为代码单元.包括 UTF8.UTF16.UTF32

let string4 = "aaa"

for everyString in string4.utf8 {

//    print("\(everyString)")

    print(everyString)

}

// Unicode 标量表示

// 可以遍历 String 值的 unicodeScalars 属性来访问他的Unicode

// unicodeScalarView是 unicodeScalar 集合