之前看到知乎上有人问，会写Parser， Tokenizer是什么水平，绝大情况下，屁用没有。小部分情况，就看你运气了。因为这东西，面试又不会加分，而且，如果你面试的小公司，可能面试官甚至都不懂你在说啥。
json这种数据格式，应该算是人人皆知的了，其语法规则不必赘述。
我想借助编写一份json parser来讲解语法解析，通过实践来学习。
简单来说，parser就是个转换器，输入是一个字符串，而输出是一个你自己定义一个数据结构。
对于字符串来说，他有各种各样的符号， 例如字符串r"{ "x": 10, "y": [20]， "z": "some" }",
有左右花括号（一般来说，左括号叫开放括号，右括号叫做闭合括号），有逗号，有分号，有字符串，数字等等。
对于JSON,我们需要实现两个方法:
- 用于解析JSON的
parse()方法. - 以及将对象/值转换为
JSON字符串的stringify()方法。
我们将一个字符串进行初次解析，将一个一个的符号，变成我们的数据结构（Token），每个Token会标识，“它”是什么， 例如：
一个字符串"some"可能会被转换成：
Token {
type: string,
content: "some"
}
对于Rust语言来说，提供了枚举，那么我们就可以借助枚举来定义我们的Token。
src/token.rs
#[derive(Debug)]pubenumToken{Comma,Colon,BracketOn,BracketOff,BraceOn,BraceOff,String(String),Number(f64),Boolean(bool),Null,}上述Token枚举就包含了JSON字符串里所有出现‘符号’的种类：逗号，分号，左方括号，右方括号，左花括号，右花括号，字符串，数字，布尔，和null。
对于将字符串解析成一系列Token的东西，我们称之为：Tokenizer。
src/tokenizer.rs
pubstructTokenizer<'a>{source:Peekable<Chars<'a>>,}对于Tokenizer，我们希望它能够有一个方法：next，每次调用这个方法，会返回
给我们一个Token，当没有Token返回的时候，则表示输入的字符串已经全部解析完。
很幸运，Rust的内置接口里面（trait我一般称作特征，这里写作了接口，这样子大众也更容易方便理解。），含有这么一个接口：
Iterator接口。
src/tokenizer.rs
impl<'a>IteratorforTokenizer<'a>{typeItem = Token;fnnext(&mutself) -> Option<Self::Item>{'lex:whileletSome(ch) = self.source.next(){returnSome(match ch {',' => Token::Comma,':' => Token::Colon,'[' => Token::BracketOn,']' => Token::BracketOff,'{' => Token::BraceOn,'}' => Token::BraceOff,'"' => Token::String(self.read_string(ch)),'0'..='9' => Token::Number(self.read_number(ch)),'a'..='z' => {let label = self.read_symbol(ch);match label.as_ref(){"true" => Token::Boolean(true),"false" => Token::Boolean(false),"null" => Token::Null,
_ => panic!("Invalid label: {}", label),}}
_ => {if ch.is_whitespace(){continue'lex;}else{panic!("Invalid character: {}", ch);}}});}None}}我们一个一个读入字符串的字符，判断他归属于哪一个类型（token type），
从上面代码里看,对于那些符号的判断,最为简单,直接返回它对应的Token就可以了. 对于字符串,数字,符号(null, true, false),就稍微难一点判断了.
对于字符串，它的样子就像"this is a string"，由一对双引号包围，更复杂一些的字符串，其含有转义字符：
"This is a string\\n".
对于解析字符串，当我们首次遇到双引号字符时，我们判定，其随后的内容是一个字符串，当第二次遇到双引号的时候，我们判断，其字符串结束。
当遇到转移字符\的时候，我们所需要做的就是忽略第一个\，将之后的字符保存。
对于其他的字符，仅仅是遍历一遍保存便可。
src/tokenizer.rs
impl<'a>Tokenizer<'a>{fnread_string(&mutself,first:char) -> String{letmut value = String::new();letmut escape = false;whileletSome(ch) = self.source.next(){if ch == first && escape == false{return value;}match ch {'\\' => {if escape {
escape = false;
value.push(ch);}else{
escape = true;}}
_ => {
value.push(ch);
escape = false;}}}
value
}}对于数字，其特征为数字开头，随后为数字，其中也可能包含一个小数点。所以，只要它是一数字开头， 我们便可判断它及其后面的字符串是一个完整的数字。并且，有且只可能有0个或1个小数点。
src/tokenizer.rs
impl<'a>Tokenizer<'a>{fnread_number(&mutself,first:char) -> f64{letmut value = first.to_string();letmut point = false;whileletSome(&ch) = self.source.peek(){match ch {'0'..='9' => {
value.push(ch);self.source.next();}'.' => {if !point {
point = true;
value.push(ch);self.source.next();}else{return value.parse::<f64>().unwrap();}}
_ => return value.parse::<f64>().unwrap(),}}
value.parse::<f64>().unwrap()}}对于符号null, true, false, { "is_symbol": true }比如这样子的json字符串。
它们不像字符串，由两个双引号包围，它们只是由单纯的英文小写字母组成。
src/tokenizer.rs
impl<'a>Tokenizer<'a>{fnread_symbol(&mutself,first:char) -> String{letmut symbol = first.to_string();whileletSome(&ch) = self.source.peek(){match ch {'a'..='z' => {
symbol.push(ch);self.source.next();}
_ => break,// 遇到非英文小写字母，判定它结束}}
symbol
}}等到这里,如果实现了Tokenizer,让他能够不断地给我们解析Token,基本上第一个难点就算结束了。
因为,当我们把输入的字符串一个一个的解析成了一系列Token之后,剩下的很大一部分就是天高任鸟飞
的时候,为什么?很简单,Token也是我们自己定义的数据结构,而且它在内存中,我们想怎么用它就可以
怎么用它.
下面,我们将我们一系列的Token解析成我们的JSON.
src/value.rs
pubenumJson{Null,String(String),Number(f64),Boolean(bool),Array(Vec<Json>),Object(HashMap<String,Json>),}如果你不清楚Json, 你可以看下: Introducing JSON
Parser接受字符串,借助我们刚才编写的Tokenizer, 然输出抽样语法树(一般来说,Parser接受字符串,然后输出抽象语法书,不过,管他呢,我们能实现我们想要实现的便可,管它具体的定义呢),
对于我们的Json Parser,输出的就是我们刚才定义的Json结构.
src/parser
pubstructParser<'a>{tokenizer:Tokenizer<'a>,}这就是我们Parser的定义，它内含一个Tokenizer，要借助它生成的Toekn去变成Json。
src/parser
impl<'a>Parser<'a>{pubfnparse(&mutself) -> Json{let token = self.step();self.parse_from(token)}fnstep(&mutself) -> Token{self.tokenizer.next().expect("Unexpected end of JSON!!!")}fnparse_from(&mutself,token:Token) -> Json{match token {Token::Null => Json::Null,Token::String(s) => Json::String(s),Token::Number(n) => Json::Number(n),Token::Boolean(b) => Json::Boolean(b),Token::BracketOn => self.parse_array(),Token::BraceOn => self.parse_object(),
_ => panic!("Unexpected token: {:?}", token),}}}以上代码就是Parser的核心了，其运行原理与Tokenizer相仿。
Json中的数据结构：boolean，string，null，以及array（以左方括号开头，右方括号结尾），object（以左花括号开头，右花括号结尾）。
借助于Tokenizer生成Token，进行模式匹配，当遇到Token::Null，Token::String(s)，Token::Number(n)，Token::Boolean(b)，
这些时，直接返回就可以了，毕竟我们已经在实现Tokenizer的时候处理过了。
当遇到Token::BracketOn，左括号！这是array开始的符号，那么我们交给self.parse_array()处理：
src/parser.rs
impl<'a>Parser<'a>{fnparse_array(&mutself) -> Json{letmut array = Vec::new();matchself.step(){Token::BracketOff => return array.into(),
token => array.push(self.parse_from(token)),}loop{matchself.step(){Token::Comma => array.push(self.parse()),Token::BracketOff => break,
token => panic!("Unexpected token {:?}", token),}}
array.into()}}如上使我们如何处理array，当遇到右方括号的时候，表明array结束了，返回即可。
对于我们array类型，其每一个元素都可以为Json，并且，元素之间用逗号分割，
那么当遇到逗号Token：：Comma的时候，就可以断定一个新的元素出现。
当遇到Token::BraceOn，左花括号！这是object开始的符号，那么我们交给self.parse_object()处理：
src/parser.rs
impl<'a>Parser<'a>{fnparse_object(&mutself) -> Json{letmut object = HashMap::new();matchself.step(){Token::BraceOff => return object.into(),Token::String(key) => {matchself.step(){Token::Colon => do_nothing(),
token => panic!("Unexpected token {:?}", token),}let value = self.parse();
object.insert(key, value);}
token => panic!("Unexpected token {:?}", token),}loop{matchself.step(){Token::Comma => {let key = matchself.step(){Token::String(key) => key,
token => panic!("Unexpected token {:?}", token),};matchself.step(){Token::Colon => {}
token => panic!("Unexpected token {:?}", token),}let value = self.parse();
object.insert(key, value);}Token::BraceOff => break,
token => panic!("Unexpected token {:?}", token),}}
object.into()}}与parse_object同理。
做到这里，目标之一的parse函数就能够实现了:
src/lib.rs
pubfnparse(s:&str) -> Json{letmut parser = Parser::new(s);
parser.parse()}当我们实现从一个字符串变成Json结构后，也要实现Json结构变回原来的字符串。
src/code_generator.rs
pubstructCodeGenerator{value:String,}implCodeGenerator{pubfnnew() -> Self{Self{value:String::new(),}}pubfngather(&mutself,json:&Json){self.write_json(json)}pubfnproduct(self) -> String{self.value}fnwrite(&mutself,slice:&str){self.value.push_str(slice);}fnwrite_char(&mutself,ch:char){self.value.push(ch);}fnwrite_json(&mutself,json:&Json){match*json {Json::Null => self.write("null"),Json::Boolean(ref b) => self.write(if*b {"true"}else{"false"}),Json::Number(ref n) => self.write(&n.to_string()),Json::String(ref s) => self.write(&format!("{:?}", s)),Json::Array(ref a) => self.write_array(a),Json::Object(ref o) => self.write_object(o),}}}定义一个CodeGenerator结构体，接受一个Json，然后产生一个String。
对于将Json转化成String这个功能，相对来说就简单多了。如果你过去学过比如Java，Python
Ruby等等一些面向对象的语言的话，都会知道一个对象的方法：toString（Python是__str__，Ruby是to_s）。
换句话说，我们就是给Json增添一个toString方法。而且，Json是我们自己定义的有规则的数据结构，实现它变成
String的操作就简单了许多。
那么，如上述代码，还是利用模式匹配，去实现Json到String的转换。
唯一有一点点复杂的也就是Array和Object的转换。
src/code_generator.rs
implCodeGenerator{fnwrite_array(&mutself,array:&[Json]){self.write_char('[');for(i, elem)in array.iter().enumerate(){self.write_json(elem);if i != (array.len() - 1){self.write_char(',');}}self.write_char(']');}}对于一个Array，他形如[element1, element2, element3, ...]，左右两边各有一个方括号。
里面的元素之间由逗号相隔（除了最后一个元素外，其他元素后尾随一个逗号）。
src/code_generator.rs
implCodeGenerator{fnwrite_object(&mutself,object:&HashMap<String,Json>){self.write_char('{');for(i,(key, value))in object.iter().enumerate(){self.write(&format!("{:?}", key));self.write_char(':');self.write_json(value);if i != (object.len() - 1){self.write_char(',');}}self.write_char('}');}}对于Object，它形如"{ "key1": value1, "key2": value2, ... }"，左右两边各有一个花括号。
里面元素为key-value形式，key与value之间有一个冒号，并且，key为String类型，value为Json类型。
同时在key-value与key-value也有逗号分隔。
最后，实现我们的stingify方法：
pubfnstringify<T>(o:T) -> StringwhereT:Into<Json>,{letmut gen = CodeGenerator::new();
gen.gather(&o.into());
gen.product()}src/implement.rs
macro_rules! impl_from_num_for_json {($($t:ident)*) => {
$(implFrom<$t> forJson{fn from(n: $t) -> Json{Json::Number(n asf64)}})*};}impl_from_num_for_json!(u8i8u16i16u32i32u64i64usizeisizef32f64);implFrom<bool>forJson{fnfrom(b:bool) -> Json{Json::Boolean(b)}}implFrom<String>forJson{fnfrom(s:String) -> Json{Json::String(s)}}impl<'a>From<&'astr>forJson{fnfrom(s:&'astr) -> Json{Json::String(s.to_string())}}implFrom<Vec<Json>>forJson{fnfrom(v:Vec<Json>) -> Self{Json::Array(v)}}implFrom<HashMap<String,Json>>forJson{fnfrom(mutmap:HashMap<String,Json>) -> Self{letmut object = HashMap::new();for(key, value)in map.drain(){
object.insert(key,Json::from(value));}Json::Object(object)}}- 错误处理， rust提供了
Result枚举，以及？语法糖来做错误处理。（尽可能的在Rust中避免使用panic!） - 过程宏，实现
jsonify过程宏，使得用户定义的数据结构能够反序列化Json和序列化成Json。 - 实现json formatter
请移步至 wiki