Swift

1.Swift项目与OC项目的区别

- Swift的类文件是以 .swift 结尾

- main.m 不见了,程序入口以 `@UIApplicationMain`

- Swift中,代码都是写到 `{}` 标识的代码块里面

- 在 Swift 中,每一行代码的末尾不用跟上 `;`

- OC 中的 initWithXXX 换成 `类名(XXX:__)` [init(XXX:)]

- Swift 中使用 `点 .` 的方式去调用方法

- Swift 枚举分为 `大类型.小类型`,而且大类型可以省略

- Swift 中,当前类的属性或者方法都可以不用 self. 开头,建议大家不要加.因为在后面闭包的使用的时候,闭包里面会使用 self

- Selector: 两种表现形式 Selector("buttonClick") / 在要传入 Selector 的地方 直接填写 "buttonClick"

- 在 Swift 中使用 print 作打印语句

2.常量和变量

- 使用 `let` 定义常量

- 使用 `var` 定义变量

- 在 Swift 中,有 `自动推导`,会根据等号后面的值,推断出前面变量(常量)的类型,也就是说,可以不用显式的去指定类型

- 在 Swift 中对类型检测非常严格,没有 `隐式转换`,只有类型相同的变量(常量)才能进行运算

- option + click 查看变量(常量)类型

- let 与 var 如何选择: 先使用 let 定义,如果需要更改的话,再变成 var

3.可选类型

- fatal error: unexpectedly found nil while unwrapping an Optional value

- 什么是可选类型: 一个变量(常量)可能有值,可能为nil,那么它就是一个可选类型

- 可选类型的变量不能直接进行运算 ,要强制解包(使用 !) 或者判断其是否有值再计算

- 使用 `?` 标识变量是一个可选类型的变量

- 输出的时候如果发现 `Optional(xxx)` 字样,代表打印的变量是一个可选类型

- `!` 用于标识可选类型的变量一定有值 [解包] (程序员向系统保证 ,a 里面一定有值,你去取a的值去计算,如果没有取到值,系统就会崩溃)

- 我们在使用 `!` 的时候,一定要小心,要确保其修饰的变量一定有值,

- `??` 空合并运算符,判断其前面的可选值是否真的有值,如果有,就直接返回该值,如果为nil,就使用 其后面的值进行运算

4.if语句

　　  - 条件语句可以不使用 `()` 圆括号括起来

- `{}` 执行代码块的花括号不能省略

- 在 Swift 中是没有`非0即真`概念,条件语句只能有 true/false

        let a = 

        // 判断 a 是否大于5, 如果大于5,就打印一句话
        if a >  {
            print("a 大于 5")
        }   

        // 方式1
        // 运算符的左右空格一定要对称 (空格大法)
        if url != nil{
            let request = NSURLRequest(URL: url!)
            print(request)
            // 如果下面有很多代码,并且多次使用 url ,都需要强行解包
        }

        // 方式2: 使用 if let
        // if let 会判断 url 是否有值,如果没有值,什么都不错
        // 如果有值,会把 url 的值取出来赋值给 u,并且进入到 if 的执行代码块中
        if let u = url {
            let request = NSURLRequest(URL: u)
            print(request)
        }    

if let 与 guard let

    func demo6(){
//        let url = NSURL(string: "http://www.baidu.com")
//
//        if let u = url {
//            let request = NSURLRequest(URL: u)
//            print(request)
//            // 写很多逻辑
//        }

        let url = NSURL(string: "http://www.qq.com")
        guard let u = url where u.host == "www.baidu.com" else {
            print("url为空或者不符合条件")
            return
        }
        let request = NSURLRequest(URL: u)
        print(request)

    }

5.switch

let scoreStr = "优"
        switch scoreStr {
        case "优":
            print("大于等于90小于等于100")
        case "良":
            print("大于等于80小于90")
        case "中":
            print("大于等于60小于80")
        case "差":
            print("大于等于0小于60")
        default:
            print("其他")
        }

        // 判断一个范围
        let score =
        switch score {
        case _ where score >=  && score <= :
            print("优")
        case let s where s <  && s >= :
            print("良")
        case let s where s <  && s >= :
            print("中")
        case let s where s < :
            print("差")
        default:
            print("其他")
        }

6.循环

        // 方式1: 仿照oc写
//        for (int i=0; i<3; i++) {
//            NSLog(@"哈哈");
//        }
        for var i = ; i < ; i++ {
            print(i)
        }

        print("==========")
        // 方式2: for in
        for i in ..< {
            print(i)
        }

        print("==========")
        for i in ... {
            print(i)
        }

        print("==========")

        // 方式3: 只需要遍历的次数,不需要当前遍历到哪个位

        for _ in ..< {
            print("哈哈")
        }

//        var i = 10
//        while i > 0 {
//            i--
//            print(i)
//        }

        var i =
        // do while 在 Swift 2.0 Xcode 7.0 beta5
        // 改成repeat while
        repeat {
            i--
            print(i)
        }while (i > )

7.字符串

    /// 字符串的截取
    func demo4(){

        let str = "听说下雨天音乐和辣条更配哟"

        // 截取: 下雨天音乐和辣条更配哟
        let r1 = str.substringFromIndex(str.startIndex.advancedBy())
        print(r1)

        // 截取: 听说下雨天音乐和辣条更
        let r2 = str.substringToIndex(str.endIndex.advancedBy(-))
        print(r2)

        // 截取: 下雨天音乐和辣条更
        let startIndex = str.startIndex.advancedBy()
        let endIndex = str.endIndex.advancedBy(-)
        let r3 = str.substringWithRange(startIndex..<endIndex)
        print(r3)

        // 如果以上的代码不会写,可以把 String 转成 NSString 进行截取
        let range = NSMakeRange(, str.characters.count - )
        let r4 = (str as NSString).substringWithRange(range)
        print(r4)

    }

    /// 字符串的拼接
    func demo3(){

        let name = "老王"
        let age =
        // 打印出:我叫老王年龄18

        // 方式1: 使用 `+`
        let r1 = "我叫" + name + "年龄" + String(age)
        print(r1)

        // 方式2: 使用 `\(_常量或者变量名_)`
        let r2 = "我叫\(name)年龄\(age)"
        print(r2)

        // 使用 formatter 的情况

        let h =
        let m =
        let s = 

        // 输出 09:10:03

        let r3 = String(format: "%02d:%02d:%02d", h, m, s)
        print(r3)

        let r4 = String(format: "%02d:%02d:%02d", arguments: [h, m, s])
        print(r4)

    }

    /// 字符串的长度获取
    func demo2(){
        let str = "别哭泣，老王会笑"
        // 获取字符串的长度
        print(str.characters.count)
        print(str.utf8.count)
        print(str.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))
    }

    /// 字符串的遍历
    func demo1(){
        let str = "别低头，绿帽会掉"
        for value in str.characters {
            print(value)
        }
    }

8.集合

// 合并字典
    func demo7(){
        var dict1 = ["name": "老王", "age": ]
        let dict2 = ["no": "哈哈", "height": , "name": "老李"]

        for (k,v) in dict2 {
            dict1[k] = v
        }
        print(dict1)
    }

    /// 遍历字典
    func demo6(){
        let dict = ["name": "老王", "age": ]
        for (k,v) in dict {
            print("key:\(k);value:\(v)")
        }
    }

    /// 字典的定义以及初始化
    /**
        - 使用 let 定义不可变的字典,使用 var 定义可变的字典
    */
    func demo5(){
        // 类型: [String : NSObject]
//        let dict1 = ["name": "老王", "age": 18]
//        print(dict1)

        // 初始化一个空字典
        var dict2 = [String : NSObject]()
        dict2["name"] = "老王"
        dict2["age"] =
        print(dict2)

        // 这种方式赋值的话,如果字典里面存对应key的键值对的话,会覆盖掉原来的值
        dict2["name"] = "老李"
        print(dict2)

//        // 取值
//        let r1 = dict2["name"]
//        print(r1)

        // 移除值
        dict2["name"] = nil
        print(dict2)
    }

    // 数组的容量,容量就代表数组能够装多少元素
    func demo4(){

        var array = [Int]()
        for i in ..< {
            array.append(i)
            // 打印array的容量
            print("当前count:\(array.count),容量是:\(array.capacity)")
        }
    }

    // 数组的合并
    func demo3(){
        var array1 = ["老王", "老张"]
        let array2 = ["老李", "小尹"]

        array1 += array2
        print(array1)

//        let result = array2 + array1
//        print(result)
    }

    // 数组的遍历
    func demo2(){
        let array = ["老王", "老张", "老李"]

        // 方式1:
        for var i = ; i < array.count; i++ {
            print(array[i])
        }

        print("============")
        // 方式2: for in

        for value in array {
            print(value)
        }

        // 方式3:
        for (index, value) in array.enumerate() {
            print("index=\(index);value=\(value)")
        }
    }

    /// 数组的定义,初始化
    /**
        - 使用 let 定义不可变数组,使用 var 定义可变数组

    */
    func demo1(){

//        var a = ["老王", 10]
//        a.append(NSValue(CGRect: CGRectZero))

//        var a = [CGRectZero, CGRect(x: 0, y: 0, width: 10, height: 10)]
//         a.append(CGRectZero)

        // 定义一个数组
        let array1 = ["老王", "老李", "老张"]

        print(array1)
        // 定义一个空数组
        var array2: [Int] = [Int]()
        // 添加元素
        array2.append()
        array2.append()
        array2.append()
        print(array2)

        // 数组取值
        print(array2[])

        // 移除值
        array2.removeFirst()
        print(array2)
    }

9.函数

 override func viewDidLoad() {
        super.viewDidLoad()
        // demo1()
        // sum1(10, b: 5)
        // sum2(num1: 4, num2: 6)

//        let result = sum3(num1: 5, num2: 7)
//        print(result)

        demo()

    }

    // 任务1: 定义一个没有参数没有返回值的函数
    // 格式: func 函数名() { __函数执行代码__ }
    func demo1(){
        print("哈哈")
    }

    // 任务1: 定义一个有参数没有返回值的函数
    // Swift中函数的第一参数名字在调用的时候默认省略
    // 格式: func 函数名(形参名1: 类型, 形参名2: 类型, ...) { __函数执行代码__ }
    func sum1(a: Int, b: Int) {
        print(a + b)
    }

    // 带有外部参数的函数
    // 格式: func 函数名(外部参数名1 形参名1: 类型, 外部参数名2 形参名2: 类型, ...) { __函数执行代码__ }
    func sum2(num1 a: Int, num2 b: Int) {
        print(a + b)
    }
    /// 定义一个有参数有返回值的函数(有外部参数的函数)
    // 格式: func 函数名(外部参数名1 形参名1: 类型, 外部参数名2 形参名2: 类型, ...) -> 返回值类型 { __函数执行代码__ }
    func sum3(num1 a: Int, num2 b: Int) -> Int {
        return a + b
    }

    // 没有返回值的3种表现形式

    // 方式1
    func demoAA(){

    }

    // 方式2
    func demoBB() -> Void {

    }

    // 方式3
    func demoCC() -> () {

    }

    // 嵌套函数
    func demo(){
        // 作用范围是在当前 demo 的函数体内
        func haha(){
            print("哈哈")
        }

        haha()
    }

10.闭包

    override func viewDidLoad() {
        super.viewDidLoad()
        demo3A()
        demo3B()
    }

    // MARK: - 定义一个有参数有返回值的闭包

    // 任务3: 定义一个有参数有返回值的闭包
    func demo3B(){
        // 闭包的类型: (num1: Int, num2: Int) -> Int
        let clourse = { (num1 a: Int, num2 b: Int) -> Int in
            return a + b
        }

        let result = clourse(num1: , num2: )
        print(result)

    }

    // 内部定义一个有参数有返回值的函数
    func demo3A(){

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

        let result = sum(num1: , num2: )
        print(result)
    }

    // MARK: - 定义一个有参数没有返回值的闭包

    // 任务2: 定义一个有参数没有返回值的闭包
    func demo2B(){

        // 有参数没有返回值的闭包类型: (num1: Int, num2: Int) -> ()
        let clourse = { (num1 a: Int, num2 b: Int) in
            print(a + b)
        }

        clourse(num1: , num2: )
    }

    // 内部定义一个有参数没有返回值的函数
    func demo2A(){

        func sum(num1 a: Int, num2 b: Int) {
            print(a + b)
        }
        sum(num1: , num2: )
    }

    // MARK: - 定义一个没有参数没有返回值的闭包

    // 任务1: 定义一个没有参数没有返回值的闭包
    func demo1B(){
        // 没有参数没有返回值的闭包的类型: () -> ()
        let clourse = {
            print("哈哈")
        }
        clourse()

        // 定义一个函数,将上面的闭包作为参数传入
//        func haha(callback: () -> ()) {
//            callback()
//        }
    }

    // 内部定义一个没有参数没有返回值的函数
    func demo1A(){
        func haha(){
            print("哈哈")
        }
        haha()
    }

    // MARK: - 没有返回值的三种情况

    // 如果闭包没有参数没有返回值

    func demo1(){
        let clourse1 = { (num1 a: Int, num2 b: Int) -> () in
            print("哈哈")
        }

        let clourse2 = { (num1 a: Int, num2 b: Int) -> Void in
            print("哈哈")
        }

        let clourse3 = { (num1 a: Int, num2 b: Int) in
            print("哈哈")
        }

    }