一、常量與變量

  let聲明常量(在整個(gè)生命周期只允許賦值一次)
  var聲明變量
         //不允許再次賦值，會(huì)報(bào)錯(cuò)
        let a = 1
            a = 10
        //可以先聲明類型再賦值
        let b : Int
            b = 10

        //let聲明的常量不要求在編譯期間確定 c在整個(gè)編譯期間可以一直改變導(dǎo)致d無法確定，只要保證用之前賦值一次就行
        var c = 1
        let d = c

  使用let 和 var 要么賦值要么明確聲明對(duì)象的類型，在使用前必須要賦值

二、基本數(shù)據(jù)類型

Bool、Int、Float、Double
String、數(shù)組[T]、字典[T1 : T2]、元組

1.字符串操作

       //閉區(qū)間...
       //開區(qū)間..<
       let strEN = "hello world"
       let strCN = "你好世界"

       //拼接
       let str10 = strEN + strCN
       print(str10)

       //截取
       let str20 = strEN.prefix(2)
       let str21 = strEN.suffix(2)

       let startIndex = strEN.index(strEN.startIndex, offsetBy: 2)
       let endIndex = strEN.index(strEN.startIndex, offsetBy: -2)
       let str22 = strEN[startIndex...endIndex]
       print(str20, str21, str22)

2.數(shù)組操作

let arr = [1, 1, 2]
        var arrM = [7, 8, 9, 10, 11, 12, 13]
        var arrM1 = ["4", "5", "6"]

        //增
        arrM.append(2)
        print("增\(arrM)")

        arrM.insert(100, at: 2)
        print("插入\(arrM)")

        //刪
        arrM.remove(at: 0)
        print("刪除\(arrM)")

        //改
        arrM[2] = 1000
        print("改\(arrM)")

        //查
        let num = arr[2]
        print("查\(num)")

//遍歷
        //1、forin遍歷 帶下標(biāo)
        for index in 0..<arr.count {
            print(arr[index]) // 1 1 2
        }

        //2、forin遍歷
        for item in arr {
            print(item) // 1 1 2
        }

        // 3、enum block遍歷：同時(shí)拿下標(biāo)和元素（元組接收）
        for (index, item) in arr.enumerated() {
            print(index, item)
        }

        // 4、反向遍歷數(shù)組，for-in直接拿數(shù)據(jù)內(nèi)元素
        for item in arr.reversed() {
            print(item) // 2 1 1
        }

        // 5、反向遍歷數(shù)組，enum block遍歷：同時(shí)拿下標(biāo)和元素（元組接收）：必須先enumerated，后reversed
        for (index, item) in arr.enumerated().reversed() {
            print(index, item)
        }

3.字典操作

//注意字典無序
        let dic = ["age": 18, "name":9]
        var dicM:[String:Any] = ["age": 18, "name":"zfc"]

        //增
        dicM["height"] = 1.88
        print("增\(dicM)")

        //刪  字典無序 通過removeAtIndex刪除會(huì)導(dǎo)致問題
        dicM.remove(at: dicM.index(dicM.startIndex, offsetBy: 1))
        print("刪index:\(dicM)")

        dicM.removeValue(forKey: "age")
        print("刪key:\(dicM)")

        //改
        dicM["height"] = 1.70
        print("改:\(dicM)")

        //查
        let hegit = dicM["height"]
        print("查:\(dicM)")

        // 同時(shí)拿key和value（元組接收） 字典無序enumerated()無意義
        for (key, value) in dicM {
            print(key, value)
        }

4.元組類型

let tuple = ("張三", 18, 1.88)
        print(type(of: tuple)) // (String, Int, Double)
        print(tuple.0) // 張三
        print(tuple.1) // 18
        print(tuple.2) // 1.88

        // 像字典一樣使用元組，只不過元組的語法糖是個(gè)小括號(hào)()
        var tuple1 = (name: "張三", age: 18, height: 1.88)
        print(tuple1.name) // 張三
        print(tuple1.age) // 18
        print(tuple1.height) // 1.88

        //應(yīng)用場(chǎng)景
        //1.給多個(gè)變量賦值
        let (name, _, height) = ("張三", 18, 1.88)

        //2.作為函數(shù)的返回值，來實(shí)現(xiàn)多返回值的效果
        func fn() -> (name: String, age: Int, height: Double) {
            return (name: "張三", age: 18, height: 1.88)
        }

5.函數(shù)

    //函數(shù)定義格式
    func 函數(shù)名(函數(shù)的參數(shù)) -> 函數(shù)的返回值 {
        函數(shù)的執(zhí)行體
    }

    //函數(shù)可選參數(shù)與必選參數(shù)
    // num1必選參數(shù)，num2可選參數(shù)
    func sum(num1 : Int, num2 : Int = 2) -> Int {
        return num1 + num2;
    }
    print(sum(num1: 11)) // num1必須得傳，num2可以不傳，結(jié)果為13
    print(sum(num1: 11, num2: 22)) // num1必須得傳，num2也可以傳，結(jié)果為33

    func sum(_ num1 : Int, _ num2 : Int = 2) -> Int {
        return num1 + num2;
    }
    print(sum(11)) // 11
    print(sum(11, 22)) // 33

6.可選？

var age:Int? //所有可選項(xiàng)類型的變量的默認(rèn)值都是nil
        //？可選類型：表示變量 age 允許為nil
        //! 可選變量age后面跟表示強(qiáng)制解包，前提是可選變量age不為nil,不然會(huì)造成崩潰

        //可選項(xiàng)解包(三種方式)
        //1.判斷可選變量age是否為nil，不為nil再進(jìn)行強(qiáng)制解包
        if age != nil { // 判斷一下可選項(xiàng)變量age是不是nil
            print(age!)
        } else {
            print("age為nil")
        }

        //2.可選項(xiàng)綁定解包（if let/var、guard let/var）
        if let age = age {
            // 臨時(shí)常量age的作用域僅限于這個(gè)大括號(hào)，并且已經(jīng)是解包之后的數(shù)據(jù)了
            print(age)
        } else {
            // 臨時(shí)常量age的作用域不包含這個(gè)大括號(hào)
            print("age為nil")
        }

        //guard作用域不再自己的大括號(hào)中，而在外層大括號(hào)中
        guard var age = age else {
            return
        }

        var age1:Int?
        //3.小三目運(yùn)算符解包??
        //如果??前面的可選項(xiàng)有值，那么就會(huì)自動(dòng)解包后使用該值；如果??前面的可選項(xiàng)為nil，就使用??后面的值。
        let str2: Int = age1 ?? 0

7.閉包

    //普通閉包
    var closure = {(a:Int, b:Int) -> Int in
        return a + b
    }



    //尾隨閉包，是一個(gè)被書寫在函數(shù)調(diào)用括號(hào)外面的閉包表達(dá)式,使用尾隨閉包增強(qiáng)函數(shù)的可讀性
    func exe(a:Int, b:Int, closure:(Int, Int)->Int) {
        print(closure(a, b))

//        exe(a:100, b:1, closure:{a, b -> Int in return a + b})  //原始
//        exe(a:100, b:1, closure:{a, b -> Int in a + b})         //簡(jiǎn)化,去掉return
//        exe(a:100, b:1, closure:{$0 + $1})                      //簡(jiǎn)化,去掉a,b
//        exe(a:100, b:1, closure:+)                              //簡(jiǎn)化,直接用+
    }

    func exe1(closure:()-> Void) {
        print("測(cè)試");
    }