Rust笔记

前言：

学了有段时间了，现在同步到博客园、

正文：

Rust语言介绍

l Rust由js之父开发的新型语言，打破了传统的难以接触底层的局面。这是个有C++开发的语言。拥有C的血统

l Rust必须严格区分大小写，不然会造成很麻烦的错误。

Rust基础语法

Rust声明变量：let 例子：let x=10; //x被赋值为10

Let x:i32 = 10; //x被定义为i32类型，并赋值为10

let (x,y)=(10,20); //x被给予值为10 y被给予值为20

Let注意事项：let x:i32 后面必须有值，否则会报错

let赋值不可变，如果想要可变得在let后面加上mut，或者用let重新赋值。

例子：let mut x=10; x=20; let y=20; let y=30;

Rust第一个例子：

Helo.rs

Fn main() { //fn声明了一个局部变量

Println!(“Hello word”); //println!用于输出

}

此时用rustc hello.rs

会在同一目录编译出hello，运行方式为：./hello

第二个例子：

1. Rs

fn main(){

Let x:i32 = 60; //定义x为i32类型赋值为60

Println!(“{}”,x);

}

被Rustc编译后将会输出：60

第三个例子：

1. Rs

Fn main(){

Let x=10;

{ //定义了一个块

Y=60;

Println!(“我能访问x和y”);

}

Println!(“我只能访问x”);

}

第三个例子告诉了我，{}定义一个块。所以这个块里的东西只有{里面才能访问到}。第二个prinln!访问不y的原因是因为是在第二个块之外访问的。

第四个例子：

1. rs

Fn main(){

Let x=10; //x赋值为10

{

Println!(“我是第一个{}”,x); //输出x为10

Let x=15; //x被重新赋值为15

Println!(“我是二个{}”,x); //输出x为15

}

Println!(“我是末{}”，x);//输出x为10 因为不在第二个块里面所以重新赋值的都无效

}

第四个例子告诉我，在同一个块里，重新定义赋值是有效的。不在同一个块里里是无效的。

第五个例子：

4.rs

Fn main(){

Let X=10;

{

Let x=20;

Let mut x=”HAq”;

X=x;

Println!(“{}”,x);

}

}

第五个例子最后面会输出HAQ因为x给重新赋值了

Rust函数例子：fn 函数名(){}

例子：fn foo(){ //声明了一个foo函数

}

函数里面带参数例子：

Fn main(){

Print_number(10); //定义一个有参数的函数

}

Fn print_number(x:i32){ //调用上面所定义的函数

Println!(“This is x:{}”,x);  //输出为10

}

另一个例子：

Fn main(){

Fuck(5); //定义一个有参数的函数为fuck

}

Fn fuck(x:i32){ //调用函数

Println!(“{}”,x);

}

注意事项：调用函数的时候必须在里面声明参数的类型

 

其他两类函数风格：

我这里只写一个,剩下那个我认为太糟糕了

Let f:fn(i32)->i32; //f是指向一个获取i32类型并返回i32类型的参数

例子：# fn plus_one(i: i32) -> i32 { i + 1 } //plus_one是指向一个获取i32类型并返回i32类型的参数,i+1

# let f = plus_one; //f等于这个函数

let six = f(5); //调用这个函数

创建函数的例子:

Fn main(){

Println!(“我是主函数”);

Foo();

}

Fn foo(){

Println!(“我是foo函数”);

}

原生类型

布尔值：let x:bool=true; let y=false; //布尔型为true或false。真或假

• 数字类型：i8
• i16
• i32
• i64
• u8
• u16
• u32
• u64
• isize
• usize
• f32
• f64

有符号和无符号

整型有两种变体：有符号和无符号。为了理解它们的区别，让我们考虑一个 4 比特大小的数字。一个有符号，4 比特数字你可以储存-8到+7的数字。有符号数采用“二进制补码”表示。一个无符号 4 比特的数字，因为它不需要储存负数，可以出储存0到+15的数字。

无符号类型使用u作为他们的分类，而有符号类型使用i。i代表“integer”。所以u8是一个 8 位无符号数字，而i8是一个 8 位有符号数字。

固定大小类型

固定大小类型在其表现中有特定数量的位。有效的位大小是8，16，32和64。那么，u32是无符号的，32 位整型，而i64是有符号，64 位整型。

可变大小类型

Rust 也提供了依赖底层机器指针大小的类型。这些类型拥有“size”分类，并有有符号和无符号变体。它有两个类型：isize和usize。

浮点类型

Rust 也有两个浮点类型：f32和f64。它们对应 IEEE-754 单精度和双精度浮点数。

强制转换类型: let x&str=10; //&类型 强制性转换

数组：

Let x=[80,60,70,80,90,100]

取值：x[0]这样

例子：

fn main(){

let a=[10,20,23,60,65];

println!("a长度为：{}",a.len());

println!("a的第一个数值为:{}",a[0]);

println!("a的最后一个值为:{}",a[4]);

let p=&a[1..3];

println!("a数组1到4的值为");

println!("切片之后的值还剩1和3.1的值为:{},2的值为:{}.",p[0],p[1]);

}

切片：&a[开始..结尾]

&a[1..3] //a切片之后就是20-60，等于一个新的数组了。

 

例子:

fn main(){

println!("数组与元组");

sz();

}

fn sz(){

let livs=["Englin","Chinse","WTF"];

println!("livs 0的值为{}",livs[0]);

println!("livs 1的值为{}",livs[1]);

println!("livs 2的值为{}",livs[2]);

println!("livs的长度为{}",livs.len());

let bs=&livs[1..2];

println!("bs是被切片出来的数组");

println!("bs 0的值是{}",bs[0]);

let g=&livs[0..1];

println!("g又被我切片出来的新数组{}",g[0]);

}

元组

定义元组为:let x=(‘haq’,’flask’); 这样

取值 x.0 //取出开的是haq

例子：

fn main(){

println!("数组与元组");

sz(); //创建一个sz的函数

yz(); //创建一个yz的函数

}

fn sz(){

let livs=["Englin","Chinse","WTF"]; //定义一个数组

println!("livs 0的值为{}",livs[0]); //取值

println!("livs 1的值为{}",livs[1]);

println!("livs 2的值为{}",livs[2]);

println!("livs的长度为{}",livs.len());

let bs=&livs[1..2]; //切片，成为一个新的数组

println!("bs是被切片出来的数组");

println!("bs 0的值是{}",bs[0]);

let g=&livs[0..1]; //切片成为一个新的数组

println!("g又被我切片出来的新数组{}",g[0]);

}

fn yz(){

let x=(1,"value"); //元组

let p:(i32,&str)=(10,"麦克雷->午时已到");

let t=(10,20,30);

let v=("何安圻","何韵欣","黎颖希");

println!("x 0:{},x 1:{}",x.0,x.1);//取值

println!("p 0:{},p 1{}",p.0,p.1);

println!("{},{},{}",v.0,v.1,v.2);

}

你可以通过一个解构let（destructuring let）访问元组中的字段。下面是一个例子：

let (x, y, z) = (1, 2, 3);

println!("x is {}", x);

判断

判断语句if

写法有js的影子。

Let x=10;

If x==10{

Println!(“x等于10”);

}Else if x==100{

Println!(“x为100”);

}else{

Println!(“x不等于10”);

}

例子：

fn main(){

rsd(); //创建了一个函数

}

fn rsd(){

let u=300; //u赋值为300

let x=[100,200]; //x赋值了一个数组

if u==x[0]{ //判断u是否等于x数组的0元素

println!("u不等等于100"); //输出

}else if u==x[1]{ //判断u是否等于x数组的1元素

println!("u等于200")

}else{ //如果都不是则判断

println!("u什么也不是");//输出

let f=(100,2000); //创建一个元组

println!("u为{},但是现在为{}",u,f.1); //输出元祖1元素

}

}

循环

Rust也有循环，有三种循环。分别为：Loop循环，while循环，for循环

Loop循环：  //变相死循环

Fn main(){

Let x=1;

Loop{ //loop循环，一直循环下去直到遇见停止语句

Println!(“{}”,x);

}

}

While循环：

Fn main(){

Foo();

}

Fn foo(){

Let mut x=6; //将x定义为可以变量，赋值为6

Let mut done=false; //将done定义为可变变量，赋值为false

While !Done{ //如果条件为假,则开始循环

X+=x-3   //x加x减去3

If x%3==0{ //如果x除于3等于0

Done=true; //将done值设置为true

}

}

}

一个完整的例子：

fn main(){

foo(); //创建了一个函数

}

fn foo(){

let mut p=10; //p定义一个可变变量赋值为10

let mut done=false; //done定义为一个可变变量，赋值为布尔值的false

while !done{ //如果条件为false

p+=p-3; //p加p减去3

println!("p value:{}",p); //输出

if p%5==1{ //p%5（余数计算）,当等于1的时候将done赋值为true

done=true;

}else{

println!("[-] p value {}",p); //不为if结果时输出

}

}

}

For循环：

Fn main(){

For x in 0..10{ //循环0到10

Println!(“{}”,x);

}

}

对于范围当你需要记录你已经循环了多少次了的时候，你可以使用.enumerate()函数

Enumerate用法

Fn main(){

For (key,value) in (0..10).enumerate(){ //固定范围不能大于5和大于10

Println!(“key:{},value:{}”,key,value);  //输出

}

}

迭代器：

例子：

Fn main(){

Let x=”username\nadmin”.lines() //lines()用于识别\n

For (x,line) in x.enumerate(){

Println!(“{}:{}”,lines,x); //line代表循环的次数

}

}

让代码跳出循环或者重新循环

fn main(){

poos(); //定义一个poos函数

}

fn poos(){

let mut  k=10; //将k赋值为10

for i in 1..10{ //循环1-9次

k+=k-3; //k加k减去3

println!("page is :{}",i); //输出循环的次数

println!("k value {}",k); //输出k的值

if k/3==1{ //如果k除于3等于1

break; //跳出循环

}

}

}

 

整体思路就是：

如果在这1-9次循环中，k加上k减去3。等到的结果在除于3，如果等于1则跳出循环。

fn main(){

poos();

}

fn poos(){

let mut  k=5;

for i in 1..2{

k+=k-3; //如果k加上k减去3

println!("page is :{}",i);

println!("k value {}",k);

if k+1==8{ //k在加1等于8

println!("[+]k==8 continue"); //进行下一次迭代

continue;

}

}

}

Vectors

“Vector”是一个动态或“可增长”的数组，被实现为标准库类型Vec<T>（其中<T>是一个泛型语句）。vector 总是在堆上分配数据。vector 与切片就像String与&str一样。你可以使用vec!宏来创建它：

Fn main(){

bz();

}

Fn bz(){

Let h=vec![0,10,20]; //创建一个可增长数组

For c in &h{ //遍历数组

Println!(“{}”,c);

}

}

变量数组：

Let a=[10,20,30];

For i in &a{ //遍历a数组

Println!(“a value is your {}”,i);

}

权限移动：

Fn main(){

Fdr();

}

Fn wds(){

Let y=[10,11,12];

Let h=v; //权限移动，此时v数组已经移动给h。在调用y就会报错

For y in &h{

Println!(“y in {}”,y);

}

}

所有权之外（More than ownership）

当然，如果我们不得不在每个我们写的函数中交还所有权：

fn foo(v: Vec<i32>) -> Vec<i32> {

// Do stuff with `v`.

// // Hand back ownership.

v

}

这将会变得烦人。它在我们获取更多变量的所有权时变得更糟：

fn foo(v1: Vec<i32>, v2: Vec<i32>) -> (Vec<i32>, Vec<i32>, i32) {

// Do stuff with `v1` and `v2`.

// Hand back ownership, and the result of our function.

(v1, v2, 42)

}

let v1 = vec![1, 2, 3];let v2 = vec![1, 2, 3];

let (v1, v2, answer) = foo(v1, v2);

额！返回值，返回的代码行（上面的最后一行），和函数调用都变得更复杂了。

记录几个函数值：

Let v=[];

V.push(10); //push添加

Iter 外部迭代

Fold() 累加器，用一个类型闭包返回给迭代器的所有元素，得到单一的一个值

例子：

Let mut i=(0..10).fold(0,|a,b|a+b);  // fold(第一个定义了0,|创建a变量对应就是值是0,创建b变量等于i,a加b)

Println!(“此时会输出{}”,i);

此时会输出：45

fn main(){

fn sum(v:&Vec<i32>)->i32{ //定义一个sum函数

return v.iter().fold(0,|a,&b|a+b); //返回迭代与一个累加器

}

let v1=vec![10,20,30]; //创建一个数组

let awser=sum(&v1);  //函数引用数组

println!("v1:{}",awser); //输出

}

&mut引用

例子：

Fn main(){

Let mut p=123; //创建一个p可变变量

{

Let x=&mut p; //引用mut p

*x+=1; //x+1 此时x等于p

Println!(“{}”,x); //输出124

}

}

CarGo使用教程

1. Cargo --version 查看Cargo版本
2. Cargo new 项目名称 --bin 创建一个新的项目

新建的项目会有一个Cargo.toml 里面是项目信息和一个src文件夹。标准的项目格式是，src放源码。项目的根目录放与源码无关的信息

例子：

[package]

name = "hello_cargo" 项目名称

version = "0.1.0" 版本

authors = ["Your Name <you@example.com>"] 作者信息

[dependencies]

1. 进入项目目录里执行cargo build 编译项目，会生成一个taget/debug文件夹里面是一些编译好的信息与编译好的可执行文件

1. Cargo check 用于检查代码是否正确。一般先检查代码是否正确在进行build编译

运行项目：Cargo run 运行项目

1. 优化项目Cargo build --release 用于优化项目。使代码运行起来的速度大大提高。编译的时间也会相应变长。编译好的项目不是放在target/debug里而是放在target/release

一个例子，让用户输入的项目：

Use std::io; //从std模块导出功能

Fn main(){

Println!(“这是一个让用户输入数字的例子”);

Println!(“请输入”);

Let mut gess=String::new(); //创建一个空的存储

Dk=io::stding:().read_line(&mut gess).expect(“Error”); //读取gess,如果报错则输出Error

Println!(“The gess:{}”,gess);// 输出gess

}

更新cargo.toml安装新的模块

[package]

name = "hello_cargo" 项目名称

version = "0.1.1" 版本

authors = ["Your Name <you@example.com>"] 作者信息

[dependencies]

Rnad=”0.3.14”

在dependencies下面添加要安装的模块与版本

执行cargo build更新Cargo.toml

更新让用户输入的例子项目：

Extern crate rand; //声明引用外部的rand模块

Use std::io; //导出std模块中的io功能

Use rand::Rng; //导出rand模块中的Rng功能

Fn main(){

Println!(“这里更新随机数字”);

Let sce=rand::thread_rang().gen_range(1,101); //随机数字设置

Println!(“set number sce:{}”,sce); //输出

Let mut gess=String::new(); //创建一个空的

Io:stdin().read_line(& mut gess).expect(“Error”); //读取

Println!(“gess:{}”,gess); //输出

}