Как правильно парсить JSON из файла в Rust с помощью serde?

Идиоматичный способ парсинга JSON с обработкой ошибок

Вы на верном пути, но давайте улучшим код. Главные проблемы вашего решения:

• Необработанные ошибки — .unwrap() вызовет панику при любой проблеме (файл не найден, некорректный JSON и т.д.)
• Избыточное чтение в память — serde_json умеет читать напрямую из File или BufReader
• Отсутствие контекста ошибок — пользователь не поймёт, где именно произошла ошибка

Правильное решение с использованием BufReader и anyhow

Добавьте в Cargo.toml:

[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"
anyhow = "1"  # для удобной обработки ошибок

Полный пример:

use serde::Deserialize;
use std::fs::File;
use std::io::BufReader;
use anyhow::{Context, Result};

#[derive(Debug, Deserialize)]
struct Config {
    name: String,
    version: u32,
    debug: bool,
    dependencies: Vec,
}

fn main() -> Result<()> {
    let config = read_config_from_file("config.json")?;
    println!("{:#?}", config);
    Ok(())
}

fn read_config_from_file(path: &str) -> Result {
    let file = File::open(path)
        .with_context(|| format!("Не удалось открыть файл: {}", path))?;
    
    let reader = BufReader::new(file);
    let config: Config = serde_json::from_reader(reader)
        .with_context(|| format!("Ошибка парсинга JSON из файла: {}", path))?;
    
    Ok(config)
}

Почему это лучше?

• BufReader — буферизированное чтение, оптимально для файлов
• serde_json::from_reader — читает напрямую из потока, не загружая весь файл в память как строку
• anyhow::Context — добавляет понятное сообщение к ошибке, упрощая отладку
• Result<()> — позволяет использовать оператор ? для проброса ошибок

Альтернатива без anyhow (стандартная библиотека)

Если не хотите использовать внешние крейты для ошибок:

use std::fs::File;
use std::io::{BufReader, Error as IoError};
use serde_json::Error as JsonError;

fn read_config(path: &str) -> Result {
    let file = File::open(path)?;
    let reader = BufReader::new(file);
    let config = serde_json::from_reader(reader)?;
    Ok(config)
}

Обработка ошибок в реальном приложении

Для production лучше использовать более детальную обработку:

fn read_config_safe(path: &str) -> Config {
    match File::open(path) {
        Ok(file) => {
            let reader = BufReader::new(file);
            match serde_json::from_reader(reader) {
                Ok(config) => config,
                Err(e) => {
                    eprintln!("Ошибка парсинга JSON: {}", e);
                    std::process::exit(1);
                }
            }
        }
        Err(e) => {
            eprintln!("Не удалось открыть файл {}: {}", path, e);
            std::process::exit(1);
        }
    }
}

Дополнительные советы

• Для больших JSON-файлов используйте serde_json::Deserializer для потокового чтения
• Если структура может меняться, используйте #[serde(default)] для полей
• Для вложенных структур используйте вложенные #[derive(Deserialize)]
• Проверяйте типы: u32 не примет отрицательное число или число с плавающей точкой

Теперь ваш код будет безопасным, эффективным и легко поддерживаемым!

use std::fs::File;
use std::io::BufReader;
use serde_json::Value;

fn main() {
    let file = File::open("config.json").expect("Файл не найден");
    let reader = BufReader::new(file);
    let value: Value = serde_json::from_reader(reader).expect("Ошибка парсинга JSON");
    
    if let Some(name) = value.get("name").and_then(|v| v.as_str()) {
        println!("Name: {}", name);
    }
    
    if let Some(version) = value.get("version").and_then(|v| v.as_u64()) {
        println!("Version: {}", version);
    }
    
    if let Some(deps) = value.get("dependencies").and_then(|v| v.as_array()) {
        for dep in deps {
            if let Some(dep_name) = dep.as_str() {
                println!("Dependency: {}", dep_name);
            }
        }
    }
}