basic-practice/envs

[giscus[bot]]

basic-practice/envs

https://course.rs/basic-practice/envs.html

[Joewt]

is_ok 有一丢丢的不严谨, IGNORE_CASE=0 这样就不行了

[924060929]

兄弟实在

env::var("IGNORE_CASE").map_or(false, |var| var.eq("1"))

[TsGanT]

改一下：

impl Config {
    pub fn build(v:&[String]) -> Result<Config, &'static str> {
        if v.len() < 3 {
            return Err("not enough arguments");
        }
        let query = v[1].clone();
        let file_path = v[2].clone();

        let ignore_case_flag = env::var("IGNORE_CASE").ok();
        let ignore_case = match ignore_case_flag.as_ref().map(String::as_ref) {
            None => false,
            Some("0") => false,
            Some(_) => true
        };

        Ok(Config { query, file_path, ignore_case })
    }
}

[AllenWu233]

改一下：

impl Config {
   pub fn build(v:&[String]) -> Result<Config, &'static str> {
       if v.len() < 3 {
           return Err("not enough arguments");
       }
       let query = v[1].clone();
       let file_path = v[2].clone();

       let ignore_case_flag = env::var("IGNORE_CASE").ok();
       let ignore_case = match ignore_case_flag.as_ref().map(String::as_ref) {
           None => false,
           Some("0") => false,
           Some(_) => true
       };

       Ok(Config { query, file_path, ignore_case })
   }
}

我试着修改了一下match语句块：

// Environment variables
// Return true if it is not empty or none zero
pub fn check_env(variable: &str) -> bool {
    let flag = env::var(variable).ok();
    !matches!(flag.as_ref().map(String::as_ref), None | Some("0"))
}

[szluyu99]

let ignore_case_flag = env::var("IGNORE_CASE").ok();
let ignore_case = match ignore_case_flag.as_ref().map(String::as_ref) {
        None | Some("0") | Some("false") => false,
        Some(_) => true,
};

[Lstmxx]

使用powershell的话可以这样运行

[Lstmxx]

$env:IGNORE_CASE=1;cargo run -- to poem.txt

[Hoteryoung]

拒绝使用win写哪怕一行代码

[freesrz93]

powershell 可不是 Windows 专属

[xzc1017964340]

set IGNORE_CASE 1 ; cargo run -- to poem.txt

[alanfliu]

尝试完成一下小作业：

pub fn build(args: &[String]) -> Result<Config, &'static str> {
      if args.len() < 3 {
          return Err("not enough argments");
      }
      let query = args[1].clone();
      let file_path = args[2].clone();

      let ignore_case = match env::var("IGNORE_CASE") {
          Err(_) => match args.get(3) {
              Some(flag) => flag != "0",
              None => false,
          },
          Ok(_) => true,
      };

      Ok(Config {
          query,
          file_path,
          ignore_case,
      })
  }

[duanyuluo]

非要说的话，应该用-i 或者—ignore-case

[acwink]

let ignore_case = match env::var("IGNORE_CASE") {
    Ok(val) => {
        val == "1"
    },
    Err(_) => {
        args.get(3)
            .map(|val| val == "1")
            .unwrap_or_else(|| false)
    }
};

[liuhq]

可以直接使用 is_some_and 方法进行比对，如下：

args.get(3).is_some_and(|v| v == "-i")

[noootwo]

let ignore_case = match env::var("IGNORE_CASE") {
            Ok(val) => val == "1",
            Err(_) => {
                let mut flag = false;
                args.iter().for_each(|arg| {
                    if arg == "-i" || arg == "--ignore-case" {
                        flag = true;
                    }
                });

                flag
            }
        };

[478619644h]

 let ignore_case = env::var("IGNORE_CASE").map_or_else(|_| {
                let mut flag = false;
                args.iter().for_each(|arg| {
                    if arg.to_lowercase().eq("--ignore-case")|| arg.to_lowercase().eq("-i") {
                        flag = true;
                    }
                });
                flag
            }, |var| var.eq("1"));

[AlfredMcfeeley]

最后测试大小写不敏感时候：你如果使用的是PowerShell终端，需要先设置环境变量：$env:IGNORE_CASE=1，然后再用cargo run -- to poem.txt，就可以了

[CregskiN]

感觉这么判断有点废话，老哥们有没有更漂亮的写法？

// 从环境变量中获取
let mut case_ignore: bool = env::var("IGNORE_CASE").map_or(false, |val: String| val != "0");
// 从命令行参数中获取
if case_ignore == false {
    for arg in args {
        if arg == "IGNORE_CASE" {
            case_ignore = true;
            break;
        }
    }
}

[csenjoy]

case_ignore等于false的情况下，不能表明没有设置环境变量IGNORE_CASE=0，这种情况下，应该以环境变量为准

[duanyuluo]

Ref to codes below without unit test.

[duanyuluo]

        // without unit test
        // read env first
        let case_ignore: bool = std::env::var("IGNORE_CASE").map_or_else(
            |_| {
                // if env don't exist, try read ignore case in CLI args
                args.iter()
                    .any(|arg| arg.to_lowercase() == "-i" || arg.to_lowercase() == "--ignore-case")
            },
            |s| s == "0" || s.to_lowercase() == "false", // if env U=IGNORE_CASE exist, check his value
        );

[duanyuluo]

Renaming “s” to “env_value” is better.

[Kaikaikaifang]

|s| s == "true" || s == "1"

[marunrun]

        let ignore_case = match env::var("IGNORE_CASE") {
            Ok(f) => f != "0",
            Err(_) => match args.get(3) {
                Some(arg) => arg.starts_with("--ignore_case") && !arg.ends_with("0"),
                None => false,
            },
        };

[zhou7rui]

  let ignore_case = match env::var("IGNORE_CASE") {
            Ok(v) => v.eq("1"),
            _ => match args.next() {
                Some(arg) => arg.contains("ignore_case"),
                None => false,
            },
        };

[wupeng1221]

impl Config {
    pub fn from(args: &Vec<String>) -> Result<Self, &str> {
        if args.len() < 3 {
            return Err("args not long enough");
        }
        Ok(Self {
            query: args[1].clone(),
            file_path: args[2].clone(),
            ignore_case: {
                let have_ignore_case = std::env::var("IGNORE_CASE").is_ok();
                if have_ignore_case {
                    have_ignore_case
                } else {
                    args[3].eq("1")
                }
            },
        })
    }
}

[bettersemut]

    let ignore_case = match env::var("IGNORE_CASE") {
        Err(_) => match args.get(3) {
            Some(flag) => flag != "0",
            None => false,
        }
        Ok(flag) => flag != "0",
    };

[AxiaNibiru]

这样吗？

let ignore_case: bool = env::var("IGNORE_CASE").map_or(
    args.iter().any(|arg| arg.to_lowercase().contains("-i")),
    |env_value| env_value.eq("1"),
);

[lqtaaaa]

记录下使用环境变量参数IGNORE_CASE="1"或者命令行参数使用 "i" || "--ignore-case"，忽略大小写
impl Config {
pub fn build(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("参数少了")
}
let query = args[1].clone();
let file_path = args[2].clone();
let ignore_case = match env::var("IGNORE_CASE") {
Ok(val) => val == "1",
Err(_) => args.get(3).map_or(false, |arg| arg.eq_ignore_ascii_case("-i") || arg.eq_ignore_ascii_case("--ignore-case")),
};
Ok(Config {
query,
file_path,
ignore_case
})
}
}

[ArchLance]

欢迎大家提出意见

impl Config {
    // #[warn(dead_code)]
    // fn new(args:&[String])->Config{
    //     let query = &args[1];
    //     let file_path = &args[2];
    //     Config { query, file_path }
    // }

    // 有一点需要额外注意下，从代码惯例的角度出发，new 往往不会失败，毕竟新建一个实例没道理失败
    // 所以改成build会比较合适
    pub fn build(args:&[String]) -> Result<Config,&'static str> {
        let mut query :String = "".to_string();
        let mut file_path:String = "".to_string();
        // 获取query和file_path
        for arg in args{
            if &arg[0..2] == "-q" {
                query = arg[3..].to_string();
            }else if &arg[0..2] == "-f" {
                file_path = arg[3..].to_string();
            }
        }
        //错误处理
        if query == "" {
            return Err("query is empty");
        }else if file_path == "" {
            return Err("file path is empty");
        }
        //忽略大小写 any返回的是bool正好符合
        let ignore_case = env::var("IGNORE_CASE").map_or_else(
        |_| args.iter().any(|arg| {arg.to_lowercase() == "-i" || arg.to_lowercase() == "--ignore-case"}), 
        |env_value| env_value == "1" || env_value.to_lowercase() == "true");
        Ok(Config { query, file_path, ignore_case})
    }
}

[ArchLance]

可以处理任何位置的变量，不过query和file path需要前面加-q=和-f=，-i也可以是任意位置，对于-i的处理参考了楼上 duanyuluo 的代码

[hzb888]

666

[iamtaojin]

结合大家的思路，为的实现方式如下：

    pub fn build(args: &[String]) -> Result<Config, &'static str> {
        if args.len() < 3 {
            return Err("Not enough arguments.");
        }
        let query = &args[1];
        let file_path = &args[2];
        let ignore_case = match env::var("IGNORE_CASE"){
            Ok(flag) => match flag.as_str() {
                "0" => false,
                _ => true,
            },
            Err(_) =>{
                match args.get(3){
                    Some(arg) => match arg.as_str(){
                        "ig" | "igc" | "ignore" | "ignorecase" | "ignore_case" => true,
                        _ => false,
                    },
                    None => false,
                }
            }
        };
        Ok(Config {
            query,
            file_path,
            ignore_case,
        })
    }

[Pledoge]

环境变量是如何输入的？为何我按照文章里的输入会报错。。。😰

[iamtaojin]

是不是没有use

[Pledoge]

有的，我把终端从powershell换成gitbash就可以读取到环境变量了，不知道为什么😥

[ybybwdwd]

看前排评论，有powershell的运行方式

[Pledoge]

看到了，感谢

[montmorill]

咱也来交作业啦：

fn aux(string: String) -> bool {
    ["", "0", "false", "nil", "null", "no", "none"]
        .iter()
        .all(|falsy| falsy.ne(&string.trim().to_lowercase().as_str()))
}

let ignore_case = match env::var("IGNORE_CASE") {
    Ok(string) => aux(string),
    Err(_) => args.next().is_some_and(aux),
    // 这里是迭代器改进后的写法，不使用迭代器的做法是将上面的 `next()` 改为 `get(3)`
};

[Endermanbugzjfc]

同时使用命令行参数和环境变量的方式来控制大小写不敏感，其中环境变量的优先级更高
我觉得参数优先才合理，环境变数是使用前设置好的，不经常修改。而参数是在使用时根据需要变更的，应该让其覆盖环境变数。

[Endermanbugzjfc]

同时使用命令行参数和环境变量的方式来控制大小写不敏感，其中环境变量的优先级更高

[DaZhou-ECHO]

有了大家的思路帮助，结合后面的对于clone的移除，完成了课后小习题，实现不用clone以及可以乱序输入参数

//移除clone的使用
impl Config {
//改写build
pub fn build(
mut args: impl Iterator<Item = String>,
) -> Result<Config, &'static str> {

//移除数组索引
args.next();
let mut query =String::new();
let mut file_path=String::new();
let mut ignore_case=false;

while let Some(arg) =args.next(){
    match arg.as_str(){
        "-q" =>{
            query = match args.next(){
                Some(q) => q,
                None => return Err("没有要找的query "),
            }
        }
        "-f" =>{
            file_path=match args.next(){
                Some(fp) => fp,
                None =>return Err("没有文件路径"),
            }
        }
        "-i" | "--ignore-case" =>{
            ignore_case = true;
        }
        _ => return Err("非法参数!"),
    }
}
    
if query.is_empty() {
    return Err("Query string is empty");
}

if file_path.is_empty() {
    return Err("File path is empty");
}

Ok(Config {
    query,
    file_path,
    ignore_case,
})

}
}

[DaZhou-ECHO]

忘记加上对于环境变量的判断了

pub fn build(
mut args: impl Iterator<Item = String>,
) -> Result<Config, &'static str> {

//移除数组索引
args.next();
let mut query =String::new();
let mut file_path=String::new();
let mut ignore_case=false;

while let Some(arg) =args.next(){
    match arg.as_str(){
        "-q" =>{
            query = match args.next(){
                Some(q) => q,
                None => return Err("没有要找的query "),
            }
        }
        "-f" =>{
            file_path=match args.next(){
                Some(fp) => fp,
                None =>return Err("没有文件路径"),
            }
        }
        "-i" | "--ignore-case" =>{
            ignore_case = true;
        }

        _ => return Err("非法参数!"),
    }
}

//加上了对于环境变量的判断条件
if env::var("IGNORE_CASE").is_ok(){
    ignore_case=true;
    //println!("{:?}",env::var("IGNORE_CASE"));
}


if query.is_empty() {
    return Err("Query string is empty");
}

if file_path.is_empty() {
    return Err("File path is empty");
}
Ok(Config {
    query,
    file_path,
    ignore_case,
})

}

[Link3750]

impl Config {
    pub fn build(args: &[String]) -> Result<Config, &'static str> {
        if args.len() < 3 {
            return Err("not enough arguments");
        }
        let query = &args[1];
        let file_path = &args[2];
        let ignore_case_input = args.get(3);

        let ignore_case = env::var("IGNORE_CASE")
            .map_or(
                match ignore_case_input {
                    Some(val) if val.eq("ignore_case") => true,
                    Some(_) | None => false,
            }, |var| var.eq("1"));

        Ok(
            Config {
                query: query.to_string(),
                file_path: file_path.to_string(),
                ignore_case,
            }
        )
    }
}

小作业以及不使用clone()处理入参
有大佬们帮忙看看还有什么可以改动的地方吗

[Link3750]

impl Config {
    pub fn build(args: &[String]) -> Result<Config, &'static str> {
        if args.len() < 3 {
            return Err("not enough arguments");
        }
        let query = &args[1];
        let file_path = &args[2];

        let ignore_case = env::var("IGNORE_CASE")
            .map_or(
                match args.get(3) {
                    Some(val) if val.eq("ignore_case") => true,
                    _ => false,
            }, |var| var.eq("1"));

        Ok(
            Config {
                query: query.to_string(),
                file_path: file_path.to_string(),
                ignore_case,
            }
        )
    }
}

稍微修改了一下

[tkkcc]

to_lowercase再比较，也有其他选择：eq_ignore_ascii_case
https://doc.rust-lang.org/std/string/struct.String.html#method.eq_ignore_ascii_case
或者regex
https://docs.rs/regex/1.10.4/regex/struct.RegexBuilder.html#method.case_insensitive

[Endermanbugzjfc]

regex 不是出了名的慢吗？ 😂

[CHonghaohao]

    let ignore_case = match env::var("IGNORE_CASE").ok() {  
        // 如果环境变量存在，并且值为 "1"  
        Some(ref s) if s == "1" => true,  
        Some(ref s) if s == "0" => false,
        // 如果环境变量不存在，或者值为 "0"，则检查命令行参数  
        _ => match args.next() {  
            // 如果命令行参数存在，并且不是 "0"  
            Some(flag) => flag != "0",  
            // 如果没有更多的命令行参数，则默认为 false  
            None => false,  
        },  
    };

[CHonghaohao]

使用迭代器后实现小作业

        let ignore_case = match env::var("IGNORE_CASE").ok() {  
            // 环境变量优先级最高
            // 如果环境变量存在，并且值为 "1"  
            Some(ref s) if s == "1" => true,  
            // 如果环境变量存在，并且值为 "0"  
            Some(ref s) if s == "0" => false,
            // 如果环境变量不存在或为其他值，则检查命令行参数  
            _ => match args.next() {  
                // 如果命令行参数存在，并且不是 "0"  
                Some(flag) => flag != "0",  
                // 如果没有更多的命令行参数，则默认为 false  
                None => false,  
            },  
        };

[Icemans007]

我也来实现下，借鉴别人代码，优化地方：自动识别命令符和变量，cargo run -- -i TO poem.txt 这样也可以查询，参数放前后都支持

pub struct Config {
    query: String,
    file_path: String,
    ignore_case: bool,
}

impl Config {
    pub fn from(args: &[String]) -> Result<Self, &'static str> {
        let command: Vec<&String> = args.iter().filter(|arg_str|!arg_str.starts_with("-")).collect();
        if command.len() < 3 {
            return Err("not enough arguments");
        }
        
        let query = command[1].clone();
        let file_path = command[2].clone();

        // 查询是否忽略大小写
        // 优先找环境变量 IGNORE_CASE
        // 没有 IGNORE_CASE 环境变量，再查找命令行参数
        let ignore_case = match env::var("IGNORE_CASE") {
            Ok(flag) => flag != "0",
            Err(_) => args.iter().any(|v| v == "-i" || v == "--ignore_case"),
        }; 

        Ok(Config{query, file_path, ignore_case})
    }
}

[pplmx]

run func

pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
    let contents = std::fs::read_to_string(config.filepath)?;

    let search = if config.is_case_sensitive {
        search
    } else {
        search_case_insensitive
    };

    for line in search(&config.query, &contents) {
        println!("{}", line);
    }

    Ok(())
}

[AllenWu233]

这个好Rusty！

[yu244]

大佬们给点改进建议

let ignore_list = ["ig", "ignore", "ignore_case"];
let ignore_case = env::var("IGNORE_CASE").is_ok();
let ignore_case = ignore_case || match arg.get(3) {
     Some(str) => ignore_list.contains(&str.as_str()),
     None => false
};

[AllenWu233]

改成能够处理无序参数？我的做法是，将带“-”前缀且长度大于1的参数当做options，取第一个non-option作为query，第二个non-option作为file_path，然后找参数就行，即：

cargo run -- --ignore-case to poem.txt

等价于

cargo run -- to --ignore-case poem.txt

也等价于

cargo run -- to poem.txt --ignore-case

具体实现可以看我在你后面发的评论（虽然写得不咋的）

[AllenWu233]

交个作业。感觉写得不够Rusty，请大佬们指教！

/// Some variables
pub struct Config {
    pub query: String,
    pub file_path: String,
    pub ignore_case: bool,
}

impl Config {
    // 'new' can not failed, use 'from/build' instead
    pub fn from(args: &[String]) -> Result<Config, &'static str> {
        if args.len() < 3 {
            return Err("not enough arguments");
        }

        // let query = args[1].clone();
        // let file_path = args[2].clone();
        let (query, file_path) = Self::get_query_and_file_path(args);

        // let ignore_case = env::var("IGNORE_CASE").map_or(false, |var| var.eq("1"));
        let ignore_case = Self::check_env("IGNORE_CASE")
            || Self::check_options(args, &[String::from("-i"), String::from("--ignore-case")]);

        Ok(Config {
            query,
            file_path,
            ignore_case,
        })
    }

    /// query: the first non-option argument
    /// file_path: the second non-option argument
    pub fn get_query_and_file_path(args: &[String]) -> (String, String) {
        let mut query = String::new();
        let mut file_path = String::new();

        for arg in &args[1..] {
            if Self::is_option(arg) {
                continue;
            }
            if query.is_empty() {
                query = String::from(arg);
            } else {
                file_path = String::from(arg);
                break;
            }
        }

        (query, file_path)
    }

    /// Options are longer than 1 with - prefix
    /// Example: -i --ignore-case
    pub fn is_option(arg: &str) -> bool {
        arg.len() > 1 && &arg[..1] == "-"
    }

    /// Check whether specific arguments exist or not
    pub fn check_options(args: &[String], targets: &[String]) -> bool {
        for target in targets {
            if args[1..].contains(target) {
                return true;
            }
        }
        false
    }

    // TODO:
    /// Check options and get there values, reture key-values
    pub fn check_options_and_get_value(_target: &str) -> Option<HashMap<String, String>> {
        todo!()
    }

    /// Environment Varibles
    /// Return true if it is not empty or non-zero
    pub fn check_env(variable: &str) -> bool {
        let flag = env::var(variable).ok();
        !matches!(flag.as_ref().map(String::as_ref), None | Some("0"))
    }
}

[AllenWu233]

参考了楼上大佬，将

&arg[..1] == "-"

改成了

arg.starts_with('-')

[Freedempire]

impl Config {
    pub fn from(args: &[String]) -> Result<Config, &'static str> {
        if args.len() < 3 {
            return Err("not enough arguments");
        }

        let query = args[1].clone();
        let filename = args[2].clone();

        // 如果使用的是 PowerShell 终端，需要先设置环境变量：$env:IGNORE_CASE=1，
        // 然后再用 cargo run -- to poem.txt 才可以获取到环境变量 IGNORE_CASE 的值
        // 也可以写成一行: $env:IGNORE_CASE=1;cargo run -- to poem.txt
        let ignore_case = env::var("IGNORE_CASE").map_or_else(
            |_| args.get(3).map_or(false, |flag| flag.to_lowercase() == "--ignore-case" || flag.to_lowercase() == "-i"),
            // |_| args.get(3).is_some_and(|flag| flag.to_lowercase() == "--ignore-case" || flag.to_lowercase() == "-i"),

            |val| val == "1",
        );

        Ok(Config {
            query,
            filename,
            ignore_case,
        })
    }
}

[shurgogo]

let ignore_case = match env::var("IGNORE_CASE") {
Ok(val) => val == "1", // IGNORE_CASE=1 时生效，=0时不生效并截断
Err(_) => args.iter().any(|x| x.contains("ignore_case")), // 没有配置环境变量时生效
};

[shaonvpiaoyaodesilian]

//命令行优先
let ignore_case = match args.get(3) {
Some(arg) if !arg.is_empty() => arg == "IGNORE_CASE=1",
_ => env::var("IGNORE_CASE").ok() == Some("1".to_string()),
};

[ShyunnY]

课后小组业~ (在迭代器中处理逻辑)

impl Config {
    const IS_SENSITIVE: &str = "SENSITIVE";

    pub fn build(args: &Vec<String>) -> Result<Self, &'static str> {
        if args.len() != 3 {
            return Err("params must equal 2!");
        }
        
        // 只要是设置了非0值, 我都认为大小写敏感
        let is_sensitive = match env::var(Self::IS_SENSITIVE) {
            Ok(v) if !v.eq("0") => true,
            _ => false,
        };

        Ok(Config {
            query: args[1].clone(),
            file_path: args[2].clone(),
            is_sensitive,
        })
    }
}

pub fn search<'a>(query: &str, content: &'a str, is_sensitive: bool) -> Vec<&'a str> {
    content
        .lines()
        .into_iter()
        .filter(|&x| {
            let x = match is_sensitive {
                true => x.to_string(),
                false => x.to_lowercase(),
            };

            x.contains(query)
        })
        .collect()
}

[visionding]

pub fn from(args: &'a [String]) -> Result<Config<'a>, &'static str> {
    if args.len() < 3 {
        return Err("not enough arguments");
    }

    let query = &args[1];
    let file_path = &args[2];

    let ignore_case = match env::var("IGNORE_CASE") {
        Ok(val) => val == "1" || val.to_lowercase() == "true",
        Err(_) => args
            .get(3)
            .is_some_and(|v| v == "-i" || v == "--ignore-case"),
    };

    Ok(Config {
        query,
        file_path,
        ignore_case,
    })
}

[relaxcn]

我也来一个小作业答案，直接一次赋值，优先匹配环境变量：

impl Config {
    pub fn new(args: &[String]) -> Result<Config, &'static str> {
        if args.len() < 3 {
            return Err("not enough arguments");
        }
        let query = args[1].clone();
        let file_path = args[2].clone();

        let ignore_case;

        ignore_case = if let Some(var) = env::var("IGNORE_CASE").ok() {
            var == "1" || var.to_lowercase() == "true"
        } else {
            if let Some(_ignore_case) = args.get(3) {
                _ignore_case.as_str() == "-i"
            } else {
                false
            }
        };

        println!("ignore: {ignore_case}");
        Ok(Config { query, file_path, ignore_case })
    }
}