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); //輸出

}