2010年7月,chirs Lattner 用一年的时间完成了swift的基本框架，于2014年6月分布，
取消了oc的指针以及其他不安全的访问的使用，舍弃的smalltalk语法，全面改为点语法，提供了类似java的命名空间 范型 重载；
SWIFT初体验：
实例化一个view ，将button 添加到view，并且剧中
let view = UIView(frame: CGRect(x: 0, y: 0, width: 100, height: 100))
view.backgroundColor = UIColor.redColor()
//menu前面的menu的名称可以省略的
let button = UIButton(type: .ContactAdd)
button.center = CGPoint(x: 50, y: 50)
view.addSubview(button)
1. # 常量&变量
swift
// 定义变量
var i = 10
print(i)
i = 15
print(i)
let j = 20
// 常量一经定义不能自改数值
// j = 25
print(j)
* 阶段性小结
* `var` 定义变量，设置之后可以修改
* `let` 定义常量，设置之后不可以修改
* 语句末尾不用使用 `;`
* 在 Swift 中使用 `print()` 替代 OC 中的 `NSLog`
* `print` 的性能更好，后面会演示
> 常量&变量的使用原则：尽量先用 let，只有需要变的时候，再用 var，能够更加安全
## 变量类型
```swift
let x = 10
let y = 10.5
let z: Double = 20
print(Double(x) + y)
print(x + Int(y))
print(y + z)
* 阶段性小结
* 初次接触 `Swift` 中会因为简单的 `var` `let` 误以为 `Swift` 中的类型非常松散
* 其实所有变量的准确类型都是在赋值的同时自动推导的
* `Swift` 是对类型要求非常严格的一门语言，`一个值永远不会被自动转换成其他类型`
* 如果要转换，必须显示转换，Swift 中
* 小数默认是 `Double` 类型
* 整数默认是 `Int` 类型
* 如果要显式的指定变量的类型，可以在定义是使用 `var 变量名: 类型 = 值`
2. # 逻辑分支
#if
var i = 10
if i > 0 {
print("OK")
}
* 阶段性小结
* `Swift` 中没有 C 语言中的`非零即真`概念
* 在逻辑判断时必须显示地指明具体的判断条件
* `if` 语句条件的 `()` 可以省略
* 但是 `{}` 不能省略
## 三目
var a = 10
var b = 50
var result = a > b ? a : b
print(result)
* 阶段性小结
* `Swift` 中的 `三目` 运算保持了和 OC 一致的风格
## 可选项
let url = NSURL(string: "http://www.520it.com/")
if url != nil {
NSURLSession.sharedSession().dataTaskWithURL(url!, completionHandler: { (data, _, _) -> Void in
print(NSString(data: data!, encoding: NSUTF8StringEncoding))
}).resume()
}
* 阶段性小结
* 在 `Swift` 中，不是所有的对象实例化方法都会返回值，在实际开发中需要注意实例化函数的返回类型，例如：
```swift
convenience init?(string URLString: String)
```
* 如果有 `?` 表示改方法有可能无法实例化到正确的对象
* 这种函数返回的对象，被称为 `可选项`，即有可能有值，也有可能没有值
* 实际开发时，需要针对这种对象加以判断，并且在分支内部使用 `!`，指明改对象确实是存在的
* 相比在 `OC` 的开发，尤其在日常练习时，会给定一个能够运行的值，而在实际运行时，一旦条件不满足，会直接闪退，这样用户体验会非常不好
> `Swift` 的设计者考虑到因为对类型的强制要求，会让代码很难看，因此提供了一个变通的解决方案
### 演练 2
if let url = NSURL(string: "http://520it.com") {
NSURLSession.sharedSession().dataTaskWithURL(url, completionHandler: { (data, _, _) -> Void in
print(NSString(data: data!, encoding: NSUTF8StringEncoding))
}).resume()
}
* 阶段性小结
* 使用 `if let 常量 = 可选构造函数` 的方式能够确保分支内部常量一定是有值的
* 并且在分支内部不再需要使用 `!`
* 这是 `Swift` 代码中的一个非常重要的使用技巧
* 提示
* 尽管 `Swift` 提供了类型校验的手段，但是要写出 `优雅` 的 Swift 代码，还是需要多加练习的，否则一不小心就会出现分支嵌套层次很深的代码
* 有关 `?` 和 `!` 的选择，可以借助 Xcode 的辅助工具，但是强烈建议每次遇到提示时，要多加思考，反复揣摩
### 演练3
var name: String?
print(name?.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))
name = "lnj"
print(name?.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))
let l = 10
print(l + (name?.lengthOfBytesUsingEncoding(NSUTF8StringEncoding) ?? 0))
* 阶段性小结
* `??` 是一个非常有用的操作符，能够快速对 `nil` 进行判断
* 如果对象是 `nil`，则使用 `??` 后面的值代替前面的 `nil` 值参与计算
* 在使用 `??` 时，整个部分需要使用 `()` 包装
* 这一技巧在 `UITableView` 的数据源方法中尤为重要
3.# 循环
// 传统写法
for var i = 0; i < 10; i++ {
print(i)
}
## Swift风格的 `for`
```swift
// 遍历 0 ~ <10
for i in 0..<10 {
print(i)
}
print("---")
// 遍历 0 ~ 10
for i in 0...10 {
print(i)
}
* 阶段性小结
* `Swift` 中使用 `in` 关键字标示循环的范围
* `0..<10` 表示从0到9
* `0...10` 表示从0到10
* 注意之间不能出现空格
## 特殊写法
```swift
for _ in 0...10 {
print("hello")
}
```
* 阶段性小结
* 如果不关心循环本身的索引，可以使用 `_` 忽略
* 这一技巧在之前的分支演练中出现过
4.# 字符串
> 在 Swift 中绝大多数的情况下，推荐使用 String 类型## 使用 `String` 的原因* `String` 是一个结构体，性能更高 * `String` 目前具有了绝大多数 NSString 的功能 * `String` 支持直接遍历* `NSString` 是一个 `OC` 对象，性能略差* `Swift` 提供了 `String` 和 `NSString` 之间的无缝转换## 遍历字符串```swiftlet str = "我要飞的更High"for s in str { print(s)}```## 字符串拼接```swiftlet str1 = "zhangsan"let str2 = "lisi"let i = 10print(str1 + str2)print("\(str1) \(str2) \(i)")```* 阶段性小结 * 直接在 `""` 中使用 `\(变量名)` 的方式可以快速拼接字符串 * 小伙伴们再也不要考虑 `stringWithFormat` 了## 格式化字符串```swiftfor _ in 0...10 { let str = String(format: "zhangsan - %04d", arguments: [arc4random_uniform(100)]) print(str)}```* 阶段性小结 * 在实际开发中，如果需要指定字符串格式，可以使用 `String(format:...)` 的方式 * 注意：后面的参数需要放在一个数组中## String & Range 的结合> 以下是超级费劲的代码```swiftlet str: String = "我要飞的更High"var subStr = str.substringWithRange(Range(start: str.startIndex, end: str.endIndex))
print(subStr)
```
### 建议写法
```swift
let str1: NSString = "我要飞的更High"
print(str1.substringWithRange(NSMakeRange(0, 3)))
```
5.# 数组
## 简单体验
```swift
let arr = ["zhangsan", "lisi"]
print(arr)
// 遍历每一个元素
for a in arr {
print(a)
}
// 像 OC 一样打印
print(arr as NSArray)
```
## 数组中保存的对象类型
```swift
// 数组中保存的都是字符串
let arr = ["zhangsan", "lisi"]
// 数组中保存的是 NSObject
let arr1 = ["zhangsan", 1]
```
* 阶段性小结
* 数组使用 [] 定义，这一点与 OC 相同
* 如果初始化时，所有内容类型一致，择数组中保存的是该类型的内容
* 如果初始化时，所有内容类型不一致，择数组中保存的是 `NSObject`
## 常见数组操作
```swift
// 定义只能保存字符串类型数组
var array: [String]
// 初始化数组
array = ["zhangsan"]
// 添加元素
array.append("lisi")
print(array)
// 删除元素
array.removeAtIndex(1)
print(array)
// 删除所有元素
array.removeAll(keepCapacity: true)
print(array.capacity)
// 注意数组容量的变化
for i in 0..<10 {
array.append("\(i)")
print("\(array) --- \(array.capacity)")
}
// 实例化新的数组
var array2 = [String]()
array2.append("1")
array2.append("2")
// 拼接数组
array += array2
print(array)
```
* 阶段性小结
* 如果定义数组时指定了保存对象的类型，择不能向数组中添加其他类型的内容
* 可以使用 `[String]()`
* `let` 定义的数组是`不可变的`
* `var` 定义的数组是`可变的`
6.# 字典
```swift
/// 定义并实例化字典
var dict = [String: AnyObject]()
dict["name"] = "zhangsan"
dict["age"] = 18
print(dict)
// 设置相同 key，之前的数值会被覆盖
dict["name"] = "lisi"
print(dict)
// 删除某一个 key
dict.removeValueForKey("age")
print(dict)
dict["title"] = "manager"
print(dict)
// 遍历字典(k, v可以随便写)
for (k, v) in dict {
print("\(k) -- \(v)")
}
// 合并字典
var dict2 = ["name": "wangwu", "age": 80, "title": "boss"]
for (k, v) in dict2 {
dict.updateValue(v, forKey: k)
}
print(dict)
```
7.# 函数
## 简单演练
```swift
func sum(a: Int, b: Int) -> Int {
return a + b
}
```
* 阶段性小结
* 函数定义格式：`func 函数名(参数: 参数类型...) -> 返回值 { // 代码实现 }`
* 如果没有返回值， `-> 返回值` 可以省略
* `->` 是一个很有意思的符号
* 默认情况下，在调用函数时，第一个参数名是省略的
## 参数名的特殊处理
### 强制要求参数名
```swift
func sum1(x a: Int, y b: Int) -> Int {
return a + b
}
```
### 省略参数名
```swift
func sum2(a: Int, _ b: Int) -> Int {
return a + b
}
```
8.# 闭包
* 闭包定义
* 闭包简化 - 尾随闭包
* 闭包参数
* 闭包返回值
* 闭包的循环引用
```swift
weak var weakSelf = self
demo("zhangsan") { (_) -> Int in
print(weakSelf?.view.backgroundColor)
return 20
}
```
9.# 懒加载
```swift
lazy var demoView: UIView = {
let v = UIView(frame: CGRectMake(10, 10, 100, 100))
v.backgroundColor = UIColor.redColor()
return v
}()
```
* 格式：
```
lazy var 变量: 类型 = { 创建变量代码 }()
```
* 懒加载的写法本质上是定义并执行一个闭包
10.# getter & setter
## 自定义 Person 类
```swift
class Person: NSObject {
var name: String?
var age: Int?
}
```
## getter & setter
```swift
var _name: String?
var name: String? {
get {
return _name
}
set {
_name = newValue
}
}
```
* 在 `Swift` 中以上形式的 getter & setter 很少用
## didSet
* 在 OC 中，我们通常希望在给某一个变量赋值之后，去做一些额外的操作
* 最经典的应用就是在自定义 Cell 的时候，通过模型的设置方法完成 Cell 的填充
```swift
var length: Int? {
didSet {
timeStr = String(format: "%02d:%02d:%02d", arguments: [length! / 3600, (length! % 3600) / 60, length! % 60])
}
}
var timeStr: String?
```
## 计算型属性
```swift
var title: String {
get {
return "Mr " + (name ?? "")
}
}
```
* 只实现 `getter` 方法的属性被称为计算型属性，等同于 OC 中的 `ReadOnly` 属性
* 计算型属性本身不占用内存空间
* 不可以给计算型属性设置数值
* 计算型属性可以使用以下代码简写
```swift
var title: String {
return "Mr " + (name ?? "")
}
```
## 构造函数
```swift
init(dict: [NSObject: AnyObject]) {
name = dict["name"] as? String
age = dict["age"] as? Int
}
```
## 析构函数
```swift
deinit {
print("88")
}
```