basic-practice/iterators

[giscus[bot]]

basic-practice/iterators

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

[l16659]

文档真好 么么哒

[Lstmxx]

感谢大佬

[ghost]

我刷 leetcode 题也是能用迭代器就用迭代器，rusty 的代码真的很优雅 ~ ❤

[litingyes]

基础完结撒花

[Calvilo]

好帅的闭包

[zeroonechange]

真舒服啊 最后这一段 我之前写kotlin的 对集合操作 array.map().filter()

[OC0311]

看到search 函数 写go 的流下了眼泪

[should-smile]

‘’‘rust
'''

[should-smile]

请问下下面的代码有returns a value referencing data owned by the current function错误怎么解决。原因好像是contents.to_lowercase引入了临时变量，生命周期与a不一致

pub fn search_case_insensitive<'a>(query: & str, contents: &'a str) -> Vec<&'a str> {
    let query = query.to_lowercase();
    contents
        .to_lowercase()
        .lines()
        .filter(|line| line.contains(&query))
        .collect()
}

[should-smile]

原因：返回值从contents.to_lowercase()处得到，是个临时变量，生命周期比a小，所以报错。
解决方法：将to_lowercase放到line中。

pub fn search_case_insensitive<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    let query = query.to_lowercase();
    contents
        .lines()
        .filter(|line| line.to_lowercase().contains(&query))
        .collect()
}

[Lartimes]

是的是的，再有参数为基础作为返回值的引用上， 要确保使用参数与返回结果 声明周期一样。

[luguanqing]

优雅也是优雅,真出问题的时候找bug也头疼吧

[ZZMarquis]

是的，不要在链式调用里写太重、太复杂的逻辑

[XPJ1993]

are you ready

[yuliang0225]

感谢大佬

[uliyanjun]

rust 是世界上最好的语言.

[VhRvo]

let query = args.next().ok_or("Didn't get a query string")?;
let file_path = args.next().ok_or("Didn't get a file path")?;

真好看呐

[starboyss]

pub fn build<T: Iterator<Item=String>>(
        mut args: T
    ) -> Result<Config, &'static str> {
        // 第一个参数是程序名，由于无需使用，因此这里直接空调用一次
        args.next();

        Ok(Config {
            query: args.next().ok_or("Didn't get a query string")?,
            file_path: args.next().ok_or("Didn't get a file path")?,
            ignore_case: env::var("IGNORE_CASE").is_ok(),
        })
    }

[Link3750]

impl Config {

    pub fn build(mut args: impl Iterator<Item = String>,) -> Result<Config, &'static str> {
        args.next();
        
        let (query, file_path, ignore_case) = Config::parse_arguements(args).unwrap_or_else(|err| {
            eprintln!("Problem parsing arguments: {err}");
            process::exit(1);
        });
        Ok(Config {query,file_path,ignore_case,})
    }

    fn parse_arguements(mut args: impl Iterator<Item = String>) -> Result<(String, String, bool), &'static str> {
        let mut query = String::new();
        let mut file_path = String::new();
        let mut ignore_case = env::var("IGNORE_CASE").map_or(false, |var| var.eq("1"));
        while let Some(arg) = args.next() {
            match arg.as_str() {
                "-q" | "--query" => {
                    query = match args.next() {
                        Some(arg) => arg,
                        None => return Err("Didn't get a query string"),
                    }
                },
                "-p" | "--path" => {
                    file_path = match args.next() {
                        Some(arg) => arg,
                        None => return Err("Didn't get a file path"),
                    };
                },
                "-i" | "--ignore_case" => {
                    ignore_case = match args.next() {
                        Some(arg) if arg.as_str().eq("true") => true,
                        Some(arg) if arg.as_str().eq("false")  => false,
                        _ => return Err("wrong input after -i or --ignore_case")
                    };
                }
                _ => return Err("Illegal arguments")
            };
        };

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

这一章节结束以后最终的成果

[Link3750]

实现了参数随机位置，但有个问题就是启动参数必须携带--，像这样：
cargo run -- -q to -p poem.txt -i true
否则就会出现异常。
有大神能给点解决的思路吗

[Anchorom]

--就是是分割参数用的，前面是给cargo的参数，后面是给二进制文件的参数

[Song-aff]

太抽象反而不太好。

[lq-math-dog]

impl Config {
pub fn build(
mut args: impl Iterator<Item = String> + std::fmt::Debug,
) -> Result<Config, &'static str> {
args.next();
let query = match args.next() {
Some(arg) => arg,
None => return Err("DIDN'T GET A QUERY STRING"),
};

    let file_path = match args.next() {
        Some(arg) => arg,
        None => return Err("DON'T GET A FILE PATH"),
    };
    let args_vec: Vec<String> = args.collect();
    let ignore_case = env::var("IGNORE_CASE").map_or_else(
        |_| {
            args_vec
                .iter()
                .any(|arg| arg.to_lowercase() == "-i" || arg.to_lowercase() == "--ignore-case")
        },
        |s| s == "0" || s.to_lowercase() == "false",
    );
    Ok(Config {
        query,
        file_path,
        ignore_case,
    })
}

}

[pplmx]

use std::env;
use std::error::Error;

pub struct Config {
    pub query: String,
    pub filepath: String,
    pub is_case_sensitive: bool,
}

impl Config {
    pub fn from(mut args: impl Iterator<Item = String>) -> Result<Config, &'static str> {
        // Skip the first argument, which is the program name.
        args.next();

        Ok(Config {
            query: args.next().ok_or("Missing query string")?,
            filepath: args.next().ok_or("Missing file path")?,
            is_case_sensitive: env::var("CASE_INSENSITIVE").is_err(),
        })
    }
}

pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
    let contents = std::fs::read_to_string(&config.filepath)?;
    let results = search(&config, &contents);
    for line in results {
        println!("{line}");
    }
    Ok(())
}

pub fn search<'a>(cfg: &'a Config, contents: &'a str) -> impl Iterator<Item = &'a str> + 'a {
    contents.lines().filter(move |line| {
        if cfg.is_case_sensitive {
            line.contains(&cfg.query)
        } else {
            line.to_lowercase().contains(&cfg.query.to_lowercase())
        }
    })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn config_from_valid_args() {
        let args = vec![
            String::from("sg"),
            String::from("query"),
            String::from("filepath"),
        ];
        let config = Config::from(args.into_iter()).unwrap();
        assert_eq!(config.query, "query");
        assert_eq!(config.filepath, "filepath");
    }

    #[test]
    fn config_from_invalid_args() {
        let args = vec![String::from("sg")];
        let config = Config::from(args.into_iter());
        assert!(config.is_err());
    }

    #[test]
    fn search_one_result() {
        let cfg = Config {
            query: String::from("safe"),
            filepath: String::from(""),
            is_case_sensitive: true,
        };
        let contents = "\
Rust:
safe, fast, productive.
Pick three.";
        let results: Vec<_> = search(&cfg, contents).collect();
        assert_eq!(vec!["safe, fast, productive."], results);
    }

    #[test]
    fn search_multiple_results() {
        let cfg = Config {
            query: String::from("the"),
            filepath: String::from(""),
            is_case_sensitive: true,
        };
        let contents = "\
The a
The b
the c
the d";
        let results: Vec<_> = search(&cfg, contents).collect();
        assert_eq!(vec!["the c", "the d"], results);
    }

    #[test]
    fn search_no_results() {
        let cfg = Config {
            query: String::from("begin"),
            filepath: String::from(""),
            is_case_sensitive: true,
        };
        let contents = "The end.";
        let results: Vec<_> = search(&cfg, contents).collect();
        assert_eq!(Vec::<&str>::new(), results);
    }

    #[test]
    fn case_sensitive() {
        let cfg = Config {
            query: String::from("the"),
            filepath: String::from(""),
            is_case_sensitive: true,
        };
        let contents = "The a\nThe b\nthe c\nthe d";
        let results: Vec<_> = search(&cfg, contents).collect();
        assert_eq!(vec!["the c", "the d"], results);
    }

    #[test]
    fn case_insensitive() {
        let cfg = Config {
            query: String::from("the"),
            filepath: String::from(""),
            is_case_sensitive: false,
        };
        let contents = "The a\nThe b\nthe c\nthe d";
        let results: Vec<_> = search(&cfg, contents).collect();
        assert_eq!(vec!["The a", "The b", "the c", "the d"], results);
    }
}