目录
表达式是一种特殊类型的语句，它计算为一个值。每个表达都由
- 操作数 - 表示数据
- 运算符 - 定义如何处理操作数以生成值。
算术运算符
| 运算符 | 意义 |
|---|---|
a＋b | 加法 |
a﹣b | 减法 |
﹣a | 一元减号，也称为否定(反转表达式的符号) |
a * b | 乘法 |
a / b | 除以 |
a ~/ b | 除以，返回整数结果 |
| ％ | a % b |
a＋＋ 或 ＋＋a | 增量 |
a﹣﹣ 或﹣﹣a | 递减 |
var num1 = 101;
var num2 = 2;
print("Addition: ${(num1+num2)}");
print("Subtraction: ${(num1-num2)}");
print("Multiplication: ${(num1*num2)}");
print("Division: ${(num1/num2)}");
print("Division returning Integer: ${(num1~/num2)}");
print("Remainder: ${(num1%num2)}");
print("Increment: ${(num1++)}");
print("Increment: ${(++num1)}");
print("Decrement: ${(num2--)}");
print("Decrement: ${(--num2)}");
输出结果
Addition: 103
Subtraction: 99
Multiplication: 202
Division: 50.5
Division returning Integer: 50
Remainder: 1
Increment: 101
Increment: 103
Decrement: 2
Decrement: 0
关系运算符
关系运算符测试或定义两个实体之间的关系类型。关系运算符返回一个布尔值，即true 或 false。
| 运算符 | 意义 |
|---|---|
a > b | 大于 |
a < b | 小于 |
a >= b | 大于等于 |
a <= b | 小于等于 |
a == b | 相等 |
a != b | 不相等 |
var num1 = 5;
var num2 = 9;
var res = num1>num2;
print('num1 greater than num2 :: ' +res.toString());
res = num1<num2;
print('num1 lesser than num2 :: ' +res.toString());
res = num1 >= num2;
print('num1 greater than or equal to num2 :: ' +res.toString());
res = num1 <= num2;
print('num1 lesser than or equal to num2 :: ' +res.toString());
res = num1 != num2;
print('num1 not equal to num2 :: ' +res.toString());
res = num1 == num2;
print('num1 equal to num2 :: ' +res.toString());
输出结果:
num1 greater than num2 :: false
num1 lesser than num2 :: true
num1 greater than or equal to num2 :: false
num1 lesser than or equal to num2 :: true
num1 not equal to num2 :: true
num1 equal to num2 :: false
位运算符
| 运算符 | 意义 |
|---|---|
a & b | 按位与。对应的两个二进位都为1时，结果位才为1 |
a〡b | 按位或。对应的两个二进位有一个为1时，结果位为1 |
a ^ b | 按位异或。对应的两个二进位值不相同，异或结果为1。反之，异或结果为0 |
~a | 按位取反。按位反转 |
a << x | 左移。将一个数的各二进制位全部左移若干位 |
a >> x | 有符号右移位。将一个二进制位的操作数按指定移动的位数向右移动 |
var a = 172; // Bit presentation 10101100
var b = 139; // Bit presentation 10001011
print("10101100 & 10001011 => ${(a & b).toRadixString(2)}");
print("10101100 | 10001011 => ${(a | b).toRadixString(2)}");
print("10101100 ^ 10001011 => ${(a ^ b).toRadixString(2)}");
print("~10001011 => ${(~b).toRadixString(2)}");
print("10001011 << 2 => ${(b << 2).toRadixString(2)}");
print("10001011 >> 2 => ${(b >> 2).toRadixString(2)}");
输出结果:
10101100 & 10001011 => 10001000
10101100 | 10001011 => 10101111
10101100 ^ 10001011 => 100111
~10001011 => -10001100
10001011 << 2 => 1000101100
10001011 >> 2 => 100010
赋值运算符
| 运算符 | 意义 |
|---|---|
a = b | (简单赋值)将值从右侧操作数分配给左侧操作数 |
variable ??= value | 仅当变量为null时才分配值 |
a += b | (加和赋值)将右操作数添加到左操作数，并将结果赋给左操作数 |
a -= b | (减和赋值)从左操作数中减去右操作数，并将结果赋给左操作数 |
a *= b | (乘和赋值)将右操作数与左操作数相乘，并将结果赋给左操作数 |
a /= b | (除和赋值)将左操作数与右操作数分开，并将结果赋给左操作数 |
注:
相同的逻辑适用于位运算符，因此它们将变为«=，»=，»=，»=，| =和^ =。
var a = 12.0;
var b = 5.0;
print("${(a)} += ${(b)} : ${(a += b)}");
print("${(a)} -= ${(b)} : ${(a -= b)}");
print("${(a)} *= ${(b)} : ${(a *= b)}");
print("${(a)} /= ${(b)} : ${(a /= b)}");
print("${(a)} %= ${(b)} : ${(a %= b)}");
var num;
num ??= 3;
print("num is ${(num)}");
输出结果:
12.0 += 5.0 : 17.0
17.0 -= 5.0 : 12.0
12.0 *= 5.0 : 60.0
60.0 /= 5.0 : 12.0
12.0 %= 5.0 : 2.0
num is 3
逻辑运算符
逻辑运算符用于组合两个或多个条件。逻辑运算符返回一个布尔值。
| 运算符 | 意义 |
|---|---|
exp1 && exp2 | 仅当指定的所有表达式都返回true时，运算符才返回true |
exp1 ‖ exp2 | 至少一个表达式返回true，运算符返回true |
!exp | 运算符返回表达式结果的反函数 |
var num1 = 10;
var num2 = 20;
var num3 = 12;
var expTrue1 = num2 > num1;
var expFalse1 = num2 < num1;
var expTrue2 = num1 < num3;
var expFalse2 = num1 > num3;
var result1 = expFalse1 && expFalse2;
var result2 = expTrue1 && expFalse1;
var result3 = expTrue1 && expTrue2;
var result4 = expTrue1 || expFalse1;
var result5 = expTrue1 || expTrue2;
var result6 = expFalse1 || expFalse2;
var result7 = !expTrue1;
print("expFalse1(${(expFalse1)}) && expFalse2(${(expFalse2)}) result is '${(result1)}'");
print("expTrue1(${(expTrue1)}) && expFalse1(${(expFalse1)}) result is '${(result2)}'");
print("expTrue1(${(expTrue1)}) && expTrue2(${(expTrue2)}) result is '${(result3)}'");
print("expTrue1(${(expTrue1)}) || expFalse1(${(expFalse1)}) result is '${(result4)}'");
print("expTrue1(${(expTrue1)}) || expTrue2(${(expTrue2)}) result is '${(result5)}'");
print("expFalse1(${(expFalse1)}) || expFalse2(${(expFalse2)}) result is '${(result6)}'");
print("!expTrue1(${(expTrue1)}) result is '${(result7)}'");
输出结果:
expFalse1(false) && expFalse2(false) result is 'false'
expTrue1(true) && expFalse1(false) result is 'false'
expTrue1(true) && expTrue2(true) result is 'true'
expTrue1(true) || expFalse1(false) result is 'true'
expTrue1(true) || expTrue2(true) result is 'true'
expFalse1(false) || expFalse2(false) result is 'false'
!expTrue1(true) result is 'false'
条件表达式
| 表达式 | 意义 |
|---|---|
condition?expr1:expr2 | 如果condition为true，则表达式计算 expr1 (并返回其值); 否则，它会计算并返回 expr2 的值 |
exp1 ?? exp2 | 如果 expr1 为非null，则返回其值; 否则，计算并返回 expr2 的值 |
var a = 10;
var res1 = a > 12 ? "a < 10":"a > 10";
print(res1);
var num1;
var num2 = 12;
var res2 = num1 ?? num2;
print("res2 = ${(res2)}");
输出结果:
a > 10
res2 = 12
类型测试运算符
| 运算符 | 意义 |
|---|---|
| is | 如果对象是指定的类型，则为True |
| is! | 如果对象不是指定的类型，则返回false |
int a = 10;
print("a is int ? ${(a is int)}");
double b = 2.0;
print("b is! int? ${(b is! int)}");
输出结果:
a is int ? true
b is! int? true
级联符号
var person1 = Person()
..name = "tom"
..age = 18
..address = "China"
..phone = (PhoneNumerBuilder()
..phoneNum = "13310022356"
..label = "home"
);
print("name:${(person1.name)}, age:${(person1.age)}, address:${(person1.address)}, "
"phoneNumber:${(person1.phone.phoneNum)}, label:${(person1.phone.label)}");
class Person {
String name;
String address;
int age;
PhoneNumerBuilder phone;
// Person(this.name,this.address,this.age);
}
class PhoneNumerBuilder {
String phoneNum;
String label;
}
输出结果
name:tom, age:18, address:China, phoneNumber:13310022356, label:home
重载操作符
在dart中可以实现类似C++那种操作符的重写功能。可以实现对象之间的加减乘除之类的运算。
void customOperators() {
final v = Vector(2, 3);
final w = Vector(2, 2);
print("(v + w).x: ${((v + w).x)}, (v + w).y:${((v + w).y)}");
}
class Vector {
final int x, y;
Vector(this.x, this.y);
Vector operator +(Vector v) => Vector(x + v.x, y + v.y);
Vector operator -(Vector v) => Vector(x - v.x, y - v.y);
}
输出结果:
(v + w).x: 4, (v + w).y:5
参考链接:
https://www.codingdict.com/article/21914
https://cloud.tencent.com/developer/article/1900208
685
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
