rust基本语法与常用功能总结

rust基本语法与常用功能总结

hello world!

fn main(){
    print!("hello,world!");//不换行
    println!("Hello, world!");//换行
}

数据类型及变量定义

基础数据类型

    let a:i8 = 1;
	let a:i16 = 1;//同一变量名,重新绑定
	let a:i32 = 1;
	let a:i64 = 1;
	let a:i128 = 1;
	let a:u8 = 1;
	let a:u16 = 1;
	let a:u32 = 1;
	let a:u64 = 1;
	let a:u128 = 1;
	let a:f32 = 1.0;
	let a:f64 = 1.0;
	let a:bool = false;
	let a:char = 'a';
	let a:String = "string".to_string();
    let a:&str = "string";
    let a:String = String::from("string");

数组

let y=[1,2,3];  //[i32;3] 不可变数组长度3,推断类型i32 
let z:[u8;3]=[1,2,3]; //声明定长不可变数组
let a1=[1..4]; //Range  [Range<i32>;1] 表示一种范围 定义与数组定义相似
let b1=&y[0..2];//&[i32] 数组引用,从定长数组产生,编译时不可知长度 
println!("len:{}",b1.len());//输出长度
println!("{:?}",b1[5])//超过长度编译不会报错,执行报错

let c1=vec!(1,2,3);//Vec<i32>  
let d1 = c1.as_slice();//&[i32] 不可变引用,所以不能有可变引用 及c1不能再修改
println!("d1.len:{}",d1.len());

let mut e1=vec!(1,2,3);
let f1=e1.as_mut_slice();//可变引用
f1[2]=23; //可以通过下标访问 或修改
e1[0]=3;//本体也可以修改
println!("e1:{:?}",e1);

let e2 = Vec::<u8>::new();//定义指定类型可变数组

变量定义

rust 是强类型语言,类型通过静态推断声明
常量 const 声明常量

const a:i32=1   //const需要提供类型

不可变变量 let 声明不可变变量 不可变变量可以重新绑定,常量不可以

let a=1;
let a=2; //重新绑定
let a:i32=2

可变变量 let mut 可变变量
rust 具有类型推断功能 使用 let 给变量设置值,使用

let mut a=1;
a=2;

元组

let mut t=(3,4);
t.0=4;
t.1=5;
println!("t={:?}",t);

结构体

普通结构体

struct D {
    a: i32,
    b: i32,
}
let a = D{a:12,b:22};
let b = a.a;
let c = a.b;

匿名结构体

struct E(i32, i32);
let e = E(12, 11);
let f = e.0;
let g = e.1;

函数及方法定义

函数定义

//普通函数定义
fn a(){
    println!("defind a");
}

//带返回值　//带返回值时 不同类型涉及变量生命周期
fn b() -> String{
    return String::from("defind b");
}

//多返回值
fn c() -> (String,String){
    return (String::from("c1"),String::from("c2"));
}

//参数与返回值
fn add(a: i32, b: i32) -> i32 {
    return a + b;
}

闭包

//lambda 表达式
let d = || String::from("d");

//lambda 带参
let i = |a: &str| println!("{}", a);　//参数名不能和const定义的常量名相同
i("abc");

//lambda 带返回值和参数  //带返回值时 不同类型涉及变量生命周期
//带返回值时必须带括号,语句超过一条也必须带括号
let j = |a: i32, b: i32| -> (i32, i32) {(a, b)};
j(1,2);

方法

struct D {
    a: i32,
    b: i32,
}

impl D {
    fn printa(&am