DEV Community: Zhangwuji

rust lifeCycle

Zhangwuji — Wed, 29 May 2024 08:02:20 +0000

what is lifeCycle?

let a = String::from("ss");
let b;

{
  let c=String::from("test");
  b=&c;

}

print!("{}",b);

&c will not live long enough；
you can solve this problem

    let mut b;

    {
        let c=String::from("test");
        b=&c;

    };
    let c2=String::from("test");
    b=&c2;
    print!("{}",b);

because &c will not be given the control' itself to b; so &c will be destroied; b now is null;if this situation in other language, will throw null pointer error

    let mut b;

    {
        let c=String::from("testfffffffffgggg");
        // let g=Box::new(c);
        b=c;

    };

    print!("{}",b);

now the control of c is given to b; the memory of c in head will not be destroied。

1-------------

fn test(&'a a,&'b b) -> &'a {
   retun b
}

&'a &'b indicate different lifecycle

2-------------------

fn test2(&a a) -> &a{

}

&a equal &'a a if the parameter only have one. this 'a could be omited

3---------------------------

pub struct NewArticle<T> {
    pub headline: String,
    pub content: String,
    pub location: T,
}

impl<T> NewArticle <T> {
    fn summarize(&self,ff:T) -> String {
        //   let content= self.content;
        //   return  content;
        return format!("{}", self.content);
    }


}

&self euqal &'a self

how to use life cycle in Gernerics？

pub struct A <'a>{
    name:&'a 


};

  struct A<'a, T> {
        a: &'a T,
        b: &'a T,
    };
    impl<'a, T> A<'a, T> {
        fn new(one: &'a T, two: &'a T) -> Self {
            A { a: one, b: two }
        }

        fn first(self) -> &'a T {
            self.a
        }

        fn update(self){
            // self.a.push
        }
    }

    let b = A::new(&[1, 23], &[1, 23]);
let c = A::new(&1, &2);
    println!("{:#?}",b.first());

1 is i32 type. it staies in stack, &1 is reference of i32. it also staies in stack。

rust trait

Zhangwuji — Wed, 22 May 2024 04:10:54 +0000

you can regard trait as interface as ts.but it is more flexiable.

pub struct Animal {
   name:String
}
pub trait Action {
    fn say() ;
    fn getName -> String；
}
impl  Action for Animal {
     fn say(){

      },
    fn getName() ->String{

    } 
}

and you can set default implement for tait
such as

pub trait Action {
   fn say(){

      },
    fn getName -> String；
}

impl  Action for Animal {

    fn getName() ->String{

    } 
}

seond powerful function

pub trait Action<T,U> {
   fn say(){

      },
    fn getName -> String；
}

pub trait2 Action<T,U> {
   fn say(){

      },
    fn getName -> String；
}

fn main(ff:impl trait<String,String> + trait2<String,String> ) {

}

fn main<T:trait<String,String> + trait2<String,String>>(ff:T){

}

fn main<T,U>(ff:T)
where
   T:trait<String,String> + trait2<String,String>
{

}

the three methods are equal

rust Generics

Zhangwuji — Wed, 22 May 2024 03:01:35 +0000

what is Generics？
the essence of Generics is assuming it to be certain type。
the true type is not know until excution

how to use generics in function？

fn <T,U>name(st:T):U{

}

how to use generics in stuct？

stuct A <T,U> {
  string:T
  age:U
}

impl <T,U> A <T,U> {
     fn say<T2>(&self,param:T2) -> T2 {

        return  param;
    }
} 


`3. how to use generics in enum？``



enum Result <T,U>{
   Ok(T),
   Err(U)

}

Rust type Result

Zhangwuji — Wed, 22 May 2024 02:48:16 +0000

type Result is enum

pub enum Result<T, E> {
    /// Contains the success value
    #[lang = "Ok"]
    #[stable(feature = "rust1", since = "1.0.0")]
    Ok(#[stable(feature = "rust1", since = "1.0.0")] T),

    /// Contains the error value
    #[lang = "Err"]
    #[stable(feature = "rust1", since = "1.0.0")]
    Err(#[stable(feature = "rust1", since = "1.0.0")] E),
};

let me create a function that returntype is Result

fn test(path:String)->Result<&str,&str> {
      if path == "d" {
            Ok("我是成功了")
       }else{
           Error("我失败了")
       }

}

match test {
    Ok(s) =>{

    },
    Error(x)=>{

    }
}

Rust release

Zhangwuji — Wed, 22 May 2024 02:23:20 +0000

setup cargo.toml

[profile.dev]
panic = 'abort'

as you called cargo run
if your code happen panic!(); rust excutor dose not expand stack，Just exit main thread. let OS solve the error.

[profile.release]
panic = 'abort'

as you called cargo run --release
if your code happen panic!(); rust excutor dose not expand stack，Just exit main thread. let OS solve the error.

--release mean product environment；the build time would be slow, but packaged file will small.

cmd and powershell

Zhangwuji — Wed, 22 May 2024 01:50:36 +0000

in windows os
how to set cmd environment variable？

set fff = 1

how to set environment variable in powershell?

$env:RUST_BACKTRACE = "1"

how to output all environment variable into console in powershell?

gci Env:

how to output all environment variable into console in cmd?

set

the mothods bellow just make environment variable live in one powershell or cmd ？ when you close it. they will be destroied。

rust hashMap

Zhangwuji — Wed, 22 May 2024 01:29:21 +0000

how to create hashmap in rust？

use std::collections::HashMap;
let a = HashMap::new();

let a2= HashMap::from([
("key","value"),
("key","value")
]);

how to insert ("key","value") into map instance?

let a2= HashMap::from([
("key","value"),
("key","value")
]);
a2.insert("dd","22")

3.how to remove someone out of map instance?

 map.remove(&String::from("color2"));

4.how to update value of key?

     map.entry("test2").or_insert(200);

5.how to get value of key?

 let val=  map.get("test2");

how to traverse map instance?

let mut a2= HashMap::from([
("key","value"),
("key","value")
]);

for (key,value) in &mut a2{
   value*="213"
};

Unicode ASCII the history of character set

Zhangwuji — Tue, 21 May 2024 15:37:54 +0000

1.
one byte have eight bit;one bit is 0 or 1. is basical unit;

computer developed in Us。So one bytes could stand for all alphabet of english and common character。they make a character set called ASCll, one character corresponded to one byte。
对应
with computer developping more and more popular，more countries lauange wanted to be joined;china make character set call GBK that chinese character occupied 2 byte.the situation is so complicated and unmananged becauseof many contries has own character set。 in order to
solve this problem apple company invented unicode table initially。

in order to compatible ASCll and the charactor of ASCll occupied one bytes；

But how to clearly know how many bytes one character corresponds to？
they invented utf-8 encode and decode plan。
it specified In a byte if the leading bytes are 111.it indicates three bytes sequence。
if one bytes
0 ....
if two bytes
110 ...... 10.....

if three bytes
110 ...... 10..... 10 ....
... correspond true code of unicode set

Rust ： String and chart set and code type

Zhangwuji — Tue, 21 May 2024 14:54:58 +0000

1.
how to splice multiple string types？

 let s1 = String::from("Hello");
 let s2 = String::from("World");
 let s3 = s1 + &s2;

s1 will be destroied in this way。 So this way is not recommonded。

  let s1 = String::from("Hello");
  let s2 = String::from("World");
  let s3 = s1.clone() + &s2;

this way is so complicated，let us see it's simple way;

        let mut s1 = String::from("Hello");
        let s2 = String::from("World");
        let s3 = format!("========={}{}", s1, s2);

2.
rust string use unicode character set，and the rule of encode and
decode useing utf-8, So the string's every char may be occupy
different numer of bytes。

     let s1 = String::from("नमस्ते");
     println!("{}",s1.len())

       let s1 = String::from("智");
       println!("{}",s1.len()) ;

      let s1 = String::from("123");
       println!("{}",s1.len()) ;

you will find different char; they occupy different number of bytes。

 let s1 = String::from("नमस्ते");
let s2= &s1[2..5];

remember this index is in the string splice'process is bytes index.

let start_byte = s.char_indices().nth(start).map(|(i, _)| i).unwrap_or(s.len());

let end_bytes = s.char_indices().nth(start).map(|(i, _)| i).unwrap_or(s.len());

Rust control and for in

Zhangwuji — Tue, 21 May 2024 05:35:00 +0000

let  mut hh=Person {
        name:String::from("jack")
};

 let  a = vec![ hh];
 a[0].name=String::from("jack");

the element inner vec's control is managed by vec instance；
So even though hh variable is mutable,but it is not useful.
a variable is mutable or immutable that really work;


 let mut a = vec![ hh];
 let refrenceA=&a

refrenceA variable's type is a immutable reference；
No matter a variable is mutable or immutable, Only it' refrence like&a is default setted up to mutable refrence. if want to become mutable refrence；

& mut a； and mut a

rust vector and for

Zhangwuji — Tue, 21 May 2024 04:59:53 +0000

1.
Vector is an array it's length can be expended。

//empty Vector
let mut a = Vec::new();
// init with one element at least
let mut a1= vec![1,2,33,44,55];
// the elements inner vec instace must be same type
enum One {
   Ha,
   String(String),
   Number(u64)
}
let mut a1= vec![One::ha,One::String(String::from("你好"))];

so how to traverse a1 it's type is vec;
recommond for in;

enum One {
   Ha,
   String(String),
   Number(u64)
}
let mut a1= vec![One::ha,One::String(String::from("你好"))];
for item in a1 {

}

print!("{:#?}",{a1});

in a1 the control is given to “for”，So after excuted for statement;
a1 was destroied;

you must use &a in order to borrow the reference；like bellow

enum One {
   Ha,
   String(String),
   Number(u64)
}
let mut a1= vec![One::ha,One::String(String::from("你好"))];
for item in &a1 {

}

print!("{:#?}",{a1});

for statement any Type that implement Iterator trait can be traverse by for; if the value was traverse is not a borrow refrence; like this

   let  mut hh=Person {
        name:String::from("jack")
    };

    let mut a = vec![ hh];

for item in a{

}

if you want change the element in for statement;
something remember;

Even though a variable is mutable or immutable;
the item is default setted up to immutable;
so if you want item to be settted to mutable;

Just like this;

 for mut item in  a{
        item.name =String::from("lo");
    };
or

 for mut item in  &a{
        item.name =String::from("lo");
    };

followed situation is not allowed;

  for &item in  a{
        item.name =String::from("lo");
    };

why？ let me analyse which steps happen？

one: take the element of a out of a;
move the control of element to item;
So & and item are combind into &item which regard as reference of the element。

a is not a borrow reference; so item'type expect to be the type of element; so this won't work. 2.if a is borrow reference;

  for &item in  &a{
        item.name =String::from("lo");
    };

reference a dose't have the control of a.So &a is not allowed to move the control of emenet to item; So this won't work.
one situation will work;
if the type implement copy trait; such as u8, u64..,bool,“char”,

   let a = vec![1,2,4,3];
    for &item in  &a{

    };

   let a = vec!["s","sa","sad"];


    for &item in  &a{
        let g=item;
    };

   let a = vec![true];


    for &item in  &a{
        let g=item;
    };

remember one strange situation

let mut a =vec![String::from("hello"),String::from("world")];
for  item in &mut a {
     item*=String::from("12312");
}

item* did not mean control moving. item* mean read from head. item* = String::from("12312") mean write from head.
follow case mean control moving;

let a=*item

rust2

Zhangwuji — Sun, 19 May 2024 23:22:51 +0000

struct animal {
   name:String
   age:u8
}

impl animal {
    // static function
    fn create(name:String,age:u8) -> animal {
         return {
            name:'jack',
            age:20
          }
    }
    // instance function
    fn say(&self){

    }


}

let animalInstance:animal = {
   name:"大灰狼",
   age：20
};
animalInstance.say();

enumerate Option
it'appearance solve the problem of null point.

let s = some(2);
let s2 = some(20);

if let some(x) = s {
    x == 2 //true
}else{
  None
};

match s {
   some(x) => {
      x == 2
   },
   (_) => {
     println!("我是none")
   }
};

match (s,s2) {
   (Some(s),Some(s2)) => {
     s == 2 // true
     s2 == 20 // true
   },
   (_,(Some(S2))) => {

  }
}

let x =0;
let y=1;

match(x,y){
   (0,1) =>{

   },
   (_,1)=>{

   }

};

package mechanism

  // lib.ts 
  // mod match2 {
      pub fn add(x:i8,y:i8) -> i32 {
          x+y
      }
   }

 // main.ts
 use  guessing_game::math2;