Swift 入门

简介

• Swift 语言由苹果公司在 2014 年推出，用来撰写 OS X 和 iOS 应用程序
• 2014 年，在 Apple WWDC 发布

历史

• 2010 年 7 月，苹果开发者工具部门总监 克里斯·拉特纳 开始着手 Swift 编程语言的设计工作
  

• 用一年时间，完成基本架构

• Swift 大约历经 4 年的开发期，2014 年 6 月发表

特色

• 苹果宣称 Swift 的特点是：快速、现代、安全、互动，而且明显优于 Objective-C 语言
• 可以使用现有的 Cocoa 和 Cocoa Touch 框架
• Swift 取消了 Objective C 的指针及其他不安全访问的使用
• 舍弃 Objective C 早期应用 Smalltalk 的语法，全面改为句点表示法
• 提供了类似 Java 的名字空间(namespace)、泛型(generic)、运算对象重载（operator overloading）
• Swift 被简单的形容为 “没有 C 的 Objective-C”（Objective-C without the C）

现状

• 2015 年 2 月，苹果同时推出 Xcode 6.2 Beta 5 和 6.3 Beta，在完善 Swift 1.1的同时，推出了 Swift 1.2 测试版
• 2015 年 6 月，苹果在 WWDC 发布了 Swift 2.0 测试版，并且宣称在年底开源
• 从发布至今，苹果的每一个举措都彰显其大力推广 Swift 的决心
• Swift 当前正式版本：1.2，测试版本是 2.0
• 目前有些公司的新项目已经直接采用 Swift 开发
• 目前很多公司已经在做 Swift 的人才储备
• 应聘时，会 Swift 开发 无疑会增加自身筹码
• 刀哥预测：到 2015 年底，iOS 9.0 正式发布的同时，Swift 势必大行其道！

资源网站

• 《The Swift Programming Language》中文版 http://numbbbbb.gitbooks.io/-the-swift-programming-language-/

• swifter 作者王巍，需要付费购买 http://onevcat.com

常量&变量

简单体验

// 定义变量
var i = 10
print(i)
i = 15
print(i)

let j = 20
// 常量一经定义不能自改数值
// j = 25
print(j)

• 阶段性小结
  
  • var 定义变量，设置之后可以修改
  • let 定义常量，设置之后不可以修改
  • 语句末尾不用使用 ;
  • 在 Swift 中使用 print() 替代 OC 中的 NSLog
  • print 的性能更好，后面会演示

定义 OC 对象

// 实例化视图
let v = UIView(frame: CGRectMake(0,0,100,100))
// 设置背景颜色
v.backgroundColor = UIColor.redColor()

// 添加到根视图
view.addSubview(v)

• 阶段性小结
  
  • 在 Swift 中要实例化一个对象可以使用 类名() 的格式，与 OC 中的 alloc/init 等价
  • OC 中的 initWithXXX 在 Swift 中通常可以使用 类名(XXX: ) 找到对应的函数
  • OC 中的 [UIColor redColor] 类方法，在 Swift 中通常可以使用 类名.XXX 找到对应的函数
  • 使用 let 修饰 v 并且赋值，表示 该常量的内存地址不允许修改，但是可以修改其内部的属性
  • 当前对象的属性，不需要使用 self.

常量&变量的使用原则：尽量先用 let，只有需要变的时候，再用 var，能够更加安全

变量类型

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 变量名: 类型 = 值

逻辑分支

简单体验

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 一致的风格

可选项

演练 1

let url = NSURL(string: "http://www.baidu.com/?word=iphone")

if url != nil {
    NSURLSession.sharedSession().dataTaskWithURL(url!,completionHandler: { (data,_,_) -> Void in print(Nsstring(data: data,encoding: NSUTF8StringEncoding)) }).resume() }

• 阶段性小结
  
  • 在 Swift 中，不是所有的对象实例化方法都会返回值，在实际开发中需要注意实例化函数的返回类型，例如：

convenience init?(string URLString: String)

* 如果有 `?` 表示改方法有可能无法实例化到正确的对象
* 这种函数返回的对象，被称为 `可选项`，即有可能有值，也有可能没有值
* 实际开发时，需要针对这种对象加以判断，并且在分支内部使用 `!`，指明改对象确实是存在的
* 相比在 `OC` 的开发，尤其在日常练习时，会给定一个能够运行的值，而在实际运行时，一旦条件不满足，会直接闪退，这样用户体验会非常不好

Swift 的设计者考虑到因为对类型的强制要求，会让代码很难看，因此提供了一个变通的解决方案

演练 2

if let let url = NSURL(string: "http://www.baidu.com/?word=iphone") {
    NSURLSession.sharedSession().dataTaskWithURL(url,encoding: NSUTF8StringEncoding)) }).resume() }

• 阶段性小结

  • 使用 if let 常量 = 可选构造函数 的方式能够确保分支内部常量一定是有值的
  • 并且在分支内部不再需要使用 !
  • 这是 Swift 代码中的一个非常重要的使用技巧

• 提示

  • 尽管 Swift 提供了类型校验的手段，但是要写出 优雅 的 Swift 代码，还是需要多加练习的，否则一不小心就会出现分支嵌套层次很深的代码
  • 有关 ? 和 ! 的选择，可以借助 Xcode 的辅助工具，但是强烈建议每次遇到提示时，要多加思考，反复揣摩

演练3

var name: String?
print(name?.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))

name = "zhangsan"
print(name?.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))

let l = 10
print(l + (name?.lengthOfBytesUsingEncoding(NSUTF8StringEncoding) ?? 0))

• 阶段性小结
  
  • ?? 是一个非常有用的操作符，能够快速对 nil 进行判断
  • 如果对象是 nil，则使用 ?? 后面的值代替前面的 nil 值参与计算
  • 在使用 ?? 时，整个部分需要使用 () 包装
  • 这一技巧在 UITableView 的数据源方法中尤为重要

循环

OC风格的 for

// 传统写法
for var i = 0; i < 10; i++ {
    print(i)
}

Swift风格的 for

// 遍历 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
  • 注意之间不能出现空格

特殊写法

for _ in 0...10 {
    print("hello")
}

• 阶段性小结
  
  • 如果不关心循环本身的索引，可以使用 _ 忽略
  • 这一技巧在之前的分支演练中出现过

字符串

在 Swift 中绝大多数的情况下，推荐使用 String 类型

使用 String 的原因

• String 是一个结构体，性能更高
  
  • String 目前具有了绝大多数 Nsstring 的功能
  • String 支持直接遍历
• Nsstring 是一个 OC 对象，性能略差
• Swift 提供了 String 和 Nsstring 之间的无缝转换

遍历字符串

let str = "我要飞的更High"

for s in str {
    print(s)
}

字符串拼接

let str1 = "zhangsan"
let str2 = "lisi"
let i = 10

print(str1 + str2) print("\(str1) \(str2) \(i)")

• 阶段性小结
  
  • 直接在 "" 中使用 \(变量名) 的方式可以快速拼接字符串
  • 我和我的小伙伴再也不要考虑 stringWithFormat 了 :D

格式化字符串

for _ in 0...10 {
    let str = String(format: "zhangsan - %04d",arguments: [arc4random_uniform(100)])
    print(str)
}

• 阶段性小结
  
  • 在实际开发中，如果需要指定字符串格式，可以使用 String(format:...) 的方式
  • 注意：后面的参数需要放在一个数组中

String & Range 的结合

以下是超级费劲的代码

let str: String = "我要飞的更High"

var subStr = str.substringWithRange(Range<String.Index>(start: str.startIndex,end: str.endindex))
print(subStr)

subStr = str.substringWithRange(Range<String.Index>(start: advance(str.startIndex,0),end: advance(str.startIndex,3)))
print(subStr)

建议写法

let str1: Nsstring = "我要飞的更High"
print(str1.substringWithRange(NSMakeRange(0,3)))

数组

简单体验

let arr = ["zhangsan","lisi"]
print(arr)

// 遍历每一个元素
for a in arr {
    print(a)
}

// 像 OC 一样打印
print(arr as NSArray)

数组中保存的对象类型

// 数组中保存的都是字符串
let arr = ["zhangsan","lisi"]

// 数组中保存的是 NSObject
let arr1 = ["zhangsan",1]

• 阶段性小结
  
  • 数组使用 [] 定义，这一点与 OC 相同
  • 如果初始化时，所有内容类型一致，择数组中保存的是该类型的内容
  • 如果初始化时，所有内容类型不一致，择数组中保存的是 NSObject

常见数组操作

// 定义只能保存字符串类型数组
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 定义的数组是可变的

字典

/// 定义并实例化字典
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)

函数

简单演练

func sum(a: Int,b: Int) -> Int {
    return a + b
}

• 阶段性小结
  
  • 函数定义格式：func 函数名(参数: 参数类型...) -> 返回值 { // 代码实现 }
  • 如果没有返回值， -> 返回值 可以省略
  • -> 是一个很有意思的符号
  • 默认情况下，在调用函数时，第一个参数名是省略的

参数名的特殊处理

强制要求参数名

func sum1(x a: Int,y b: Int) -> Int {
    return a + b
}

省略参数名

func sum2(a: Int,_ b: Int) -> Int {
    return a + b
}

闭包

• 闭包定义
• 闭包简化 - 尾随闭包
• 闭包参数
• 闭包返回值
• 闭包的循环引用

weak var weakSelf = self
demo("zhangsan") { (_) -> Int in
    print(weakSelf?.view.backgroundColor)

    return 20
}

懒加载

lazy var demoView: UIView = {

    let v = UIView(frame: CGRectMake(10,10,100))
    v.backgroundColor = UIColor.redColor()

    return v
}()

• 格式：

lazy var 变量: 类型 = { 创建变量代码 }()

• 懒加载的写法本质上是定义并执行一个闭包

getter & setter

自定义 Person 类

class Person: NSObject {

    var name: String?
    var age: Int?
}

getter & setter

var _name: String?

var name: String? {
    get {
        return _name
    }
    set {
        _name = newValue
    }
}

• 在 Swift 中以上形式的 getter & setter 很少用

didSet

• 在 OC 中，我们通常希望在给某一个变量赋值之后，去做一些额外的操作
• 最经典的应用就是在自定义 Cell 的时候，通过模型的设置方法完成 Cell 的填充

var length: Int? {
    didSet {
        timeStr = String(format: "%02d:%02d:%02d",arguments: [length! / 3600,(length! % 3600) / 60,length! % 60])
    }
}
var timeStr: String?

计算型属性

var title: String {
    get {
        return "Mr " + (name ?? "")
    }
}

• 只实现 getter 方法的属性被称为计算型属性，等同于 OC 中的 ReadOnly 属性
• 计算型属性本身不占用内存空间
• 不可以给计算型属性设置数值
• 计算型属性可以使用以下代码简写

var title: String {
    return "Mr " + (name ?? "")
}

构造函数

init(dict: [NSObject: AnyObject]) {
    name = dict["name"] as? String
    age = dict["age"] as? Int
}

析构函数

deinit {
    print("88")
}

ATS 应用传输安全

App Transport Security (ATS) lets an app add a declaration to its Info.plist file that specifies the domains with which it needs secure communication. ATS prevents accidental disclosure,provides secure default behavior,and is easy to adopt. You should adopt ATS as soon as possible,regardless of whether you’re creating a new app or updating an existing one.

If you’re developing a new app,you should use HTTPS exclusively. If you have an existing app,you should use HTTPS as much as you can right Now,and create a plan for migrating the rest of your app as soon as possible.

强制访问

<key>NSAppTransportSecurity</key>
<dict>
  <!--Include to allow all connections (DANGER)-->
  <key>NSAllowsArbitraryLoads</key>
      <true/>
</dict>

设置白名单

<key>NSAppTransportSecurity</key>
<dict>
    <key>NSExceptionDomains</key>
    <dict>
        <key>localhost</key>
        <dict>
            <key>NstemporaryExceptionAllowsInsecureHTTPLoads</key>
            <true/>
        </dict>
    </dict>
</dict>