1 # Serde JSON   [![Build Status]][travis] [![Latest Version]][crates.io] [![Rustc Version 1.15+]][rustc]
3 [Build Status]: https://api.travis-ci.org/serde-rs/json.svg?branch=master
4 [travis]: https://travis-ci.org/serde-rs/json
5 [Latest Version]: https://img.shields.io/crates/v/serde_json.svg
6 [crates.io]: https://crates.io/crates/serde\_json
7 [Rustc Version 1.15+]: https://img.shields.io/badge/rustc-1.15+-lightgray.svg
8 [rustc]: https://blog.rust-lang.org/2017/02/02/Rust-1.15.html
10 **Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**
19 You may be looking for:
21 - [JSON API documentation](https://docs.serde.rs/serde_json/)
22 - [Serde API documentation](https://docs.serde.rs/serde/)
23 - [Detailed documentation about Serde](https://serde.rs/)
24 - [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/codegen.html)
25 - [Release notes](https://github.com/serde-rs/json/releases)
27 JSON is a ubiquitous open-standard format that uses human-readable text to
28 transmit data objects consisting of key-value pairs.
35 "street": "10 Downing Street",
45 There are three common ways that you might find yourself needing to work
46 with JSON data in Rust.
48 - **As text data.** An unprocessed string of JSON data that you receive on
49 an HTTP endpoint, read from a file, or prepare to send to a remote
51 - **As an untyped or loosely typed representation.** Maybe you want to
52 check that some JSON data is valid before passing it on, but without
53 knowing the structure of what it contains. Or you want to do very basic
54 manipulations like insert a key in a particular spot.
55 - **As a strongly typed Rust data structure.** When you expect all or most
56 of your data to conform to a particular structure and want to get real
57 work done without JSON's loosey-goosey nature tripping you up.
59 Serde JSON provides efficient, flexible, safe ways of converting data
60 between each of these representations.
62 ## Operating on untyped JSON values
64 Any valid JSON data can be manipulated in the following recursive enum
65 representation. This data structure is [`serde_json::Value`][value].
74 Object(Map<String, Value>),
78 A string of JSON data can be parsed into a `serde_json::Value` by the
79 [`serde_json::from_str`][from_str] function. There is also
80 [`from_slice`][from_slice] for parsing from a byte slice &[u8] and
81 [`from_reader`][from_reader] for parsing from any `io::Read` like a File or
84 <a href="https://play.rust-lang.org/?edition=2018&gist=d69d8e3156d4bb81c4461b60b772ab72" target="_blank">
85 <img align="right" width="50" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/run.png">
89 use serde_json::{Result, Value};
91 fn untyped_example() -> Result<()> {
92 // Some JSON input data as a &str. Maybe this comes from the user.
103 // Parse the string of data into serde_json::Value.
104 let v: Value = serde_json::from_str(data)?;
106 // Access parts of the data by indexing with square brackets.
107 println!("Please call {} at the number {}", v["name"], v["phones"][0]);
113 The result of square bracket indexing like `v["name"]` is a borrow of the data
114 at that index, so the type is `&Value`. A JSON map can be indexed with string
115 keys, while a JSON array can be indexed with integer keys. If the type of the
116 data is not right for the type with which it is being indexed, or if a map does
117 not contain the key being indexed, or if the index into a vector is out of
118 bounds, the returned element is `Value::Null`.
120 When a `Value` is printed, it is printed as a JSON string. So in the code above,
121 the output looks like `Please call "John Doe" at the number "+44 1234567"`. The
122 quotation marks appear because `v["name"]` is a `&Value` containing a JSON
123 string and its JSON representation is `"John Doe"`. Printing as a plain string
124 without quotation marks involves converting from a JSON string to a Rust string
125 with [`as_str()`] or avoiding the use of `Value` as described in the following
128 [`as_str()`]: https://docs.serde.rs/serde_json/enum.Value.html#method.as_str
130 The `Value` representation is sufficient for very basic tasks but can be tedious
131 to work with for anything more significant. Error handling is verbose to
132 implement correctly, for example imagine trying to detect the presence of
133 unrecognized fields in the input data. The compiler is powerless to help you
134 when you make a mistake, for example imagine typoing `v["name"]` as `v["nmae"]`
135 in one of the dozens of places it is used in your code.
137 ## Parsing JSON as strongly typed data structures
139 Serde provides a powerful way of mapping JSON data into Rust data structures
140 largely automatically.
142 <a href="https://play.rust-lang.org/?edition=2018&gist=15cfab66d38ff8a15a9cf1d8d897ac68" target="_blank">
143 <img align="right" width="50" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/run.png">
147 use serde::{Deserialize, Serialize};
148 use serde_json::Result;
150 #[derive(Serialize, Deserialize)]
157 fn typed_example() -> Result<()> {
158 // Some JSON input data as a &str. Maybe this comes from the user.
169 // Parse the string of data into a Person object. This is exactly the
170 // same function as the one that produced serde_json::Value above, but
171 // now we are asking it for a Person as output.
172 let p: Person = serde_json::from_str(data)?;
174 // Do things just like with any other Rust data structure.
175 println!("Please call {} at the number {}", p.name, p.phones[0]);
181 This is the same `serde_json::from_str` function as before, but this time we
182 assign the return value to a variable of type `Person` so Serde will
183 automatically interpret the input data as a `Person` and produce informative
184 error messages if the layout does not conform to what a `Person` is expected
187 Any type that implements Serde's `Deserialize` trait can be deserialized
188 this way. This includes built-in Rust standard library types like `Vec<T>`
189 and `HashMap<K, V>`, as well as any structs or enums annotated with
190 `#[derive(Deserialize)]`.
192 Once we have `p` of type `Person`, our IDE and the Rust compiler can help us
193 use it correctly like they do for any other Rust code. The IDE can
194 autocomplete field names to prevent typos, which was impossible in the
195 `serde_json::Value` representation. And the Rust compiler can check that
196 when we write `p.phones[0]`, then `p.phones` is guaranteed to be a
197 `Vec<String>` so indexing into it makes sense and produces a `String`.
199 ## Constructing JSON values
201 Serde JSON provides a [`json!` macro][macro] to build `serde_json::Value`
202 objects with very natural JSON syntax.
204 <a href="https://play.rust-lang.org/?edition=2018&gist=6ccafad431d72b62e77cc34c8e879b24" target="_blank">
205 <img align="right" width="50" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/run.png">
209 use serde_json::json;
212 // The type of `john` is `serde_json::Value`
222 println!("first phone number: {}", john["phones"][0]);
224 // Convert to a string of JSON and print it out
225 println!("{}", john.to_string());
229 The `Value::to_string()` function converts a `serde_json::Value` into a
230 `String` of JSON text.
232 One neat thing about the `json!` macro is that variables and expressions can
233 be interpolated directly into the JSON value as you are building it. Serde
234 will check at compile time that the value you are interpolating is able to
235 be represented as JSON.
237 <a href="https://play.rust-lang.org/?edition=2018&gist=f9101a6e61dfc9e02c6a67f315ed24f2" target="_blank">
238 <img align="right" width="50" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/run.png">
242 let full_name = "John Doe";
243 let age_last_year = 42;
245 // The type of `john` is `serde_json::Value`
248 "age": age_last_year + 1,
250 format!("+44 {}", random_phone())
255 This is amazingly convenient but we have the problem we had before with
256 `Value` which is that the IDE and Rust compiler cannot help us if we get it
257 wrong. Serde JSON provides a better way of serializing strongly-typed data
258 structures into JSON text.
260 ## Creating JSON by serializing data structures
262 A data structure can be converted to a JSON string by
263 [`serde_json::to_string`][to_string]. There is also
264 [`serde_json::to_vec`][to_vec] which serializes to a `Vec<u8>` and
265 [`serde_json::to_writer`][to_writer] which serializes to any `io::Write`
266 such as a File or a TCP stream.
268 <a href="https://play.rust-lang.org/?edition=2018&gist=3472242a08ed2ff88a944f2a2283b0ee" target="_blank">
269 <img align="right" width="50" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/run.png">
273 use serde::{Deserialize, Serialize};
274 use serde_json::Result;
276 #[derive(Serialize, Deserialize)]
282 fn print_an_address() -> Result<()> {
283 // Some data structure.
284 let address = Address {
285 street: "10 Downing Street".to_owned(),
286 city: "London".to_owned(),
289 // Serialize it to a JSON string.
290 let j = serde_json::to_string(&address)?;
292 // Print, write to a file, or send to an HTTP server.
299 Any type that implements Serde's `Serialize` trait can be serialized this
300 way. This includes built-in Rust standard library types like `Vec<T>` and
301 `HashMap<K, V>`, as well as any structs or enums annotated with
302 `#[derive(Serialize)]`.
306 It is fast. You should expect in the ballpark of 500 to 1000 megabytes per
307 second deserialization and 600 to 900 megabytes per second serialization,
308 depending on the characteristics of your data. This is competitive with the
309 fastest C and C++ JSON libraries or even 30% faster for many use cases.
310 Benchmarks live in the [serde-rs/json-benchmark] repo.
312 [serde-rs/json-benchmark]: https://github.com/serde-rs/json-benchmark
316 Serde developers live in the #serde channel on
317 [`irc.mozilla.org`](https://wiki.mozilla.org/IRC). The #rust channel is also a
318 good resource with generally faster response time but less specific knowledge
319 about Serde. If IRC is not your thing, we are happy to respond to [GitHub
320 issues](https://github.com/serde-rs/json/issues/new) as well.
324 This crate currently requires the Rust standard library. For JSON support in
325 Serde without a standard library, please see the [`serde-json-core`] crate.
327 [`serde-json-core`]: https://japaric.github.io/serde-json-core/serde_json_core/
329 [value]: https://docs.serde.rs/serde_json/value/enum.Value.html
330 [from_str]: https://docs.serde.rs/serde_json/de/fn.from_str.html
331 [from_slice]: https://docs.serde.rs/serde_json/de/fn.from_slice.html
332 [from_reader]: https://docs.serde.rs/serde_json/de/fn.from_reader.html
333 [to_string]: https://docs.serde.rs/serde_json/ser/fn.to_string.html
334 [to_vec]: https://docs.serde.rs/serde_json/ser/fn.to_vec.html
335 [to_writer]: https://docs.serde.rs/serde_json/ser/fn.to_writer.html
336 [macro]: https://docs.serde.rs/serde_json/macro.json.html
343 Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
344 2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
350 Unless you explicitly state otherwise, any contribution intentionally submitted
351 for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
352 be dual licensed as above, without any additional terms or conditions.