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

循环

• 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<String.Index>(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
}

闭包

• 闭包定义
• 闭包简化 - 尾随闭包
• 闭包参数
• 闭包返回值
• 闭包的循环引用
• 闭包类似c的block,就是一种特殊的数据类型

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

    return 20
}

• 闭包表达式优化,
• 1.类型优化, 由于函数中已经声明了闭包参数的类型, 所以传入的实参可以不用写类型
• 2.返回值优化, 同理由于函数中已经声明了闭包的返回值类型,所以传入的实参可以不用写类型
• 3.参数优化, swift可以使用$索引的方式来访问闭包的参数, 默认从0开始

bubbleSort(&arr){
//    (a , b) -> Int in
//    (a , b) in
    if $0 > $1{
        return 1;
    }else if $0 < $1
    {
        return -1;
    }else
    {
        return 0;
    }
}


// 如果只有一条语句可以省略return
let hehe = {
    "我是lnj"
}
print(hehe())

懒加载

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.

• 强制访问

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