类型

标量类型（scalar type）

  • 有符号整型（signed integers）：i8、i16、i32、i64 和 isize（指针宽度）
  • 无符号整型（unsigned integers）： u8、u16、u32、u64 和 usize（指针宽度）
  • 浮点类型（floating point）： f32、f64
  • char（字符）：单个 Unicode 字符，如 'a'，'α' 和 '∞'（每个都是 4 字节）
  • bool（布尔型）：只能是 true 或 false
  • 单元类型（unit type）：()。其唯一可能的值就是 () 这个空元组

    复合类型（compound type）

    数组（array）：如 [1, 2, 3]
    元组（tuple）：如 (1, true)

数字还可以通过后缀 （suffix）或默认方式来声明类型。整型默认为 i32 类型，浮点型默认为 f64 类型。没有指定类型，或者无法推断时使用默认类型。

  1. let an_integer = 5i32; // 后缀说明
  3. // 可以用掩蔽（shadow）来覆盖前面的变量。
  4. let an_integer = 666u32;

字面量和运算符

整数 1、浮点数 1.2、字符 'a'、字符串 "abc"、布尔值 true 和单元类型 () 可以用数字、文字或符号之类的 “字面量”（literal）来表示。
通过加前缀 0x、0o、0b，数字可以用十六进制、八进制或二进制记法表示。

  1. fn main() {
  2.     // 短路求值的布尔逻辑
  3.     println!("true AND false is {}", true && false);
  4.     println!("true OR false is {}", true || false);
  5.     println!("NOT true is {}", !true);
  7.     // 位运算
  8.     println!("0011 AND 0101 is {:05b}", 0b0011u32 & 0b0101);
  9.     println!("0011 OR 0101 is {:04b}", 0b0011u32 | 0b0101);
  10.     println!("0011 XOR 0101 is {:04b}", 0b0011u32 ^ 0b0101); //0011 XOR 0101 is 0110
  11.     println!("1 << 5 is {}", 1u32 << 5);
  12.     println!("0x80 >> 2 is 0x{:x}", 0x80u32 >> 2);
  14.     // 使用下划线改善数字的可读性！
  15.     println!("One million is written as {}", 1_000_000u32);
  16. }

元组

元组是一个可以包含各种类型的值的组合。

  1. // 元组可以充当函数的参数和返回值
  2. fn reverse(pair: (i32, bool)) -> (bool, i32) {
  3.     // 可以使用 `let` 把一个元组的成员绑定到一些变量
  4.     let (integer, boolean) = pair;
  6.     (boolean, integer)
  7. }
  9. fn main() {
  10.     // 创建单元素元组需要一个额外的逗号，这是为了和被括号包含的字面量作区分。
  11.     println!("one element tuple: {:?}", (5u32,));
  12.     println!("just an integer: {:?}", (5u32));
  14.     // 元组可以被解构（deconstruct），从而将值绑定给变量
  15.     let tuple = (1, "hello", 4.5, true);
  17.     let (a, b, c, d) = tuple;
  18.     println!("{:?}, {:?}, {:?}, {:?}", a, b, c, d);
  19. }

数组和切片

数组（array）是一组拥有相同类型 T 的对象的集合，在内存中是连续存储的。数组的类型标记为 [T; size]。
切片（slice）类型和数组类似，但其大小在编译时是不确定的。slice 的类型标记为 &[T]。

  1. use std::mem;
  2. fn main() {
  3.     // 定长数组（类型标记是多余的）
  4.     let xs: [i32; 5] = [1, 2, 3, 4, 5];
  6.     // 所有元素可以初始化成相同的值
  7.     let ys: [i32; 500] = [0; 500];
  9.     // 数组是在栈中分配的
  10.     println!("array occupies {} bytes", mem::size_of_val(&xs));
  12.     // 数组可以自动被借用成为 slice
  13.     println!("borrow the whole array as a slice");
  14.     analyze_slice(&xs);
  16.     // slice 可以指向数组的一部分
  17.     println!("borrow a section of the array as a slice");
  18.     analyze_slice(&ys[1 .. 4]);
  19. }