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 都是结构体，而不是基本数据类型

// 整数默认的类型是 Int
let x: Int = 200
// 小数的默认类型是 Double
let 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() {
        var x: Int? = 10
        var oName: 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? = 18
  
  guard 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 = url where u.host == "www.baidu.com" {     let request = NSURLRequest(URL: u) }

多个可选项判断

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

判断之后对变量需要修改

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

if var 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 个字符
        let subStr2 = str.substringFromIndex(str.startIndex.advancedBy(2))
        print(subStr2)
       
        // can not increment endIndex，不允许递增 endIndex，会出现越界
        let subStr3 = str.substringToIndex(str.endIndex.advancedBy(-2))
        print(subStr3)
       
        // 从 Xcode 7 beta 5 开始就固定了格式了
        let startIndex = str.startIndex //.advancedBy(2)
        let endIndex = str.endIndex //.advancedBy(-2)
       
        print(startIndex)
        print(endIndex)
       
        // 提示如果 范围越界，会崩溃
        let subStr4 = 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 是唯一的
        var dict = ["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
        // 语义不直观
        for e 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]()
        // 以上两句代码也可以合并成一条语句
        var array = [Int]()
        print(array.capacity)
       
        // 关于容量：数组的初始容量默认是0
        // 在添加元素的时候，如果超出当前容量范围，在当前容量范围基础上 * 2
        for i 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]
        let array = ["zhang", "wang", "li"]
       
        // 1. 直接按照下标遍历
        for i in 0..<array.count {
            print(array[i])
        }
       
        // 2. for in
        // s 的类型取决于 数组的类型
        for s in array {
            print(s)
        }
       
        // 3. 遍历内容和下标
        for e 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. 倒序遍历数组
        for s in array.reverse() {
            print(s)
        }
       
        // 6. 倒序下标遍历
        for e in array.reverse().enumerate() {
            print(e)
            print("\(e.index) \(e.element)")
        }
     }
   
    /// 数组的定义 []
    func demo1() {
        // [String] -> 表示存放字符串的数组
        // 根据右侧的内容自动推导数组中的元素类型
        let array = ["zhang", "wang", "li"]
       
        // [Int]，Swift中基本数据类型不需要包装，Int 是一个结构体
        let array1 = [1, 2, 3, 4, 5]
       
        // [NSObject](继承自 NSObject 的子类) ->
        // [AnyObject]，在 Swift 中使用的更多，任意对象
        // Swift 中允许对象没有任何父类
        // 如果数组中的元素类型不一致，会推导出 [NSObject] 类型
        let array2 = [1, "zhang"]
       
        print(array)
    }

}