02*：运算符、合并空值运算符、区间运算符

问题

 

目录

1：运算符

2：合并空值运算符、区间运算符

预备

 

正文

一：运算符

/*
         四：Swift 运算符
         运算符是一个符号，用于告诉编译器执行一个数学或逻辑运算。
         Swift 提供了以下几种运算符：
         1：算术运算符：+  -  *  /  % 取余
         2：比较运算符： ==    !=  >   <   >=   <=
         3：逻辑运算符:   &&  ||  !
         4：位运算符
            &：按位与：两个数都为1时值为1，其他为0。
            |：按位或。两个数任意一个为1值为1。
            ^：异或。两个数相同为1，不同为0。
            ~：取反
            <<：按位左移。左移操作符（<<）将操作数的所有位向左移动指定的位数。左移：乘以2的n次方
            >>：按位右移。右移操作符（>>）将操作数的所有位向右移动指定的位数。右移：除以2的n次方
         5：赋值运算符
         6：区间运算符：闭区间运算符（a...b），，，半开区间运算符（a..<5）
         7：其他运算符
         */
        print("四：Swift 运算符：");
        // 1:算数运算法
        var A = 10
        var B = 20
        print("A + B 结果为：\(A + B)") // 30
        print("A - B 结果为：\(A - B)") // -10
        print("A * B 结果为：\(A * B)") // 200
        print("B / A 结果为：\(B / A)") //2
        A += 1   // 类似 A++  11
        print("A += 1 后 A 的值为 \(A)")
        B -= 1   // 类似 B--  19
        print("B -= 1 后 B 的值为 \(B)")
        
        // 2: 比较运算符号
        print("A == B 结果为：\(A == B)") // false
        print("A != B 结果为：\(A != B)") //true
        print("A > B 结果为：\(A > B)")  //false
        print("A < B 结果为：\(A < B)")  //true
        print("A >= B 结果为：\(A >= B)")  //false
        print("A <= B 结果为：\(A <= B)")  //true
       
        // 3：逻辑运算符
        let boolA: Bool = true
        let boolB: Bool = false
        print("A && B 结果为：\(boolA && boolB)") // false
        print("A || B 结果为：\(boolA || boolB)") //true
        print("!A 结果为：\(!boolA)") //false
        print("!B 结果为：\(!boolB)") //true
        
        // 4：区间运算符
        print("闭区间运算符:")
        for index in 1...5 {
            print("\(index) * 5 = \(index * 5)")
        }

        print("半开区间运算符:")
        for index in 1..<5 {
            print("\(index) * 5 = \(index * 5)")
        }
        
        print("四：Swift 运算符：");

/*
 四：Swift 运算符：
 A + B 结果为：30
 A - B 结果为：-10
 A * B 结果为：200
 B / A 结果为：2
 A += 1 后 A 的值为 11
 B -= 1 后 B 的值为 19
 A == B 结果为：false
 A != B 结果为：true
 A > B 结果为：false
 A < B 结果为：true
 A >= B 结果为：false
 A <= B 结果为：true
 A && B 结果为：false
 A || B 结果为：true
 !A 结果为：false
 !B 结果为：true
 闭区间运算符:
 1 * 5 = 5
 2 * 5 = 10
 3 * 5 = 15
 4 * 5 = 20
 5 * 5 = 25
 半开区间运算符:
 1 * 5 = 5
 2 * 5 = 10
 3 * 5 = 15
 4 * 5 = 20
 四：Swift 运算符：
 */

**** 合并空值运算符、区间运算符

/* 运算符
 1：赋值运算符 =
 

 2：专门用语
    一元运算符 -a !a a!
    二元运算符 +-*&
    三元运算符 a ? b : c
 
 3: 算数运算符
     加 ( + )
     减 ( - )
     乘 ( * )
     除 ( / )
     取余 %

 4：逻辑运算符
    && || !
 
 5：合并空值运算符
  （ a ?? b ）
 
 6：区间运算符
    a..<b   闭区间      左闭右闭
    a...b   半开区间    左闭右开
 
    [2...]  >=2
    [...2]  <=2
 
 7：合并空值运算符
    a ?? b
    等价于 a != nil ? a! : b
 
 */

func testData() {
        // 1：合并空值运算符
        /*
         合并空值运算符
         合并空值运算符 （ a ?? b ）如果可选项 a  有值则展开，如果没有值，是 nil  ，则返回默认值 b 。表达式 a 必须是一个可选类型。表达式 b  必须与 a  的储存类型相同。

         合并空值运算符是下边代码的缩写：
         a != nil ? a! : b
         上边的代码中，三元条件运算符强制展开（ a! ）储存在 a  中的值，如果 a  不是 nil  的话，否则就返回 b  的值。合并空值运算符提供了更加优雅的方式来封装这个条件选择和展开操作，让它更加简洁易读。
         注意
         如果 a  的值是非空的， b  的值将不会被考虑。这就是所谓的 短路计算 。
         */
        var a :Int?
        var b :Int?
        b = 5
        let c = a ?? b
        print("--->>>:\(self.classForCoder) 1：合并空值运算符：\(c ?? 2)")
        
        
        // 2: 闭区间运算符号 1、2、3、4、5
        for index in 1...5 {
            print("--->>>:\(self.classForCoder) 1：合并空值运算符：\(index)")
        }
        
        // 3: 半开区间 0 1 2 没有3
        let names = ["Anna", "Alex", "Brian", "Jack"]
        let count = names.count
        for i in 0..<count {
            print("--->>>:\(self.classForCoder) Person \(i + 1) is called \(names[i])")
        }
        
        // 4：单侧区间
        for name in names[0...] {
            print("--->>>:\(self.classForCoder) Person is called \(name)")
        }
        
    }

 

注意

 

引用

1：