使用Rust实现一个JSON解析器

最新推荐文章于 2024-08-09 14:45:19 发布
最新推荐文章于 2024-08-09 14:45:19 发布
阅读量442 收藏 14
点赞数 21
文章标签： rust json 开发语言 算法 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuan__once/article/details/139687268
版权

摘要

使用Rust实现一个JSON解析器，这里不涉及编译原理相关知识，只需要使用几个栈就可以实现JSON格式的数据解析。

{
    "name": "John Doe",
    "age": 43,
    "address": {
        "street": "10 Downing Street",
        "city": "London"
    },
    "phones": [
        "+44 1234567",
        "+44 2345678"
    ]
}

上面的JSON数据对应Rust的HashMap与Vec嵌套的数据结构，被解析后显示效果如下图所示。
在这里插入图片描述

解析原理

先将原始的JSON数据转换成Token集合，Token集合中每一个Token都必须是合法，因此在解析Token的时候可以对JSON的基本数据类型进行校验。
JSON是一种类似树的数据结构，JSON的根节点可以是{}，也可以是[]，但是{}不可以直接包含[]和{}，必须是键值对的形式存在，而[]可以直接包含{}和[]，如[{},{},[]]，这个是合法JSON结构，因此这里选用[]JSON的根节点。
利用栈来保存上下文状态。

 	let mut maps = Vec::new();
    let mut arrays = Vec::new();
    let mut keys = Vec::new();
    let mut parent_node = Vec::new();
    let mut symbols = Vec::new();
    let mut parse_state = Vec::new();
    let mut next_maybe_symbols = vec![SymbolEnum::BeginObject, SymbolEnum::BeginArray];

我们需要栈来保存上下文的状态，以此来判断该JSON数据是否是合法的JSON数据。栈保存了以下信息：

  • maps与arrays保存父节点。
  • keys保存当前的键，以确保键和值相互对应。
  • parent_node用来保存当前父节点是{}还是[]。
  • symbols是一个符号栈，用来确定{、}和[、]是否成对出现。
  • parse_state代表解析状态，代表当前是在解析key还是value，因为需要根据解析状态来确定下一个可能会遇见哪些Token，当解析状态为ParseKey时，那么下一个Token必须是String类型。
  • next_maybe_symbols 保存了下一步可能会遇见哪些符号，如{后面只能是String。
 { -> string(key) }
 : -> bool number string null [ { (:只能出现在{}中)
 [ -> bool number string null [ { ]
 , -> string(key) (在{}中)
 , -> bool number string null [ { (在[]中)
 bool number string null -> , ] }
 } -> , } ]
 ] -> , } ]

代码实现

将JSON数据转换成Token集合

定义Token枚举，其中Token还包含Token所在JSON数据中行列位置，当解析出错时可以给出相应的提示。

#[derive(Clone, Debug, PartialEq)]
pub enum Token {
    //row col
    BeginObject(u64, u64), //{
    EndObject(u64, u64),   //}
    Colon(u64, u64),       //:
    BeginArray(u64, u64),  //[
    EndArray(u64, u64),    //]
    Comma(u64, u64),       //,
    Null(u64, u64),        //null
    Boolean(u64, u64, bool),
    String(u64, u64, String),
    Int64(u64, u64, i64),
    Float64(u64, u64, f64),
}

解析String类型

fn parse_string(row: &mut u64, col: &mut u64, chars: &mut Chars) -> Result<Token> {
    let r = *row;
    let c = *col;
    let mut token = String::new();
    let mut prev_ch = ' ';
    loop {
        if let Some(ch) = chars.next() {
            match ch {
                '"' => {
                    *col += 1;
                    if prev_ch == '\\' {
                        continue;
                    }else {
                        return Ok(Token::String(r, c, token));
                    }
                }
                '\n' => {
                    return Err(ParseError::InvalidToken(format!("JSON's Key and Value cannot contain '\\n', at {row}:{col}")))?;
                }
                '\t' => {
                    *col += 4;
                    token.push(ch);
                }

                _ => token.push(ch),
            }
            prev_ch = ch;
            *col += 1;
        } else {
            return Err(ParseError::InvalidToken(format!("String ends abnormally, at {row}:{col}.")))?;
        }
    }
}

解析Token集合

定义JSON值类型的枚举

#[derive(Debug)]
pub enum JsonValue {
    String(String),
    Int64(i64),
    Float64(f64),
    Boolean(bool),
    Object(HashMap<String, JsonValue>),
    Array(Vec<JsonValue>),
    Null,
}

定义Token对应的符号枚举

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum SymbolEnum {
    /// {
    BeginObject,
    /// }
    EndObject,
    /// :
    Colon,
    /// [  
    BeginArray,
    /// ]
    EndArray,
    /// ,
    Comma,
    /// null
    Null,
    Boolean,
    String,
    Int64,
    Float64,
}

解析Token步骤如下

这里以解析到}为例。

  1. symbols栈弹出符号，判断是不是{
  2. }属于结束符，maps弹出一个HashMap，代表当前节点
  3. parent_node栈弹出
  4. 判断parent_node栈顶是Map类型还是Array类型，如果是Map类型，keys栈弹出一个key，并将第2步弹出的HashMap添加的到maps栈顶的HashMap
  5. 下一步可能遇见的符号，, ] }
    更多解析细节请查看完整代码。

实现Index、IndexMut特征

Rust支持运算符重载，JsonValue实现Index、IndexMux后可以使用[]来访问和修改JsonValue

let _=&json["data"]["list"][0]["url"];
json["data"]["list"][1]["url"]=JsonValue::String("http://www.abc123.com".to_string());

完整可运行代码

  1. Cargo.toml依赖
[package]
name = "json-parserlea"
version = "0.1.0"
edition = "2021"
[dependencies]
anyhow = "1.0.83"
thiserror = "1.0.61"
  1. 定义一个错误类型模块error.rs
use thiserror::Error;

#[derive(Error,Debug)]
pub enum  ParseError{
    #[error("parse int error")]
    ParseIntError(#[from] std::num::ParseIntError),
    #[error("parse float error")]
    ParseFloatError(#[from] std::num::ParseFloatError),
    #[error("`{0}`")]
    InvalidToken(String),
    #[error("`{0}`")]
    SymbolMismatch(String),
    #[error("`{0}`")]
    Unknown(String),
}
  1. 定义一个词法解析模块lex.rs
use std::{fmt::Display, str::Chars};
use anyhow::Result;

use crate::ParseError;

#[derive(Clone, Debug, PartialEq)]
pub enum Token {
    //row col
    BeginObject(u64, u64), //{
    EndObject(u64, u64),   //}
    Colon(u64, u64),       //:
    BeginArray(u64, u64),  //[
    EndArray(u64, u64),    //]
    Comma(u64, u64),       //,
    Null(u64, u64),        //null
    Boolean(u64, u64, bool),
    String(u64, u64, String),
    Int64(u64, u64, i64),
    Float64(u64, u64, f64),
}

impl Display for Token {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self {
            Token::BeginObject(_, _) => write!(f, "{{"),
            Token::EndObject(_, _) => write!(f, "}}"),
            Token::Colon(_, _) => write!(f, ":"),
            Token::BeginArray(_, _) => write!(f, "["),
            Token::EndArray(_, _) => write!(f, "]"),
            Token::Comma(_, _) => write!(f, ","),
            Token::Null(_, _) => write!(f, "null"),
            Token::Boolean(_, _, v) => write!(f, "{v}"),
            Token::String(_, _, v) => write!(f, "\"{v}\""),
            Token::Int64(_, _, v) => write!(f, "{v}"),
            Token::Float64(_, _, v) => write!(f, "{v}"),
        }
    }
}

pub fn parse<S: AsRef<str>>(s: S) -> Result<Vec<Token>> {
    let mut token_stream = vec![];
    let mut chars = s.as_ref().chars();
    let mut row = 1;
    let mut col = 1;
    while let Some(ch) = chars.next() {
        match ch {
            '{' => token_stream.push(Token::BeginObject(row, col)),
            '}' => token_stream.push(Token::EndObject(row, col)),
            '[' => token_stream.push(Token::BeginArray(row, col)),
            ']' => token_stream.push(Token::EndArray(row, col)),
            ':' => token_stream.push(Token::Colon(row, col)),
            ',' => token_stream.push(Token::Comma(row, col)),
            '\r' => continue,
            ' ' => {
                col += 1;
                continue;
            }
            '\t' => {
                col += 4;
                continue;
            }
            '\n' => {
                row += 1;
                col = 1;
                continue;
            }
            '"' => {
                let token = parse_string(&mut row, &mut col, &mut chars)?;
                token_stream.push(token);
            }
            '-' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' => {
                let (token, next_token) = parse_number(&mut row, &mut col, ch, &mut chars)?;
                token_stream.push(token);
                token_stream.push(next_token);
            }
            't' | 'f' => {
                let token = parse_bool(&mut row, &mut col, ch, &mut chars)?;
                token_stream.push(token);
            }
            'n' => {
                let token = parse_null(&mut row, &mut col, &mut chars)?;
                token_stream.push(token);
            }
            _ => {
                return Err(ParseError::InvalidToken(format!("Invalid char '{ch}', at {row}:{col}.")))?;
            }
        }
        col += 1;
    }

    Ok(token_stream)
}

fn parse_string(row: &mut u64, col: &mut u64, chars: &mut Chars) -> Result<Token> {
    let r = *row;
    let c = *col;
    let mut token = String::new();
    let mut prev_ch = ' ';
    loop {
        if let Some(ch) = chars.next() {
            match ch {
                '"' => {
                    *col += 1;
                    if prev_ch == '\\' {
                        continue;
                    }else {
                        return Ok(Token::String(r, c, token));
                    }
                }
                '\n' => {
                    return Err(ParseError::InvalidToken(format!("JSON's Key and Value cannot contain '\\n', at {row}:{col}")))?;
                }
                '\t' => {
                    *col += 4;
                    token.push(ch);
                }

                _ => token.push(ch),
            }
            prev_ch = ch;
            *col += 1;
        } else {
            return Err(ParseError::InvalidToken(format!("String ends abnormally, at {row}:{col}.")))?;
        }
    }
}

fn parse_number(row: &mut u64, col: &mut u64, ch: char, chars: &mut Chars) -> Result<(Token, Token)> {
    let mut token = String::new();
    token.push(ch);
    let mut is_int = true;
    let mut next_token = Token::Comma(0, 0);
    let mut next_parse = false;
    loop {
        if let Some(ch) = chars.next() {
            match ch {
                '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' => {
                    *col += 1;
                    token.push(ch);
                }
                '.' => {
                    *col += 1;
                    token.push(ch);
                    is_int = false;
                }
                ' ' | '\r' => {
                    *col += 1;
                    next_parse = true;
                    break;
                }
                '\t' => {
                    *col += 4;
                    next_parse = true;
                    break;
                }
                '\n' => {
                    *row += 1;
                    *col = 1;
                    next_parse = true;
                    break;
                }
                '}' => {
                    next_token = Token::EndObject(*row, *col);
                    *col += 1;
                    break;
                }
                ']' => {
                    next_token = Token::EndArray(*row, *col);
                    *col += 1;
                    break;
                }
                ',' => {
                    next_token = Token::Comma(*row, *col);
                    *col += 1;
                    break;
                }
                _ => {
                    return Err(ParseError::InvalidToken(format!("Invalid char '{ch}', at {row}:{col}.")))?;
                }
            }
        } else {
            return Err(ParseError::InvalidToken(format!("Number ends abnormally, at {row}:{col}.")))?;
        }
    }

    if next_parse {
        loop {
            if let Some(ch) = chars.next() {
                match ch {
                    '}' => {
                        next_token = Token::EndObject(*row, *col);
                        *col += 1;
                        break;
                    }
                    ']' => {
                        next_token = Token::EndArray(*row, *col);
                        *col += 1;
                        break;
                    }
                    ',' => {
                        next_token = Token::Comma(*row, *col);
                        *col += 1;
                        break;
                    }
                    ' ' | '\r' => {
                        *col += 1;
                        continue;
                    }
                    '\t' => {
                        *col += 4;
                        continue;
                    }
                    '\n' => {
                        *row += 1;
                        *col = 1;
                        continue;
                    }
                    _ => {
                        return Err(ParseError::InvalidToken(format!("Invalid char '{ch}', at {row}:{col}.")))?;
                    }
                }
            } else {
                return Err(ParseError::InvalidToken(format!("Number ends abnormally, at {row}:{col}.")))?;
            }
        }
    }

    let token = if is_int {

        match token.parse::<i64>() {
            Ok(v)=>Token::Int64(*row, *col, v),
            Err(e)=>{
                return Err(ParseError::ParseIntError(e))?;
            }
        }
    } else {
        match token.parse::<f64>() {
            Ok(v)=>Token::Float64(*row, *col, v),
            Err(e)=>{
                return Err(ParseError::ParseFloatError(e))?;
            }
        }
        
    };
    Ok((token, next_token))
}

fn parse_bool(row: &mut u64, col: &mut u64, ch: char, chars: &mut Chars) -> Result<Token> {
    let r = *row;
    let c = *col;
    let token = if ch == 't' {
        if let Some(c) = chars.next() {
            if c != 'r' {
                return Err(ParseError::InvalidToken(format!("Invalid char '{c}', at {row}:{col}.")))?;
            }
        } else {
            return Err(ParseError::InvalidToken(format!("Boolean ends abnormally, at {row}:{col}.")))?;
        }
        if let Some(c) = chars.next() {
            if c != 'u' {
                return Err(ParseError::InvalidToken(format!("Invalid char '{c}', at {row}:{col}.")))?;
            }
        } else {
            return Err(ParseError::InvalidToken(format!("Boolean ends abnormally, at {row}:{col}.")))?;
        }
        if let Some(c) = chars.next() {
            if c != 'e' {
                return Err(ParseError::InvalidToken(format!("Invalid char '{c}', at {row}:{col}.")))?;
            }
        } else {
            return Err(ParseError::InvalidToken(format!("Boolean ends abnormally, at {row}:{col}.")))?;
        }
        *col += 4;
        Ok(Token::Boolean(r, c, true))
    } else if ch == 'f' {
        if let Some(c) = chars.next() {
            if c != 'a' {
                return Err(ParseError::InvalidToken(format!("Invalid char '{c}', at {row}:{col}.")))?;
            }
        } else {
            return Err(ParseError::InvalidToken(format!("Boolean ends abnormally, at {row}:{col}.")))?;
        }
        if let Some(c) = chars.next() {
            if c != 'l' {
                return Err(ParseError::InvalidToken(format!("Invalid char '{c}', at {row}:{col}.")))?;
            }
        } else {
            return Err(ParseError::InvalidToken(format!("Boolean ends abnormally, at {row}:{col}.")))?;
        }
        if let Some(c) = chars.next() {
            if c != 's' {
                return Err(ParseError::InvalidToken(format!("Invalid char '{c}', at {row}:{col}.")))?;
            }
        } else {
            return Err(ParseError::InvalidToken(format!("Boolean ends abnormally, at {row}:{col}.")))?;
        }
        if let Some(c) = chars.next() {
            if c != 'e' {
                return Err(ParseError::InvalidToken(format!("Invalid char '{c}', at {row}:{col}.")))?;
            }
        } else {
            return Err(ParseError::InvalidToken(format!("Boolean ends abnormally, at {row}:{col}.")))?;
        }
        *col += 5;
        Ok(Token::Boolean(r, c, false))
    } else {
        return Err(ParseError::InvalidToken(format!("Invalid char '{c}', at {row}:{col}.")))?;
    };

    token
}

fn parse_null(row: &mut u64, col: &mut u64, chars: &mut Chars) -> Result<Token> {
    if let Some(c) = chars.next() {
        if c != 'u' {
            return Err(ParseError::InvalidToken(format!("Invalid char '{c}', at {row}:{col}.")))?;
        }
    } else {
        return Err(ParseError::InvalidToken(format!("Null ends abnormally, at {row}:{col}.")))?;
    }
    if let Some(c) = chars.next() {
        if c != 'l' {
            return Err(ParseError::InvalidToken(format!("Invalid char '{c}', at {row}:{col}.")))?;
        }
    } else {
        return Err(ParseError::InvalidToken(format!("Null ends abnormally, at {row}:{col}.")))?;
    }
    if let Some(c) = chars.next() {
        if c != 'l' {
            return Err(ParseError::InvalidToken(format!("Invalid char '{c}', at {row}:{col}.")))?;
        }
    } else {
        return Err(ParseError::InvalidToken(format!("Null ends abnormally, at {row}:{col}.")))?;
    }
    let t = Token::Null(*row, *col);
    *col += 4;
    Ok(t)
}
  1. 解析Token的lib.rs
#![allow(dead_code)]
use anyhow::Result;
use std::collections::HashMap;
use std::ops::Index;
use std::ops::IndexMut;


mod error;
pub use error::ParseError;
mod lex;
pub use lex::parse;
pub use lex::Token;

#[derive(Debug)]
pub enum JsonValue {
    String(String),
    Int64(i64),
    Float64(f64),
    Boolean(bool),
    Object(HashMap<String, JsonValue>),
    Array(Vec<JsonValue>),
    Null,
}

#[derive(Debug)]
pub enum Json {
    Object(HashMap<String, JsonValue>),
    Array(Vec<JsonValue>),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ParentNode {
    Map,
    Array,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum State {
    ParseKey,
    ParseValue,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum SymbolEnum {
    /// {
    BeginObject,
    /// }
    EndObject,
    /// :
    Colon,
    /// [  
    BeginArray,
    /// ]
    EndArray,
    /// ,
    Comma,
    /// null
    Null,
    Boolean,
    String,
    Int64,
    Float64,
}

impl Token {
    fn get_symbol(&self) -> SymbolEnum {
        match &self {
            Token::BeginObject(_, _) => SymbolEnum::BeginObject,
            Token::EndObject(_, _) => SymbolEnum::EndObject,
            Token::Colon(_, _) => SymbolEnum::Colon,
            Token::BeginArray(_, _) => SymbolEnum::BeginArray,
            Token::EndArray(_, _) => SymbolEnum::EndArray,
            Token::Comma(_, _) => SymbolEnum::Comma,
            Token::Null(_, _) => SymbolEnum::Null,
            Token::Boolean(_, _, _) => SymbolEnum::Boolean,
            Token::String(_, _, _) => SymbolEnum::String,
            Token::Int64(_, _, _) => SymbolEnum::Int64,
            Token::Float64(_, _, _) => SymbolEnum::Float64,
        }
    }
}

// { -> string(key) }
// : -> bool number string null [ { (:只能出现在{}中)
// [ -> bool number string null [ { ]
// , -> string(key) (在{}中)
// , -> bool number string null [ { (在[]中)
// bool number string null -> , ] }
// } -> , } ]
// ] -> , } ]

pub fn parse_json(token_stream: Vec<Token>) -> Result<Json> {
    let mut token_stream = token_stream.into_iter();

    let mut maps = Vec::new();
    let mut arrays = Vec::new();
    let mut keys = Vec::new();
    let mut parent_node = Vec::new();
    let mut symbols = Vec::new();
    let mut parse_state = Vec::new();
    let mut next_maybe_symbols = vec![SymbolEnum::BeginObject, SymbolEnum::BeginArray];

    parent_node.push(ParentNode::Array);
    arrays.push(Vec::new());

    while let Some(token) = token_stream.next() {
        let symbol = token.get_symbol();

        if !next_maybe_symbols.contains(&symbol) {
            let (row, col) = get_row_col(&token);
            let content = format!(
                "The following symbols may be required `{next_maybe_symbols:?}`,
             but provided is `{symbol:?}`, at {row}:{col}"
            );
            return Err(ParseError::SymbolMismatch(content))?;
        }

        next_maybe_symbols.clear();

        match token {
            Token::BeginObject(_, _) => {
                symbols.push(symbol);
                maps.push(HashMap::new());
                parent_node.push(ParentNode::Map);

                parse_state.push(State::ParseKey);
                next_maybe_symbols.push(SymbolEnum::String);
                next_maybe_symbols.push(SymbolEnum::EndObject);
            }
            Token::EndObject(row, col) => {
                if symbols.pop() != Some(SymbolEnum::BeginObject) {
                    let content = format!("Missing corresponding symbol, at {row}:{col}");
                    return Err(ParseError::SymbolMismatch(content))?;
                }

                let current_map = maps.pop().unwrap();
                let _ = parent_node.pop().unwrap();
                if current_map.is_empty() {
                    assert_eq!(parse_state.pop(), Some(State::ParseKey));
                }
                match parent_node.last().unwrap() {
                    ParentNode::Map => {
                        assert_eq!(parse_state.pop(), Some(State::ParseValue));
                        assert_eq!(parse_state.pop(), Some(State::ParseKey));

                        let k = keys.pop().unwrap();
                        maps.last_mut()
                            .unwrap()
                            .insert(k, JsonValue::Object(current_map));
                    }
                    ParentNode::Array => {
                        arrays
                            .last_mut()
                            .unwrap()
                            .push(JsonValue::Object(current_map));
                    }
                }

                next_maybe_symbols.push(SymbolEnum::Comma);
                next_maybe_symbols.push(SymbolEnum::EndArray);
                next_maybe_symbols.push(SymbolEnum::EndObject);
            }
            Token::BeginArray(_, _) => {
                symbols.push(symbol);
                arrays.push(Vec::new());
                parent_node.push(ParentNode::Array);

                next_maybe_symbols.push(SymbolEnum::String);
                next_maybe_symbols.push(SymbolEnum::Int64);
                next_maybe_symbols.push(SymbolEnum::Float64);
                next_maybe_symbols.push(SymbolEnum::Boolean);
                next_maybe_symbols.push(SymbolEnum::Null);
                next_maybe_symbols.push(SymbolEnum::BeginArray);
                next_maybe_symbols.push(SymbolEnum::EndArray);
                next_maybe_symbols.push(SymbolEnum::BeginObject);
            }
            Token::EndArray(row, col) => {
                if symbols.pop() != Some(SymbolEnum::BeginArray) {
                    let content = format!("Missing corresponding symbol, at {row}:{col}");
                    return Err(ParseError::SymbolMismatch(content))?;
                }

                let current_list = arrays.pop().unwrap();
                let _ = parent_node.pop().unwrap();

                match parent_node.last().unwrap() {
                    ParentNode::Map => {
                        assert_eq!(parse_state.pop(), Some(State::ParseValue));
                        assert_eq!(parse_state.pop(), Some(State::ParseKey));

                        let k = keys.pop().unwrap();
                        maps.last_mut()
                            .unwrap()
                            .insert(k, JsonValue::Array(current_list));
                    }
                    ParentNode::Array => {
                        arrays
                            .last_mut()
                            .unwrap()
                            .push(JsonValue::Array(current_list));
                    }
                }

                next_maybe_symbols.push(SymbolEnum::Comma);
                next_maybe_symbols.push(SymbolEnum::EndArray);
                next_maybe_symbols.push(SymbolEnum::EndObject);
            }
            Token::Comma(_, _) => match parent_node.last().unwrap() {
                ParentNode::Map => {
                    parse_state.push(State::ParseKey);
                    next_maybe_symbols.push(SymbolEnum::String);
                }
                ParentNode::Array => {
                    next_maybe_symbols.push(SymbolEnum::String);
                    next_maybe_symbols.push(SymbolEnum::Int64);
                    next_maybe_symbols.push(SymbolEnum::Float64);
                    next_maybe_symbols.push(SymbolEnum::Boolean);
                    next_maybe_symbols.push(SymbolEnum::Null);
                    next_maybe_symbols.push(SymbolEnum::BeginArray);
                    next_maybe_symbols.push(SymbolEnum::BeginObject);
                }
            },
            Token::String(_, _, string) => match parent_node.last().unwrap() {
                ParentNode::Map => match parse_state.last().unwrap() {
                    State::ParseKey => {
                        keys.push(string);
                        next_maybe_symbols.push(SymbolEnum::Colon);
                    }
                    State::ParseValue => {
                        let key = keys.pop().unwrap();
                        let value = JsonValue::String(string);
                        maps.last_mut().unwrap().insert(key, value);

                        assert_eq!(parse_state.pop(), Some(State::ParseValue));
                        assert_eq!(parse_state.pop(), Some(State::ParseKey));

                        next_maybe_symbols.push(SymbolEnum::Comma);
                        next_maybe_symbols.push(SymbolEnum::EndObject);
                    }
                },
                ParentNode::Array => {
                    let value = JsonValue::String(string);
                    arrays.last_mut().unwrap().push(value);

                    next_maybe_symbols.push(SymbolEnum::Comma);
                    next_maybe_symbols.push(SymbolEnum::EndArray);
                }
            },
            Token::Colon(_, _) => {
                parse_state.push(State::ParseValue);

                next_maybe_symbols.push(SymbolEnum::String);
                next_maybe_symbols.push(SymbolEnum::Int64);
                next_maybe_symbols.push(SymbolEnum::Float64);
                next_maybe_symbols.push(SymbolEnum::Boolean);
                next_maybe_symbols.push(SymbolEnum::Null);
                next_maybe_symbols.push(SymbolEnum::BeginArray);
                next_maybe_symbols.push(SymbolEnum::BeginObject);
            }
            Token::Int64(_, _, int64) => match parent_node.last().unwrap() {
                ParentNode::Map => {
                    let key = keys.pop().unwrap();
                    let value = JsonValue::Int64(int64);
                    maps.last_mut().unwrap().insert(key, value);

                    assert_eq!(parse_state.pop(), Some(State::ParseValue));
                    assert_eq!(parse_state.pop(), Some(State::ParseKey));

                    next_maybe_symbols.push(SymbolEnum::Comma);
                    next_maybe_symbols.push(SymbolEnum::EndObject);
                }
                ParentNode::Array => {
                    let value = JsonValue::Int64(int64);
                    arrays.last_mut().unwrap().push(value);

                    next_maybe_symbols.push(SymbolEnum::Comma);
                    next_maybe_symbols.push(SymbolEnum::EndArray);
                }
            },
            Token::Float64(_, _, float64) => match parent_node.last().unwrap() {
                ParentNode::Map => {
                    let key = keys.pop().unwrap();
                    let value = JsonValue::Float64(float64);
                    maps.last_mut().unwrap().insert(key, value);

                    assert_eq!(parse_state.pop(), Some(State::ParseValue));
                    assert_eq!(parse_state.pop(), Some(State::ParseKey));

                    next_maybe_symbols.push(SymbolEnum::Comma);
                    next_maybe_symbols.push(SymbolEnum::EndObject);
                }
                ParentNode::Array => {
                    let value = JsonValue::Float64(float64);
                    arrays.last_mut().unwrap().push(value);

                    next_maybe_symbols.push(SymbolEnum::Comma);
                    next_maybe_symbols.push(SymbolEnum::EndArray);
                }
            },
            Token::Boolean(_, _, boolean) => match parent_node.last().unwrap() {
                ParentNode::Map => {
                    let key = keys.pop().unwrap();
                    let value = JsonValue::Boolean(boolean);
                    maps.last_mut().unwrap().insert(key, value);

                    assert_eq!(parse_state.pop(), Some(State::ParseValue));
                    assert_eq!(parse_state.pop(), Some(State::ParseKey));

                    next_maybe_symbols.push(SymbolEnum::Comma);
                    next_maybe_symbols.push(SymbolEnum::EndObject);
                }
                ParentNode::Array => {
                    let value = JsonValue::Boolean(boolean);
                    arrays.last_mut().unwrap().push(value);

                    next_maybe_symbols.push(SymbolEnum::Comma);
                    next_maybe_symbols.push(SymbolEnum::EndArray);
                }
            },
            Token::Null(_, _) => match parent_node.last().unwrap() {
                ParentNode::Map => {
                    let key = keys.pop().unwrap();
                    let value = JsonValue::Null;
                    maps.last_mut().unwrap().insert(key, value);

                    assert_eq!(parse_state.pop(), Some(State::ParseValue));
                    assert_eq!(parse_state.pop(), Some(State::ParseKey));

                    next_maybe_symbols.push(SymbolEnum::Comma);
                    next_maybe_symbols.push(SymbolEnum::EndObject);
                }
                ParentNode::Array => {
                    let value = JsonValue::Null;
                    arrays.last_mut().unwrap().push(value);

                    next_maybe_symbols.push(SymbolEnum::Comma);
                    next_maybe_symbols.push(SymbolEnum::EndArray);
                }
            },
        }
    }

    let json = arrays.pop().unwrap().pop().unwrap();
    match json {
        JsonValue::Object(m) => Ok(Json::Object(m)),
        JsonValue::Array(l) => Ok(Json::Array(l)),
        _ => unreachable!(),
    }
}

#[inline]
fn get_row_col(token: &Token) -> (u64, u64) {
    match token {
        Token::BeginObject(r, c) => (*r, *c),
        Token::EndObject(r, c) => (*r, *c),
        Token::Colon(r, c) => (*r, *c),
        Token::BeginArray(r, c) => (*r, *c),
        Token::EndArray(r, c) => (*r, *c),
        Token::Comma(r, c) => (*r, *c),
        Token::Null(r, c) => (*r, *c),
        Token::Boolean(r, c, _) => (*r, *c),
        Token::String(r, c, _) => (*r, *c),
        Token::Int64(r, c, _) => (*r, *c),
        Token::Float64(r, c, _) => (*r, *c),
    }
}

impl<'a> Index<&'a str> for Json {
    type Output = JsonValue;
    fn index(&self, index: &str) -> &Self::Output {
        match self {
            Json::Array(_) => {
                panic!("This operation is not supported.")
            }
            Json::Object(value) => &value[index],
        }
    }
}

impl Index<usize> for Json {
    type Output = JsonValue;
    fn index(&self, index: usize) -> &Self::Output {
        match self {
            Json::Array(value) => &value[index],
            Json::Object(_) => {
                panic!("This operation is not supported.")
            }
        }
    }
}

impl<'a> Index<&'a str> for JsonValue {
    type Output = JsonValue;
    fn index(&self, index: &str) -> &Self::Output {
        match self {
            JsonValue::Object(value) => &value[index],
            _ => {
                panic!("This operation is not supported.")
            }
        }
    }
}

impl Index<usize> for JsonValue {
    type Output = JsonValue;
    fn index(&self, index: usize) -> &Self::Output {
        match self {
            JsonValue::Array(value) => &value[index],
            _ => {
                panic!("This operation is not supported.")
            }
        }
    }
}



impl<'a> IndexMut<&'a str> for Json {
    
    fn index_mut(&mut self, index: &str) -> &mut Self::Output {
        match self {
            Json::Array(_) => {
                panic!("This operation is not supported.")
            }
            Json::Object(value) => value.get_mut(index).expect("no entry found for key"),
        }
    }
}

impl IndexMut<usize> for Json {
    
    fn index_mut(&mut self,  index: usize) -> &mut Self::Output {
        match self {
            Json::Array(value) => value.get_mut(index).expect("Index out of bounds."),
            Json::Object(_) => {
                panic!("This operation is not supported.")
            }
        }
    }
}


impl<'a> IndexMut<&'a str> for JsonValue {
    
    fn index_mut(&mut self, index: &str) -> &mut Self::Output {
        match self {
            JsonValue::Object(value) => value.get_mut(index).expect("no entry found for key"),
            _ => {
                panic!("This operation is not supported.")
            }
        }
    }
}

impl IndexMut<usize> for JsonValue {
    
    fn index_mut(&mut self,  index: usize) -> &mut Self::Output {
        match self {
            JsonValue::Array(value) => value.get_mut(index).expect("Index out of bounds."),
            _ => {
                panic!("This operation is not supported.")
            }
        }
    }
}

效果演示

JSON文件

use json_parserlea::{parse, Json, JsonValue};
use std::fs;

fn main() {
    let json = fs::read_to_string("./jsons/images.json").unwrap();

    let tokens = parse(json.as_str()).unwrap();
    let mut json = json_parserlea::parse_json(tokens).unwrap();
    println!("{:#?}", json);

    json["data"]["list"][1]["url"]=JsonValue::String("http://www.abc123.com".to_string());
    let j=&json["data"]["list"][0]["url"];
    println!("{:#?}",j);
    
    match json {
        Json::Array(_) => unreachable!(),
        Json::Object(map) => match &map["data"] {
            JsonValue::Object(map) => match &map["list"] {
                JsonValue::Array(list) => {
                    let urls = list
                        .iter()
                        .map(|value| match value {
                            JsonValue::Object(obj) => &obj["url"],
                            _ => unreachable!(),
                        })
                        .map(|value| match value {
                            JsonValue::String(v) => v,
                            _ => unreachable!(),
                        })
                        .collect::<Vec<&String>>();
                    println!("{:#?}", urls);
                }
                _ => unreachable!(),
            },
            _ => unreachable!(),
        },
    }
}

解析结果

yuan__once
关注
  • 21
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
「Rust笔记」Rust之JSON数据处理
图解AI
12-01 4633
JSON 处理 JSON 是一种无处不在的开放标准格式, 它使用人类可读的文本来传输由键值对组成的数据对象. 这里借助一下serde_json这个库. [dependencies] url = "2.2.0" serde = "1.0.117" serde_derive = "1.0.117" serde_json = "1.0.59" 假设有如下文件: { "name": "John Doe", "age": 43, "address": { "s..
json-rust：Rust中的JSON实现
02-03
此外，理解和处理JSON解析和编码过程中的错误也非常重要，因为JSON数据可能会存在语法错误或者与预期的Rust类型不匹配。 总之，`json-rust`是Rust生态系统中的一个重要工具，它为处理JSON数据提供了强大而灵活的...
json-rs:Rust 中的 JSON 解析器
06-19
json-rs Rust 中的 JSON 解析器。 用法 一个JsonValue可以与retreived JsonValue::from_string ： let src = "{ \" hello \" : \" world \" }" . to_string (); let json = JsonValue :: from_string (src). unwrap (); JsonValue可以是对象、数组、布尔值、空值、字符串、整数或浮点值，具体取决于输入字符串。
快速获取JSON值-Rust的JSON解析器-Rust开发
05-27
GJSON是一个Rust板条箱，它提供了一种快速，简单的方法来从json文档中获取值。 它具有诸如单行检索，点符号路径，迭代和解析json行之类的功能。 快速获取JSON值GJSON是Rust板条箱，它提供了一种快速，简单的方法来从json文档中获取值。 它具有诸如单行检索，点符号路径，迭代和解析json行之类的功能。 该库使用与Go版本相同的路径语法。 入门用法将其放在Cargo.toml中：[dependencies] gjson =“ 0.7”获取值获取搜索json以查找指定的路径。 路径采用点语法，例如“ name.last”或“ age”。 当值是
rust怎么解析json数据？
Program with head, not hand
08-04 2326
在 Rust 中，你可以使用serde库来实现结构体与 JSON 之间的互相转换。serde是 Rust 社区最常用的序列化和反序列化库，它提供了方便的功能来处理结构体与 JSON 之间的转换。首先，在你的项目的Cargo.toml文件中添加serde和serde_json然后，你需要在你的结构体上添加Serialize和trait 来实现序列化和反序列化。这可以通过在结构体上添加注解来自动派生实现。现在，你可以使用serde_json。
Rust 中如何解析 JSON?
xuejianxinokok的专栏
03-05 1429
在本文中，我们将讨论如何在 Rust 中使用 JSON 解析库，以及比较最流行的库及其性能。
Rust构造JSON和解析JSON
05-15 486
添加依赖项 代码： 输出结果：serde_json - RustSerde JSONhttps://docs.rs/serde_json/latest/serde_json/ JSON中国 | JSON中文网 JSON中国是国内最专业的JSON研究机构, 致力于在国内介绍、推广、使用JSON, 同时也提供了各个JSON工具的汉化支持工作.https://www.json.org.cn/JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。它使得人们很容
基于simdjson端口的高性能JSON解析器-Rust开发
05-27
具有Serde兼容性的极其快速的simdjson JSON解析器的Rust端口。 自述文件（真正的！）simdjson版本当前正在跟踪Rust的具有serde兼容性的极快simdjson JSON解析器的Rust的Rust端口。 自述文件（真正的！）simdjson版本...
pjson.rs：Rust的JSON流解析器
02-23
Rust的JSON流解析器。 这是 Go库的端口。 例子 打印JSON文档中的所有字符串值。 fn main () { let json = br#" { "name": {"first": "Tom", "last": "Anderson"}, "age":37, "children": ["Sara","Alex",...
没有fastjson，rust怎么方便的解析提取复杂json呢？
Program with head, not hand
08-04 1877
方法将提取的值转换为你期望的类型，如字符串、整数等。在 Rust 中解析和提取复杂的 JSON 结构，你可以使用。方法来简化代码，但在实际应用中，你可能需要处理错误情况。提供了一组功能强大的方法来解析和操作 JSON 数据。在这个示例中，我们首先将 JSON 字符串解析为。来提取特定字段的值。
发现JSON5：Rust语言下的优雅数据解析新选择
gitblog_00031的博客
06-03 357
发现JSON5：Rust语言下的优雅数据解析新选择 项目地址:https://gitcode.com/callum-oakley/json5-rs 在当今的软件开发世界中，数据交换是核心环节之一，而JSON作为轻量级的数据交换格式，几乎无处不在。然而，原始的JSON规范有时显得过于严格，特别是对于开发者来说，在编写配置文件或进行快速测试时，更灵活的格式成了迫切需求。因此，【JSON5】应运而生——...
Rust json 序列化与反序列化
热门推荐
红叶谷 wsp_1138886114的博客
10-29 1万+
文章目录一、json-rust1.1 反序列化1.2 序列化 Serialize二、Serde JSON三、拓展：【使用 Rust 写 Parser 】 json在大多数的语言中都具有举足轻重的地位，特别在网络传中的常用数据交换格式。【百度百科】 关于 Rust 结构数组、序列化与反序列化 。 一、json-rust 下面会举例一些常用的json序列化与反序列化的用法，在Rust中json对象详情【请查看】 1.1 反序列化 反序列化 json::parse json-rust：https://github
Rust下的JSON动态反序列化
yeholmes的专栏
05-21 1460
Rust下的结构体反序列化 在之前的一篇文章中，笔者介绍了在Rust编程语言中，使用serde_json包对结构体的序列化和反序列化的基本操作；重点是在定义结构体时，继承源于serde包的 Deserialize及Serialize特性： use serde_json; use serde::{Deserialize, Serialize}; #[derive(Serilize, Deserialize, Debug)] struct rust_struct { member_0: String,
c++map的使用_【使用 Rust 写 Parser】3. 解析JSON
weixin_39851918的博客
11-26 315
系列所有文章PrivateRookie：【使用 Rust 写 Parser】1. 初识 nom​zhuanlan.zhihu.comPrivateRookie：【使用 Rust 写 Parser】2. 解析Redis协议​zhuanlan.zhihu.comPrivateRookie：【使用 Rust 写 Parser】3. 解析JSON​zhuanlan.zhihu.comPrivateRook...
Rust CSV 转换成 JSON 示例代码 （迭代实现）
瞎几波写
10-10 816
Rust的第三方库 没有CSV  转换成 JSON 的方法，只能自己写，实例代码如下： fn converter2_json(header: &amp;mut Vec&lt;String&gt;, rows: Vec&lt;Vec&lt;String&gt;&gt;) -&gt; Vec&lt;String&gt; { let mut json_vet = vec![]; fo...
【Rust快速入门】-- json序列化与反序列化
xzpdxz的博客
02-10 1687
rust中如何进行json变换 第一种方式 # doc: https://crates.io/crates/json [dependencies] json = "0.12.4" 第二种方式 # doc: https://crates.io/crates/serde [dependencies] serde_json = "1.0" serde = { version = "1.0", features = ["derive"] } 示例 use serde::{Deserialize, S
Rust : Json Web Token
Julia & Rust & Python
11-24 1237
https://github.com/Keats/jsonwebtoken use std::{thread, time}; extern crate jsonwebtoken as jwt; #[macro_use] extern crate serde_derive; use jwt::errors::ErrorKind; use jwt::{decode, encode, Algorith...
vs code 插件: Crabviz
最新发布
galoiszhou的博客
08-09 240
Crabviz 是一个用于创建调用图的 Visual Studio Code 插件。这些图表是交互式的，这在使用中等规模的代码库（例如微服务）时起到了很大的作用。它们按文件分组显示类型、方法、函数和接口，并显示函数调用关系和接口实现关系。因为 Crabviz 基于语言服务器协议，只要安装了相应的语言服务器，就可以支持任意数量的语言。该插件是用 Rust 编写的，可在 Visual Studio Code Marketplace 上获取。
使用rust实现一个计算器，要求给出完整代码
03-21
好的，以下是使用 Rust 实现的计算器的完整代码： ```rust use std::io; fn main() { loop { println!("请输入要计算的表达式："); let mut input = String::new(); io::stdin().read_line(&mut input).expect("读取输入失败"); let input = input.trim(); if input == "exit" { break; } let result = eval(input); match result { Ok(value) => println!("计算结果为：{}", value), Err(msg) => println!("计算失败：{}", msg), } } } fn eval(input: &str) -> Result<f64, String> { let mut tokens = tokenize(input); let mut result = parse_number(&mut tokens)?; while !tokens.is_empty() { let op = tokens.remove(0); let num = parse_number(&mut tokens)?; match op { "+" => result += num, "-" => result -= num, "*" => result *= num, "/" => result /= num, _ => return Err(format!("未知的操作符：{}", op)), } } Ok(result) } fn tokenize(input: &str) -> Vec<&str> { input.split_whitespace().collect() } fn parse_number(tokens: &mut Vec<&str>) -> Result<f64, String> { let token = tokens.remove(0); match token.parse() { Ok(num) => Ok(num), Err(_) => Err(format!("无效的数字：{}", token)), } } ``` 这个计算器可以处理加减乘除四种基本运算，支持浮点数计算。你可以在命令行中输入表达式，程序会输出计算结果。如果输入 exit，则程序会退出。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值