Swift 基本语法 : 一

• let 定义常量，一经赋值不允许再修改
• var 定义变量，赋值之后仍然可以修改

  1.  BUTTON  的监听方法 

         //  button 监听方法

        btn.addTarget(self, action: "clickButton:", forControlEvents: .TouchUpInside)
       

    }

   //在 action: "clickButton:” 先写下面的方法

 

    func clickButton(btn: UIButton) {
        print(__FUNCTION__)
        print(btn)

    }

  2. 没有隐式转换！！！

// 如果要对不同类型的数据进行计算，必须要显式的转换

// 注意：Int & Double 都是结构体，而不是基本数据类型

// 整数默认的类型是 Intlet x: Int = 200// 小数的默认类型是 Doublelet y: Double = 10.5// Binary operator '+' cannot be applied to operands of type 'Int' and 'Double'// 不同数据类型之间不能直接计算// print(x + y)// 如果要对不同类型的数据进行计算，必须要显式的转换print(x + Int(y))print(Double(x) + y)

3.Optional-可选项

                //定义可选项，类型?的格式

       // Int? 表示 x 要么有整数值，要么为 nil
        // `?` 是专门用来定义可选项的

       // 常量的可选项，没有默认值

        let y: Int?

        y =10

        // 变量的可选项，默认值是 nil

        var z: Int?

        z = 100

        // 可选项不能直接参与计算！因为可能有值，也有可能为 nil
        // 如果要让可选项参与计算，需要 `解包unwarp`
        // unexpectedly found nil while unwrapping an Optional value
        // 翻译：在解包可选项的时候，发现了空值
        // `!` 用来解包 - 如果出现 任何一个值为nil，会直接崩溃！
        // `!`表示程序猿向编译器承诺，一定有值，如果没有，就崩！
        // `!`又叫做强行解包！从可选项中把值取出来，如果没有值，抛出异常

       print(x! + y! + z!)

4.三目运算

     1.  ///三目运算

   func demo2() {

       let x =10

       // 三目运算符在 Swift 中如果使用得当，能够简化代码

        x > 5 ?print("大") : print("小")

       if x >6 {
            print("大")

        }

       let v =UIView()

       /* 目的：`()`表示执行，空的执行*/

        x > 6 ?print("大") : ()

    }

     2.  /// ?? 的使用方法
    func optionDemo2() {

       var x: Int?//= 10

       // (x ?? 0)
        // 对于可选项x，如果有值，使用x 的值
        // 如果没有值，使用?? 后面的值替代
        // 正确写法
        print((x ?? 0) + 10)
       
        // ?? 的优先级低，为了不必要的麻烦，一定记住使用 ()
        // 错误的写法
        print(x ?? 20 + 10)

    }

  3./// if let/var  的使用

         可选项的演示

   /// if let/var
    func optionDemo3() {

       var x: Int? =10

       // if let 判断(是否为nil) +设置数值
        // 分支内部的num 是一定有值的，可以避免考虑 `!` 的问题
        // num 的作用域只是在{} 内部
        // 使用频率高！
        if let num = x {
            // num += 10
            print(num)

        }

       // 如果在分支内部希望修改数值，可以使用 if var
        if var num = x {
            num += 10
            print(num)

        }

       // if let x = x，前面的x 是一个临时的局部变量，作用域仅在 {}
        // 用处：有的时候，起名字困难！
        if let x = x {
            print("----")
            print(x +10)
        }

    }

4.  guard的用法

 /// guard 守卫，在Swift 2.0 推出的语法
    func optionDemo4() {
        varx: Int? = 10
        varoName: String? //= "老王"
        var oAge: Int? = 18
       
        // 和 if let 刚好相反
        // guard let 是在判断之后的分支有效
        // 如果守护的变量为 nil，直接提示并且返回
        guard let num = x else{
            print("x为 nil")
            return

        }

       guard let name = oName else {
            print("name为 nil")
            return

        }

       guard let age = oAge else {
            print("age为 nil")
            return

        }

       // 当所有条件都满足之后，开始真正的逻辑处理
        // 通常下面的代码更复杂，少一层`{}` 的嵌套！
        // 提示：无论从阅读角度，还是编译角度，都需要尽量减少嵌套层次！
        print(num)
        print(name)
        print(age)
        // 可选项值打印 Optional(10)
        print(x)

    }

• guard 是与 if let 相反的语法，Swift 2.0 推出的 
• 使用 guard 的好处
• • 能够判断每一个值
  • 在真正的代码逻辑部分，省略了一层嵌套

• let oName: String? = "张三"let oNum: Int? = 18guard let name = oName else {    print("name 为空")    return}guard let num = oNum else {    print("num 为空")    return}// 代码执行至此，name & num 都是有值的print(name)print(num)

5.控制流

• if let 不能与使用 &&、|| 等条件判断
• 如果要增加条件，可以使用 where 子句
• 注意：where 子句没有智能提示

可选项条件判断

//: 2> 使用 where 关键字， if let u = urlwhere u.host == "www.baidu.com" {    let request = NSURLRequest(URL: u) }

多个可选项判断

iflet name = oName, let no = oNo {     print("姓名:" + name + " 学号: " +String(no)) }

判断之后对变量需要修改

let oName: String? = "张三" let oNum: Int? = 1

ifvar name = oName, num = oNum {     name = "李四"     num =1

print(name, num) }

6.取字符串子串

 // 2. 方法2，Swift的语法
        // startIndex是字符串的起始索引位置 -> 0
        // endIndex是字符串的结束的索引位置-> count
        // advancedBy是将索引递进的函数
        //  n > 0向右递进 n 个字符
        //  n < 0向左递进 n 个字符
        letsubStr2 = str.substringFromIndex(str.startIndex.advancedBy(2))
        print(subStr2)
       
        // can not increment endIndex，不允许递增endIndex，会出现越界
        letsubStr3 = str.substringToIndex(str.endIndex.advancedBy(-2))
        print(subStr3)
       
        // 从 Xcode 7 beta 5 开始就固定了格式了
        letstartIndex = str.startIndex//.advancedBy(2)
        letendIndex = str.endIndex//.advancedBy(-2)
       
        print(startIndex)
        print(endIndex)
       
        // 提示如果 范围越界，会崩溃
        letsubStr4 = str.substringWithRange(startIndex..<endIndex)
        print(subStr4)

    }

7.数组 和 字典   ---------遍历的方法  6种

 // MARK: - 字典
    /// 拼接
    func demo9() {
        var dict1 = ["name":"zhang", "age": 18]
        let dict2 = ["title":"boss", "name": "老王","height": 1.3]
       
        // 目标，将 dict2 的内容合并到 dict1 中
        // dict1 += dict2
        //遍历字典2，依次设置数值
        //遵守 key 唯一的原则，如果有，覆盖/ 如果没有 新建
        for(k, v) in dict2 {
            dict1[k] = v
        }
       
        print(dict1)
    }
   
    /// 增删改
    /// 可变 var
    /// 不可变 let
    func demo8() {
        // 字典中的 key 是通过 hash 哈希值来取值的 －在字典中 key 是唯一的
        vardict = ["name":"zhang", "age": 18]
       
        // 添加值 - 如果 key 不存在，新建值对
        dict["title"] ="boss"
       
        print(dict)
       
        // 修改值 - 如果 key 存在，覆盖原有值对
        dict["name"] ="老王"
        print(dict)
       
        // 删除
        dict.removeValueForKey("age")
        print(dict)
       
        // 还有一种删除方法
        dict["name"] =nil
        print(dict)
    }
   
    /// 字典的遍历
    func demo7() {
        let dict = ["name":"zhang", "age": 18]
       
        // 0 是 key
        // 1是 value
        //语义不直观
        fore in dict {
            print("\(e.0),\(e.1)")
        }
       
        /**
            前面的参数 key 是 KEY
            后面的参数 value 是 值
        */
        for (key, value)in dict {
            print("\(key)\(value)")
        }
    }
   
    /// 字典的定义
    /// OC中使用 {}
    /// Swift中还是 []
    func demo6() {
       
        // [String : NSObject] / [String : AnyObject]在 Swift 开发中，非常普遍
        /**
        An object that may be converted to JSON must have the following properties:
       
        - Top level object is an NSArray or NSDictionary
            顶级节点是 NSArray 或者 NSDictionary
        - All objects are NSString, NSNumber, NSArray, NSDictionary, or NSNull
            所有对象必须是 NSString, NSNumber, NSNull
            字典和数组中只能包含以上三种类型的值
        - All dictionary keys are NSStrings
            所有字典的 key 都必须是 NSString
        - NSNumbers are not NaN or infinity
            数值不能为空或者无穷大 (infinity)
        */
        let dict = ["name":"zhang", "age": 18]
       
        print(dict)
    }
   
    // MARK: - 数组的演练
    /// 合并数组
    func demo5() {
        var a1 = [1,2, 3]
        let a2 = [4,5, 6]
       
        // 目标，将 a2 合并到 a1 中
        a1 += a2
       
        print(a1)
    }

    /// 演示数组的容量
    func demo4() {
        /// 定义类型，没有初始化，如果定义一个空的数组
//        var array: [String]
//        // 实例化一个空的字符串数组
//        array = [String]()
        //以上两句代码也可以合并成一条语句
        vararray = [Int]()
        print(array.capacity)
       
        // 关于容量：数组的初始容量默认是0
        //在添加元素的时候，如果超出当前容量范围，在当前容量范围基础上* 2
        fori in 0..<9 {
            array.append(i)
            print("\(array) -- 容量: \(array.capacity)")
        }
    }
   
    /// 增删改 -> 可变 NSMutableArray -- var / 不可变 NSArray -- let
    func demo3() {
        var array = ["zhang","wang", "li"]
       
        // 添加内容 addObject
        array.append("小花")
       
        print(array)
       
        // 以下代码有问题吗？
        // Cannot convert value of type 'Int' to expected argument type 'String'
        //不能向数组中追加不允许的类型
        // array.append(180)
       
        // 修改
        array[0] ="老王"
        print(array)
       
        // 删除全部
        //其他的语法 remove 开头，大家可以课后练习！
        array.removeAll()
        print(array)
    }
   
    /// 遍历数组
    func demo2() {
        // [String]
        letarray = ["zhang","wang", "li"]
       
        // 1. 直接按照下标遍历
        fori in 0..<array.count{
            print(array[i])
        }
       
        // 2. for in
        // s的类型取决于 数组的类型
        fors in array {
            print(s)
        }
       
        // 3. 遍历内容和下标
        fore in array.enumerate() {
            print("\(e.index)\(e.element)")
        }
       
        print("----")
       
        // 4. 示例代码
        // n就是索引，s就是字符串
        // n和 s 的名字可以随便写
        for(n, s) in array.enumerate() {
            print("\(n)\(s)")
        }
       
        print("----")
        // 5. 倒序遍历数组
        fors in array.reverse() {
            print(s)
        }
       
        // 6. 倒序下标遍历
        fore in array.reverse().enumerate() {
            print(e)
            print("\(e.index)\(e.element)")
        }
     }
   
    /// 数组的定义 []
    func demo1() {
        // [String] -> 表示存放字符串的数组
        //根据右侧的内容自动推导数组中的元素类型
        letarray = ["zhang","wang", "li"]
       
        // [Int]，Swift中基本数据类型不需要包装，Int是一个结构体
        letarray1 = [1,2, 3, 4,5]
       
        // [NSObject](继承自NSObject 的子类) ->
        // [AnyObject]，在Swift 中使用的更多，任意对象
        // Swift中允许对象没有任何父类
        //如果数组中的元素类型不一致，会推导出[NSObject] 类型
        letarray2 = [1,"zhang"]
       
        print(array)
    }

}