que - lista de datos en json

¿Cómo puedo analizar un archivo JSON?

Question

Tengo esto hasta ahora en mi objetivo de analizar estos datos JSON en Rust:

extern crate rustc_serialize;
use rustc_serialize::json::Json;
use std::fs::File;
use std::io::copy;
use std::io::stdout;
fn main() {
let mut file = File::open("text.json").unwrap();
let mut stdout = stdout();
let mut str = &copy(&mut file, &mut stdout).unwrap().to_string();
let data = Json::from_str(str).unwrap();
}

y text.json es

{
"FirstName": "John",
"LastName": "Doe",
"Age": 43,
"Address": {
"Street": "Downing Street 10",
"City": "London",
"Country": "Great Britain"
},
"PhoneNumbers": [
"[phone]",
"[phone]"
]
}

¿Cuál debería ser mi próximo paso para analizarlo? Mi objetivo principal es obtener datos JSON como este y analizar una clave, como Age.

Answer 1

Hay un ejemplo breve y completo de cómo leer JSON desde un archivo en los serde_json::de::from_reader de serde_json::de::from_reader .

Aquí hay un breve fragmento de:

• leyendo un archivo
• analizando su contenido como un JSON
• y extrayendo un campo con la llave deseada.

Disfrutar:

let file = fs::File::open("text.json")
.expect("file should open read only");
let json: serde_json::Value = serde_json::from_reader(file)
.expect("file should be proper JSON");
let first_name = json.get("FirstName")
.expect("file should have FirstName key");

Answer 2

Resuelto por los muchos miembros útiles de la comunidad de Rust:

extern crate rustc_serialize;
use rustc_serialize::json::Json;
use std::fs::File;
use std::io::Read;
fn main() {
let mut file = File::open("text.json").unwrap();
let mut data = String::new();
file.read_to_string(&mut data).unwrap();
let json = Json::from_str(&data).unwrap();
println!("{}", json.find_path(&["Address", "Street"]).unwrap());
}

Answer 3

Serde es el proveedor de serialización JSON preferido. Puede leer el texto JSON de un archivo de varias maneras . Una vez que lo tengas como una cadena, usa serde_json::from_str :

extern crate serde;
extern crate serde_json;
fn main() {
let the_file = r#"{
"FirstName": "John",
"LastName": "Doe",
"Age": 43,
"Address": {
"Street": "Downing Street 10",
"City": "London",
"Country": "Great Britain"
},
"PhoneNumbers": [
"[phone]",
"[phone]"
]
}"#;
let json: serde_json::Value =
serde_json::from_str(the_file).expect("JSON was not well-formatted");
}

Incluso puedes usar algo como serde_json::from_reader para leer directamente desde un File abierto.

Serde se puede utilizar para formatos distintos de JSON y se puede serializar y deserializar en una estructura personalizada en lugar de una colección arbitraria:

#[macro_use]
extern crate serde_derive;
#[derive(Debug, Deserialize)]
#[serde(rename_all = "PascalCase")]
struct Person {
first_name: String,
last_name: String,
age: u8,
address: Address,
phone_numbers: Vec<String>,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "PascalCase")]
struct Address {
street: String,
city: String,
country: String,
}

let person: Person = serde_json::from_str(the_file).expect("JSON was not well-formatted");
println!("{:?}", person)

Consulte el sitio web de Serde para más detalles.

Answer 4

Upvoted la respuesta aceptada (ya que ayuda), pero solo agregando mi respuesta, usando la caja de serde_json ampliamente utilizada a la que serde_json referencia @FrickeFresh

Asumiendo que tu foo.json es

{
"name": "Jane",
"age": 11
}

La implementación se vería algo así como

extern crate serde;
extern crate json_serde;
#[macro_use] extern crate json_derive;
use std::fs::File;
use std::io::Read;
#[derive(Serialize, Deserialize)]
struct Foo {
name: String,
age: u32,
}
fn main() {
let mut file = File::open("foo.json").unwrap();
let mut buff = String::new();
file.read_to_string(&mut buff).unwrap();
let foo: Foo = serde_json::from_str(&buff).unwrap();
println!("Name: {}", foo.name);
}