零基础学iOS系列之swift语法基础

1. 变量与数据类型

a) 数据类型

i. 基本数据类型

整数类型 Int, UInt, Int8, UInt8, Int16,UInt16, Int32, UInt32, Int64, UInt64

实数类型 Double, CGFloat

字符串 String

集合类型 Array, Dictionary, Set

ii. 类型之间的转换(调用目标类型的构造函数)

整数类型 –> 实数类型:

let n: Int = 0 
let b = Double(n)

数字类型 -> 字符串类型：

let number = 4
let string = String(number)

b) 变量的声明

i. 基本声明方法

let/var name[: Type][ = Initialization],中括号内表示可省略, 但第一个中括号与第二个中括号内的内容只能省略一处， 除了类成员属性有默认值的情况不需要省略，其他均建议采用省略形式， 如

let number = 1

var string: String?

ii. 使用let声明

表示常量，声明之后只允许有一次赋值， 如

let x = 10

x = 100 //编译不通过

iii. 使用var声明

表示变量， 一次声明，可以多次修改其值， 但效率没有let高

var name = "小明"

///...

name = "大明"

iv. let 与var的区别与使用规则

区别在于前者声明的变量为值不可变，后者值可变，前者效率更高，使用原则：

方法体中，优先使用let, 当需要修改变量值的时候， 根据编译器提示和修改建议进行修改即可

v. 语法糖

适用于Array，Dictionary和Optional， 但写法更简洁，

对于数组， 应该写成

let array: [Int]

而不建议写成

let array: Array<Int>

对于字典， 应该写成

let dict: [String:String]

而不应该写成

let dict: Dictionary<String,String>

对于Optional，从名字上看叫可选值， 也就是可空值， 表示该类型的变量的值可以是nil(或者.None)， 建议使用简洁形式声明可选类型变量, 如

var name: String?

而不要使用

var name: Optional<String>

c) 区间

区间分为半开区间和闭区间，区间值必须为整数， 半开区间用..<表示， 如0到99， 则可以表示

0..<100

闭区间用…表示， 如0到99表示为

0…99

2. 控制语句

a) 条件语句

i. if else语句

最基本的条件判断，

if 条件 {
    条件为真的时候的操作
} else {
    条件为假时的操作
}

else 后仍可接ifelse完成语句，如：

if 条件1 {
   /// 条件1为真的时候的操作
} else if 条件2 {
   /// 条件2为真的时候的操作
} else{
   ///条件为假时的操作
}

ii. guard else 语句

guard 条件 else{
    return/break
}

表示确保条件成立的情况下继续往下执行，否则执行完else中的内容后退出，break/return要求必须写一个，因此guard语句一般在方法体中或者循环中使用，具体看使用情况，guard else语句一般用来避免嵌套if else语句造成的代码结构混乱

iii. if let 语句

表示可选值的绑定，如果可选值非空，可以绑定成功，则执行后面{ }中的语句，否则跳过{ }

形式：

if let some = someOptioal {

    如果someOptional的值不是nil，则执行此处代码

}

if let语句也可以和if else语句一样，可以有else分支，如果有多个可选值需要绑定，只需要在{ }前面增加let 语句即可，然后与前面的语句用英文逗号隔开

if let 语句可以用来避免使用！进行强制拆包导致的nil异常

iv. guard let … else语句

类似于if let，同样用于可选值绑定，绑定失败则执行else 后面的{ }里面的语句并退出

b) 选择语句

switch case语句

使用形式：

switch some {

case value1:

    ...

case value2:

    ...

default: break

}

使用要求， 如果some为枚举类型的变量，则不建议使用default分支, 应该将所有枚举值case 出来， 如果some为非枚举类型变量，则要求必须有default分支，且每一个case分支下如果语句非空， 则不需要使用break，否则需要在该分支使用break，case 分支的值除了可以是单个的值之外，也可以是区间

c) 循环语句

i. 传统for循环

for init; condition; change{
/// loop body
}

传统的for循环， 不建议使用

ii. for in

for some in collection {
/// loop body
} 

用于对集合类型的遍历, 建议使用

iii. while 语句

while condition {
/// 循环体
}

iv. repeat语句

repeat {
/// 循环体
} while condition

与while循环功能相同， 但是区别在于while循环先判断在执行， repeat while语句先执行后判断

d) 循环中的跳转

跳过当前循环，使用continue, 终止当前循环，使用break， break可以终止多层循环，配合标签使用， 如

lp:
for i in 0..<10 {
    for j in 0..<5 {
       if i* i == j * j * j {
           break lp
       }	
	}
}

3. 自定义类型

a) typealias使用

给已有类型取别名， 如

typealias Point = (Double, Double)

表示将(Double， Double)类型的元组取别名为Point

b) enum

定义枚举类型， 枚举值以case 为前缀列举, 如

enum School{

case primary

case middleSchool

case university

case college

}

与其他语言不同， 枚举值中也可以有包括构造方法在内的方法存在，也可以以其他如Int 类型为父类进行继承

c) tuple

元组类型, 用来包裹多个不同数据类型的集合类型。有点类似结构体，但不需要像结构体一样预先定义

let student = ("Oyoung", 26, "男")
student.0 // "Oyoung"
student.1 // 26
student.2 // "男"
typealias Student = (name: String, age: Int, gender: String)

let namedStudent: Student = student

namedStudent.name  /// <=> namedStudent.0
namedStudent.age  /// <=> namedStudent.1
namedStudent.gender  /// <=> namedStudent.2

d) struct

声明一个类，但是该类属于值类型，每一个该类型的变量之间互不相关，修改任何一个该类型变量不会影响到其他同类型变量的值

struct Point {
	var x: Int
	var y: Int
}

let pointA = Point(x: 0, y: 0)
let pointB = pointA

pointB.x = 100
pointB.y = 200

println(pointA.x == pointB.x) /// false
println(pointA.x == pointB.y) /// false

e) class

与struct相同，也是声明一个类， 但区别在于， 声明的类为引用类型，如果将该类型的一个变量赋值给另一个同类型变量，则这两个变量指向的是同一个实体，如果有其中一个变量修改了实体的某个值， 另一个变量的实体的值会跟着修改

class Student {
	var name: String
	var number: Int
	var age: Int
}

let xiaoming = Student(name: "小明", number: 10001, age: 16)
let theMonitor = xiaoming

theMonitor.age += 1

println (xiaoming.age) /// 17

f) protocol

表示协议， 用来声明接口， 声明后不可直接使用，只能使用class或者struct声明的类实现该协议

protocol Writable {
	func write(data: Data) -> Int
}

class Buffer {
	private var data: [UInt8] = [UInt8]()
}

extension Buffer: Writbale {
	func write(data: Data) -> Int {
		self.data += data.map{$0}
		return data.count
	}
}