字面量与运算符 - Rust 教程

字面量：代码里直接写出来、一眼就能看出值的常量数据，是程序中最基础的数据表达形式。

值固定不变，写死在代码里，运行中不会改变；不需要计算、不用变量解析，直译就是 “字面上的值”。

例如：下面的13 ,3.14 就是字面量了，其他语言也叫字面值。

fn main() {
    println!("{}", 13);
    println!("{}", 3.14);
}Code language: JavaScript (javascript)

为了方便学习，官方提供了一个在线的rust编辑工具，读者可以不安装本机环境，就可以在上面学习这些rust的基本语法。点击下面链接

Rust Playground

字面量

Rust 支持整数、浮点数、字符、字符串、布尔值、单元（unit ）类型这些类型的字面量。

整数：11
字符：'a'（单引号）
字符串："abc"（双引号）
布尔：true / false
单元类型：()

整数多种进制写法

通过前缀区分进制，仅用于整数：

十六进制：0x 开头，例：0x1F
八进制：0o 开头，例：0o77
二进制：0b 开头，例：0b1010

数字分隔符

数值字面量中可插入下划线 _ 提升可读性，不影响实际数值：

整数：1_000 = 1000
浮点数：0.000_001 = 0.000001

科学计数法

浮点数支持科学 E 表示法，默认类型为 f64：

1e6 = 1000000
7.6e-4 = 0.00076

字面量类型后缀（关键）

Rust 需明确字面量类型，常用后缀：

u32：32 位无符号整数（非负数）
i32：32 位有符号整数（正负均可）

注意：有符号、无符号整数不能混合运算，会直接报错。

例子：

fn main() {
    // 1. 普通整数字面量
    println!("整数: {}", 13);
    // 二进制、八进制、十六进制整数
    println!("二进制: {}", 0b1010);
    println!("八进制: {}", 0o77);
    println!("十六进制: {}", 0x2A);
    // 带分隔符的整数（提升可读性）
    println!("带下划线整数: {}", 1_000_000);
    // 带类型后缀整数
    println!("u32无符号整数: {}", 100u32);
    println!("i32有符号整数: {}", -50i32);

    // 2. 浮点数字面量
    println!("浮点数: {}", 3.14);
    // 带下划线浮点数
    println!("带下划线浮点数: {}", 0.000_001);
    // 科学计数法浮点数
    println!("科学计数法: {}", 1e6);
    println!("负科学计数法: {}", 7.6e-4);

    // 3. 字符串字面量（双引号）
    println!("字符串: {}", "hello world");

    // 4. 字符字面量（单引号，只能单个字符）
    println!("字符: {}", 'a');
    println!("中文字符: {}", '中');

    // 5. 布尔字面量
    println!("布尔true: {}", true);
    println!("布尔false: {}", false);

    // 6. 单元字面量 () （Rust 单元类型）
    println!("单元类型: {:?}", ());
}Code language: JavaScript (javascript)

运算符

Rust 运算符规则、优先级和类 C 语言基本一致。

1. 算术运算符

加减等基础运算，搭配整数类型后缀使用：

加法：+
减法：-

2. 布尔逻辑运算符（短路逻辑）

仅作用于布尔值 true/false：

与 &&：两边都为 true 结果才为 true
或 ||：任意一边为 true 结果即为 true
非 !：取反

表达式	运算结果
true && true	true
true && false	false
false && true	false
false && false	false
true \|\| true	true
true \|\| false	true
false \|\| true	true
false \|\| false	false
!true	false
!false	true

3. 位运算（操作二进制位）

多用于整数，示例用 {:04b} 格式化输出4 位二进制：

按位与 &：同位都为 1，结果才为 1
按位或 |：同位有一个 1，结果即为 1
按位异或 ^：同位不同则为 1，相同则为 0
左移 <<：二进制整体左移（等价 ×2ⁿ）
右移 >>：二进制整体右移（等价 ÷2ⁿ）

  0 0 1 1
& 0 1 0 1
-----------
  0 0 0 1  

  0 0 1 1
| 0 1 0 1
-----------
  0 1 1 1

  0 0 1 1
^ 0 1 0 1
-----------
  0 1 1 0

左移 <<
二进制：00000001
左移 5 位 → 00100000，结果 = 32

右移 >>
0x80 二进制：10000000
右移 2 位 → 00100000（十六进制 0x20），结果 = 32

fn main() {
    // ========== 算术运算符 ==========
    // 整数加法：u32 32位无符号整数
    // 运行结果：1 + 2 = 3
    println!("1 + 2 = {}", 1u32 + 2);

    // 整数减法：i32 32位有符号整数，支持负数
    // 若改为 1u32 会报错，无符号整数无法表示负数
    // 运行结果：1 - 2 = -1
    println!("1 - 2 = {}", 1i32 - 2);

    // ========== 浮点数字面量 - 科学计数法 ==========
    // 运行结果：1e4 是 10000, -2.5e-3 是 -0.0025
    println!("1e4 是 {}, -2.5e-3 是 {}", 1e4, -2.5e-3);

    // ========== 布尔逻辑运算符（短路运算） ==========
    // 逻辑与 &&：两边同时为 true 结果才为 true
    // 运行结果：true 与 false = false
    println!("true 与 false = {}", true && false);

    // 逻辑或 ||：任意一边为 true 结果就为 true
    // 运行结果：true 或 false = true
    println!("true 或 false = {}", true || false);

    // 逻辑非 !：对布尔值取反
    // 运行结果：非 true = false
    println!("非 true = {}", !true);

    // ========== 位运算符（操作二进制位） ==========
    // {:04b} 固定输出4位二进制，不足补0
    // 按位与 &：同位都为1结果才为1
    // 运行结果：0011 按位与 0101 = 0001
    println!("0011 按位与 0101 = {:04b}", 0b0011u32 & 0b0101);

    // 按位或 |：同位有一个为1结果就为1
    // 运行结果：0011 按位或 0101 = 0111
    println!("0011 按位或 0101 = {:04b}", 0b0011u32 | 0b0101);

    // 按位异或 ^：同位不同则为1，相同则为0
    // 运行结果：0011 按位异或 0101 = 0110
    println!("0011 按位异或 0101 = {:04b}", 0b0011u32 ^ 0b0101);

    // 左移 <<：二进制整体左移5位
    // 运行结果：1 左移 5 位 = 32
    println!("1 左移 5 位 = {}", 1u32 << 5);

    // 右移 >>：二进制整体右移2位，{:x} 输出十六进制
    // 运行结果：0x80 右移 2 位 = 0x20
    println!("0x80 右移 2 位 = 0x{:x}", 0x80u32 >> 2);

    // ========== 数字分隔符 _ ==========
    // 下划线仅提升可读性，不改变数值
    // 运行结果：一百万写作：1000000
    println!("一百万写作：{}", 1_000_000u32);
}Code language: JavaScript (javascript)

三、代码运行补充说明

把 1i32 改成 1u32 执行减法 1u32 - 2 会报错：无符号整数不能表示负数。
{:04b}：格式化输出，b 代表二进制，04 代表不足 4 位时左侧补 0。
大数值推荐用下划线分隔（如 1_000_000u32），代码可读性更高。

Previous: 基本类型

字面量