Qual linguagem tem o parser de JSON mais rápido?

Linguagens compiladas (Go, Rust, Java com Jackson, C# com System.Text.Json) geralmente superam as interpretadas. Para a maioria das aplicações, a diferença é insignificante comparada aos custos de rede e banco de dados.

Devo usar um struct tipado ou um mapa genérico?

Structs/classes tipados capturam incompatibilidades de schema em tempo de compilação e oferecem autocompletar. Use mapas genéricos apenas quando o formato é realmente dinâmico ou desconhecido.

Exemplos de JSON em 7 linguagens: JavaScript, Python, Go, Rust, PHP, Java, C#

JavaScript

O JavaScript é a casa nativa do JSON. Faça parsing com JSON.parse, serialização com JSON.stringify e sempre envolva o parsing em try/catch.

typescript

// Parse a JSON string into an object (always guard with try/catch)
let data;
try {
  data = JSON.parse('{"name": "Alice", "age": 30}');
  console.log(data.name); // "Alice"
} catch (err) {
  console.error("Invalid JSON:", err.message);
}

// Serialize an object back to JSON
const json = JSON.stringify(data, null, 2);

// Fetch JSON from an API (res.json() rejects on invalid JSON)
const res = await fetch("/api/users/1");
const user = await res.json(); // parsed automatically

Python

O módulo json embutido no Python mapeia objetos JSON para dicts e arrays para lists. Use json.loads (string → objeto) e json.dumps (objeto → string).

python

import json

# Parse JSON string into a dict
data = json.loads('{"name": "Alice", "age": 30}')

# Serialize a dict to a pretty JSON string
text = json.dumps(data, indent=2, ensure_ascii=False)

# Read/write a JSON file
with open("data.json", encoding="utf-8") as f:
    data = json.load(f)

Go

O pacote encoding/json do Go mapeia JSON para structs por meio de tags. Use json.Marshal para serializar e json.Unmarshal para analisar, com as tags das structs controlando os nomes dos campos.

type User struct {
    Name string   `json:"name"`
    Age  int      `json:"age"`
}

// Struct → JSON
b, _ := json.Marshal(User{Name: "Alice", Age: 30})

// JSON → struct
var u User
_ = json.Unmarshal([]byte(`{"name":"Bob","age":25}`), &u)

Rust

O Rust usa as crates serde e serde_json para (de)serialização com segurança de tipos e custo zero. Derive Serialize/Deserialize em um struct e o serde_json cuida do resto — incluindo mensagens de erro precisas com linha e coluna quando o parsing falha.

rust

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct User {
    name: String,
    age: u8,
}

fn main() -> Result<(), serde_json::Error> {
    // JSON → struct
    let u: User = serde_json::from_str(r#"{"name":"Alice","age":30}"#)?;

    // Struct → JSON (pretty-printed)
    let json = serde_json::to_string_pretty(&u)?;
    println!("{}", json);
    Ok(())
}

PHP

O PHP tem json_encode/json_decode nativos, sem dependências. Passe true como segundo argumento para json_decode obter arrays associativos em vez de objetos stdClass, e verifique sempre json_last_error() — json_decode retorna null em caso de falha, que também é um valor JSON válido.

php

<?php
// PHP array → JSON
$json = json_encode(["name" => "Alice", "age": 30],
    JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);

// JSON → PHP array
$data = json_decode($json, true);
if (json_last_error() !== JSON_ERROR_NONE) {
    echo "JSON error: " . json_last_error_msg();
}

Java

O Java normalmente usa o ObjectMapper do Jackson. Os records (Java 16+) criam DTOs limpos sem boilerplate — o Jackson faz a ligação com eles diretamente, incluindo o tratamento de propriedades desconhecidas via configure.

java

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.DeserializationFeature;

record User(String name, int age) {}

ObjectMapper mapper = new ObjectMapper()
    .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

// JSON → record
User user = mapper.readValue("{\"name\":\"Alice\",\"age\":30}", User.class);

// Record → JSON
String json = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(user);

C#

O C# moderno usa System.Text.Json (integrado ao .NET). Atributos como JsonPropertyName mapeiam as convenções de nomes do JSON para propriedades PascalCase, e JsonSerializerOptions controla a caixa das letras na saída.

csharp

using System.Text.Json;
using System.Text.Json.Serialization;

public class User
{
    [JsonPropertyName("name")]
    public string Name { get; set; } = "";

    [JsonPropertyName("age")]
    public int Age { get; set; }
}

// JSON → object
var user = JsonSerializer.Deserialize<User>(
    "{\"name\":\"Alice\",\"age\":30}")!;

// Object → JSON (camelCase to match JSON conventions)
var options = new JsonSerializerOptions {
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};
string json = JsonSerializer.Serialize(user, options);

Melhores práticas universais

Sempre trate os erros de parsing — JSON malformado derrubará código sem proteção. Para APIs em produção, valide contra um JSON Schema antes de processar. Em linguagens compiladas, prefira structs/classes tipados a mapas genéricos. Use pretty-print durante o desenvolvimento e minifique em produção.

FAQ

Qual linguagem tem o parser de JSON mais rápido?: Linguagens compiladas (Go, Rust, Java com Jackson, C# com System.Text.Json) geralmente superam as interpretadas. Para a maioria das aplicações, a diferença é insignificante comparada aos custos de rede e banco de dados.
Devo usar um struct tipado ou um mapa genérico?: Structs/classes tipados capturam incompatibilidades de schema em tempo de compilação e oferecem autocompletar. Use mapas genéricos apenas quando o formato é realmente dinâmico ou desconhecido.

Exemplos de JSON em 7 linguagens: JavaScript, Python, Go, Rust, PHP, Java, C#

JavaScript

Python

Go

Rust

PHP

Java

C#

Melhores práticas universais

FAQ

Artigos relacionados

O que é JSON? Um guia completo para iniciantes →

A história do JSON: de 2000 a padrão da indústria →

O guia completo do JSON Schema (Draft 7) →