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 for 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 json_last_error(). json_decode retorna null em caso de falha, e null 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 código Java costuma usar o ObjectMapper do Jackson. Os records (Java 16+) criam DTOs limpos sem boilerplate. O Jackson se liga a eles diretamente, e configure controla o tratamento de propriedades desconhecidas.

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

Trate os erros de parsing, porque JSON malformado derruba 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 for 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) →