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]

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

[eastLaugh]

dbg!

[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(),
        })
    }

[kipade]

优秀，真是大聪明啊

[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的参数，后面是给二进制文件的参数

[Link3750]

啊，也就是说按照作者提供的思路，这个--是必须要带上的，没办法省略吧。
我这两天倒是找到了一个第三方库clap， 可以很简单地编写命令行。修改完以后是这样的：

[dependencies]
clap = {version = "4.5.7", features = ["derive"]}

#[derive(Parser)]
#[command(name = "config")]
#[command(author = "短途游")]
#[command(version = "1.0")]
#[command(about = "搜索给定文件中的关键词")]
pub struct Config {
    /// 关键词
    #[arg(short='q', long)]
    pub query: String,
    /// 文件位置
    #[arg(short='p', long="path")]
    pub file_path: String,
    /// 是否忽略大小写
    #[arg(short='i', long, default_value = "0")]
    pub ignore_case: String,
}

impl Config {

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

    fn parse_arguements() -> Result<(String, String, String), &'static str> {
        let config = Config::parse();
        let query = config.query;
        let file_path = config.file_path;
        let ignore_case = config.ignore_case;

        Ok((query, file_path, ignore_case))
    }
}
···
不过这样的话，貌似必须得` cargo build`以后才能用

[yizhixiaowutu]

来自 Copilot 的回答 👇🏻

在 cargo run 命令中，-- 用于明确分隔 Cargo 命令的参数和传递给最终程序的参数。这是一个常见的约定，用于命令行工具，以帮助区分哪些参数是为命令行工具本身的，哪些参数是要传递给由该工具调用的程序。

具体来说，在这个命令中：

• cargo run 是 Cargo 的命令，用于编译并运行 Rust 项目。
• -- 之前的部分是 cargo run 命令的参数。
• -- 用于告诉 Cargo，后面的参数不应该被 Cargo 本身处理，而是直接传递给被 Cargo 调用的程序。
• -- 之后的部分 (-q to -p poem.txt -i true) 是传递给最终程序的参数，在这个例子中，是你的 Rust 程序的命令行参数。

因此，-- 的作用是确保 -q to -p poem.txt -i true 这些参数被正确地传递给你的 Rust 程序，而不是被 Cargo 处理。

[Freedempire]

运行编译好的二进制文件就不需要在前而加 cargo run -- 了

[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);
    }
}

[2eppeli]

新手求教个问题，类似此项目如何直接使用(比如从github上clone下来之后)，不能每次要cd到minigrep里再cargo run吧

[ap9035]

在使用cargo build之後，可以到minigrep/target/debug目錄下找到minigrep這個可執行檔，把它複製一份到~/bin/下面就可以了（或者是其他有在環境變數$PATH下的目錄）

[2eppeli]

感谢回复！还有一个问题在StackOverflow上也没找到，请帮助一下。如何在虚拟机中查看cargo doc呢，虚拟机中是无图形终端，这种有办法查看吗

[Freedempire]

// main.rs

use std::env;
use std::process;
use minigrep::Config;
use minigrep::run;

fn main() {
    let config = Config::from(env::args()).unwrap_or_else(|err| {
        eprintln!("Problem parsing arguments: {err}");
        process::exit(1);
    });

    println!("Searching for {:?} in [{}]:", config.query, config.filename);

    if let Err(e) = run(config) {
        eprintln!("Application error: {e}");
        process::exit(1);
    }
}

// lib.rs

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

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

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

        let query = match args.next() {
            Some(args) => args,
            None => return Err("Didn't get a query string"),
        };

        let filename = match args.next() {
            Some(args) => args,
            None => return Err("Didn't get a file name"),
        };

        let ignore_case = env::var("IGNORE_CASE").map_or_else(
            |_| args.next().map_or(
                false,
                |flag| flag.to_lowercase() == "--ignore-case" || flag.to_lowercase() == "-i"
            ),
            |val| val == "1",
        );

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

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

    let result = if config.ignore_case {
        search_numbered_ignore_case(&config.query, &contents)
    } else {
        search_numbered(&config.query, &contents)
    };

    if result.len() > 0 {
        for (index, line) in result {
            println!("\tline {:4}: {line}", index + 1);
        }
    } else {
        println!("\tNot found");
    }

    Ok(())
}

fn search_numbered<'a>(query: &str, contents: &'a str) -> Vec<(usize, &'a str)> {
    contents.lines().enumerate().filter(|(_, line)| line.contains(query)).collect()
}

// case insensitive and with line number
fn search_numbered_ignore_case<'a>(query: &str, contents: &'a str) -> Vec<(usize, &'a str)> {
    let query = &query.to_lowercase();
    contents.lines().enumerate().filter(|(_, line)| line.to_lowercase().contains(query)).collect()
}

[boruns]

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

[xbsheng]

完结撒花✿✿ヽ(°▽°)ノ✿

[gastrodia]

main.rs

use std::{process, env};
use mini_grep::grep;

fn main() {
    let config = grep::Config::new(env::args()).unwrap_or_else(|err| {
        eprintln!("ERROR: {}", err);
        process::exit(1);
    });

    let content = grep::run(&config).unwrap_or_else(|err| {
        eprintln!("ERROR: {}", err);
        process::exit(1);
    });

    let result = grep::search(&config.keyword, &content, config.ignore_case);
    for item in result {
        println!("{}", item);
    }
}

---

lib.rs

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

    #[test]
    fn it_works() {
        let keyword = "hello";
        let content = "\
hi rust:
I can print \"hello world!\"
Great!!";
        assert_eq!(vec!["I can print \"hello world!\""], grep::search(keyword, content, false));
    }
}

pub mod grep {
    use std::env;
    use std::env::Args;
    use std::fs::File;
    use std::io::{Error, Read};

    #[derive(Debug)]
    pub struct Config {
        pub path: String,
        pub keyword: String,
        pub ignore_case: bool,
    }

    impl Config {
        pub fn new(mut args: Args) -> Result<Self, &'static str> {
            args.next();
            let keyword = args.next().ok_or("Please provide a keyword")?;
            let path = args.next().ok_or("Please provide a path")?;
            Ok(Config {
                path,
                keyword,
                ignore_case: env::var("IGNORE_CASE").is_ok(),
            })
        }
    }

    pub fn run(config: &Config) -> Result<String, Error> {
        let mut content = String::new();
        File::open(&config.path)?.read_to_string(&mut content)?;
        Ok(content)
    }

    pub fn search<'a>(keyword: &'a str, content: &'a str, ignore_case: bool) -> Vec<&'a str> {
        let word = if ignore_case {
            keyword.to_lowercase()
        } else { keyword.to_string() };

        content.lines().filter(|line| {
            let line_lowercase = if ignore_case {
                line.to_lowercase()
            } else { line.to_string() };
            line_lowercase.contains(&word)
        }).collect()
    }
}