表达式

• 定义：由 运算符 和 操作数 组成。

赋值运算符

• 定义：= 用于给常量的值初始化和给变量的值初始化或者更新。

  (1) 赋值运算`a = b`中，表示用等号右边的 b 的值初始化或更新 a 的值；
  
  (2) 示例代码：
      let b = 10
      var a = 8
      a = b
      a 的值等于 10.
  
      let (x, y) = (1, 2)
      x 的值等于1，y 的值等于2.
  
  (3) 不返回任何值
      if a = b {
         // 这句代码有错，因为 a = b 并不返回任何值 
      }
  

单目负运算符

• 定义：- 用于切换数值类型的负正。

  var a = 1

  // b 的值为-1
  let b = -a

  // a 的值为1
  a = -b

   书写规范：单目负运算符写在操作数的前面，中间没有空格。

算术运算符

• 基本四则算术运算符：+、-、*、/。

  // 等于 3
  2 + 1

  // 等于 2
  6 - 4

  // 等于 8 
  2 * 4

  // 等于 4.0
  10.0 / 2.5

   加法运算符也可以用于字符串的拼接，示例代码如下：
    var abc = "hello" + "博库"

    print("abc")

• 求余运算符：% 用于计算 a 除以 b 之后的余数的运算。

   内部实现细节：
    为了得到 a % b 的结果，% 计算了以下等式，并输出余数作为结果：
    a = (b * 倍数) + 余数

  (1) 正整数求余
      let a = 5 / 2         // 除法操作，a = 2
      let b = 5 % 2         // 求余操作，b = 1

  (2) 负数求余
      let a = -9 % 2        // a = -1
      let b = -9 % -2       // b = -1
      let c = 9 % -2        // c = 1
       求余操作的结果是正还是负，由求余操作符左边的被除数来决定。

  (3) 浮点数求余
      let a = (7.5).truncatingRemainder(dividingBy: 2)      // a 的值是 1.5
       需要使用 truncatingRemainder(_:) 方法实现。

• 复合赋值运算符：由一个数学运算符和一个赋值运算符组合而成。

  var a = 20
  let b = 5
  a += b                 // 相当于 a = a + b     // a 的值为 25
  a -= b                 // 相当于 a = a - b     // a 的值为 15
  a *= b                 // 相当于 a = a * b     // a 的值为 100
  a /= b                 // 相当于 a = a / b     // a 的值为 4
  a %= b                 // 相当于 a = a % b     // a 的值为 0
   复合赋值运算符将算术运算和赋值运算组合进一个运算符里，同时完成两个任务。

  注意：
  1. 复合赋值运算符没有返回值，所以 let b = (a += 2) 这样的表达式是错误的；
  2. 去掉了自增运算符(++)和自减运算符(--)，可使用(+=)运算符和(-=)运算符来代替。

比较运算符

• 定义: 用于计算两个操作数之间的数值大小关系，与数学意义上的比较意义相同。

  (1) 等于       (a == b)
  (2) 不等于      (a != b)
  (3) 大于         (a > b)
  (4) 小于          (a < b)
  (5) 大于或者等于    (a >= b)
  (6) 小于或者等于     (a <= b)

   比较运算符返回值为 Bool 类型，表示表达式是否成立。示例代码：
    1 == 1        // true, 因为 1 等于 1 成立
    1 != 2        // true, 因为 1 不等于 2 成立
    2 > 1         // true, 因为 2 大于 1 成立
    1 < 2         // true, 因为 1 小于 2 成立
    1 >= 2        // false, 因为 1 并不大于或者等于 2，而是小于 2
    2 <= 3        // true, 因为 2 小于或者等于 3  是成立的

   比较运算符多用于条件语句，比如 if 条件语句，示例代码：
    let name = "博库"
    if name == "博库" {
       print("hello, 博库") 
    } else {
      print("对不起，我不认识你")
    }

三目运算符

• 定义：a ? b : c；特殊之处是有三个操作数, 简义为二选一。

  格式：a ? b : c

  a 表示问题，可以是表达式、常量或者变量等，a 必须返回 Bool 类型；
  若 a 为 true，则表达式结果为 b；
  若 a 为 false，则表示式结果为 c。

  用代码表示：
  if a {
     b 
  } else {
    c
  }

  let contentHeight = 40
  let hasHeader = true
  let rowHeight = contentHeight + (hasHeader ? 50 : 20)

逻辑运算符

• 定义：用来判断一个表达式成立还是不成立。

  (1) 逻辑与 (a && b)：只有 a 和 b 都为 true 时，整个表达式的值才会是 true;
      let noError = true
      let hasResult = false
      if noErrorr && hasResult {
         print("获取结果成功")
      } else {
        print("失败")
      }
       在 if 和 guard 语句中，逗号 也可代表 &&

  (2) 逻辑或 (a || b)：只要有一个布尔表达式为 true，则整个表达式都为 true;
      let isTeacher = false
      let isStudent = true
      if isTeacher || isStudent {
        print("学生或者老师都可以参见活动")
      } else {
        print("您没有权限参加活动")
      }      
       在 switch 语句中，逗号 也可代表 ||

  (3) 逻辑非 (!a)：对一个布尔值取反，使得 true 变成 false, false 变成 true。
      let hasError = false
      if !hasError {
        print("没有错误，运行良好")
      } 

  (4) 组合逻辑判断
      1. && 和 || 是左结合的；
      2. && 的优先级要高于 || ;
      3. 括号可以改变表达式中各操作的运算优先级。

区间运算符

• 定义：表示一个区间的值。

  (1) 闭区间运算符：a...b
      for i in 1...5 {
          print(i)
      }

  (2) 半闭区间运算符：a..<b
      let array = ["a", "b", "c", "d", "e"]
      let count = array.count
      for i in 0..<count {
          print(array[i])
      }

合空并运算符

• 定义：用于对可选类型进行空判断。

  语法：a ?? b

  简单表达式： a != nil ? a! : b

  使用条件：
  (1) 表达式 a 必须是可选类型(Optional);
  (2) 默认值 b 的数据类型必须与 a 的值数据类型一致。

  示例代码：
  let num: Int? = 5
  let result = (num ?? 0) + 10
  print(result)