devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Rust 快速入门60分① 看完这篇就能写代码了

作者：很楠不爱3 | 2024-02-14 22:58:36

赞

踩

rust 快速入门

Rust 一门赋予每个人构建可靠且高效软件能力的语言https://hannyang.blog.csdn.net/article/details/130467813?spm=1001.2014.3001.5502关于Rust安装等内容请参考上文链接，写完上文就在考虑写点关于Rust的入门文章，本专辑将直接从Rust基础入门内容开始讲起。标题《快速入门60分》并不指60分钟，而是希望自己写完这个专辑后，可以得个60分，也能掌握Rust60%上下的内容，请看第一章《变量与常量》：

目录

一、变量与常量

1.1 变量

1.1.1. 变量命名

1.1.2. 变量声明、赋值

1.1.3. Snake case

1.1.4. 禁止使用和避免使用

1.1.5 匿名变量

1.2 基本数据类型

1.2.1 整型

1.2.2 浮点型 

1.2.3 字符型

1.2.4 布尔型

1.3 变量的可变和不可变

1.3.1 不可变变量

1.3.2 可变变量

1.3.3 变量遮蔽

1.3.4 静态变量（全局变量）

1.4 常量

1.4.1 常量命名

1.4.2 常量用法

1.4.3 标准库常量

1.5 本章小结

一、变量与常量

1.1 变量

1.1.1. 变量命名

变量名由字母、数字或下划线组成，应该具有描述性，能够清楚地表达变量的含义。命名的基本规则和大多数编程语言基本相同，有些细节上稍微有所不同。规则如下：

  1. 变量名必须以字母或下划线开头。
  2. 变量名不能以数字开头。
  3. 变量名区分大小写，推荐使用 snake_case 规则（字母全部小写和下划线）。
  4. 禁止使用和 Rust 关键字同名的变量名。
  5. 避免使用和 Rust 标准库中已有的函数、类型或模块同名的变量名。
  6. 对于私有变量 (private variables)，可以使用 _ 作为前缀，区分开公共变量和私有变量。

1.1.2. 变量声明、赋值

Rust 变量声明使用 let 关键字，有些早期版本的basic语言也用LET（现在通常是DIM）。

示例：

  1. fn main() {
  2.     let x = 323;
  3.     let y = 3.23;
  4.     print!("x: {}, ", x);
  5.     println!("y: {}", y);
  6.     //输出 x: 323, y: 3.23
  7. }

上面示例中，fn 是函数 function 的缩写，表示 main() 是这个rust程序的主函数；

let 变量名 = 常数；就是一个变量声明、赋值语句；

print!() 和 println!() 是打印的“宏”，宏不是函数，但功能也就相近于Java中的System.out.print()函数和System.out.println()函数的功能，两者输出差一个换行符。

// 表示注释语句，注释与C++相同，行注释用 //，块注释用 /*  */；Rust另外还有文档注释。

函数体中每一行都是一个语句（当然语句也可以跨多行表达），语句由各种表达式组成。第一条语句必须有标点符号分号作结尾，表达式一般没有符号作结尾的。关于Rust中的“宏”，它和C/C++中的“宏”还是不同的，更多函数相关内容，放到之后的函数章节再讲。

let 语句也可以分成两行，先声明再分配值（赋值绑定）：

  1. fn main() {
  2.     let x;
  3.     x = 100;
  4.     println!("x: {}", x); 
  5. }

let 语句还可以一行赋值多个变量，但要加上括号（其实是复合数据类型之一的元组）：

  1. fn main() {
  2.     let (x, y) = (3, 4);
  3.     let z = (x*x+y*y) as f64;
  4.     let z = z.sqrt().round() as i32;
  5.     println!("{},{},{}", x, y, z); // 3,4,5
  6.     let (a, b, c) = (1, 2, 3);
  7.     println!("{},{},{}", a, b, c); // 1,2,3
  8. }

其中，as 也是Rust关键字之一，在这里用于强制转换数据类型。 

sqrt()、round() 分别为平方根、取整函数。

1.1.3. Snake case

Snake case 是一种命名规范，它使用小写字母，单词之间用下划线 "_" 连接。

Rust不推荐在变量中有大写字母，示例如下：

  1. fn main() {
  2.     let Int = 100;
  3.     let My_Integer = 200;
  4.     let my_integer = 300;
  5.     
  6.     println!("{} {} {}", Int, My_Integer, my_integer)
  7. }

以上代码可以编译执行，但会有警告出现：

···Rust
warning: variable `Int` should have a snake case name
 --> D:\Rust\hello.rs:2:9
   |
2 |     let Int = 100;
   |         ^^^ help: convert the identifier to snake case (notice the capitalization): `int`
   |
  = note: `#[warn(non_snake_case)]` on by default

warning: variable `My_Integer` should have a snake case name
 --> D:\Rust\hello.rs:3:9
   |
3 |     let My_Integer = 200;
   |         ^^^^^^^^^^ help: convert the identifier to snake case: `my_integer`

warning: 2 warnings emitted

100 200 300
···

1.1.4. 禁止使用和避免使用

变量命名使用关键字，报错通不过编译，所以是禁止使用；但与标准库中已有的函数、类型同名，只是容易混淆，但编译不警告不报错，所以只能说是避免使用。如：

  1. fn main() {
  2.     //let fn = 10; //禁止使用
  3.     //let let = 2; //禁止使用
  4.     let u8 = 10u8; //避免使用
  5.     let pow;       //避免使用
  6.     pow = u8.pow(2);
  7.     println!("{} {}", u8, pow)  //输出 10 100
  8. }

其中， u8 的变量类型是8位无符号整型，pow() 是标准库函数平方幂函数。

函数名、类型名称作变量名不会报错，而fn, let关键字作变量名则报错：

```Rust
expected identifier, found keyword
  |
help: escape `fn` to use it as an identifier 
```

1.1.5 匿名变量

下划线 _ 是一个特殊的变量名，更确切地说是变量名称的缺失，就称它为匿名变量。它的基本意思是舍弃，可以理解为废纸篓，这个变量扔掉不要了，不能被再次调用。（Go, Python里也有  _ 用作匿名变量，但细节各不相同，而且在python里 “_ = 5;print(_)” 是合法的）

  1. fn main() {
  2.     let (a,_) = (6,2);
  3.     println!("{}", a);
  4.     //println!("{}", _); //报错^ `_` not allowed here
  5. }

1.2 基本数据类型

1.2.1 整型

Rust整型 分为有符号整型（signed，标记 in）和无符号整型（unsigned，标记 un），区别在于数字是否有负数。带符号整型的安全存储范围为 -2^(n-1) 到 2^(n-1) - 1，无符号整型的安全存储范围为 0 到 2^n，n 为数据位长度，见下表：

位长度有符号无符号
8-biti8u8
16-biti16u16
32-biti32u32
64-biti64u64
128-biti128u128
arch
由系统构架而定		isizeusize

isize 和 usize 是根据系统架构决定的，例如带符号整型，如果系统是 64 位，类型为 i64，如果系统是 32 位，类型为 i32。（这和C++中的size_t类型相似）

指定类型和默认类型

变量声明时，可以先指定类型，再分配绑定数值，变量名后面使用冒号跟随类型来明确指定变量的类型，称为显式指定；Rust 是强类型语言，具有自动判断变量类型的能力，可理解为这是隐式指定。以下示例中声明的变量 z 并没有明确指定其具体类型，则默认为 i32 类型，这也是 Rust 的特性之一类型推断。

  1. fn main() {
  2.     let x: u8;
  3.     x = 123;
  4.     let y = -1000i64;
  5.     let z = -323;  //不指定类型，默认为i32
  6.     println!("x: {}, y: {}, z: {}", x, y, z);
  7. }

1.2.2 浮点型 

Rust浮点型 分为 32 位浮点数（f32）和 64 位浮点数（f64）。浮点型若不指定具体类型，则默认为 f64 浮点数，现在的高性能CPU对两种浮点数计算的速度几乎相同，但 64 位浮点数精度更高。

  1. fn main() {
  2.     let x: f32;
  3.     x = 1.23;
  4.     let y: f64 = 3.23;
  5.     let z = -3.23;  //不指定类型，默认为f64
  6.     println!("x: {}, y: {}, z: {}", x, y, z);
  7. }

1.2.3 字符型

Rust字符型 是一个4字节 Unicode 码，支持中文等非英文字符，使用单引号''包括。

  1. fn main() {
  2.     let a = 'a';
  3.     let b: char = '字';
  4.     let c = '
    声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/82419
    推荐阅读
    相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。