rust中的函数和常见错误分析

rust中的函数

iter()

迭代

use std::collections::HashMap;
fn main() {
    let mut map=HashMap::new();
    for i in 0..10{
        map.insert(i,i.to_string()+"str");
    }
    for i in map.iter(){
        println!("{:?}",i);
    }
}

pow(i)--i次方

sqrt()--->对f64类型求根号

pub trait GetAdd{
    fn add(&self)->i32;
    fn get_name(&self){
        println!("babay");
    }
}
pub trait GetMultiple{
    fn multiple(&self)->i32;
}

pub struct Point{
    pub x:i32,
    pub y:i32
}

struct Ractangle{
    lenght:i32,
    width:i32
}
impl GetAdd for Point{
    fn add(&self)->i32{
        self.x+self.y
    }
}
impl GetMultiple for Point{
    fn multiple(&self)->i32{
        self.x*self.y
    }
}
impl GetAdd for Ractangle{
    fn add(&self)->i32{
        self.lenght+self.width
    }
}
impl GetMultiple for Ractangle{
    fn multiple(&self)->i32{
        self.width*self.width
    }
}

fn main(){
    let p1:Point=Point{x:1,y:2};
    let r1:Ractangle=Ractangle{lenght:100,width:200};
    display_add(&p1);
    display_add(&r1);
    let p2:Point=Point{x:2,y:3};
    get_distance(&p1,&p2);
}

pub fn display_add(arg:&impl GetAdd){
    println!("Point_add={}",arg.add());
}

pub fn get_distance(p1:&Point,p2:&Point){
    println!("The distance between p1 to p2 is {}",(((p1.x-p2.x).pow(2)+(p1.y-p2.y).pow(2))as f64).sqrt());
}

类型转换函数

into()---类型转换函数

fn main() {
    let arr=[1,2,3,4,5];
    let _v:Vec<i32>=arr.into();

    let x=100;
    let _y:f64=x.into();

    let s="ssss";
    let _s1:String=s.into();
}

pasre::<T>()类型解析函数

链接

注意：这个函数的使用对象只能是String或者&str

unwrap()---检测错误

unwrap 方法，该方法在发现错误时，会直接调用 panic 导致程序的崩溃退出，在实际项目中，请不要这么使用，

split_whitespace()--空格分隔字符串

use std::collections::HashMap;
fn main() {
    let mut map=HashMap::new();
    let text="This is a very nice girl.";
    for word in text.split_whitespace(){
        let count=map.entry(word).or_insert(0);
        *count +=1;
    }
    println!("{:?}",map);
}

panic

作用：调用panic！宏来终止程序(简而言之：让程序崩溃)。

unwrap

unwrap 意味着发出以下命令：对Option和Result计算结果值，如果有错误，恐慌并停止程序。

Unwrap 在收到 none 时返回 panic。

pub fn unwrap_or(self, default:T) -> T

assert_eq!(Some("car").unwrap_or("bike"), "car");

assert_eq!(None.unwrap_or("bike"), "bike");

从返回的Result取值，如果取不到就用默认值

字符类型判定函数

    let my_first_initial = 'C';
    if my_first_initial.is_alphabetic(){
        println!("Alphabetical!");
    } else if my_first_initial.is_numeric() {
        println!("Numerical!");
    } else {
        println!("Neither alphabetic nor numeric!");
    }

字符串函数

增加和删除

链接

匹配字符和删除--trim

trim之后返回&str类型

链接

注意：

format()，to_lowercase(),to_uppercase()返回的是String类型，不是&str.

fn main() {
    let s:String="abcd".to_string();
    let ups:String=s.to_uppercase();
    println!("s={}\nups={}",s,ups);

    let re_s:&str="nnnn";
    let re_up_s:&str=re_s.to_uppercase();//报错
    println!("re_s={}\nre_up_s={}",re_s,re_up_s);
}

从字符串中读取行，字符串转为Vec，字符串分隔

for r in results.lines() {
        let v: Vec<&str> = r.split(',').collect();

...

}

判定字符串为空

string.is_empty()
 

字符串切片的函数

chars()

链接

chain()---连接连个迭代器

用来改变首字母

fn some_kind_of_uppercase_first_letter(s: &str) -> String {
    let mut c = s.chars();
    match c.next() {
        None => String::new(),
        Some(f) => f.to_uppercase().chain(c).collect(),
    }
}

fn main() {
    println!("{}", some_kind_of_uppercase_first_letter("joe"));
    println!("{}", some_kind_of_uppercase_first_letter("jill"));
    println!("{}", some_kind_of_uppercase_first_letter("von Hagen"));
    println!("{}", some_kind_of_uppercase_first_letter("ß"));
}

split()

fn main(){
    let mut sp="I am a cute babay";

    for s in sp.split(" "){
        println!("{}",s);
    }
}

fn main(){
    let mut sp="I am a cute babay";
    let v:Vec<&str>=sp.split(" ").collect();
    println!("{:?}",v);
}
1,被分割的字符串变为了迭代器

time时间函数

use std::time::Duration;

时

分：

秒：thread::sleep(Duration::from_secs(1));

sleep()

tokio::time::sleep()。

注：std::time也提供了sleep()，但它会阻塞整个线程，而tokio::time中的sleep()则只是让它所在的任务放弃CPU并进入调度队列等待被唤醒，它不会阻塞任何线程，它所在的线程仍然可被用来执行其它异步任务。因此，在tokio runtime中，应当使用tokio::time中的sleep()。

HashMap

求键值对个数：hashmap.len()

求所有键生成vec:let mut keys: Vec<&String> = scores.keys().collect();

求所有值的个数：hashmap.values().sum::<T>();

T是interge类型

hashmap函数链接

map()闭包函数

链接

map中最后返回什么就是什么，只是通过collect收集，形成其他集合。

map不是一次返回，而是自动循环完所有，再返回。

collect::<T>()----collect()

收集迭代器的结果，生成指定类型的集合,集合的类型要显示的标记出来。

最简单的理解：

let numbers: Vec<_> = (0..100u32).collect();

fn main() {
    let a=[1,2,3,4,5,6];
    println!("{:?}", a.into_iter().filter(|x|x%2==0));
    println!("{:?}", a.into_iter().filter(|x|x%2==0).collect::<Vec<i32>>());
}

filter和collect返回的对象：

也就是filter本身没有其他操作时，不会过滤，有其他操作才会过滤出需要的值。 

生成vec

fn main() {
    let a=[1,2,3,4,5];
    let v:Vec<_>=a.iter().map(|x|x*2).collect();
    println!("{:?}",v);
}

生成HashMap

一定要使用into_iter()

use std::collections::HashMap;
fn main() {
    let a=[(1,"n1"),(2,"n2"),(3,"n3")];
    let hmap:HashMap<_,_>=a.into_iter().collect();
    println!("{:?}",hmap);
    println!("{:?}",a);//静态数组，不会被move
}

filter()

筛选出符合条件的元素

fn main() {
    let a=[1,2,3,4,5];
    let v:Vec<_>=a.iter().filter(|x|*x%2==0).collect();
    println!("{:?}",a);
    println!("{:?}",v);
}

swap()

链接

take()

拿走一个变量合作一个值，可以返回这个变量的值或者返回给定的常量值。可以是数组。

链接

a.iter().fold(x,|res,ax|{})

x是初始值，res是每一次运算之后保存的结果，res第一次的值是x，ax每一次是从读取中国获取的值

assert类型的宏

1，assert！()

2，assert_eq!()

3，assert_ne!()---详情链接

 env模块的函数

此模块包含用于检查环境变量、进程参数、当前目录和其他各种重要目录等各个方面的函数。

此模块中有几个函数和结构，其对应项以os结尾。以os结尾的将返回 OsString，而不返回字符串的将返回字符串。

 pub fn args() -> Args

返回启动此程序时使用的参数

use std::env;
  
fn main(){
    for arg in env::args(){
        println!("{:?}",arg);
    }
}

第一个不是cargo run 

std::env模块下有如下函数：

详情链接

args	返回命令行传递的参数
args_os	返回当前进程的参数
current_dir	返回当前的工作目录，该目录保存在PathBuf中
current_exe	返回当前可执行程序的全路径
home_dir	返回当前用户目录的路径
join_paths	添加一些环境变量到PATH这个变量中
remove_var	删除当前运行进程的环境变量（系统中的环境变量不会改变，只改变当前进程的环境变量）
set_current_dir	指定当前可执行程序的工作目录
set_var	将当前进程的环境变量修改为新的值
split_paths	Parses input according to platform conventions for the PATH environment variable.
temp_dir	返回临时文件所存放的目录
var	从当前进程获取环境变量，通过环境变量的key值获取value值
var_os	Fetches the environment variable key from the current process, returning None if the variable isn't set.
vars	Returns an iterator of (variable, value) pairs of strings, for all the environment variables of the current process.
vars_os	Returns an iterator of (variable, value) pairs of OS strings, for all the environment

env!()

链接

std::path---路径操作函数

链接

num_cpus

链接

两个函数：

计算当前计算机上的 CPU 数量

计算当前计算机上的 物理内核数量

fn main(){
    println!("cpus={}",num_cpus::get());
    println!("physical kernel={}",num_cpus::get_physical());
}

需要引入依赖包：

[dependencies]
num_cpus = "1.0"

as_bytes()

将字符串转换为字节数组。

fn main(){
    let cs="abbcc".as_bytes();
    println!("{:?}",cs);
}

base64::encode()

将字节数组转为String类型，

参数一定要是Bytes类型，可以用函数转：as_bytes()，或者直接在字符串之前加一个b.

extern crate base64;

fn main() {
    let b64 = base64::encode(b"hello world");
    println!("{}", b64);
}