Swift 4.0学习之旅—基本运算符

        let a = 10
        var b = 1
        b = a
        let x = (1,2,3)
        print(x)
        let (q,e) = (1,2)
        
        if a == b{
            
        }
        
        //溢出运算
        print(a &+ b)
        
        //加号也可用于两个字符串拼接
        print("hello" + "world")

        //取余运算
        print(a % x.2) // a = (b * 倍数) + 余数
        
        //在对负数取余时，负数符号会被忽略
        print(a % -x.2)
        
        a == b
        a != b
        a > b
        a < b
        a >= b
        a <= b
        
        //恒等与不恒等 用来判断两个对象是否引用同一个对象实例
        
        //a === b  a !== b
        
        //元组比较大小 会按照从左到右逐值比较方法 直到发现有两个值不相等时 停止
        
        print((1,"a") < (2,"a")) //true  1 < 2
        print((1,"a") < (1,"a")) //false 1 不小于1
        print((1,"a") < (1,"b")) //true a 比b小
        print((1,"aa") < (1,"ab")) //true  第二个字母a 比后面的第二个字母b小
        print((1,"a") < (1,"A")) //逐值比较 按字母从小到大  大写字母比小写字母 值大
        
        //三目运算符
//        if 表达式{
//            结果1
//        }else{
//            结果2
//        }

        let height = 100
        let auto = true
        let allheight = height + (auto ? 44 : 64)
        print(allheight)
        
        //空格运算符
        //对第一个变量或常量进行非空判断，如果包含一个值就进行解封，否则就返回一个默认值 第二个变量或常量
        //        a ?? b ==  a != nil ? a! : b
        //上代码中 当可选类型 a 的值不为空是，进行强制解封取 a！ ，访问a中的值。反之返回默认值b。空合运算符？？ 封装判断条件，和解封两种行为。
        //a 为非空 non-nil 那么b不会被计算。这种成为 短路求值
        
        let red = "red"
        var blue : String? //tm  blue还必须得是变量
        
        let black : String? = "black" //这样就不会提示要初始化，有个初始值，并且为可选类型
        
        var color = black ?? red
        
        //区间运算符
        //闭区间运算符 （a...b） 从a到b的所有值 。a不可能超过b。经常应用在for-in 循环中
        //区间必须是 int类型数字
        for index in 0...4{
            print("\(index) * 5 = \(index * 5)")
        }
        
        let name = ["a","b","c","d"]
        
        for str in 0..<name.count{ //因为是数组下标，不能超过数组下标个数
            //str 此时为int类型
            print(name[str])
        }
        
        
        //单侧区间 表达往一侧无线延伸
        for str in name[0...]{
            //此时str 为name数组中的元组 从下标0开始
            print("string " + str)
        }
        
        for str in name[...1]{
            //此时str 为name数组中的元组 从下标0开始
            print("单侧区间 " + str)
        }
        
        for str in name[..<name.count]{
            //此时str 为name数组中的元组 从下标0开始
            print("单侧区间元素 " + str)
        }
        
        let range = ...5 //打印出 PartialRangeThrough<Int>(upperBound: 5)  为Int类型元素
        print(range)
        print(range.contains(0))//true
        print(range.contains(6))//false
        
        
        //逻辑运算符 !a a&&b a||b
        //非 是对一个布尔值取反  与oc 不同 不能针对对象存在 与不存在
        
        let zhenjia = true
        var haha : Int?
        if !zhenjia{
            print("判断结果为真")
        }else{
            print("判断结果为 假")
        }
        
        if haha != nil{ //对应变量只能这样判断
            
        }else{
            
        }
        
        //与 也不同oc一样
        if !zhenjia && haha != nil{
            print("条件满足")
        }else{
            print("与条件有一错误")
        }
        
        //或 第一个条件没满足 就去判断第二个条件 从左到右 有一个条件满足就执行后续代码
        if !zhenjia || haha != nil{
            print("条件满足")
        }else{
            print("与条件有一错误")
        }
        
        //多个运算符一起用 用（）来确定优先级