Swift基础语法

常量&变量

简单体验

// 定义变量
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.520it.com/")

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

```swift
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 的数据源方法中尤为重要

循环

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")
}

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

数组

简单体验

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)

字符串

在 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 了

格式化字符串

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(start: str.startIndex, end: str.endIndex))
print(subStr)

建议写法

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

函数

简单演练

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, 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.

强制访问

NSAppTransportSecurity

  
  NSAllowsArbitraryLoads
      

设置白名单

NSAppTransportSecurity

    NSExceptionDomains
    
        localhost
        
            NSTemporaryExceptionAllowsInsecureHTTPLoads