jzon 0.12.5

Continuation of json-rust, a JSON implementation in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

<div align="center">

# jzon-rs

![](https://raw.githubusercontent.com/rustadopt/jzon-rs/master/json-rust-logo-tiny.png)

Adoption and continuation of [maciejhirsz/json-rust](https://github.com/maciejhirsz/json-rust).
Big shout-out to its creator [Maciej Hirsz](https://github.com/maciejhirsz).

Rust library to parse and serialize [JSON](http://json.org/) with ease.

**[Changelog](https://github.com/rustadopt/jzon-rs/releases) -**
**[Complete Documentation](https://docs.rs/jzon/) -**
**[Cargo](https://crates.io/crates/jzon) -**
**[Repository](https://github.com/rustadopt/jzon-rs)**

</div>

## Why?

JSON is a very loose format where anything goes - arrays can hold mixed
types, object keys can change types between API calls or not include
some keys under some conditions. Mapping that to idiomatic Rust structs
introduces friction.

This crate intends to avoid that friction.

```rust
let parsed = jzon::parse(r#"

{
    "code": 200,
    "success": true,
    "payload": {
        "features": [
            "awesome",
            "easyAPI",
            "lowLearningCurve"
        ]
    }
}

"#).unwrap();

let instantiated = object!{
    // quotes on keys are optional
    "code": 200,
    success: true,
    payload: {
        features: [
            "awesome",
            "easyAPI",
            "lowLearningCurve"
        ]
    }
};

assert_eq!(parsed, instantiated);
```

## First class citizen

Using macros and indexing, it's easy to work with the data.

```rust
let mut data = object!{
    foo: false,
    bar: null,
    answer: 42,
    list: [null, "world", true]
};

// Partial equality is implemented for most raw types:
assert!(data["foo"] == false);

// And it's type aware, `null` and `false` are different values:
assert!(data["bar"] != false);

// But you can use any Rust number types:
assert!(data["answer"] == 42);
assert!(data["answer"] == 42.0);
assert!(data["answer"] == 42isize);

// Access nested structures, arrays and objects:
assert!(data["list"][0].is_null());
assert!(data["list"][1] == "world");
assert!(data["list"][2] == true);

// Error resilient - accessing properties that don't exist yield null:
assert!(data["this"]["does"]["not"]["exist"].is_null());

// Mutate by assigning:
data["list"][0] = "Hello".into();

// Use the `dump` method to serialize the data:
assert_eq!(data.dump(), r#"{"foo":false,"bar":null,"answer":42,"list":["Hello","world",true]}"#);

// Or pretty print it out:
println!("{:#}", data);
```

## Installation

Just add it to your `Cargo.toml` file:

```toml
[dependencies]
jzon = "*"
```

Then import it in your `main.rs` / `lib.rs` file:

```rust
#[macro_use]
extern crate jzon;
```

## Performance and Conformance

There used to be a statement here saying that performance is not the main goal of this
crate. It is definitely one of them now.

While this crate doesn't provide a way to parse JSON to native Rust structs, it does a
lot to optimize its performance for DOM parsing, stringifying and manipulation. It does
[very well in benchmarks](https://github.com/serde-rs/json-benchmark), in some cases it
can even outperform parsing to structs.

This crate implements the standard according to the [
RFC 7159](https://tools.ietf.org/html/rfc7159) and
[ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf)
documents. For the best interoperability numbers are treated stored as 64bit precision
mantissa with 16 bit decimal exponent for floating point representation.

## License

This crate is distributed under the terms of both the MIT license
and the Apache License (Version 2.0). Choose whichever one works best for you.

See [LICENSE-APACHE](LICENSE-APACHE) and [LICENSE-MIT](LICENSE-MIT) for details.