第二节: Dart 操作符(运算符)

Dart 语法学习目录

第一节: Dart 语法了解,认识变量,常量,数据类型
第二节: Dart 操作符(运算符)
第三节: Dart 中常用集合 List/Map
第四节: Dart 函数使用,声明函数/匿名函数/可选参数/作用域/闭包
第五节: Dart 面向对象/构造函数/静态属性
第六节: Dart中抽象类abstract/接口implements/混入Mixin
第七节: Dart中泛型/泛型定义与使用
第八节: Dart 中的库/自定义库/内置库/第三方库

1. 算术运算符

+ - * / % (取余) ~/(取整)

void main(){

    // 算术运算符
    int num1 = 13;
    int num2 = 5;

    print(num1 + num2);  // 加  18
    print(num1 - num2);  // 减   8
    print(num1 * num2);  // 乘  65
    print(num1 / num2);  // 除  2.6
    print(num1 % num2);  // 取余  3
    print(num1 ~/ num2);  // 取整 2

}

2. 一元运算符

-expr负数 ++expr 递增 expr++ 递增 --expr递减 expr--递减

void main(){

    // 一元运算符
    int num = 13;
    int num2 = 5;

    // 负数
    print(-num);  // 负数 -13

    // 递增
    ++ num;
    num2 ++;
    print(num);    // 14
    print(num2);   // 6

    // 递减
    -- num;
    num2 --;
    print(num);    // 13
    print(num2);   // 5

}

那么++在前在后有什么区别呢

如果不用再表达式中, 在前在后都一样, 都是对当前变量的递增.

如果是在表达式中参与运算结果就不一样了

void main(){

    // 一元运算符 
    int num = 13;

    // ++ 操作符
    int price = num + 12;
    print(price);   // 25
    print(num);     // 13   普通加法 num值不变

    // ++ 操作符在前
    int price2 = ++num + 12;
    print(price2);       // 26
    print(num);          // 14  

    // ++ 在前是先运算自增,然后在运算表达式
    // 等价于
    // ++num  // num+1 变成了14
    // int price2 = num + 12   此时num是14  所以price2值为16

    // ++ 操作符在后
    int price3 = num++ + 12;
    print(price3);       // 26
    print(num);          // 15

    // ++ 在后是先运算表达式,然后在运算自增
    // 等价于
    // int price3 = num + 12   此时num是14  所以price2值为16
    // num++   自增等价于 num+1 变成了15

}

也就是++自增运算符无论在前在后对于变量本事来说都是一样的,就是自身值加1,

所以如果不参与表达式运算, 对于变量本事没有影响

如果参与到表达式中运算, ++在前就是变量先自增,然后用自增的结果参与运算

++在后, 就是先用变量之前的值参与表达式运算, 在让变量自己自增.

3. 关系运算符

== 相等 != 不 > 大于 < 小于 >= 大于等于 <=小于等于

void main(){

  // 关系运算符
  int num1 = 13;
  int num2 = 5;

  print(num1 == num2);  // 判断是否相等
  print(num1 != num2);  // 判断是否不等
  print(num1 > num2);  // 判断是否大于
  print(num1 < num2);  // 判断是否小于
  print(num1 >= num2);  // 判断是否大于等于
  print(num1 <= num2);  // 判断是否小于等于

}

关系运算符主要用到条件判断里

void main(){

  // 关系运算符
  int num1 = 13;
  int num2 = 5;

  // 条件判断
  if(num1 > num2){
    print("num1 大于 num2");
  }else{
    print("num1 不大于 num2");
  }

}

4. 逻辑运算符

!取反 && 逻辑与(并且的意思) || 逻辑或(或者的意思)

void main(){

  // 逻辑运算符
  bool a = true;
  bool b = false;

  print(!a);
  print(a && b);
  print(a || b);

}

5. 赋值运算符

基础赋值运算符

= 赋值 ??= 变量为 null 时才会赋值,变量不为null不赋值

复合赋值运算符

+= 加等于 -=减等于 *=乘等于 /=除等于 %= 取模等于 ~/=取整等于

5.1 基础赋值

void main(){

  // 赋值运算符
  // 1\. 基本的赋值运算符
  // 普通赋值
  int num = 20;
  int num2 = num;
  print(num);
  print(num2);

  // 判断变量是否为空,为空才赋值,不为空则不赋值
  int n = 6;
  n ??= 23;   // 如果n为空,就赋值23,否则就不给n赋值
  print(n);    // 6

  int n = null;
  n ??= 23;   // 如果n为空,就赋值23,否则就不给n赋值
  print(n);  // 23
}

5.2 复合赋值

void main(){

    // 赋值运算符
    // 2\. 复合赋值运算符
    // 普通赋值
    double num = 30.0;
    int num2 = 20;

    //   += 加等于
    //   num += num2;
    //   print(num);    // 50
    //   print(num2);   // 20

    //   -= 减法等于
    //   num -= num2;
    //   print(num);    // 10
    //   print(num2);   // 20

    //   *= 乘等于
    //   num *= num2;
    //   print(num);    // 600
    //   print(num2);   // 20

    //   /=  除等于
    //   num /= num2;
    //   print(num);    // 1.5
    //   print(num2);   // 20

    //   %= 取模等于
    //   num %= num2;
    //   print(num);    // 10
    //   print(num2);   // 20

    int result = 30;

    //   ~/= 取整等于
    //   result ~/= num2;
    //   print(result);    // 1
    //   print(num2);   // 30

}

6 条件表达式

condition ? expr1 : expr2 三目运算符

expr1 ?? expr2 返回其中不为空的表达式执行结果

6.1 三目运算符

void main(){

  // 三目运算符怒
  bool flag = false;
  String c;
  // if(flag){
  //   c = "我是true";
  // }else{
  //   c = "我是false";
  // }

  // print(c);

  // 三目写法
  c = flag ? "我是true": "我是false";
  print(c);
}

6.2 ?? 运算符

返回其中不为空的表达式执行结果

void main(){

  // ?? 运算符 (有点类似于默认值的感觉)
  int num;
  int num2 = num ?? 23;  // num的值为空,所以将23赋值给num2
  print(num2); // 23

  int a = 10;
  int b = a ?? 23; // a的值不为空,所以将a的值赋值给b
  print(b);   // 10

}

7 .. 联级运算符

..：级联操作符 .. 可以在同一个对象上 连续调用多个函数以及访问成员变量。使用级联操作符可以避免创建临时变量，并且写出来的代码看起来更加流畅。

class Person{
    // 属性
    String name ="小明";
    int age = 18;
    String sex = "男";

    void getInfo(){
        print("${this.name}:${this.age}:${this.sex}");
    }

}

void main(){
    Person student = new Person() ;
    student.getInfo();  // 小明:18:男

    // 修改属性值
    // student.name = "小红";
    // student.age = 14;
    // student.sex = "女";
    // student.getInfo();   // 小红:14:女

    // 修改多个属性值可以使用联级调用
    // 结果完全一样
    student..name = "小红"
        ..age = 14
        ..sex = "女";
    student.getInfo();   // 小红:14:女
}

如果class类不太明白的话也不要紧,后面会继续讲解.

8 类型判定运算符

as， is， 和 is! 运算符用于在运行时处理类型检查：
as：类型转换
is：如果对象是指定的类型返回 True
is!：如果对象是指定的类型返回 False
具体例子参考面向对象的总结

9 其他操作符

1. ()：使用方法。代表调用一个方法
2. []：访问 List。访问 list 中特定位置的元素
3. .：访问成员(属性)。访问元素，例如 foo.bar 代表访问 foo对象 的 bar 成员
4. ?.：条件成员访问。和 . 类似，但是左边的操作对象不能为 null，例如
5. foo?.bar 如果 foo 为 null 则返回 null，否则返回 bar 成员