Rust基础语法(变量、常量、数据类型)

2022-11-28 15:46:30 浏览数 (1)

变量，基本类型，函数，注释和控制流，这些几乎是每种编程语言都具有的编程概念。

变量

变量的命名规则

Rust 中的变量名并不是随便什么字符都可以的，它遵循着一套规则

  1. 变量名中可以包含 字母、数字 和 下划线。也就只能是 abcdefghijklmnopqrstuvwxyz013456789_ 以及大写字母。
  2. 变量名必须以 字母 或 下划线 开头。也就是不能以 数字 开头。
  3. 变量名是 区分大小 写的。也就是大写的 A 和小写的 a 是两个不同的字符。

不可变变量

变量默认是不可改变的（immutable），这是Rust 提供的安全性和简单并发性来编写代码的众多方式之一。 let 关键字用于定义变量，默认定义的是不可变变量：

代码语言：javascript复制
fn main() {
    // 可以通过类型推导得到变量类型，因此可以不制定变量类型
    let a = 1;
    // 也可以明确指定变量类型
    let b: bool = true;
}

Rust 编译器保证，如果声明一个值不会变，它就真的不会变。这意味着当阅读和编写代码时，不需要追踪一个值如何和在哪可能会被改变，从而使得代码易于推导。不可变变量不能第二次赋值。

可变变量

变量只是默认不可变；你可以在变量名之前加 mut 来使其可变。除了允许改变值之外，mut 向读者表明了其他代码将会改变这个变量值的意图。可变变量可以第二次赋值。

代码语言：javascript复制
fn main() {
    let mut x = 666;
    println!("The value of x is: {}", x);
    x = 888;
    println!("The value of x is: {}", x);
}

权衡使用

  • 使用大型数据结构时，适当地使用可变变量，可能比复制和返回新分配的实例更快
  • 对于较小的数据结构，总是创建新实例，采用更偏向函数式的编程风格，可能会使代码更易理解，为可读性而牺牲性能或许是值得的

当多种类型均有可能时，必须增加类型注解：

代码语言：javascript复制
let guess: u32 = "42".parse().expect("Not a number!");

常量

类似于不可变变量，常量(constants) 是绑定到一个名称的不允许改变的值，不过常量与变量还是有一些区别。 首先，不允许对常量使用 mut。常量不光默认不能变，它总是不能变。 声明常量使用 const 关键字而不是 let，并且 必须 注明值的类型。在下一部分，“数据类型” 中会介绍类型和类型注解，现在无需关心这些细节，记住总是标注类型即可。 常量可以在任何作用域中声明，包括全局作用域，这在一个值需要被很多部分的代码用到时很有用。 最后一个区别是，常量只能被设置为常量表达式，而不可以是其他任何只能在运行时计算出的值。 下面是一个声明常量的例子：

代码语言：javascript复制
const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;

常量的名称是 THREE_HOURS_IN_SECONDS，它的值被设置为 60（一分钟内的秒数）乘以 60（一小时内的分钟数）再乘以 3（我们在这个程序中要计算的小时数）的结果。Rust 对常量的命名约定是在单词之间使用全大写加下划线。编译器能够在编译时计算一组有限的操作，这使我们可以选择以更容易理解和验证的方式写出此值，而不是将此常量设置为值10,800。有关声明常量时可以使用哪些操作的详细信息，请参阅 Rust Reference 的常量求值部分。 在声明它的作用域之中，常量在整个程序生命周期中都有效，此属性使得常量可以作为多处代码使用的全局范围的值，例如一个游戏中所有玩家可以获取的最高分或者光速。 将遍布于应用程序中的硬编码值声明为常量，能帮助后来的代码维护人员了解值的意图。如果将来需要修改硬编码值，也只需修改汇聚于一处的硬编码值。

数据类型

Rust 有四种基本的标量类型：整型、浮点型、布尔类型和字符类型。

代码语言：javascript复制
fn main() {
   let company_string = "TutorialsPoint";  // string 字符串类型
   let rating_float = 4.5;                 // float 类型
   let is_growing_boolean = true;          // boolean 类型
   let icon_char = '♥';                    //unicode character 类型

   println!("company name is:{}",company_string);
   println!("company rating on 5 is:{}",rating_float);
   println!("company is growing :{}",is_growing_boolean);
   println!("company icon is:{}",icon_char);
}

上面的代码中，我们并没有为每一个变量指定它们的数据类型。Rust 编译器会自动从 等号 = 右边的值中推断出该变阿玲的类型。例如 Rust 会自动将 双引号 阔起来的数据推断为 字符串，把没有小数点的数字自动推断为 整型。把 true 或 false 值推断为 布尔类型。 println!() 是一个 宏，而不是一个函数，区分函数和宏的唯一办法，就是看函数名/宏名最后有没有 感叹号 !. 如果有感叹号则是宏，没有则是函数。 println!() 宏接受两个参数：

  • 第一个参数是格式化符，一般是 {}，如果是复杂类型，则是 {:?}。
  • 第二个参数是变量名或者常量名。

整型(integers)

整数型简称整型，按照比特位长度和有无符号分为一下种类：

位长度

有符号

无符号

8-bit

i8

u8

16-bit

i16

u16

32-bit

i32

u32

64-bit

i64

u64

128-bit

i128

u128

arch

isize

usize

isize 和 usize 两种整数类型是用来衡量数据大小的，它们的位长度取决于所运行的目标平台，如果是 32 位架构的处理器将使用 32 位位长度整型。 整数的表述方法有以下几种：

进制

例

十进制

98_222

十六进制

0xff

八进制

0o77

二进制

0b1111_0000

字节(只能表示 u8 型)

b’A’

很显然，有的整数中间存在一个下划线，这种设计可以让人们在输入一个很大的数字时更容易判断数字的值大概是多少。

浮点数型（floating-point numbers）

Rust 与其它语言一样支持 32 位浮点数（f32）和 64 位浮点数（f64）。默认情况下，64.0 将表示 64 位浮点数，因为现代计算机处理器对两种浮点数计算的速度几乎相同，但 64 位浮点数精度更高。

代码语言：javascript复制
fn main() {
 let x = 2.0; // f64
 let y: f32 = 3.0; // f32
}

数学运算

用一段程序反应数学运算：

代码语言：javascript复制
fn main() {
 let sum = 5   10; // 加
 let difference = 95.5 - 4.3; // 减
 let product = 4 * 30; // 乘
 let quotient = 56.7 / 32.2; // 除
 let remainder = 43 % 5; // 求余
}

许多运算符号之后加上 = 号是自运算的意思，例如： sum = 1 等同于 sum = sum 1。 注意：Rust 不支持 和 --，因为这两个运算符出现在变量的前后会影响代码可读性，减弱了开发者对变量改变的意识能力。

布尔型(Booleans)

布尔型用 bool 表示，值只能为 true 或 false。

字符型(characters)

字符型用 char 表示。 Rust的 char 类型大小为 4 个字节，代表 Unicode标量值，这意味着它可以支持中文，日文和韩文字符等非英文字符甚至表情符号和零宽度空格在 Rust 中都是有效的 char 值。 Unicode 值的范围从 U 0000 到 U D7FF 和 U E000 到 U 10FFFF （包括两端）。 但是，"字符"这个概念并不存在于 Unicode 中，因此您对"字符"是什么的直觉可能与Rust中的字符概念不匹配。所以一般推荐使用字符串储存 UTF-8 文字（非英文字符尽可能地出现在字符串中）。 注意：由于中文文字编码有两种（GBK 和 UTF-8），所以编程中使用中文字符串有可能导致乱码的出现，这是因为源程序与命令行的文字编码不一致，所以在 Rust 中字符串和字符都必须使用 UTF-8 编码，否则编译器会报错。

复合类型

元组用一对 ( ) 包括的一组数据，可以包含不同种类的数据：

代码语言：javascript复制
let tup: (i32, f64, u8) = (500, 6.4, 1);
// tup.0 等于 500
// tup.1 等于 6.4
// tup.2 等于 1
let (x, y, z) = tup;
// y 等于 6.4

数组用一对 [ ] 包括的同类型数据。

代码语言：javascript复制
let a = [1, 2, 3, 4, 5];
// a 是一个长度为 5 的整型数组

let b = ["January", "February", "March"];
// b 是一个长度为 3 的字符串数组

let c: [i32; 5] = [1, 2, 3, 4, 5];
// c 是一个长度为 5 的 i32 数组

let d = [3; 5];
// 等同于 let d = [3, 3, 3, 3, 3];

let first = a[0];
let second = a[1];
// 数组访问

a[0] = 123; // 错误：数组 a 不可变
let mut a = [1, 2, 3];
a[0] = 4; // 正确

本文内容到此结束了， 如有收获欢迎点赞

rust ide unicode 编程算法

0 人点赞