Advanced JSON Techniques & Performance

Native JSON.parse() vs Libraries

Optimization Techniques

// ❌ Slow: Multiple parse operations
for (const item of items) {
  const parsed = JSON.parse(item);
  process(parsed);
}

// ✓ Fast: Parse once, process many
const allData = JSON.parse(jsonString);
for (const item of allData) {
  process(item);
}

// ✓ Fastest: Avoid parsing if possible
// Use structured data directly

When to Use Streaming

• → Files larger than available RAM (100MB+)
• → Processing data incrementally without loading all
• → Real-time data processing pipelines
• → Memory-constrained environments

Node.js Streaming Example

const fs = require('fs');
const JSONStream = require('JSONStream');

// Stream large JSON array
fs.createReadStream('huge-file.json')
  .pipe(JSONStream.parse('*'))  // Parse each array item
  .on('data', (item) => {
    // Process one item at a time
    // Memory usage stays constant!
    processItem(item);
  })
  .on('end', () => {
    console.log('Processing complete');
  });

Browser Streaming with Fetch

async function streamJSON(url) {
  const response = await fetch(url);
  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  let buffer = '';

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;

    buffer += decoder.decode(value, { stream: true });

    // Process complete JSON objects from buffer
    const lines = buffer.split('\n');
    buffer = lines.pop(); // Keep incomplete line

    for (const line of lines) {
      if (line.trim()) {
        const item = JSON.parse(line);
        processItem(item);
      }
    }
  }
}

Compression Comparison

Enable Compression

// Express.js server compression
const compression = require('compression');
app.use(compression({
  level: 6,  // Balance between speed and ratio
  threshold: 1024  // Only compress > 1KB
}));

// Nginx configuration
gzip on;
gzip_types application/json;
gzip_min_length 1000;
gzip_comp_level 6;

Reduce Memory Usage

// ❌ High memory: Load entire file
const data = JSON.parse(fs.readFileSync('huge.json', 'utf8'));

// ✓ Low memory: Stream processing
const stream = fs.createReadStream('huge.json')
  .pipe(JSONStream.parse('items.*'));

// ❌ High memory: Store all results
const results = [];
for (const item of data) {
  results.push(processItem(item));
}

// ✓ Low memory: Process and discard
for (const item of data) {
  const result = processItem(item);
  if (result.important) {
    saveToDatabase(result);  // Store only what you need
  }
}

1. JSON Schema Caching

const Ajv = require('ajv');
const ajv = new Ajv();

// Compile schema once, reuse many times
const validateUser = ajv.compile(userSchema);

// Fast validation on each request
app.post('/users', (req, res) => {
  if (!validateUser(req.body)) {
    return res.status(400).json({ errors: validateUser.errors });
  }
  // Process valid data
});

2. Lazy Parsing

// Parse only what you need
function getField(jsonString, fieldPath) {
  // Use regex to extract specific field without full parse
  const regex = new RegExp(`"${fieldPath}"\s*:\s*"([^"]*)"`);
  const match = jsonString.match(regex);
  return match ? match[1] : null;
}

// For huge JSON, this is much faster than:
// const obj = JSON.parse(jsonString);
// return obj[fieldPath];

3. Binary JSON Alternatives

For performance-critical applications, consider binary formats:

• → MessagePack: 2x faster parsing, smaller size
• → Protocol Buffers: Type-safe, very efficient
• → CBOR: Similar to JSON, binary encoding
• → BSON: Used by MongoDB, includes types

4. Parallel Processing

// Node.js Worker Threads for CPU-intensive JSON processing
const { Worker } = require('worker_threads');

function processLargeJSONFiles(files) {
  return Promise.all(files.map(file => {
    return new Promise((resolve, reject) => {
      const worker = new Worker('./json-worker.js', {
        workerData: { file }
      });
      worker.on('message', resolve);
      worker.on('error', reject);
    });
  }));
}

HTTP Caching

// Server-side cache headers
app.get('/api/data', (req, res) => {
  res.set({
    'Cache-Control': 'public, max-age=3600',
    'ETag': generateETag(data),
    'Last-Modified': data.updatedAt
  });
  res.json(data);
});

// Client-side conditional request
const response = await fetch('/api/data', {
  headers: {
    'If-None-Match': cachedETag
  }
});

if (response.status === 304) {
  // Use cached data
  return cachedData;
}

In-Memory Caching

// Simple LRU cache
class JSONCache {
  constructor(maxSize = 100) {
    this.cache = new Map();
    this.maxSize = maxSize;
  }

  set(key, value) {
    if (this.cache.size >= this.maxSize) {
      // Remove oldest entry
      const firstKey = this.cache.keys().next().value;
      this.cache.delete(firstKey);
    }
    this.cache.set(key, {
      data: value,
      timestamp: Date.now()
    });
  }

  get(key, maxAge = 300000) {  // 5 min default
    const entry = this.cache.get(key);
    if (!entry) return null;

    if (Date.now() - entry.timestamp > maxAge) {
      this.cache.delete(key);
      return null;
    }

    return entry.data;
  }
}

Measure Parse Performance

// Node.js performance measurement
const { performance } = require('perf_hooks');

const start = performance.now();
const data = JSON.parse(largeJSONString);
const parseTime = performance.now() - start;

console.log(`Parse time: ${parseTime.toFixed(2)}ms`);
console.log(`Size: ${(largeJSONString.length / 1024 / 1024).toFixed(2)}MB`);
console.log(`Speed: ${(largeJSONString.length / parseTime / 1024).toFixed(2)}KB/ms`);

Memory Profiling

// Check memory usage
const used = process.memoryUsage();

console.log(`Heap Used: ${(used.heapUsed / 1024 / 1024).toFixed(2)} MB`);
console.log(`Heap Total: ${(used.heapTotal / 1024 / 1024).toFixed(2)} MB`);
console.log(`External: ${(used.external / 1024 / 1024).toFixed(2)} MB`);

// Take heap snapshot for analysis
const v8 = require('v8');
const heapSnapshot = v8.writeHeapSnapshot();