Swift基础-01

1.Swift中let和var的基本用法

        let a: Double = 10.5
        let b = 11.5
        print(a + b)
        
        let view = UIView()
        // 定义的view是let，为什么可以修改
        // 因为在这里修改的view的属性，并没有修改view的指针
        view.backgroundColor = UIColor.red

2.在swift中不存在基本数据类型，都是结构体，不同类型的数据直接，不允许直接运算

      var x = 10
      x = 20
      print(x)

      // 在不同类型的数据之间 不允许直接运算
      // 在swift中不存在基本数据类型，都是结构体
      let a = 10
      let b = 11.5
// 先的这种写法会报错，对于a和b来说是不同的数据类型，不能直接进行运算，这一点和OC是不同的。
//      print(a + b)  
       
       // 1. 解决方法，把b转化为Int类型
       print(a + Int(b))
       
       // 2.   解决方法，把a转化为Double类型
       print(Double(a) + b)

3.基本的for循环

    func textFor() {
        var  sum = 0
        for i in 0..<10 {
            sum += i
        }
        print(sum)
    }

4、Swift中可选项操作以及默认值

• swift中let和var的默认值

    // 关于let和var的默认可选值
    func demo1() {
        
        let x: Int?
        x = 10  // 给常量做初始化的操作，只能做一次，
//        x = 20  // 再次修改的时候就会报错
        print(x)
        
        // var 的可选值是nil
        // let 没有默认的可选值
        var y: Int?
//        y = 10
//        y = 20
        print(y)
    }

• 关于可选选项 option，以及强制解包操作 ！

    // 总结一个小规律
    // 定义 可选项使用 ？ 
    // 解包使用! 
    // 在开发的时候，进行
    func demo()  {
        
        // 原始的可算定义
        // none表示没有值 some表示某一类的值,x是任意类型
        let x: Optional = 10
        
        // 简单的定义
        // ? 用来定义 y 是一个可选的 Int类型，可能没有值nil，也可能是一个整数
        let y: Int? = 20
        
        print(x!)
        print(y!)
        
        // 对于option 或者 ？定义的，需要进行解包操作
        // 使用 ！进行解包的时候，需要保证值不能为 nil，从可选值中强行获取对应值的时候，必须保证非 nil
        // 不同类型之间的值不能直接运算，如果值为nil,  nil不是任何数据类型，不能参与计算
        print(x! + y!)
    }

5.分支

• 基本的条件分支

 func demo()  {
        /// 1。条件不需要加 ()  这一点与OC不同
        /// 2. 语句必须有 {}  这个与OC只有一个执行语句不用加{} 不同
        let x = 10
        if x > 5 {
            print("大")
        } else {
            print("小")
        }
    }

• 三元运算符

    func demo1() {
        let a: Int = 10
//      a > 5 ? print("大") : print("小")
        a > 5 ? print("大") : ()  // ()  表示一个空语句
    }

• 强行解包的处理

    func demo2(x: Int?, y: Int?) {
        // 强行解包有风险
        print(x! + y!);

        // 使用if 判断
        if x != nil && y != nil {
            print(x! + y!)
        } else {
            printf("x或者y为nil")
        }
    }

• 关于?? 运算符的使用

    // ?? 是一个简单的三目运算符 
    // 如果有就使用值
    // 如果没有值 就是用 ?? 后面的值代替
    // ?? 操作符的优先级比较低，在使用的时候最好加上 ()
    
    func demo3(x: Int?, y: Int?) {
        
        print((x ?? 0) + (y ?? 0))

        let name: String? = nil

        print((name ?? "") + "你好") // 你好
        
        print(name ?? "" + "你好") // 你好
    }

• if let的使用

    // if let 连用， 判断对象的值是否为nil {} 内一定有值，可以直接使用，不需要解包
    func demo4()  {
        let oName: String? = "周文超";
        let oAge: Int? = 10

        // 如果oName和oAge类型相同的时候，let age  = oAge 的let就可以省略不写
        if let name = oName ,
           let age  = oAge {
            
            // 进入分支之后，name和age一定有值，不需要解包
            // name和age的作用域在{}内
            print(name + String(age));
        } else {
            print("name或者age为nil")
        }
    }

• if var 的使用

    func demo5() {

        var oName: String? = "周文超";
        let oAge: Int? = 10
        
        if var name = oName ,
           var age  = oAge {

            // 可以修改值
            age = 20
            name = "好学生"

            // 进入分支之后，name和age一定有值，不需要解包
            // name和age的作用域在{}内
            print(name + String(age));
        } else {
            print("name或者age为nil")
        }
    }

• guard let的时候用

    // guard let 与 if let 刚好相反
    func demo() {
        
        let oName: String? = "老王"
        let oAge: Int? = 10
        
        guard let name = oName,
              let age = oAge else {
                print("姓名或者年龄为nil")
                return
        }
        
        // guard 执行到这个地方，name 和 age一定有值
        // guard let 比 if let少了一层分支
        // guard 的作用域大于 if 
        print("姓名:" + name + ",年龄:" + String(age))
    }

• guard 的高级使用

    func demo2(name: String?, age: Int?) {
        
        // 非空的name和age只在{}内有效
        if let name = name,
            let age = age {
            print("姓名:" + name + ",年龄:" + String(age))
        }
        
        // 使用同名的变量接受值的时候，在后续使用的都是非空值，不需要解包
        // 好处是，可以避免起名字的烦恼
        // 非空的name和age只在{}外同样有效
        guard let name = name,
              let age = age else {
            print("name或者age为nil")
            return
        }
        print("姓名:" + name + ",年龄:" + String(age))
    }