Swift学习备忘录

1、常量的定义

常量定义使用let关键字，可以采用下面两种方式之一：

1）标准方式初始化

    let CPU_NUM: Int = 2

2) 对于确切的值，可以使用类型推断，如 let CPU_NUM = 2

常量一般在定义时即初始化，为了简洁一般采用上面第2）种方式。

常量可以只声明但不初始化，随后在具体的场合初始化，但只能初始化一次。因为声明时没有具体的值，无法进行确切的类型推断，所以需要按照标准的方式声明，加上类型值。

如：let CPU_NUM: Int; CPU_NUM = 2 

 2、变量的定义

变量定义使用var关键字，可以采用的形式如：

1）标准方式

    var Welcome: String = "Hello World!"

2）类型推断

   var Welcome = "Hello World!"

也可以只声明，如var Welcome: String

3、元组

let HTTP404Error = (404, "Not found")

var (statusCode, statusMessage) = HTTP404Error

var (_, result) = HTTP404Error

也可以在定义元组时为每个字段指定名字，如：

let HTTP200Status = (statusCode: 200, Content:"OK")

打印时可以这样使用：

print(HTTP200Status.statusCode, HTTP200Status.Content)

 4、可选类型

可以定义一个类型为可选类型，对于此类型的变量，它可以有具体的值，也可以没有值，如果没有值则为nil

如：

let IsCheckID: Bool? = true

if IsCheckID == nil {

    print("No need check ID")

} else {

    print("Check ID")

}

5、数组

定义数组的几种方式:

1）可以先声明，在适当的时候初始化

　　var Score: [Int]; Score = [Int]()

2）可以直接定义一个空数组

　　var Score = [Int]()   

3）定义一个有初始大小的数组，并按照指定的值初始化

　　var Score = [Int](count: 10, repeatedValue: 0)

4）定义具有初始值的数组

　　var Score = [90, 59, 85.5]

向数组中插入元素，假设定义了以下数组：

varScore = [Int]()

可以用以下方式向数组中加入元素：

Score.append(10)

Score.append(20)

Score.append(30)

print(Score)

// output

[10, 20, 30]

数组下标的方法只能用来查询或修改已有元素，不能用来插入新元素。如以下代码将会印发运行时错误：

Score[3] = 100

但是可以修改已存在的元素：

Score[2] = 100

// output

[10, 20, 100]

也可以在已有的元素中间插入一个新元素：

Score.insert(100, atIndex: 0)

// output

[100, 0, 20, 100]

也可以在当前数组的大小基础上插入一个新元素，此时insert函数的作用等效于append

Score.insert(100, atIndex: 4)

//引发运行时异常

Score.insert(100, atIndex: 20)

 6、集合

集合是用来存放具有相同数据类型的值得容器，集合中的数据不能重复。

集合的定义：

1）var Cities: Set<String> = ["Beijing", "Shanghai", "Shenzhen"]

2）var Cities: Set = ["Beijing", "Shanghai", "Shenzhen"] // 基于类型推断

Set的元素顺序具有不确定性，即遍历时打印不一定和声明或插入元素的顺序一致。

print(Cities)

// output

["Shanghai", "Shenzhen", "Beijing"]

7、字典

字典属于关联容器，它是<key-value>键值对的集合，其中key不能重复。

字典的定义：

1） var Score: [String: Int] = ["Jack": 90, "Aaron": 100]

2）var Score = ["Jack": 90, "Aaron": 100]

3）var Score = Dictionary<String, Int>()

字典的操作：

 1）访问某个元素

字典的值是可选类型，如果直接用下标法访问，可能会和你的预期不一样，如

print(Score["Jack"])

// output

Optional(90)

不过如果可以通过值进行正常比较，如if Score["Jack"] == 90

如果想正常打印值，可以这样：

if let JackScore = Score["Jack"] {

    print(JackScore)

}

// output

90

遍历字典

for (name, score) in Score {

    print(name, score)

} 

打印一个不存在的Key的值，将会返回nil

字典和Set一样，顺具有不确定性

2） 插入数据

Score["Merry"] = 80

3）修改数据

Score.updateValue(95, forKey: "Merry")

updateValue一个不存在的Key，相当于新增加一个元素

 8、For循环

Swift提供两种for循环方式

1）for-in用于遍历一个区间，序列，集合、系列里的所有元素的一系列执行语句

2）for条件递增（for-condition-increment）语句，用来重复执行一系列语句直到达成特定条件达成，一般通过在每次循环完成后增加计数器的值来实现。

如果不需要知道区间内每一项的值，你可以使用下划线（_）替代变量名来忽略对值的访问

 

9、函数

函数的返回值形参中定义的变量不能直接使用

如 func Div(a: Int, b: Int) -> (c: Int, d: Int) {

//不能直接用形参中的c,d，必须重新定义变量

// c = a/b; d = a%b

var c: Int, d: Int

c = a/b; d = a%b

return (c, d)

}

 

10、属性 (Properties)

如果创建了一个结构体的实例并赋值给一个常量，则无法修改实例的任何属性，即使定义了变量存储属性

let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
// 该区间表示整数0，1，2，3
rangeOfFourItems.firstValue = 6
// 尽管 firstValue 是个变量属性，这里还是会报错

这种行为是由于结构体（struct）属于值类型。当值类型的实例被声明为常量的时候，它的所有属性也就成了常量。

属于引用类型的类（class）则不一样，把一个引用类型的实例赋给一个常量后，仍然可以修改实例的变量属性。

 

延迟存储属性是指当第一次被调用的时候才会计算其初始值的属性。在属性声明前使用lazy来标示一个延迟存储属性。

属性观察器监控和响应属性值的变化，每次属性被设置值的时候都会调用属性观察器，甚至新的值和现在的值相同的时候也不例外。

可以为属性添加如下的一个或全部观察器：

• willSet在设置新的值之前调用
• didSet在新的值被设置之后立即调用