Rust从安装到语法基础

rust学习资源

rust中文网
通过例子学rust
rust程序语言设计
下载安装包从本地安装rust

下面的rust安装是需要联网安装的

linux安装rust

curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

rust的更新

rustup update

卸载rust

rustup self uninstall

Rust在windows上的安装

需要安装VS2013或更高版本。选中C++开发工具中，指定安装组件

• windows10/11 SDK,
• C++ Cmake tools for windows,
• MSVC V142
  rustup安装器
  下载rustup安装器，点击后会开始安装rust.

cargo配置国内镜像

在路径$HOME/.cargo/路径下新建一个config文件内容如下：

[source.crates-io]
registry = "https://github.com/rust-lang/crates.io-index"
replace-with = 'ustc'
[source.ustc]
registry = "git://mirrors.ustc.edu.cn/crates.io-index"

集成开发环境

建议使用VS code.
后续开发都是基于VS code.
安装VS code开发插件 Rust或Rust-analyzer，两者会冲突，前者是官方的，后者是最近比较活跃的插件，我选择后者。

\\查看rust的版本
rustc -V
cargo --version

打开VS code,终端-新建终端，快捷键ctrl+shift+`
输入

cargo new first
cd first
cargo build
cargo run

参考:https://www.runoob.com/rust/rust-setup.html

cargo check来代替cargo build,即不生成可执行文件，这样编译速度会快很多。
上面的命令即，创建first,进入该目录，编译，运行。输出即Hello, world!

rust基础语法：
rust是编译型语言，要求是先编译后执行，生成的可执行文件是二进制文件，即可以在系统上直接运行的程序，不需要使用者安装rust.区别于python，JavaScript等后编译语言。
cargo是rust的构建系统和包管理器，安装rust的时候会自动安装cargo.
上面的示例：cargo创建了first文件夹，
包含Cargo.toml 和 src文件夹，src里有一个main.rs即自动生成的hello world的rust程序代码。
和其他语言一样，rust也有保留关键字
rust的标注库的模块API

每行语句结束一定要有分号，否则会报错，一行命令分为多行书写的时候，中间的行可以不用分号

rust注释代码

//这是一行注释文本

/*这是一个
多行的
注释代码
*/
fn main(){
  let a = 5 + /*95+*/5;
  println!(“a is 10 or 100? a is {}”,a);
}
/*行内注释*/

rust依赖的是大括号{}和()来表示结构，不依赖缩进表示代码结构（与python区别很大）。

rust的文本打印

-print!输出到std out
-println!输出到std out 结尾有换行符
-eprint!输出到std err
-eprintln!输出到std err 结尾有换行符
-format!标准化字符串
其实都是print扩展的，加上ln就是在输出末尾加上换行符，前面加上e就是error。

rust变量定义

let author=“Zhang san”;
let author=“Wang si” ;//此处是author被重新声明了，覆盖了前面的声明。

let mut age = 23;
age = 32; //此处是age被重新赋值了，赋值的类型必须和原来的一样

变量定义必须要用let,默认定义的是常量，常量可以被后面重新定义而覆盖。let mut声明变量，但是变量不能被重新定义，但是可以被重新赋值。
上面的age就是变量，设置数字后，默认就是i32格式，所以后续赋值必须是i32格式，如果赋值给的是字符串或浮点f32,就会报错。

数据类型

整型	无符号整型	浮点型
i8	u8	NA
i16	u16	NA
i32	u32	f32
i64	u64	f64
i128	u128	NA
isize	usize	NA

数据的储存位数是2^{n,因为所有的种类都包含0，所以减去2}n-1就是能储存的其他数字的数量。
i是整型，例如i8最大是127，最小是-127
u是无符号整型，所以只能是正整数，u8,范围是0-255.
f是浮点，而且只能是f32或f64,其他的是没有的。f32范围是[-2147483647,+2147483647]
rust的下标是从0开始的,可以使用_作为数字的视觉分隔符。例如：10000可以写成10_000,rust会认为是一样的。
isize是根据你的系统来决定位数，系统一般是32或64位。

rust默认的整型数字是有符号的i32，浮点数子是f64.

运算符 + - * / %加减乘除整除
逻辑运算符bool：true false

let control_name: bool = false;
let center_n = true;

元组tuple()长度是固定的，每个元素类型可以不同

let name_list = ("zhangan","Maliu","Wangsi",230);
println!("第4个人是:{}",name_list.3);

使用.3来获取name_list的第4个元素。注意：下标是从0开始的，第一个元素是对应.0

数组array []长度是固定的，而且每个元素类型必须相同

    let test_a = [100, 202, 263, 354, 455];
    println!("the first number is:{}",test_a[0]);

使用的是[0]来获取数组第一个元素。

函数function

fn main(){
    plus_plus(122,345,"zhangsan");
}
fn plus_plus (x:i32,y:i32,str1:&str){
    let  sum_xy = x + y;
    println!("welcome you :{0} NO:{1}",sum_xy,str1);
}

在主函数main里调用自定义函数plus_plus,函数定义的时候指定参数的类型

有返回值的函数

 fn main(){
let sum_one = plus_one(99);
 println!("有返回值的函数，返回的是{}",sum_one);
}
fn plus_one (x:i32) -> i32{x+1}

注意定义的有返回值的函数plus_one的{}中结尾是没有;的，因为这是一个表达式，如果有分号会报错的。指定输出的类型是i32,但是不指定输出的值的名称

if else结构

//if else if else循环
 let age:u8 = 95;
    if age > 60 {
        println!("老年!");
    } else if age < 18 {
        println!("未成年！");
    } else {
        println!("青年人！");
    }

//if和let的联合使用，通过if判断来给某个变量赋值。
    let sex:bool = false;
    let sexy = if sex {"man"} else {"woman"};
    println!("{0}，代表的性别是：{1}",sex,sexy);

循环 loop while for

  let mut counter = 0;
    let mut sums = 0;
    let results = loop{
        sums = sums + counter; 
        counter += 1;

        if counter == 100 {//
            break sums; 
        }
    };
    println!("1到99的和是:{0}",results);

loop循环，使用break终止，break后跟的是返回值。上面的代码就是返回0到99的所有自然数的和。

 let mut numbers1 = 99;
    let mut sums1 = 0;
    while numbers1 > 9 {
        sums1 += numbers1;
        numbers1 -=1;
    }
    println!("10到99之间所有自然数的和是:{}",sums1);

使用for循环打印99乘法表

//打印9x9乘法表
    let a = [1,2,3,4,5,6,7,8,9];
    let b = [1,2,3,4,5,6,7,8,9];
    for i in a {
        print!("{}\t",i);//打印第1列
        for j in b {
            print!("{}\t",i*j);
        }
        println!()//打印每行的换行符
    }

输出的99乘法表,使用的是tab分割符。注意需要使用print!来打印，这样不会输出换行符。

1       1       2       3       4       5       6       7       8       9
2       2       4       6       8       10      12      14      16      18
3       3       6       9       12      15      18      21      24      27
4       4       8       12      16      20      24      28      32      36
5       5       10      15      20      25      30      35      40      45
6       6       12      18      24      30      36      42      48      54
7       7       14      21      28      35      42      49      56      63
8       8       16      24      32      40      48      56      64      72
9       9       18      27      36      45      54      63      72      81

打印倒置的99乘法表，显然这次的代码量更少。使用(1..10).rev生成9到1的自然数.后面的rev就是倒序的意思。

    //打印倒排的99乘法表
    for i in (1..10).rev(){
        //print!("{}\t",i); //输出第1列，这次就不输出第1列了
        for j in (1..10).rev() {
            print!("{}\t",i*j);
        }
        println!();
    } 

---

下面是语法深入学习阶段

堆栈的区别：堆是先进先出，栈是先进后出。
编译时，大小不固定的对象必须存储在堆上，栈的大小是固定的。