JSON 파일을 해석하려면 어떻게 해야 하나요?

JSON 파일을 해석하려면 어떻게 해야 하나요?

이 JSON 데이터를 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();
}

그리고.text.json이

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

해석하기 위한 다음 단계는 무엇입니까?제 주된 목표는 이와 같은 JSON 데이터를 가져와 Age와 같은 키를 해석하는 것입니다.

Serde는 우선 JSON 시리얼라이제이션 프로바이더입니다.파일에서 JSON 텍스트를 읽을 수 있는 방법은 여러 가지가 있습니다.문자열로 지정되면 다음과 같이 사용합니다.

fn main() {
    let the_file = r#"{
        "FirstName": "John",
        "LastName": "Doe",
        "Age": 43,
        "Address": {
            "Street": "Downing Street 10",
            "City": "London",
            "Country": "Great Britain"
        },
        "PhoneNumbers": [
            "+44 1234567",
            "+44 2345678"
        ]
    }"#;

    let json: serde_json::Value =
        serde_json::from_str(the_file).expect("JSON was not well-formatted");
}

Cargo.toml:

[dependencies]
serde = { version = "1.0.104", features = ["derive"] }
serde_json = "1.0.48"

열린 상태에서 직접 읽을 수도 있습니다.File.

Serde는 JSON 이외의 포맷에 사용할 수 있으며 임의의 컬렉션이 아닌 커스텀구조로 시리얼화 및 역시리얼화할 수 있습니다.

use serde::Deserialize;

#[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,
}

fn main() {
    let the_file = /* ... */;

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

상세한 것에 대하여는, Serde 의 Web 사이트를 참조해 주세요.

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());
}

문서 내의 파일에서 JSON을 읽는 방법에 대한 간략하고 완전한 예를 다음에 나타냅니다.

다음은 간단한 스니펫입니다.

• 파일 읽기
• 내용을 JSON으로 해석
• 원하는 키를 사용하여 필드를 추출합니다.

즐길 수 있다:

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");

받아들여진 답변(도움이 되는 대로)을 갱신했습니다만, @FrickeFresh가 참조하는 널리 사용되는 serde_json crate를 사용하여 답변을 추가했습니다.

고객님의foo.json이

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

구현은 다음과 같습니다.

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);
}

이 기능을 유틸리티로 추출할 수 있습니다.문서에 따르면 이는 유효한 소프트웨어일 수 있습니다.

use std::{
    fs::File,
    io::BufReader,
    path::Path,
    error::Error
};

use serde_json::Value;

fn read_payload_from_file<P: AsRef<Path>>(path: P) -> Result<Value, Box<dyn Error>> {
    // Open file in RO mode with buffer
    let file = File::open(path)?;
    let reader = BufReader::new(file);

    // Read the JSON contents of the file
    let u = serde_json::from_reader(reader)?;

    Ok(u)
}

fn main() {
  let payload: Value = 
     read_payload_from_file("./config/payload.json").unwrap();
}

녹은 우아한 네이티브-json 상자와 함께 제공되며, 이것은 Rust와 함께 네이티브 JSON 객체를 선언하고 멤버에게 네이티브 액세스를 제공합니다.

의 예native-json

use native_json::json;
use std::collections::HashMap;
use serde::{Deserialize, Serialize};

fn main()
{
    let mut json = json!{
        name: "native json",
        style: {
            color: "red",
            size: 12,
            bold: true,
            range: null
        },
        array: [5,4,3,2,1],
        vector: vec![1,2,3,4,5],
        hashmap: HashMap::from([ ("a", 1), ("b", 2), ("c", 3) ]);,
        students: [
            {name: "John", age: 18},
            {name: "Jack", age: 21},
        ],
    };

    // Native access
    json.style.size += 1;
    json.students[0].age += 2;

    // Debug
    println!("{:#?}", t);

    // Stringify
    let text = serde_json::to_string_pretty(&json).unwrap();
    println!("{}", text);
}

네이티브-제이슨 방식

use wsd::json::*;

fn main() {
    // Declare as native JSON object
    let mut john = json!{
        name: "John Doe",
        age: 43,
        phones: [
            "+44 1234567",
            "+44 2345678"
        ]
    };

    // Native access to member
    john.age += 1;

    println!("first phone number: {}", john.phones[0]);

    // Convert to a string of JSON and print it out
    println!("{}", stringify(&john, 4));
}

serde_json 방식

use serde_json::json;

fn main() {
    // The type of `john` is `serde_json::Value`
    let john = json!({
        "name": "John Doe",
        "age": 43,
        "phones": [
            "+44 1234567",
            "+44 2345678"
        ]
    });

    println!("first phone number: {}", john["phones"][0]);

    // Convert to a string of JSON and print it out
    println!("{}", john.to_string());
}

언급URL : https://stackoverflow.com/questions/30292752/how-do-i-parse-a-json-file