JSON
The flexible way to store & share data across systems. It's a text file with curly braces & key-value pairs { }
Simplest JSON format
{"id": "1","name":"Rachel"}
Properties
Language Independent.
Self-describing and easy to understand.
Basic Rules
Curly braces to hold the objects.
Data is represented in Key-Value or Name-Value pairs.
Data is separated by a comma.
The use of double quotes is necessary.
Square brackets [ ] hold an array of data.
JSON Values
String {"name":"Rachel"}
Number {"id":101}
Boolean {"result":true, "status":false} (lowercase)
Object {
"character":{"fname":"Rachel","lname":"Green"}
}
Array {
"characters":["Rachel","Ross","Joey","Chanlder"]
}
NULL {"id":null}
Sample JSON Document
{
"characters": [
{
"id" : 1,
"fName":"Rachel",
"lName":"Green",
"status":true
},
{
"id" : 2,
"fName":"Ross",
"lName":"Geller",
"status":true
},
{
"id" : 3,
"fName":"Chandler",
"lName":"Bing",
"status":true
},
{
"id" : 4,
"fName":"Phebe",
"lName":"Buffay",
"status":false
}
]
}
JSON Best Practices
No Hyphen in your Keys.
{"first-name":"Rachel","last-name":"Green"} is not right. ✘
Under Scores Okay
{"first_name":"Rachel","last_name":"Green"} is okay ✓
Lowercase Okay
{"firstname":"Rachel","lastname":"Green"} is okay ✓
Camelcase best
{"firstName":"Rachel","lastName":"Green"} is the best. ✓
JSON & RUST
- The Deserialize trait is required to parse (that is, read) JSON strings into this Struct.
- The Serialize trait is required to format (that is, write) this Struct into a JSON string.
- The Debug trait is for printing a Struct on a debug trace.
// main.rs
use serde_derive::{Deserialize, Serialize};
use std::env;
use std::fs;
// Remember attributes should be below the use statements
#[allow(non_snake_case)]
#[derive(Deserialize, Serialize, Debug)]
struct Characters {
id: u32,
fName: String,
lName: String,
status: bool
}
#[derive(Deserialize, Serialize, Debug)]
struct CharacterArray {
characters: Vec<Characters>
}
fn main() {
let input_path = env::args().nth(1).unwrap();
//let output_path = env::args().nth(2).unwrap();
let friends = {
let jsondata = fs::read_to_string(&input_path).unwrap();
// Load the Friends structure from the string.
serde_json::from_str::<CharacterArray>(&jsondata).unwrap()
};
for index in 0..friends.characters.len() {
println!("{} - {}",friends.characters[index].fName,friends.characters[index].lName);
}
}
Save the above json document as sample.json

// cargo.toml
[dependencies]
serde = "1.0.147"
serde_derive = "1.0.147"
serde_json = "1.0.87"
Convert Struct to JSON
use serde_derive::{Serialize};
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct Person {
first_name: String,
last_name: String,
id: i32,
status: bool
}
fn main() {
let person = Person {
first_name: "Rachel".to_string(),
last_name: "Green".to_string(),
id: 1,
status:true
};
let person1 = Person {
first_name: "Monica".to_string(),
last_name: "Geller".to_string(),
id: 2,
status:true
};
let v = vec![&person,&person1];
let output_path = "sample_output.json";
let json = serde_json::to_string_pretty(&v).unwrap(); // <- unwrap
println!("{}", json);
std::fs::write(
output_path,
json,
).unwrap()
}
// cargo.toml
serde = "1.0.147"
serde_derive = "1.0.147"
serde_json = "1.0.87"