Swift语法

Swift的基本语法：

 

swift中的所有代码，都包含在最外侧的 {}中。

oc与swift比较：

1.oc的alloc initWithXXX 在swift中是 （xxx:）

 

2.oc中的类方法在swift中是.语法

 

 

3.oc中的枚举 在swift中用点语法隔开，也可以直接省略前缀，但不建议

例如： OC 的枚举 UIButtonTypeContactAdd

Swift 中 UIButtonType.ContactAdd

1>可以直接省略前缀 .ContactAdd，但是Xcode 的智能提示有的时候不给力

2> 如果没有智能提示，可以直接 `回车`，`->`，`.`

4、监听方法              

swift直接使用字符串，提示：可以直接用智能提示，然后加引号和左右键，

如果有参数直接增加`:`

5. 没有分号 － 在程序语言中，`;` 用于拆分语句，表示一个完整的语句结束

Swift 中，大多数情况下不需要分号

例如：

leta = 10; let b = 20

6.所有的swift 程序如果崩溃在AppDelegate，都是oc的问题， oc是消息机制

7.变量和常量：

 1.    

 let a = 20

       
        // a = 30会报错，因为let是定义常量，一旦设置就不能修改
       
        var b = 20
       

        b = 40 //不会报错，因为var是定义变量，设置以后可以修改

2.

///自动推导 - 可以根据右侧的计算结果，推导出左侧变量／常量的类型
    /// Option + Click 热键非常重要，可以快速查看变量的准确类型
    /// 但是：Swift对类型转换要求非常严格，任何不同类型之间的数据，不允许计算
    /// Int 和Double 都是结构体，而 不是基本数据类型！
    func demo2() {
        //整型默认类型是int，如果64位机器，long 、32位机器 ，int
        let x = 10
        // 在Swift中，小数默认是 Double ，双精度，精度比float高
        //在 OC中， 默认是 float，浮点数
        let y = 10.5
       
//        print(x +y)会报错： Binary operator '+' cannot be applied to operands of type 'Int' and 'Double'  ----如果要给不同类型的数据进行计算，必须手动转换类型。
            // OC 中如果要做类型转换`(int)y`
        // Swift中，使用的是`Int()` 构造函数 `init`
//        例子：
        print(x + Int(y))
        print(Double(x) + y)
       
        //也可以这样转换：如果定义的变量／常量需要指定自己需要的类型，可以使用`:类型`
        let a: Double = 10; let b = 20.9  //let a = 10; let b: Int = 20.9
       
        print(a + b)
       

    }

3.如果仅仅定义类型，并没有设置数值，会报一个没有初始化的错误： Constant 'x' used before being initialized

例子： func demo3() {
        // 仅仅定义了类型，并没有设置数值
        let x: Int
       
        // 常量定义完成类型后，可以有`一次`设置机会
        x = 10
        // 设置之后，不允许再修改
        // x = 20
       
        // Constant 'x' used before being initialized
        // 常量在使用之前，必须要做初始化
        print(x)

    }

4.  如何选择变量和常量？，只有在需要改变的时候，才应该使用‘var’

 如果从来没有变过的变量，Xcode会提示使用 let

 例子：letv = UIView()

       // 修改了 v 的属性，而没有修改 v 的`地址`

        v.backgroundColor= UIColor.redColor()

8.可选项： 表示一个值可以有内容，也可以为 nil

 1.定义可选项，最原始的方法， let x: Optional = 10 ： Optional，表示x 要么有整数值，要么为 nil。 表示泛型

2.  2. 定义可选项，类型?的格式 ：  let y: Int? ：Int? 表示 x 要么有整数值，要么为 nil，`?` 是专门用来定义可选项的，

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

例子：

lety: Int?

        y =10
       
        print(y)

       

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

例子：

varz: Int?

        z = 100

        print(z) // nil

3.注意：

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

       // `!` 又叫做强行解包！从可选项中把值取出来，如果没有值，抛出异常

例子： print(x! + y! + z!)

9.控制流

1、基本 if 逻辑 

注意的地方：  1. 没有 ()
            2. 必须要有 `{}`
            3. 没有单条的 if ，一定要使用 {}
                `{}` 是用来包装一段代码
            4. 很多公司的代码规范中，是不允许不使用 {}

            5. Swift中没有，非零即真，所有的逻辑条件必须指定true / false

例子：

 letx = 10

 if x > 5 {
            print("大")
        } else {
            // 编译器自动判断分支结构，无法进入
            print("小")

        }

2、三目运算

let x = 10

x > 5 ? print("大") : print("小”) // 三目运算符 在Swift 中如果使用得当，能够简化代码

3、 `()` 表示执行，空的执行， 例子：  x >6 ? print("大") : ()

4、可选项参与计算前需要解包，在 Swift 中，关于if 语句如果没有写好，可能会非常的丑陋！

例子：

letx: Int? = 10

ifx !=  nil{
            print(x! +10)

        }

5、 ??   -- (x ?? 0)：表示  对于可选项 x，如果有值，使用x 的值， 如果没有值，使用?? 后面的值替代。注意： ?? 的优先级低，为了不必要的麻烦，一定记住使用 ()

6、 if let/var 

if let ： 作用 ：判断(是否为nil) + 设置数值  ，分支内部的 num 是一定有值的，可以避免考虑`!` 的问题， num 的作用域只是在 {} 内部 ， 使用频率高，if let 可以同时判断多值，使用，隔开，如果其中有一个值为nil，那就打印不出值来。大括号的作用，标示作用域，否则会穿透的。  

letx: Int? = 10

iflet num = x {

            // num += 10 let不能修改数值，想要修改数值的话，就用 if var

           print(num)

        }

if var：如果在分支内部希望修改数值，可以使用if var，

7、guard 守卫，在 Swift 2.0 推出的语法。

        //和 if let刚好相反
        // guard let是在判断之后的分支有效

       // 如果守护的变量为 nil，直接提示并且返回

例子： var x: Int? =10
       
        var oName:String? ="老二"
       
        var oAge:Int? =19
       
       
        guardlet  num = xelse {
           
            print("x wei nil")
            return
        }
        guardlet  name = oNameelse {
           
            print("name wei nil")
           
            return
        }
        guardlet age = oAgeelse {
           
            print("age wei nil")
            return

        }

        //当所有条件都满足之后，开始真正的逻辑处理
        //通常下面的代码更复杂，少一层 `{}`的嵌套！

       // 提示：无论从阅读角度，还是编译角度，都需要尽量减少嵌套层次！

        print(x)
        print(age)
        print(name)
        print(num)
       结果： //Optional(10)
             //19
             //老二

             //1

control +i 自动调整缩进 

10、 switch 

        1.没有 break
        2. 不仅仅局限在 int，可以对任何类型的数据进行 switch
        3. 每一个 case都必须至少有一条语句，如果实在没有，可以用 break
        4. 如果要 switch多值，使用 ,分隔
        5. case 要涵盖所有的可能，如果不能列举，需要使用 default
     穿透

  

   func demo() {
       
        let x =“9”、9、9.9 
       
        switch x {
        case"10","9":print("优")

        case"8":print("良")

        case  “7":break

       default:print("一般")
        }

    }

11、for 循环

1.for变量 in范围 { //代码实现 }，0..<5表示 0~4的范围。注意：`..<`和 `...`用于定义 `Range`类型，左右都不要添加空格

例子： for i in0..<5 {
            print(i) 01234

        }

 // 0...5表示 0~5的范围
        for iin0...5 {
            print(i)

        }

2.Range表示一个整数的范围 ：起始值..<结束值  

例子：let range1 =0..<5

        print(range1) 答案：0..<5

       let range2 =0...5

        print(range2)答案： 0..<6

3.传统的 for

            没有 ()

            i是一个 var，循环过程中，增长

           提示：Swift 3.0中，i++将被取消
       
            i++ / ++i
       
            num = i++
            等效代码
            temp = i + 1
            num = i
            i = temp
       
            num = ++i
            等效代码
            i = i + 1
            num = i

      

     例子：   forvar i = 0; i <10; i +=1 {
            print(i)

        }

11、字符串

Swift   String，是一个结构体，量级更轻，效率略高，推荐使用，可以支持遍历

1.oc的NSString不支持遍历的 swift的String支持遍历。

       let string:String ="飞的更高"
       
        // 遍历字符串
        for cin string.characters {
            print(c)

        }

2.字符串拼接

        let name ="zhangsan"
        let age =18
        let point =self.view.center
       
        // 格式 "\(变量/常量名)"
        //告别了 -> NSStringStringWithCGPoint

       print("\(name) ~~~ \(age)\(point)")

3.字符串的长度：将字符串转换成对应编码 UTF8字节的长度，一个中文对应的 UTF8编码占 3个字节， UTF8的字符，占用字节数为 1~4个，

 例子：

let name ="hello world你好世界"

print(name.lengthOfBytesUsingEncoding(NSUTF8StringEncoding)) 23

//获得字符串中字符的个数

       print(name.characters.count) 15

// as是类型转换 => OC (CZDemoCell *)UITableViewCell  转换成 NSString类型
        let ocName = nameasNSString

        print(ocName.length) 15

4. 格式化字符串

        let h =8
        let m =5
        let s =6
       

        let dateStrig = "\(h):\(m):\(s)"

        print(dateStrig) 8:5:6

       
        // 使用数组生成格式字符串
        // String(format: <#T##String#>, arguments: <#T##[CVarArgType]#>)
       方式一: let dateString1 =String(format:"%02d:%02d:%02d", arguments: [h, m, s])
        print(dateString1)  08:05:06
       

        // String(format: <#T##String#>, <#T##arguments: CVarArgType...##CVarArgType#>)

        方式二：let dateString2 =String(format:"%02d:%02d:%02d", h, m, s)

        print(dateString2)  08:05:06

5.子串 -方便的方法，转换成 NSString

  例子：  let str ="我们一起去飞"

       
        // 1. 方法1，使用 NSString
        let subStr1 = (strasNSString).substringWithRange(NSMakeRange(2,4))
        print(subStr1)
       
        // 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)

       

        // 提示如果范围越界，会崩溃 str.substringWithRange(aRange: Range)类型

       let subStr4 = str.substringWithRange(startIndex..

        print(subStr4)

12.集合（数组和字典）

A：数组：

 1.定义一个空的数组：  let array =[String]()：[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)

2.遍历数组

let array = ["zhang","wang","li"]
       
        // 1. 直接按照下标遍历
        for iin0..count {
            print(array[i])
        }
       
        // 2. for in
        // s的类型取决于数组的类型
        for sin array {
            print(s)
        }
       
        // 3. 遍历内容和下标
        for ein 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 sin array.reverse() {
            print(s)
        }
       
        // 6. 倒序下标遍历
        for ein array.reverse().enumerate() {
            print(e)
            print("\(e.index)\(e.element)")

        }

3.增删改 ->可变 NSMutableArray -- var /不可变 NSArray -- let

 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)
       

        // 删除全部

  

       

       array.removeAll()

        print(array)

4.演示数组的容量

///定义类型，没有初始化，如果定义一个空的数组
//        var array: [String]
//        // 实例化一个空的字符串数组
//        array = [String]()
        //以上两句代码也可以合并成一条语句
        var array = [Int]()
        print(array.capacity)0
       
        // 关于容量：数组的初始容量默认是0
        //在添加元素的时候，如果超出当前容量范围，在当前容量范围基础上 * 2
        for iin0..<9 {
            array.append(i)

            print("\(array) --容量 :\(array.capacity)”) 16

        }

5.合并数组

 var a1 = [1,2,3]
        let a2 = [4,5,6]
       
        // 目标，将 a2合并到 a1中
        a1 += a2
       

        print(a1)

B:字典

1.字典的定义：OC中使用 {}  Swift中还是 []， 类型： [String : NSObject] / [String : AnyObject]在 Swift开发中，非常普遍

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

2.字典的遍历

let dict = ["name":"zhang","age":18]
       
        // 0 是 key
        // 1是 value
        //语义不直观
        for ein dict {
            print("\(e.0),\(e.1)")
        }

      

           前面的参数 key是 KEY

            后面的参数 value 是值

       

       for (key, value)in dict {

           print("\(key)\(value)")

        }

3.增删改，可变 var，不可变 let

 //字典中的 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)

    4.拼接

        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)