算术操作符

• 加法（+）：计算两个操作数的和
• 减法（-）：计算两个操作数的差
• 乘法（*）：计算两个操作数的乘积
• 除法 （/）:计算两个操作数的商，返回一个双精度浮点数（double）
• 整除（~/）: 计算两个操作数的商，返回一个整数（int）
• 取模（%）：计算两个操作数的余数

void main() {
  int a = 10;
  int b = 3;

  print(a + b); // 13
  print(a - b); // 7
  print(a * b); // 30
  print(a / b); // 3.3333333333333335
  print(a ~/ b); // 3
  print(a % b); // 1
}

关系操作符

• 等于（==）：检查两个操作数是否相等
• 不等于（!=）: 检查两个操作数是否不相等
• 大于（>）: 检查左侧操作数是否大于右侧操作数
• 小于（<）: 检查左侧操作数是否小于右侧操作数
• 大于等于（>=）: 检查左侧操作数是否大于等于右侧操作数
• 小于等于（<=）: 检查左侧操作数是否小于或等于右侧操作数

void main() {
  int a = 10;
  int b = 3;
  print(a == b); // false
  print(a != b); // true
  print(a > b); // true
  print(a < b); // false
  print(a >= b); // true
  print(a <= b); // false
}

类型判断操作符

• 类型测试（is）: 检查对象是否是某个类型的实例
• 非类型测试（is !）: 检查对象是否不是某个类型的实例

void main() {
  var x = 'Hello, Dart';

  print(x is String); // true
  print(x is! int); // true
}

赋值操作符

• 简单赋值（=）：将右操作数的值赋值给左操作数
• 复合赋值（+=、-=、*=、/=、~/=、%=）：进行运算并且将结果赋值为左操作数

void main() {
  double a = 10.0;
  a /= 4; // 相当于 a = a / 4;
  print(a); // 输出: 2.5
}
void main() {
  double a = 10.0;
  a /= 4; // 相当于 a = a / 4;
  print(a); // 输出: 2.5
}
void main() {
  int a = 10;
  a %= 4; // 相当于 a = a % 4;
  print(a); // 输出: 2
}

逻辑操作符

• 逻辑与（&&）：如果两个操作数都为 true 则返回 true
• 逻辑或（||）：如果两个操作数中至少有一个为 true，则返回 true
• 逻辑非（！）： 返回操作数的布尔值的相反值

void main() {
  bool a = true;
  bool b = false;

  print(a && b); // false
  print(a || b); // true
  print(!a); // false
}

条件操作符

• 条件表达式(?:): 如果条件为 true 返回第一个值，否则返回第二个值
• 如果为空（??）:如果左操作数为 null ，则返回右操作数

void main() {
  int a = 10;
  int b = 5;

  var result = a > b ? 'a is greater' : 'b is greater';
  print(result); // a is greater

  String? name;
  print(name ?? 'Guest'); // Guest
}

位操作符

• 按位与（&）：对两个操作数的每一位执行与操作
• 按位或（|）：对两个操作数的每一位执行或操作
• 按位异或（^）:对两个操作数的每一位执行异或操作
• 按位取反 (~): 对操作数的每一位执行取反操作。
• 左移 (<<): 将左操作数的二进制表示向左移位。
• 右移 (>>): 将左操作数的二进制表示向右移位。

void main() {
  int a = 5; // 0101
  int b = 3; // 0011

  print(a & b); // 1 (0001)
  print(a | b); // 7 (0111)
  print(a ^ b); // 6 (0110)
  print(~a); // -6 (二进制表示：..11111010)
  print(a << 1); // 10 (1010)
  print(a >> 1); // 2 (0010)
}
按位与：按位与操作对两个操作数的每一位执行与操作。只有两个操作数对应的位都是1时，结果才是1，否则是0。
void main() {
  int a = 12; // 二进制: 1100
  int b = 5;  // 二进制: 0101

  int result = a & b; // 二进制: 0100 (十进制: 4)
  print(result); // 输出: 4
}
按位或：按位或操作对两个操作数的每一位执行或操作。只要两个操作数对应的位有一个是1，结果就是1。
void main() {
  int a = 12; // 二进制: 1100
  int b = 5;  // 二进制: 0101

  int result = a | b; // 二进制: 1101 (十进制: 13)
  print(result); // 输出: 13
}
按位异或：按位异或操作对两个操作数的每一位执行异或操作。只有两个操作数对应的位不同，结果才是1，否则是0。
void main() {
  int a = 12; // 二进制: 1100
  int b = 5;  // 二进制: 0101

  int result = a ^ b; // 二进制: 1001 (十进制: 9)
  print(result); // 输出: 9
}
按位取反：按位取反操作对操作数的每一位执行取反操作。0变成1，1变成0。
void main() {
  int a = 12; // 二进制: 1100

  int result = ~a; // 二进制: 0011 (在Dart中，这个会显示为补码)
  print(result); // 输出: -13 (在补码表示中，~1100 为 0011，结果为 -13)
}
左移：左移操作将左操作数的二进制表示向左移位，右侧补0
void main() {
  int a = 3; // 二进制: 0011

  int result = a << 2; // 二进制: 1100 (十进制: 12)
  print(result); // 输出: 12
}
右移：右移操作将左操作数的二进制表示向右移位，左侧补0（如果是有符号整数则根据符号位填充）。
void main() {
  int a = 12; // 二进制: 1100

  int result = a >> 2; // 二进制: 0011 (十进制: 3)
  print(result); // 输出: 3
}

其他操作符

• 成员访问（.）: 访问对象的成员
• 条件成员访问（?.）:安全的访问对象的成员，如果对象为null，则返回 null
• 类型转换（as）:将对象转换为指定的类型

void main() {
  var list = [1, 2, 3];
  print(list.length); // 3

  int? num;
  print(num?.isEven); // null

  var x = 'Hello' as Object;
  print(x is String); // true
}
as 操作符用于类型转换，但是它不会改变对象的实际类型，它只是告诉编译器在特定的上下文中将对象视为特定的类型
void main() {
  var x = 'Hello' as Object; // 将字符串 'Hello' 视为 Object 类型
  print(x.runtimeType); // 输出: String
  print(x is Object);   // 输出: true
  print(x is String);   // 输出: true
  
  // 即使我们将 x 视为 Object，它仍然保持 String 类型
  Object y = x; // 这在实际上没有改变对象的类型
  print(y.runtimeType); // 输出: String
  print(y is Object);   // 输出: true
  print(y is String);   // 输出: true
}