心辰·Dev

Swift 基本特性总结

发表于

不同类型的变量

Swift 中有很多数据类型如:

1
2
3
4
5
var count: Int
var shouldRemind: Bool
var text: String
var list: [ChecklistItem]
var item: ChecklistItem

其他数据类型如:

  • Double
  • Character
  • UInt(unsigned Int)
  • Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64.
  • CGFloat(CG stands for the Core Graphics framework)

要点:

  1. Swift 无法进行数据类型的自动转换。
  2. 变量赋初值时 Swift 可以进行数据类型推断。

  3. 对象赋值格式可简写如下:

    1
    2
    var item: ChecklistItem()
    var newitem: ChecklistItem(text: "Charge my iPhone", checked: false)  // 传递参数到init方法

  4. 在类方法中使用self避免实例被隐藏

    1
    2
    3
    4
    5
    6
    7
    class MyObject { 
        var count = 7
        func myMethod() {
            var count = 42 
            println(self.count)  //打印结果为7
        }
    }

定义常量

可以把所有变量定义为常量，如果程序运行过程中 IDE 警告常量值发生改变，可再将常量声明为变量。

1
2
3
4
let pi = 3.141592
let difference = abs(targetValue - currentValue) 
let message = "You scored \(points) points"
let image = UIImage(named: "SayCheese")

数组和字典

必须声明所存储的数据的类型。

  1. 数组

    1
    2
    3
    4
    5
    6
    7
    8
    // 包含对象的数组
    var items: Array<Classname> 
    // 使用短语法
    var items: [Classname]
    // 创建数组实例
    items = [Classname]()
    // 访问数组中对象
    let item = items[3]

  2. 字典

    1
    2
    3
    4
    5
    6
    7
    8
    // 存储(String, Int) 键值对的字典
    var ages: Dictionary<String, Int>
    // 短语法
    var ages: [String: Int]
    // 创建字典实例
    ages = [String: Int]()
    // 访问字典中的对象
    var age = dict["Jony Ive"]

可选值类型

如果一个变量可以没有值，应该把它声明为可选值(optional)类型。

1
var checklistToEdit: Checklist?

如果不确定值是否为空，可使用可选链防止 crash :

1
navigationController?.delegate = self

使用这个类型的变量之前，要测试它是否为空，这一过程称为拆包(unwrapping)。

1
2
3
4
5
if let checklist = checklistToEdit {
    // “checklist”中包含真实对象
} else {
    // 可选值为nil
}

从字典中取值时，并不知道字典中是否包含该键值，要使用如下代码拆包:

1
2
3
if let age = dict["Jony Ive"] { 
    // 可以使用age变量
}

如果确定字典中含有该键值，可强制拆包:

1
var age = dict["Jony Ive"]!

同时，可以把变量用!声明为绝对拆包可选值(Implicitly unwrapped optional)。
使用此变量不用拆包，但如果值为空，会引发 APP 崩溃。所以一般在无法在声明变量时赋初值的情况才使用。

1
var dataModel: DataModel!

数值类型和引用类型

实例化的对象是引用类型:

1
2
3
4
5
6
var firstLabel = UILabel()
firstLabel.text = "Programmers are the best!"
var secondLabel = firstLabel 
secondLabel.text = "I like ice cream"
println(firstLabel.text) 
// 打印“I like ice cream”

其他都是数值类型:

1
2
3
4
5
6
7
var a = [1, 2, 3]
let b = a
a.append(4)
println(a) 
// 打印 [1, 2, 3, 4] 
println(b) 
// 打印 [1, 2, 3]

方法

调用一个对象的方法，就像从一个对象向另一个对象传递消息:

1
2
3
lists.append(checklist)
// 为checklist对象发送append消息给lists对象
tableView.insertRowsAtIndexPaths(indexPaths, withRowAnimation: .Fade)

调用同个类中的方法时，可使用关键字self:

1
2
3
4
5
6
7
8
9
10
class DataModel {
    func loadChecklists() {
        ...
        self.sortChecklists() 
        // 这个方法是DataModel中定义的方法 
    }
    func sortChecklists() { 
        ...
    } 
}

选择语句

关键字if和switch的一般用法同 C 语言:

1
2
3
4
5
6
7
func performDifficultCalculation(list: [Double]) { 
    if list.count < 2 {
        println("Too few items in list") 
    } else {
        // 其他操作
    } 
}

循环语句

for和while的一般用法同 C 语言:

1
2
3
for var i = start; i < end; ++i { 
    // 其他操作
}

在数组和字典中可以使用 for-in 语句:

1
2
3
4
5
for item in items { 
    if !item.checked {
        count += 1 
    }
}
1
2
3
for i in stride(from: 0, to: 5, by: 2) { 
    println(i)
}

对象

创建 MyObject.swift 文件，写入新类以创建对象:

1
2
3
4
5
6
7
8
9
10
11
class MyObject { 
    var text: String 
    var count = 0
    let maximum = 100
    init() {
        text = "Hello, world"   
    }
    func doSomething() { 
        // 其他操作
    } 
}

实例化一个对象:

1
2
var myInstance = MyObject()  // 创建一个实例
myInstance.doSomething()  // 调用方法

工厂方法创建实例:

1
2
3
4
5
6
7
8
class MyObject { 
    class func makeObjectWithCount(count: Int) -> MyObject { 
        let m = MyObject()
        m.count = count
        return m
    } 
}
var myInstance = MyObject.makeObjectWithCount(40)

定义初始化方法，初始化时必须给实例赋初值。
一个对象可以有多个初始化方法:

1
2
3
4
5
6
class MyObject { 
    init(count: Int) { 
        self.count = count
    } 
}
var myInstance = MyObject(count: 40)

继承

1
class ChecklistViewController: UITableViewController

实际上的继承树是
ChecklistViewController -> UITableViewController -> UIViewController -> UIResponder -> NSObject

覆写

要修改继承的方法、属性等的实现，必须使用override:

1
2
3
4
5
6
7
class MyViewController: UIViewController { 
    override func viewWillAppear(animated: Bool) {
    // 首先调用父类方法
    // super用于调用父类方法
    super.viewWillAppear(animated) 
    } 
}

协议

协议就是方法名的列表:

1
2
3
4
protocol MyProtocol {
    func someMethod(value: Int) 
    func anotherMethod() -> String
}

如果对象表明要遵从某个协议，必须去实现协议中的方法，它是哪种对象并不重要:

1
2
3
4
class MyObject: MyProtocol { 
    ...
}
var m2: MyProtocol = MyObject()