Arc<Mutex>

Guides

Rust walkthroughs

← Back to all guides

What is the difference between serde_json::from_reader and from_slice for deserializing JSON from different sources?

from_reader deserializes from any type implementing Read (files, network streams, stdin) without requiring the entire JSON to be loaded into memory, while from_slice deserializes from a byte slice &[u8] that must already be in memory. The choice affects memory usage, performance, and error handling: from_slice is faster for in-memory data because it avoids IO overhead and can randomly access bytes, while from_reader enables streaming deserialization from sources too large to fit in memory or where loading everything upfront is impractical.

Basic from_slice Usage

use serde_json::{from_slice, Result};
 
#[derive(serde::Deserialize)]
struct User {
    name: String,
    age: u32,
}
 
fn from_slice_example() -> Result<()> {
    // from_slice takes a &[u8] that's already in memory
    let json_data = br#"{"name":"Alice","age":30}"#;
    
    let user: User = from_slice(json_data)?;
    
    println!("Name: {}, Age: {}", user.name, user.age);
    Ok(())
}

from_slice accepts a byte slice already in memory and deserializes directly from it.

Basic from_reader Usage

use serde_json::{from_reader, Result};
use std::fs::File;
 
#[derive(serde::Deserialize)]
struct User {
    name: String,
    age: u32,
}
 
fn from_reader_example() -> Result<()> {
    // from_reader takes any type implementing Read
    let file = File::open("user.json")?;
    
    let user: User = from_reader(file)?;
    
    println!("Name: {}, Age: {}", user.name, user.age);
    Ok(())
}

from_reader accepts any Read implementation, reading and deserializing from the stream.

Function Signatures

use serde_json::{from_slice, from_reader};
 
// Simplified signatures:
 
// from_slice: takes a byte slice
// pub fn from_slice<'a, T>(v: &'a [u8]) -> Result<T>
// where T: Deserialize<'a>
 
// from_reader: takes a Read implementor
// pub fn from_reader<R, T>(rdr: R) -> Result<T>
// where R: Read, T: DeserializeOwned
 
fn signature_differences() {
    // from_slice borrows the input bytes
    let data: Vec<u8> = br#"{"key":"value"}"#.to_vec();
    let result: serde_json::Value = from_slice(&data).unwrap();
    // data is still valid after deserialization
    
    // from_reader takes ownership of the reader
    use std::io::Cursor;
    let cursor = Cursor::new(data);
    let result: serde_json::Value = from_reader(cursor).unwrap();
    // cursor is consumed
}

from_slice borrows the byte slice; from_reader takes ownership of the reader.

Memory Usage Comparison

use serde_json::{from_slice, from_reader, Result};
use std::fs::File;
 
#[derive(serde::Deserialize)]
struct LargeData {
    records: Vec<Record>,
}
 
#[derive(serde::Deserialize)]
struct Record {
    // Many fields...
    id: u64,
    name: String,
    // ... more fields
}
 
fn memory_comparison() -> Result<()> {
    // Scenario: 1GB JSON file
    
    // from_slice approach: Must load entire file into memory
    // - Load 1GB into Vec<u8>
    // - Deserialize from slice
    // - Peak memory: 1GB + deserialized data
    // let data = std::fs::read("large.json")?;
    // let parsed: LargeData = from_slice(&data)?;
    // data still exists until dropped
    
    // from_reader approach: Reads incrementally
    // - Opens file, reads chunks as needed
    // - Parses incrementally
    // - Peak memory: much lower (only active buffers)
    let file = File::open("large.json")?;
    let parsed: LargeData = from_reader(file)?;
    
    // No need to hold entire JSON in memory
    
    Ok(())
}

from_reader streams data without loading the entire JSON into memory.

Reading from Stdin

use serde_json::{from_reader, Result};
use std::io::{self, Read};
 
#[derive(serde::Deserialize)]
struct Config {
    setting: String,
    value: i32,
}
 
fn read_from_stdin() -> Result<()> {
    // from_reader works with stdin (streaming source)
    let stdin = io::stdin();
    let config: Config = from_reader(stdin.lock())?;
    
    println!("Setting: {}, Value: {}", config.setting, config.value);
    Ok(())
    
    // from_slice would require reading all stdin first:
    // let mut buffer = Vec::new();
    // io::stdin().read_to_end(&mut buffer)?;
    // let config: Config = from_slice(&buffer)?;
    // This is less efficient and may not be possible for infinite streams
}

from_reader can handle streaming sources like stdin without buffering everything.

Reading from Network

use serde_json::from_reader;
 
#[cfg(feature = "network-example")]
fn read_from_network() {
    use std::net::TcpStream;
    
    // from_reader works with network streams
    let stream = TcpStream::connect("example.com:80").unwrap();
    
    // Can deserialize directly from the stream
    // No need to buffer entire response first
    let result: serde_json::Value = from_reader(stream).unwrap();
}

Network streams can be deserialized directly with from_reader.

Error Handling Differences

use serde_json::{from_slice, from_reader, Error};
use std::fs::File;
 
fn error_handling() {
    // from_slice only has JSON parsing errors
    let bad_json = b"not valid json";
    match from_slice::<serde_json::Value>(bad_json) {
        Ok(_) => println!("Parsed successfully"),
        Err(e) => println!("Parse error: {}", e),
    }
    
    // from_reader can have IO errors too
    // The IO error is wrapped in the Result
    match File::open("nonexistent.json") {
        Ok(file) => {
            match from_reader::<_, serde_json::Value>(file) {
                Ok(_) => println!("Parsed successfully"),
                Err(e) => println!("Parse error: {}", e),
            }
        }
        Err(e) => println!("IO error: {}", e),
    }
    
    // Note: from_reader's error can contain both:
    // - IO errors (opening/reading)
    // - Parse errors (invalid JSON)
}

from_reader can encounter IO errors during deserialization; from_slice only has parse errors.

Working with Strings

use serde_json::{from_slice, from_str};
 
fn string_vs_slice() {
    let json_string = r#"{"name":"Alice"}"#;
    
    // from_str: from String or &str (convenience for UTF-8 strings)
    let value1: serde_json::Value = serde_json::from_str(json_string).unwrap();
    
    // from_slice: from &[u8] (works for any bytes)
    let value2: serde_json::Value = from_slice(json_string.as_bytes()).unwrap();
    
    // Both work for valid UTF-8 strings
    // from_slice is more general (accepts any bytes)
    // from_str is clearer when you have strings
    
    // from_slice can also handle bytes that aren't valid UTF-8
    // (though valid JSON must be UTF-8)
}

from_str is a convenience for string input; from_slice works with raw bytes.

Lifetimes and Ownership

use serde_json::{from_slice, from_reader};
use serde::Deserialize;
 
#[derive(Deserialize)]
struct Owned {
    name: String,  // Owned string
    count: u32,
}
 
// Reference types require 'de lifetime
#[derive(Deserialize)]
struct Borrowed<'a> {
    name: &'a str,  // Borrowed string
    count: u32,
}
 
fn lifetime_examples() {
    let json_data = br#"{"name":"Alice","count":42}"#;
    
    // from_slice can deserialize into borrowed types
    // because it has access to the original bytes
    let borrowed: Borrowed = from_slice(json_data).unwrap();
    println!("Borrowed name: {}", borrowed.name);
    
    // from_reader cannot deserialize into borrowed types
    // because the reader is consumed during parsing
    // let borrowed: Borrowed = from_reader(Cursor::new(json_data)).unwrap();
    // ^ This would NOT compile - Borrowed needs 'de lifetime
    
    // from_reader requires DeserializeOwned
    let owned: Owned = from_reader(std::io::Cursor::new(json_data)).unwrap();
}

from_slice can deserialize into types borrowing from the input; from_reader requires owned output.

DeserializeOwned vs Deserialize

use serde::de::{Deserialize, DeserializeOwned};
use serde_json::{from_slice, from_reader};
use std::io::Cursor;
 
fn deserialize_traits() {
    // from_slice signature (simplified):
    // fn from_slice<'a, T>(v: &'a [u8]) -> Result<T>
    // where T: Deserialize<'a>
    //
    // T can borrow from the input bytes
    
    // from_reader signature (simplified):
    // fn from_reader<R, T>(rdr: R) -> Result<T>
    // where R: Read, T: DeserializeOwned
    //
    // T must own all its data (cannot borrow)
    
    // This affects what types you can deserialize into:
    
    // Owned types (String, Vec, etc.): both work
    // Borrowed types (&str, &[u8]): only from_slice
    
    let data = br#"{"items":["a","b","c"]}"#;
    
    // Owned: both from_slice and from_reader work
    let owned: Vec<String> = from_slice(data).unwrap();
    let owned: Vec<String> = from_reader(Cursor::new(data)).unwrap();
    
    // Borrowed: only from_slice works
    let borrowed: Vec<&str> = from_slice(data).unwrap();
    // let borrowed: Vec<&str> = from_reader(Cursor::new(data)).unwrap();
    // ^ Compile error: expected DeserializeOwned, found Deserialize<'de>
}

from_slice accepts types implementing Deserialize<'de>; from_reader requires DeserializeOwned.

Performance Characteristics

use serde_json::{from_slice, from_reader};
use std::io::Cursor;
 
fn performance_characteristics() {
    // from_slice: generally faster for in-memory data
    // - Direct access to all bytes
    // - No IO overhead
    // - Can optimize for contiguous memory
    // - Can borrow from input for strings/bytes
    
    // from_reader: potentially slower but more flexible
    // - IO overhead for reading chunks
    // - Must handle partial reads
    // - Cannot borrow from input
    // - Must allocate strings/bytes
    
    // Small in-memory data: prefer from_slice
    let small_json = br#"{"x":1}"#;
    let value: serde_json::Value = from_slice(small_json).unwrap();
    
    // Large files: prefer from_reader
    // let file = File::open("large.json")?;
    // let value: serde_json::Value = from_reader(file)?;
}

from_slice is faster for in-memory data; from_reader is necessary for large files.

File Reading Patterns

use serde_json::{from_slice, from_reader, Result};
use std::fs::File;
use std::io::Read;
 
#[derive(serde::Deserialize)]
struct Data {
    items: Vec<String>,
}
 
fn file_patterns() -> Result<()> {
    // Pattern 1: from_reader with File (streaming)
    let file = File::open("data.json")?;
    let data: Data = from_reader(file)?;
    
    // Pattern 2: read entire file, then from_slice
    let mut buffer = Vec::new();
    File::open("data.json")?.read_to_end(&mut buffer)?;
    let data: Data = from_slice(&buffer)?;
    
    // Pattern 3: using std::fs::read (convenience)
    let buffer = std::fs::read("data.json")?;
    let data: Data = from_slice(&buffer)?;
    
    // from_reader is preferred for files because:
    // - Doesn't load entire file into memory first
    // - Starts parsing immediately
    // - Lower peak memory usage
    
    Ok(())
}

from_reader is preferred for file reading; from_slice requires loading the entire file first.

Working with Vec

use serde_json::{from_slice, from_reader};
use std::io::Cursor;
 
fn vec_u8_handling() {
    // When you already have Vec<u8> in memory:
    let buffer: Vec<u8> = br#"{"status":"ok"}"#.to_vec();
    
    // Option 1: from_slice (preferred - no copying)
    let value: serde_json::Value = from_slice(&buffer).unwrap();
    
    // Option 2: from_reader with Cursor (wraps Vec, implements Read)
    let value: serde_json::Value = from_reader(Cursor::new(&buffer)).unwrap();
    
    // from_slice is better here because:
    // - More direct (no Cursor wrapper)
    // - Can borrow from the buffer
    // - Slightly less overhead
}

When data is already in a Vec<u8>, from_slice is more efficient.

Cursor Wrapper

use serde_json::from_reader;
use std::io::Cursor;
 
fn cursor_wrapper() {
    // Cursor implements Read, wrapping in-memory data
    let data = br#"{"key":"value"}"#;
    
    // This works - Cursor<&[u8]> implements Read
    let value: serde_json::Value = from_reader(Cursor::new(data)).unwrap();
    
    // Also works with owned data
    let owned_data = data.to_vec();
    let value: serde_json::Value = from_reader(Cursor::new(owned_data)).unwrap();
    
    // Use Cursor when:
    // - You have in-memory data
    // - But want to use from_reader (e.g., generic code)
    // - Testing code that expects Read trait
}

Cursor wraps in-memory bytes to implement Read for use with from_reader.

Generic Code with Read

use serde::Deserialize;
use serde_json::from_reader;
use std::io::Read;
 
fn generic_deserialization<R: Read, T: for<'de> Deserialize<'de>>(reader: R) -> Result<T, serde_json::Error> {
    // Generic function that works with any Read source
    from_reader(reader)
}
 
fn using_generic() {
    use std::fs::File;
    use std::io::Cursor;
    
    #[derive(serde::Deserialize)]
    struct Item {
        name: String,
    }
    
    // Works with File
    let file = File::open("item.json").unwrap();
    let item: Item = generic_deserialization(file).unwrap();
    
    // Works with Cursor (for testing)
    let cursor = Cursor::new(br#"{"name":"test"}"#);
    let item: Item = generic_deserialization(cursor).unwrap();
    
    // Works with stdin
    // let item: Item = generic_deserialization(io::stdin().lock()).unwrap();
}

Generic code over Read can use from_reader for any source.

Partial Deserialization

use serde_json::{from_reader, from_slice};
use std::io::Cursor;
 
fn partial_consumption() {
    // Both functions consume their input
    // But what if you need remaining data?
    
    // from_slice doesn't tell you where it stopped
    // You'd need to use a more complex API
    
    // from_reader consumes the reader
    let data = br#"{"a":1}extra"#;
    let mut cursor = Cursor::new(data);
    let value: serde_json::Value = from_reader(&mut cursor).unwrap();
    
    // cursor is consumed, but position is updated
    // Remaining bytes after JSON: "extra"
    let remaining = &data[cursor.position() as usize..];
    assert_eq!(remaining, b"extra");
    
    // This works because Cursor tracks position
    // Not all readers support checking position
}

from_reader with Cursor can reveal how much was consumed; from_slice cannot.

Large File Deserialization

use serde_json::from_reader;
use std::fs::File;
 
#[derive(serde::Deserialize)]
struct LogFile {
    entries: Vec<LogEntry>,
}
 
#[derive(serde::Deserialize)]
struct LogEntry {
    timestamp: String,
    level: String,
    message: String,
}
 
fn large_file() -> Result<(), Box<dyn std::error::Error>> {
    // For a 10GB JSON file:
    
    // DON'T do this (loads 10GB into memory):
    // let data = std::fs::read("huge.json")?;  // 10GB allocation
    // let log: LogFile = serde_json::from_slice(&data)?;
    
    // DO this (streams from disk):
    let file = File::open("huge.json")?;
    let log: LogFile = from_reader(file)?;
    // Reads chunks as needed, much lower peak memory
    
    Ok(())
}

For large files, from_reader streams data; from_slice requires loading everything.

Comparison Summary

use serde_json::{from_slice, from_reader};
 
fn comparison_table() {
    // | Aspect | from_slice | from_reader |
    // |--------|-----------|-------------|
    // | Input type | &[u8] | impl Read |
    // | Memory | Must be in memory | Can stream |
    // | Ownership | Borrows slice | Takes ownership of reader |
    // | Lifetime | Can borrow from input | Must own output (DeserializeOwned) |
    // | Speed | Faster (no IO) | Slower (IO overhead) |
    // | Use case | In-memory data | Files, streams, stdin |
    // | IO errors | No | Possible |
    
    // Use from_slice when:
    // - Data is already in memory
    // - You want to borrow from input
    // - Performance is critical
    
    // Use from_reader when:
    // - Data comes from files or streams
    // - Data is large (streaming)
    // - Writing generic code over Read
}

Practical Recommendations

use serde_json::{from_slice, from_reader, from_str};
use std::fs::File;
use std::io::{Cursor, Read};
 
fn recommendations() {
    // Network responses: from_reader or from_slice
    // If response body is in Vec<u8>: from_slice
    // If streaming response: from_reader
    
    // Files: from_reader (streaming)
    let file = File::open("data.json").unwrap();
    let data: serde_json::Value = from_reader(file).unwrap();
    
    // Small files where you need speed: read + from_slice
    let buffer = std::fs::read("small.json").unwrap();
    let data: serde_json::Value = from_slice(&buffer).unwrap();
    
    // Strings: from_str (convenience)
    let data: serde_json::Value = from_str(r#"{"x":1}"#).unwrap();
    
    // Testing: from_slice or from_reader with Cursor
    let data: serde_json::Value = from_slice(br#"{"test":true}"#).unwrap();
    let data: serde_json::Value = from_reader(Cursor::new(br#"{"test":true}"#)).unwrap();
}

Synthesis

Quick reference:

use serde_json::{from_slice, from_reader, from_str};
use std::fs::File;
use std::io::Cursor;
 
fn quick_reference() {
    // from_slice: &[u8] -> T
    // - Input must be in memory
    // - Can borrow strings from input
    // - Faster for small/medium data
    let data: &[u8] = br#"{"key":"value"}"#;
    let value: serde_json::Value = from_slice(data).unwrap();
    
    // from_reader: impl Read -> T
    // - Streams from any Read source
    // - Must own output (DeserializeOwned)
    // - Lower memory for large data
    let file = File::open("data.json").unwrap();
    let value: serde_json::Value = from_reader(file).unwrap();
    
    // from_str: &str -> T
    // - Convenience for string input
    // - Can borrow from input
    let value: serde_json::Value = from_str(r#"{"key":"value"}"#).unwrap();
}

Key insight: The fundamental difference is the source type and its implications for memory and ownership. from_slice accepts a byte slice &[u8] that must already be loaded into memory—it's the right choice when you have the JSON data available as a Vec<u8>, &[u8], or string. from_reader accepts any type implementing Read, enabling deserialization directly from files, network streams, stdin, or any streaming source without requiring the entire input to be buffered first. This distinction has important consequences: from_slice can deserialize into types that borrow from the input (like &str), because the original bytes remain accessible during deserialization. from_reader cannot—since it streams data, the bytes are consumed during parsing and the output must own its data (implementing DeserializeOwned). For files, from_reader is generally preferred because it streams content without loading the entire file; for in-memory data, from_slice is faster and enables borrowing. Both produce the same deserialization errors; only from_reader can encounter IO errors during reading. Choose from_slice for in-memory data when you want speed or the ability to borrow; choose from_reader for files, streams, or when writing generic code over Read.