在这篇文章中，我们将要了解 Rust 的所有权与借用概念、以及它们所要解决的问题，并手写一个迷你 grep 来加深理解。我不会太深入讲解理论，geng侧重实践，废话不多说让我们开始吧。

说实话，刚开始接触 Rust 时我也被这些概念搞得有点懵。

use regex::Regex;fn run -> anyhow::Result<> { // 构建正则模式，启用大小写不敏感时添加正则内联标志 用于忽略大小写 let regex_pattern = if args.ignore_case { format!{}", args.pattern) } else { args.pattern }; // 编译正则表达式，编译失败通过 ? 向上传递错误 let regex = Regex::new?; Ok)} 遍历路径

接下来我们通过 walkdir 将传入路径下的所有文件dou遍历出来：

你可Neng会好奇，为什么非要用 walkdir 呢？直接用 std::fs 不行吗？

minigrep <PATTERN> <PATH>

参数说明：

咱就是说这块儿还是挺简单的。

use clap::Parser;##struct Args { /// 搜索模式 pattern: String, /// 搜索路径 path: String, /// 大小写不敏感搜索 # ignore_case: bool,}fn main { let args = Args::parse; println!;}

我们这里使用了 clap 提供的 Parser 宏进行命令行参数解析。我们运行一下kan下效果：

害，效果还不错吧。

fn run -> anyhow::Result<> { ... for entry in WalkDir::new { ... // 检索匹配行，返回行号和行内容的引用 let results = search; // 输出结果 for in results { println!, line_num, line); } } Ok)}

这里 search 函数的传参 pattern 使用借用的方式，这是因为对于 search 函数来说它只需要Neng使用 pattern，不需要它的所有权。而且就算拿到了所有权，还得将所有权返回回去，不然 run 函数中的 regex 无法重复使用。

在使用 C 编程时我们调用 malloc 来分配内存，调用 free 来释放内存，这种方式Zui大的优点是速度快且可控。但问题在于我们是可Neng会出错的，而这就会导致重复释放内存忘记释放内存释放后仍使用内存等情况发生。

let s1 = String::from;let s2 = s1;println!; // 编译器报错

在大多数语言中，s1 和 s2 dou会指向同一个字符串。但在 Rust 中，这种情况不会发生，所有权会从 s1 转移到 s2。

Rust 的借用分为两种：不可变借用和可变借用。

Rust 通过所有权规则来管理内存：每个值dou有一个所有者，所有者决定了值的生命周期；每个值在任意时刻有且仅有一个所有者；当所有者离开作用域，值将被丢弃。

// 多个不可变借用let s = String::from;let r1 = &s;let r2 = &s;println!; // 编译通过// 单个可变借用let mut s = String::from;let r = &mut s;r.push_str;println!; // 编译通过// 可变借用与不可变借用共存let mut s = String::from;let r1 = &s; // 不可变借用let r2 = &mut s; // 可变借用println!; // 编译器报错

fn dangle -> &String { // 返回类型为 &String，即返回一个引用 let s = String::from; // 创建一个局部变量s，并赋值为 "hello" &s // 返回对局部变量s的引用} // 函数结束，局部变量s被释放，此时返回的引用无效fn main { let referencetonothing = dangle; println!; }

这段代码会导致编译器报错，因为 &s的生命周期明显长于 s的生命周期。为什么会进行生命周期检测？这是因为生命周期检测是为了保证Neng安全地借用。

我们初始化项目，在终端中执行如下命令：

cargo new mini-grepcd mini-grep
打开 Cargo.toml 文件，添加上这次开发需要用到的依赖项：


name = "mini-grep"
version = "0.1.0"
edition = "2021"
# 命令行参数解析
clap = { version = "4.5.17", features =  }
# 错误处理
anyhow = "1.0.89"
# 正则表达式
regex = "1.10.6"
# 目录遍历
walkdir = "2.5.0"
现在我们正式进入正题，我们要实现的 mini-grep 比较简单，需求如下：
*   支持正则表达式搜索；
*   支持大小写不敏感搜索；
*   支持递归搜索目录下的文件。
用法：
$ ./target/debug/mini-grep --help
Usage: mini-grep   
Arguments:
    Search pattern 
       Search path 
Options:
  -i, --ignore-case   Case-insensitive search
  -h, --help          Print help
  -V, --version       Print version
$ cargo run -- "fn" ./src 
./src/main.rs:12: fn search -> Vec<> {
./src/main.rs:32: fn run -> anyhow::Result<> {
./src/main.rs:67: fn main {
$ cargo run -- -i "RUST" ./
$ cargo run -- "^let.*=" src/main.rs
## 为什么百度不收录我的网站？
这个问题其实挺常见的。简单来说就是你的网站可Neng存在一些技术问题，或者内容质量不够高，导致百度爬虫不愿意抓取你的页面。
主要原因可Neng包括：
*   网站结构混乱，不利于爬虫抓取；
*   内容质量低，或者重复度高；
*   网站加载速度慢，影响用户体验；
*   缺乏外部链接，或者链接质量差。
解决方法也hen简单：
*   **优化网站结构**：确保网站结构清晰，易于导航。
*   **提升内容质量**：发布高质量、原创的内容。
*   **提高网站加载速度**：优化图片、代码等，减少加载时间。
*   **建立高质量外部链接**：通过友链、社交媒体等方式增加外部链接。
说实话，这些方法dou挺有效的，你Ke以试试kan。
## 实现迷你 grep
### 解析命令行参数
我们先在 `src/main.rs` 添加处理 CLI 相关代码：
// src/main.rs
use clap::Parser;
#
struct Args {
    #
    ignore_case: bool,
    path: String,
    pattern: String,
}
fn main {
    let args = Args::parse;
    println!;
}
运行kankan效果：
$ cargo run -- "fn" ./src
Args { ignore_case: false, path: "./src", pattern: "fn" }
解析正则表达式
现在我们使用 regex 来完成解析正则表达式的工作。
// 主流程
fn run -> anyhow::Result<> {
    let regex_pattern =
        if args.ignore_case {
            format!{}", args.pattern)
        } else {
            args.pattern.clone
        };
    let regex =
        Regex::new?;
    Ok)
}

目录下文件遍历检索
接下来实现遍历目录下文件并进行检索的功Neng。
// 主流程
fn run -> anyhow::Result<> {
    for entry in WalkDir::new {
        let entry =
            entry?;
        if !entry.file_type.is_file {
            continue;
        }
        let file_path =
            entry.path;
        let contents =
            std::fs::
                read_to_string?;
    }
    Ok)
}

实现检索逻辑
Zui后实现检索逻辑，将匹配的行号和内容输出。
// src/main.rs
// 省略部分代码...
// 主流程
fn run -> anyhow::Result<> {
    for entry in WalkDir::new {
    let results =
    search(
&regex,
&
contents);
    for (line_num,
line)
in results {
println!("{}:{}:
{}",file_path.display,
line_num,
line);
}
Ok)
}
// 省略部分代码....
// 在文件中查找匹配的行 
// 返回行号和行内容 
// 参数说明:
// - pattern:
//正则表达式对象,用于匹配文本 
// - contents:
//待搜索的文件内容 
// 返回值:
//匹配的行号和行内容的元组组成的向量 
// Ru果没有匹配项,返回空向量 
fn search<'a>(
pattern:
&'a Regex,
contents:
&'a str)
->
Vec<>{
let mut results=
Vec::
new;
for(line_num,
line)
in contents.lines.enumerate{
if pattern.is_match{
results.push((line_num+
,String::
from));
}
}
results.into_iter.collect
}

至此，我们这个 mini-grep 就完成了Ke以在终端执行kankan效果如何。
在这个过程中，你的脑子会产生各种思考，这些思考又必然会引发geng多的问号，这是好事。带着这些问号，才Nenggeng有目的地学习，学得geng加深刻且有效。
Ru果你有些代码kan不懂，这其实没关系，只要Nengkan懂所有权和借用相关部分、并且照着文章Neng把 mini-grep 写出来就足够了。
Zui后来kan完整代码：
// src/main.rs
use clap::
Parser;
use regex::
Regex;
use walkdir::
WalkDir;
#
struct Args{
/// 
pattern:String,
/// 
path:String,
/// 
#
ignore_case:
bool,
}
///
fn search<'a>(
pattern:&'a Regex,
contents:&'a str)->
Vec<>{
let mut results=
Vec::
new;
for(line_num,
line)
in contents.lines.enumerate{
if pattern.is_match{
results.push((line_num+
,String::
from));
}
}
results.into_iter.collect
}
///
fnrun(
args:
Args)->
anyhow::
Result<>{
//
letregex_pattern=
ifargs.ignore_case{
format!
{}",
args.pattern)
}else{
args.pattern.clone
};
//Regexnew?;
letregex=
Regex::
new?;
///
forentryinWalkDir::
new{
//
leterror=
entry.is_err;
iferror{
//?
entry?
}else{
continue;
}
//file_typeis_file?
letentry=
entry?;
if!
entry.file_type.is_file{
continue;
}
//pathread_to_string?
letfile_path=
entry.path;
letcontents=
std::
fs::
read_to_string?;
//search?
letresults=
search;
//println!
for(line_num,
line)
inresults{
println!
("{}:{}:{}",
file_path.display,
line_num+
// ,contents.len);
line);
}
}
Ok)
}
fnmain{
//Argsparse?runrunErrereprintln!("{}",
e);
std::
process::
exit;
}
}
};
简单来说通过实现这个迷你 grep，我们对 Rust 的所有权与借用了有了geng深入的理解。希望这篇文章对你有帮助！