脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → Rust语言 → todo 命令行入门Rust

从迷你todo 命令行入门Rust示例详解

 更新时间：2023年01月10日 08:52:34   作者：PuffMeow  
这篇文章主要为大家介绍了从一个迷你todo命令行入门Rust的示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪

一个迷你 todo 应用

该文章将使用 Rust 从零去做一个入门级别的 TODO 命令行应用

你将学会什么？

  • 基本的命令行操作
  • 文件读写和文件结构组织

我们将会通过命令行输入来实现对根目录下 state.json 文件的编辑，如：

cargo run create 买菜

cargo run get 买菜

cargo run delete 买菜

cargo run edit 买菜

我们的 todo 状态会有 pending 和 done 这两种，create 操作将创建一个 {"买菜":"pending"} 的状态，edit 操作主要就是将 pending 状态转变为 done 状态

需要安装的依赖

我们要操作 json 数据结构，所以要安装下面这个 crate

[package]
edition = "2021"
name = "todo_app"
version = "0.1.0"
[dependencies]
serde_json = {default-feature = false, version = "1.0", feature = ["alloc"]}

文件目录组织

|   main.rs               主文件
|   process.rs            处理 todo 命令行输入
|   state.rs              读写文件
|
\---todo
    |   mod.rs            类似于 js 里面的 index.js
    |
    \---structs           struct 数据结构组织
        |   base.rs       基础参数的数据结构
        |   done.rs       完成状态的数据结构
        |   mod.rs        类似于 js 里面的 index.js
        |   pending.rs    处理中状态的数据结构
        |
        \---traits        (特征)类似于 ts 里面的 interface
                create.rs 创建操作
                delete.rs 删除操作
                edit.rs   编辑操作
                get.rs    查询操作
                mod.rs    类似于 js 里面的 index.js

主文件

// 有一点点像 import process from './process.rs'
mod process;
mod state;
mod todo;
// 使用外部的库、标准库或自己定义的工具
use process::process_input;
use serde_json::Map;
use serde_json::Value;
use state::read_file;
use std::env;
use todo::todo_factory;
fn main() {
    // 收集所有命令行的参数，转换成数组
    let args: Vec<String> = env::args().collect();
    // 拿到第一个参数如 get、delete、edit、create
    let command: &String = &args[1];
    // 第二个参数是用来记录事件的
    let title: &String = &args[2];
    // 读取根目录的 state.json 文件并转换成 map json 结构
    let state: Map<String, Value> = read_file("./state.json");
    // 如果事件已经存取过了，那就直接获取，没有就将其状态设置为 pending
    let status: String;
    match &state.get(title) {
        Some(result) => status = result.to_string().replace('\"', ""),
        None => status = "pending".to_string(),
    }
    // todo_factory 工厂函数用于处理 pending 和 done 状态的输入
    let item = todo_factory(&status, title).expect(&status);
    // 将状态输入到本地文件中
    process_input(item, command.to_string(), &state);
}

上面我们看到了 3 个主要我们需要自己编写的函数:

  • read_file 读取文件
  • todo_factory 状态工厂函数
  • process_input 处理输入

接下来让我们一个一个来看下这几个函数

读取文件

read_file 函数位于 src/state.rs 路径下，该文件主要是用来存储状态操作的，里面包含读取和写入两个函数，让我们主要看下 read_file 这个函数，它的功能：

  • 打开文件
  • 读取文件
  • 将读取到的文件内容转成 json 对象
  • 返回读取到的 json 对象
use std::fs::{self, File};
use std::io::Read;
use serde_json::json;
use serde_json::value::Value;
use serde_json::Map;
/** 读取文件 */
pub fn read_file(file_name: &str) -> Map<String, Value> {
    // 打开文件
    let mut file = File::open(file_name).unwrap();
    // 创建一个 string buffer 用于存储数据
    let mut data = String::new();
    // 读取数据写入到 buffer
    file.read_to_string(&mut data).unwrap();
    // 将读取到的字符串转换成 json 文本格式 Value 类型
    let json: Value = serde_json::from_str(&data).unwrap();
    // 将 json 文本格式转换成 json 对象
    let state: Map<String, Value> = json.as_object().unwrap().clone();
    // 将这个对象返回出去
    return state;
}
/** 写入文件 */
pub fn write_to_file(file_name: &str, state: &mut Map<String, Value>) {
    // json! 这个宏用于将 json 字面量对象转换回 json 文本 Value 格式
    let new_data = json!(state);
    // 将 json 文本写入到文件中
    fs::write(file_name, new_data.to_string()).expect("unable to write to file");
}

状态处理工厂函数

看完文件读取操作我们再来看下第二个主要函数 todo_factory，这个函数主要是根据事件的状态和通过命令行输入的 title 事件名称，然后构建出一个相应的数据结构

该文件位于 src/todo/mod.rs 路径下

它的作用主要是根据输入的 pending/done 状态，然后创建出一个对应的数据结构

// 将 structs 向外部导出
pub mod structs;
use structs::done::Done;
use structs::pending::Pending;
// 创建一个包含 pending 和 done 状态的枚举
pub enum ItemTypes {
    Pending(Pending),
    Done(Done),
}
/** 状态处理工厂函数 */
pub fn todo_factory(item_type: &str, item_title: &str) -> Result<ItemTypes, &'static str> {
    match item_type {
        "pending" => {
            // 创建一个 pending 状态的数据结构，然后返回出去
            let pending_item = Pending::new(item_title);
            Ok(ItemTypes::Pending(pending_item))
        }
        "done" => {
            // 创建一个 done 状态的数据结构，然后返回出去
            let done_item = Done::new(item_title);
            Ok(ItemTypes::Done(done_item))
        }
        // 如果不是这两个状态就返回一个错误
        _ => Err("This is not accepted!"),
    }
}

从上面的代码中我们可以看到下面这两行代码，这是我们主要需要定义的两个状态数据结构，他们位于 src/todo/structs 路径下

use structs::done::Done;
use structs::pending::Pending;

不过在看上面两个数据结构之前，我们需要先来看下另一个基础的数据结构，就是 base，因为上面两个数据结构是基于 base 的，实现一个类似于面向对象语言里继承的做法，base 是它们俩的基类

该文件位于 src/todo/structs/base.rs 路径下

pub struct Base {
    pub title: String,
    pub status: String,
}
// 为这个 Base 数据结构实现一个 new 方法，并返回一个实例化后的数据结构
impl Base {
    pub fn new(input_title: &str, input_status: &str) -> Base {
        Base {
            title: input_title.to_string(),
            status: input_status.to_string(),
        }
    }
}

现在我们用 Pending 和 Done 两个 struct 来 "继承" Base

该文件位于 src/todo/structs/pending.rs 路径下

use super::base::Base;
pub struct Pending {
    pub super_struct: Base,
}
impl Pending {
    pub fn new(input_title: &str) -> Pending {
        Pending {
            super_struct: Base::new(input_title, "pending"),
        }
    }
}

该文件位于 src/todo/structs/done.rs 路径下

use super::base::Base;
pub struct Done {
    pub super_struct: Base,
}
impl Done {
    pub fn new(input_title: &str) -> Done {
        Done {
            super_struct: Base::new(input_title, "done"),
        }
    }
}

Trait(特征)

Trait 类似于 TS 里的 interface 接口，现在我们要为我们的 struct 来实现一些在 Trait 里面定义的方法，文件路径在 src/todo/structs/traits

Create trait

文件路径在 src/todo/structs/traits/create

use serde_json::{json, Map, Value};
use crate::state::write_to_file;
pub trait Create {
    // 为这个 trait 实现一个默认的 create 方法
    fn create(&self, title: &String, status: &String, state: &mut Map<String, Value>) {
        state.insert(title.to_string(), json!(status));
        write_to_file("./state.json", state);
        println!("\n\n{} is being created\n\n", title);
    }
}

Get trait

文件路径在 src/todo/structs/traits/get

use serde_json::{Map, Value};
pub trait Get {
    fn get(&self, title: &String, state: &Map<String, Value>) {
        let item = state.get(title);
        match item {
            Some(result) => {
                println!("\n\nItem: {}", title);
                println!("Status: {} \n\n", result);
            }
            None => println!("item: {} was not find", title),
        }
    }
}

Delete trait

文件路径在 src/todo/structs/traits/delete

use serde_json::{Map, Value};
use crate::state::write_to_file;
pub trait Delete {
    fn delete(&self, title: &String, state: &mut Map<String, Value>) {
        state.remove(title);
        write_to_file("./state.json", state);
        println!("\n\n{} is being deleted\n\n", title);
    }
}

Edit trait

该 Trait 主要实现两个方法，一个是将事件设置为 pending 状态，一个将事件设置为 done 状态

文件路径在 src/todo/structs/traits/edit

use serde_json::{json, Map, Value};
use crate::state::write_to_file;
pub trait Edit {
    fn set_to_done(&self, title: &String, state: &mut Map<String, Value>) {
        state.insert(title.to_string(), json!("done".to_string()));
        write_to_file("./state.json", state);
        println!("\n\n{} is being set to done\n\n", title);
    }
    fn set_to_pending(&self, title: &String, state: &mut Map<String, Value>) {
        state.insert(title.to_string(), json!("pending".to_string()));
        write_to_file("./state.json", state);
        println!("\n\n{} is being set to pending\n\n", title);
    }
}

导出 trait

文件路径在 src/todo/structs/traits/mod

pub mod create;
pub mod delete;
pub mod edit;
pub mod get;

为 struct 实现 trait

接下来我们为 Pending 和 Done 两个 struct 来实现这几个 trait

Pending

我们为 Pending 实现所有的 4 个 trait

use super::base::Base;
use super::traits::create::Create;
use super::traits::delete::Delete;
use super::traits::edit::Edit;
use super::traits::get::Get;
pub struct Pending {
    pub super_struct: Base,
}
impl Pending {
    pub fn new(input_title: &str) -> Pending {
        Pending {
            super_struct: Base::new(input_title, "pending"),
        }
    }
}
impl Delete for Pending {}
impl Create for Pending {}
impl Edit for Pending {}
impl Get for Pending {}

Done

为 Done 实现除了 Create 以外的 trait

文件路径在 src/todo/structs/done

use super::base::Base;
use super::traits::delete::Delete;
use super::traits::edit::Edit;
use super::traits::get::Get;
pub struct Done {
    pub super_struct: Base,
}
impl Done {
    pub fn new(input_title: &str) -> Done {
        Done {
            super_struct: Base::new(input_title, "done"),
        }
    }
}
impl Delete for Done {}
impl Edit for Done {}
impl Get for Done {}

导出 struct

mod base;
pub mod done;
pub mod pending;
pub mod traits;

Process 输入处理

文件位于 src/process.rs 路径下

use serde_json::{Map, Value};
use crate::todo::{
    structs::{
        done::Done,
        pending::Pending,
        traits::{create::Create, delete::Delete, edit::Edit, get::Get},
    },
    ItemTypes,
};
// 处理 pending 状态
fn process_pending(item: Pending, command: String, state: &Map<String, Value>) {
    let mut state = state.clone();
    // 根据用户的输入来调用不同的方法
    match command.as_str() {
        "get" => item.get(&item.super_struct.title, &state),
        "create" => item.create(
            &item.super_struct.title,
            &item.super_struct.status,
            &mut state,
        ),
        "delete" => item.delete(&item.super_struct.title, &mut state),
        "edit" => item.set_to_done(&item.super_struct.title, &mut state),
        _ => println!("command: {} is not supported", command),
    }
}
// 处理 done 状态
fn process_done(item: Done, command: String, state: &Map<String, Value>) {
    let mut state = state.clone();
    match command.as_str() {
        "get" => item.get(&item.super_struct.title, &state),
        "delete" => item.delete(&item.super_struct.title, &mut state),
        "edit" => item.set_to_pending(&item.super_struct.title, &mut state),
        _ => println!("command: {} is not supported", command),
    }
}
// 处理用户的输入，根据输入来匹配枚举，然后执行不同的操作
pub fn process_input(item: ItemTypes, command: String, state: &Map<String, Value>) {
    match item {
        ItemTypes::Pending(item) => process_pending(item, command, state),
        ItemTypes::Done(item) => process_done(item, command, state),
    }
}

最后

按照上面的代码一步一步来完成就可以执行程序了，在根目录下新建一个 state.json 文件，写入一个空对象，不然会报错(代码没做处理)

{}

最后再在控制台上去执行

cargo run create shopping

然后就能看到 state.json 中多了一条记录

{ "shopping": "pending" }

其它的方法就交由你们自己去尝试好了~

以上就是从迷你 todo 命令行入门 Rust的详细内容，更多关于todo 命令行入门Rust的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

相关文章

  • Rust字符串类型全解析(最新推荐)

    Rust字符串类型全解析(最新推荐)

    Rust语言中,字符串类型众多,设计初衷是为了确保程序的安全、高效和灵活性,本文详细解释了Rust中不同的字符串类型,感兴趣的朋友跟随小编一起看看吧
    2024-09-09
  • 如何使用rust实现简单的单链表

    如何使用rust实现简单的单链表

    实现单链表在别的语言里面可能是一件简单的事情,单对于Rust来说,绝对不简单,下面这篇文章主要给大家介绍了关于如何使用rust实现简单的单链表的相关资料,文中通过实例代码介绍的非常详细,需要的朋友可以参考下
    2022-03-03
  • Rust读取配置文件的实现步骤

    Rust读取配置文件的实现步骤

    任何项目都离不开对于配置文件的读取和解析,rust项目也一样,本文主要介绍了Rust读取配置文件的实现步骤,具有一定的参考价值,感兴趣的可以了解一下
    2023-12-12
  • 如何使用VSCode配置Rust开发环境(Rust新手教程)

    如何使用VSCode配置Rust开发环境(Rust新手教程)

    这篇文章主要介绍了如何使用VSCode配置Rust开发环境(Rust新手教程),本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2020-07-07
  • 教你使用RustDesk 搭建一个自己的远程桌面中继服务器

    教你使用RustDesk 搭建一个自己的远程桌面中继服务器

    这篇文章主要介绍了RustDesk 搭建一个自己的远程桌面中继服务器,主要包括服务端安装和客户端配置方法，配置好相关操作输入控制码即可发起远程或文件传输，本文通过图文给大家讲解的非常详细，需要的朋友可以参考下
    2022-08-08
  • Rust实现一个表达式Parser小结

    Rust实现一个表达式Parser小结

    这篇文章主要为大家介绍了Rust实现一个表达式Parser小结，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2022-11-11
  • Rust 函数详解

    Rust 函数详解

    函数在 Rust 语言中是普遍存在的。Rust 支持多种编程范式，但更偏向于函数式，函数在 Rust 中是“一等公民”，函数可以作为数据在程序中进行传递，对Rust 函数相关知识感兴趣的朋友一起看看吧
    2021-11-11
  • rust 中生成与使用protobuf的方法

    rust 中生成与使用protobuf的方法

    这篇文章主要介绍了rust中protobuf生成与使用,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2023-05-05
  • Rust错误处理之`foo(...)?`的用法与错误类型转换小结

    Rust错误处理之`foo(...)?`的用法与错误类型转换小结

    foo(...)?语法糖为Rust的错误处理提供了极大的便利,通过结合map_err方法和From trait的实现,你可以轻松地处理不同类型的错误,并保持代码的简洁性和可读性,这篇文章主要介绍了Rust错误处理：`foo(...)?`的用法与错误类型转换,需要的朋友可以参考下
    2024-05-05
  • 用rust 写一个jar包 class冲突检测工具

    用rust 写一个jar包 class冲突检测工具

    这篇文章主要介绍了用rust 写一个jar包 class冲突检测工具 的相关资料,需要的朋友可以参考下
    2023-05-05

最新评论