Swift学习---基础二

发现Swift和OC的基本运算符和语法相差不是很大,这里仅仅把差异和遇到的新东西做个简单汇总

1.转义特殊字符 \0 (空字符)、\(反斜线)、\t (水平制表符)、\n (换行符)、\r (回车符)、\” (双引号)、\’ (单引号)。
2.单字节 Unicode 标量,写成 \xnn,其中 nn 为两位十六进制数。
3.双字节 Unicode 标量,写成 \unnnn,其中 nnnn 为四位十六进制数。
4.四字节 Unicode 标量,写成 \Unnnnnnnn,其中 nnnnnnnn 为八位十六进制数。

> 注意:

1.不同的 Unicode 字符以及相同 Unicode 字符的不同表示方式可能需要不同数量的 内存空间来存储,所以 Swift 中的字符在一个字符串中表示并不一定占用相同的内存空 间。因此,字符串的长度不得不通过迭代字符串中每一个字符的长度来进行计算。如果 您正在处理一个长字符串,需要注意 countElements 函数必须遍历字符串中的字符,以 精准计算字符串的长度。
2.另外需要注意的是通过 countElements 返回的字符数量并不总是与包含相同字符的 NSString 的 length 属性相同。NSString 的 length 属性是基于利用 UTF-16 表示的十 六位 code units 数目,而不是基于 Unicode 字符。为了解决这个问题,NSString 的 length 属性在被 Swift 的 String 值访问时会被称为 utf16count。

可以通过加法赋值运算符(+)或 (+=) 将一个字符串

let string1 = "hello"
let string2 = " there"
let character1: Character = "!"
let character2: Character = "?"
let stringPlusCharacter = string1 + character1 // 等
于 "hello!"
let stringPlusString = string1 + string2 // 等
于 "hello there"
let characterPlusString = character1 + string1 // 等
于 "!hello"
let characterPlusCharacter = character1 + character2 // 等于 "!?"

var instruction = "look over"
instruction += string2
// instruction 现在等于 "look over there"
var welcome = "good morning" 
welcome += character1
// welcome 现在等于 "good morning!"

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

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

&计算字符数量全局函数countElements

let unusualMenagerie = "Koala ????, Snail ????, Penguin ????, Dromedar
y ????"
println("unusualMenagerie has \(countElements(unusualMenagerie)) chara
cters")
// prints "unusualMenagerie has 40 characters"

&每一个 UnicodeScalar 拥有一个值属性,可以返回对应的21位数值,用 UInt32值来表示

for scalar in dogString.unicodeScalars { 
print("\(scalar.value) ")
}
print("\n")
// 68 111 103 33 128054

&作为查询字符值属性的一种替代方法,每个 UnicodeScalar 值也可以用来构建一个新的字 符串值

for scalar in dogString.unicodeScalars { 
    println("\(scalar) ")
}
// D
// o
// g 
// !
//????

集合类型

基本概念和OC差不多不做解释,只是写成基本方法,和不同的地方
数组
使用字面量(let是常亮相当于不可变数组,var是变量,相当于可变数组)

var shoppingList: String[] = ["Eggs", "Milk"]
// shoppingList 已经被构造并且拥有两个初始项。

shoppingList 变量被声明为“字符串值类型的数组“,记作 String[]。 因为这个数组被规定只 有 String
一种数据结构,所以只有 String 类型可以在其中被存取
&由 于 Swift 的类型推断机制,当我们用字面语句构造只拥有相同类型值数组的时候,我们也可以不必把数组的类型定义清楚
基本使用

 println("The shopping list contains \(shoppingList.count) items.") 
// 打印出"The shopping list contains 2 items."(这个数组有2个项)

if shoppingList.isEmpty {
println("The shopping list is empty.")
} else {
println("The shopping list is not empty.")
}
// 打印 "The shopping list is not empty."(shoppinglist 不是空的)

// 添加新数据
shoppingList.append("Flour") //shoppingList 现在有3个数据项,有人在摊煎饼
//使用加法赋值运算符(+=)也可以直接在数组后面添加数据项
shoppingList += "Baking Powder" // shoppingList 现在有四项了
// 也可以使用加法赋值运算符(+=)直接添加拥有相同类型数据的数组
shoppingList += ["Chocolate Spread", "Cheese", "Butter"] // shoppingList 现在有7项了
// 可以直接使用下标语法来获取数组中的数据项
var firstItem = shoppingList[0]// 第一项是 "Eggs"
// 用下标来改变 个已有索引值对应的数据值:
shoppingList[0] = "Six eggs"// 其中的第一项现在是 "Six eggs" 而不是 "Eggs"
// 还可以利用下标来一次改变一系列数据值,即使新数据和原有数据的数量不一样
shoppingList[4...6] = ["Bananas", "Apples"] // shoppingList 现在有六项
*注意: 我们不能使用下标语法在数组尾部添加新项
// 插入数据可以使用(和OC一样,只是书写方式变化了,要熟悉这种写法)
shoppingList.insert("Maple Syrup", atIndex: 0)
// shoppingList 现在有7项
// "Maple Syrup" 现在是这个列表中的第一项

// 删除数据
let mapleSyrup = shoppingList.removeAtIndex(0)
//索引值为0的数据项被移除
// shoppingList 现在只有6项,而且不包括Maple Syrup
// mapleSyrup常量的值等于被移除数据项的值 "Maple Syrup"
// removeLast属性可以用来移除最后一项,从而不必再次获取下标

数组的遍历
for-in的用法和OC一样,但是这里可以使用enumerate 函数来进行数组遍历,用来获取每个数据项的值和索引值

for (index, value) in enumerate(shoppingList) {
    println("Item \(index + 1): \(value)")
}
// Item 1: Six eggs
// Item 2: Milk 
// Item 3: Flour
// Item 4: Baking Powder 
// Item 5: Bananas

创建并且构造数组

var someInts = Int[]()
println("someInts is of type Int[] with \(someInts。count) items。") 
// 打印 "someInts is of type Int[] with 0 items。"(someInts 是 0 数据项的Int[]数组)

除此之外,如果代码上下文中 供了类型信息, 例如一个函数参数或者一个已经定义好类 型的常量或者变量,我们可以使用空数组语句创建一个空数组,它的写法很简单:[](一对 空方括号)

someInts.append(3)
// someInts 现在包含一个INT值 
someInts = []
// someInts 现在是空数组,但是仍然是Int[]类型的。

Swift 中的 Array 类型还 供一个可以创建特定大小并且所有数据都被默认的构造方法。

var threeDoubles = Double[](count: 3, repeatedValue:0.0) 
// threeDoubles 是一种 Double[]数组, 等于 [0.0, 0.0, 0.0]

我们也可以使用加法操作符(+)来组合已存在的想同类型数组,新数组的数据类型会根据两个数组的数据类型推断出来

var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles 被推断为 Double[], 等于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

字典

var airports: Dictionary<String, String> = ["TYO": "Tokyo", "DUB": "Dublin"]

和数组一样,如果我们使用字面语句构造字典就不用把类型定义清楚。airports 的也可以用这种方法简短定义:

var airports = ["TYO": "Tokyo", "DUB": "Dublin"]

基本使用方法

// 通过字典的只读属性 count 来获取 个字典的数据项数量
println("The dictionary of airports contains \(airports.count) items."
)
// 打印 "The dictionary of airports contains 2 items."(这个字典有两个数据2项)

//在字典中使用下标语法添加新的数据项
airports["LHR"] = "London"// airports 字典现在有三个数据项

// 使用下标语法改变特定键值对
airports["LHR"] = "London Heathrow" // "LHR"对应的值 被改为 "London Heathrow

// updateValue(forKey:)方法在这个键不存在对应值的时候设置值或者 在存在时更新已存在的值。和上面的下标方法不一样,这个方法返回更新值之前的原值。
if let oldValue = airports.updateValue("DublinInternation", forKey: "DUB") {
    println("The old value for DUB was \(oldValue).")
}
// 打印出 "The old value for DUB was Dublin."(dub 原值是 dublin)

// 移除键值对
airports["APL"] = "Apple Internation"// "Apple Internation"不是真的 APL机场, 删除它
airports["APL"] = nil // APL现在被移除了

// removeValueForKey 方法也可以用来在字典中移除键值对.这个方法在键值对存在 的情况下会移除该键值对并且返回被移除的value 或者在没有值的情况下返回 nil:
if let removedValue = airports.removeValueForKey("DUB") {   
    println("The removed airport's name is \(removedValue).")
} else {
    println("The airports dictionary does not contain a value for DUB.
") }
// 打印 "The removed airport's name is Dublin International."(被移除的 机场名字是都 林国际)

**字典遍历**
// for-in
for (airportCode, airportName) in airports {
    prINTln("\(airportCode): \(airportName)") 
}
// TYO: Tokyo
// LHR: London Heathrow
// 也可以通过keys和values属性检索字典的键或值

// 如果我们只是需要使用 个字典的键集合或者值集合来作为 个接受 Array 实例 API 的参 数,可以直接使用 keys 或者 values 属性直接构造一个新
let airportCodes = Array(airports.keys)// airportCodes is ["TYO", "LHR"]

let airportNames = Array(airports.values)// airportNames is ["Tokyo", "London Heathrow"]

**创建空字典**
var namesOfIntegers = Dictionary<Int, String>()
// namesOfIntegers 是一个空的 Dictionary<Int, String>

//如果上下文已经 供了信息类型,我们可以使用空字典字面语句来创建一个空字典,记作[:]
namesOfIntegers[16] = "sixteen"//namesOfIntegers 现在包含一个键值对
namesOfIntegers = [:]// namesOfIntegers 又成为了一个 Int, String类型的空字典

**集合的可变性**
注意: 在我们不需要改变数组大小的时候创建不可变数组是很好的习惯。如此 Swift 编译 器可以优化我们创建的集合。