返回专栏
· 15 分钟阅读

运算符与表达式(Operators & Expressions)


一、什么是运算符?

运算符(Operator)是编程语言中用于执行特定操作的符号或关键字。

例如:

a = 10
b = 5

result = a + b

这里:

  • + 是运算符。
  • a 和 b 是操作数(Operand)。
  • a + b 是一个表达式。
  • 运算结果为 15。

运算符的核心作用是定义操作行为,例如:

  • 数值计算
  • 比较判断
  • 逻辑运算
  • 位操作
  • 赋值
  • 成员访问
  • 类型判断

1.1 运算符的组成

一个运算符表达式通常由运算符和操作数组成。

例如:

result = a + b * c

其中:

元素 含义
a、b、c 操作数
+、* 运算符
b * c 子表达式
a + b * c 完整表达式

运算符根据操作数数量,可以分为以下几类:

类型 含义 示例
一元运算符 操作一个操作数 -a、!a
二元运算符 操作两个操作数 a + b、a == b
三元运算符 根据条件选择表达式 a ? b : c

需要注意,运算符的符号和行为由具体编程语言定义。同一个符号在不同语言中,可能具有不同语义。

二、什么是表达式?

表达式(Expression)是由字面量、变量、运算符、函数调用等元素组合而成,并能够按照语言规则进行求值的代码结构。

例如:

10 + 20

这是一个表达式,求值结果为 30。

再例如:

age >= 18

这是一个比较表达式,求值结果为布尔值。

表达式可以非常简单,也可以由多个子表达式嵌套组成。

total = price * quantity + shipping_fee

其中:

  • price * quantity 是子表达式。
  • price * quantity + shipping_fee 是完整表达式。
  • total = ... 是赋值语句。

2.1 表达式与语句的区别

表达式和语句(Statement)是两个不同的语法概念。

表达式通常用于计算并产生值,语句则用于组织程序执行行为。

例如 Python:

a + b

这是一个表达式。

result = a + b

这是一个赋值语句,其中包含表达式 a + b。

if a > b:
    print(a)

这是一个条件语句,其中 a > b 是条件表达式。

二者的区别:

对比维度 表达式 语句
英文 Expression Statement
主要作用 计算并产生值 表达程序执行结构
是否可以嵌套 通常可以 取决于语言语法
示例 a + b if、while、赋值语句
是否一定产生值 通常有求值结果 不一定

不同语言对表达式和语句的划分并不完全相同。

例如,Python 的赋值语句本身不是普通表达式,而 JavaScript 的赋值表达式可以产生赋值后的值。

2.2 表达式的组成

表达式通常可以包含:

  • 字面量
  • 变量
  • 运算符
  • 函数调用
  • 属性访问
  • 数组或对象访问
  • 其他子表达式

例如:

const result = user.score * 2 + calculateBonus();

可以拆分为:

flowchart TB
    A["完整表达式"] --> B["user.score * 2"]
    A --> C["calculateBonus()"]
    B --> D["属性访问 user.score"]
    B --> E["乘法运算"]
    A --> F["加法运算"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

三、算术运算符(Arithmetic Operators)

算术运算符用于执行数值计算,是最常见的运算符类型。

3.1 基本算术运算符

运算符 名称 示例 结果
+ 加法 10 + 3 13
- 减法 10 - 3 7
* 乘法 10 * 3 30
/ 除法 10 / 3 依语言而定
% 取余 10 % 3 1
** 幂运算 2 ** 3 8

需要注意,不同语言对除法和取余的规则存在差异。

例如 Python:

print(10 / 3)   # 3.3333333333333335
print(10 // 3)  # 3
print(10 % 3)   # 1

Python 使用 / 执行真除法,使用 // 执行向下取整的除法。

Java:

System.out.println(10 / 3);    // 3
System.out.println(10.0 / 3);  // 3.3333333333333335

Java 中两个整数相除,结果仍然是整数,小数部分被截断。

3.2 整数除法与浮点数除法

整数除法和浮点数除法是一个容易出错的地方。

例如:

int a = 10;
int b = 3;

double result = a / b;
System.out.println(result);

结果是:

3.0

原因是:

  1. a 和 b 都是整数。
  2. a / b 首先执行整数除法。
  3. 整数除法得到 3。
  4. 再将结果转换为 double,得到 3.0。

如果希望得到浮点数结果,需要在运算之前转换操作数:

double result = (double) a / b;

结果为:

3.3333333333333335

类型转换发生的时间,会直接影响表达式的计算结果。

3.3 取余运算

取余运算通常用于获得除法运算后的余数。

例如:

print(10 % 3)  # 1

取余运算常见用途:

  • 判断奇偶数
  • 循环索引
  • 时间换算
  • 周期性计算
  • 哈希算法

例如判断奇偶数:

number = 10

if number % 2 == 0:
    print("偶数")
else:
    print("奇数")

需要注意,负数参与取余时,不同语言可能采用不同规则。

Python:

print(-7 % 3)  # 2

Java:

System.out.println(-7 % 3); // -1

Python 的取余结果与除数的符号相关;Java 的余数符号与被除数相关。

因此,跨语言处理负数取余时,不能假设结果完全一致。

四、关系运算符(Relational Operators)

关系运算符用于比较两个操作数之间的关系。

通常返回布尔结果。

运算符 含义 示例
== 等于 a == b
!= 不等于 a != b
> 大于 a > b
< 小于 a < b
>= 大于等于 a >= b
<= 小于等于 a <= b

例如:

age = 20

print(age >= 18)  # True
print(age == 20)  # True
print(age < 18)   # False

4.1 等值比较与引用比较

在一些语言中,需要区分比较两个对象的值是否相等,以及比较两个引用是否指向同一个对象。

Java:

String a = new String("hello");
String b = new String("hello");

System.out.println(a == b);      // false
System.out.println(a.equals(b)); // true

这里:

  • == 对引用类型比较引用身份,即是否指向同一个对象。
  • equals() 默认继承自 Object,但 String 重写了它,用于比较字符串内容。

Python:

a = [1, 2, 3]
b = [1, 2, 3]

print(a == b)  # True
print(a is b)  # False

这里:

  • == 比较对象的值是否相等。
  • is 比较两个名称是否指向同一个对象。

这说明相等性比较与对象身份比较是两个不同概念。

4.2 浮点数比较

浮点数由于精度限制,直接使用相等运算符比较计算结果可能产生问题。

例如:

a = 0.1 + 0.2
b = 0.3

print(a == b)  # False

实际开发中,通常需要根据业务精度要求设置容差:

a = 0.1 + 0.2
b = 0.3

epsilon = 1e-9

print(abs(a - b) < epsilon)

对于不同数量级的数据,固定绝对误差可能不够,还需要考虑相对误差。

五、逻辑运算符(Logical Operators)

逻辑运算符用于组合或反转布尔条件。

常见逻辑运算包括:

运算 Python Java / C JavaScript
逻辑与 and && &&
逻辑或 or || ||
逻辑非 not ! !

5.1 逻辑与(AND)

只有所有条件都成立,结果才为真。

A B A AND B
True True True
True False False
False True False
False False False

例如:

age = 25
is_member = True

result = age >= 18 and is_member

只有年龄满足要求并且是会员,结果才为真。

5.2 逻辑或(OR)

只要有一个条件成立,结果就为真。

A B A OR B
True True True
True False True
False True True
False False False

例如:

is_admin = False
is_owner = True

result = is_admin or is_owner

管理员或者资源所有者都可以满足访问条件。

5.3 逻辑非(NOT)

逻辑非用于反转布尔值。

A NOT A
True False
False True

例如:

is_login = False

if not is_login:
    print("请先登录")

5.4 短路求值(Short-Circuit Evaluation)

短路求值是逻辑运算中非常重要的执行机制。

当逻辑表达式的结果已经可以确定时,运行时可能不再计算剩余操作数。

对于常见的短路逻辑运算:

  • A && B:当 A 为假时,不再计算 B。
  • A || B:当 A 为真时,不再计算 B。

例如 JavaScript:

let user = null;

if (user && user.name) {
    console.log(user.name);
}

当 user 为 null 时,user && user.name 的结果已经可以确定,不会继续访问 user.name。

短路求值的流程:

flowchart TD
    A["开始计算逻辑表达式"] --> B["计算左操作数"]
    B --> C{"是否可以确定结果"}
    C -->|"可以"| D["返回当前结果"]
    C -->|"不可以"| E["计算右操作数"]
    E --> F["得到最终结果"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

短路求值不仅能够提高效率,还经常用于保护可能产生异常的表达式。

例如:

if user is not None and user.name == "Alice":
    print("匹配成功")

先判断 user 是否为空,再访问其属性。

需要注意,并非所有逻辑运算符都采用短路求值。部分语言还提供不短路的逻辑运算或位运算形式。

六、赋值运算符(Assignment Operators)

赋值运算符用于将值赋给变量,或者更新变量当前关联的数据。

6.1 基本赋值

age = 25
name = "Alice"

= 表示赋值,而不是数学意义上的相等判断。

例如:

x = 10
x = x + 5

第二行表示:

  1. 读取当前 x 的值。
  2. 计算 x + 5。
  3. 将结果重新赋给 x。

最终 x 的值为 15。

6.2 复合赋值运算符

复合赋值将运算与赋值组合在一起。

运算符 等价形式
+= a = a + b
-= a = a - b
*= a = a * b
/= a = a / b
%= a = a % b
&= a = a & b
|= a = a \| b
^= a = a ^ b
<<= a = a << b
>>= a = a >> b

例如:

count = 10
count += 5

print(count)  # 15

需要注意,复合赋值不一定在所有语言中都与展开后的表达式完全等价。

例如 Python:

a = [1, 2]
a += [3]

这通常会原地扩展列表。

而:

a = [1, 2]
a = a + [3]

会创建新的列表对象并重新绑定 a。

对于具有重载运算符或自定义赋值行为的类型,这种区别可能更加明显。

6.3 自增与自减运算符

C、C++、Java、JavaScript 等语言提供:

  • ++:自增。
  • --:自减。

例如:

int count = 10;

count++;
count--;

自增和自减还存在前置与后置形式。

int a = 10;

int x = ++a;
int y = a++;

区别:

表达式 行为
++a 先增加,再使用结果
a++ 先使用原值,再增加

执行过程:

flowchart TD
    A["变量 a = 10"] --> B["执行 ++a"]
    B --> C["a 变为 11"]
    C --> D["表达式结果为 11"]
    D --> E["执行 a++"]
    E --> F["表达式结果为 11"]
    F --> G["a 变为 12"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

Python 不支持 ++ 和 -- 作为自增、自减运算符。

七、位运算符(Bitwise Operators)

位运算符直接对整数的二进制位进行操作。

位运算在底层开发、网络协议、权限控制、图形计算和性能优化中非常常见。

7.1 按位与(AND)

运算符:&

只有对应的两个二进制位都为 1,结果才为 1。

  0101
& 0011
------
  0001

例如:

print(5 & 3)  # 1

7.2 按位或(OR)

运算符:|

只要对应位置有一个为 1,结果就是 1。

  0101
| 0011
------
  0111
print(5 | 3)  # 7

7.3 按位异或(XOR)

运算符:^

两个对应位不同时结果为 1,相同时结果为 0。

  0101
^ 0011
------
  0110
print(5 ^ 3)  # 6

7.4 按位取反(NOT)

运算符:~

对整数的二进制位进行取反。

在 Python 中:

print(~5)  # -6

Python 整数使用无限精度的有符号整数语义,因此不能简单地把 ~5 理解为固定 8 位或 32 位补码取反。

对于 Python 整数:

\sim x = -x-1

7.5 左移与右移

运算符 含义
<< 左移
>> 右移

例如:

print(5 << 1)  # 10
print(8 >> 1)  # 4

二进制示意:

5  = 0101
5 << 1 = 1010 = 10

8  = 1000
8 >> 1 = 0100 = 4

对于非负整数,左移一位通常相当于乘以 2,右移一位通常相当于除以 2 后向下取整。

但这不是所有情况下都能直接套用的数学规则:

  • 左移可能导致整数溢出。
  • 有符号右移可能涉及符号位扩展。
  • 逻辑右移与算术右移的行为不同。
  • 移位位数和操作数类型受到语言规范约束。

7.6 位运算的实际用途

权限控制

可以使用不同二进制位表示不同权限。

READ = 1       # 0001
WRITE = 2      # 0010
EXECUTE = 4    # 0100

permissions = READ | WRITE

print(permissions & READ)  # 1

判断奇偶数

number = 10

if number & 1:
    print("奇数")
else:
    print("偶数")

判断某一位是否被设置

flags = 0b1010
mask = 0b0010

if flags & mask:
    print("目标标志位已设置")

八、条件运算符(三元运算符)

条件运算符用于根据条件选择不同的表达式结果。

常见形式:

条件 ? 表达式1 : 表达式2

例如 JavaScript:

const age = 20;

const result = age >= 18 ? "成年人" : "未成年人";

当条件为真时,返回第一个表达式的结果;否则返回第二个表达式的结果。

部分语言采用不同语法。

Python:

age = 20

result = "成年人" if age >= 18 else "未成年人"

条件表达式可以简化简单的分支逻辑。

但如果条件嵌套过多,会降低可读性:

const result = score >= 90
    ? "优秀"
    : score >= 60
        ? "及格"
        : "不及格";

复杂逻辑通常更适合使用 if、else 或其他分支结构。

九、其他常见运算符

除了上述运算符,不同编程语言还提供了许多具有特殊用途的运算符。

9.1 成员访问运算符

用于访问对象属性或结构体成员。

例如:

user.name

其中 . 用于访问 user 对象的 name 属性。

C 语言:

user.age

如果通过结构体指针访问成员:

user_ptr->age

9.2 数组与索引访问运算符

通过索引访问数组或集合中的元素。

numbers = [10, 20, 30]

print(numbers[0])  # 10

这里 [] 用于索引访问。

9.3 函数调用运算符

使用圆括号调用函数。

result = calculate(10, 20)

() 在这里表示函数调用。

9.4 类型判断运算符

用于判断对象或表达式的类型。

JavaScript:

console.log(typeof "hello"); // string
console.log(typeof 123);     // number

Java:

if (obj instanceof String) {
    System.out.println("字符串");
}

Python:

isinstance(123, int)

9.5 空值合并运算符

JavaScript 提供 ??,用于在左侧操作数为 null 或 undefined 时使用右侧默认值。

const username = inputName ?? "Guest";

与逻辑或 || 不同,?? 不会把 0、false 和空字符串当作需要替换的空值。