Como usar Arrays em JSON (Com Exemplos em Código)

Introdução

JSON (JavaScript Object Notation) é um dos formatos de dados mais amplamente utilizados para transmitir informações estruturadas entre sistemas. Entre seus principais blocos de construção está o array, que permite representar listas ordenadas de dados, como strings, números, objetos ou até mesmo outros arrays.

Seja definindo arquivos de configuração, enviando dados para uma API ou processando respostas de servidor, entender como usar arrays em JSON é essencial. Este guia cobre como os arrays funcionam, como defini-los, acessá-los no código e lidar com casos mais complexos, como arrays de objetos.

O que é um Array em JSON?

Um array JSON é uma lista ordenada, delimitada por colchetes []. Ele pode conter qualquer combinação de valores, incluindo:

• Strings
• Números
• Booleanos
• Objetos
• Outros arrays
• null

Exemplo: Array de strings

{
  "colors": ["red", "green", "blue"]
}

Array JSON de Objetos

Um dos padrões mais poderosos em JSON é o array de objetos. Isso é usado para representar coleções de dados estruturados — como listas de usuários, produtos ou pedidos.

Exemplo: Array de Objetos

{
  "users": [
    { "id": 1, "name": "Alice", "email": "alice@example.com" },
    { "id": 2, "name": "Bob", "email": "bob@example.com" }
  ]
}

Array JSON de Arrays

Um array JSON de arrays é uma estrutura de dados aninhada onde cada item dentro do array externo é, ele mesmo, um array. Essa estrutura é frequentemente usada para representar dados tabulares, matrizes ou conjuntos de coordenadas, onde cada array interno contém um grupo relacionado de valores.

Exemplo: Matriz (Grade 2D)

{
  "matrix": [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
  ]
}

Exemplo: Coordenadas

{
  "coordinates": [
    [35.6895, 139.6917],     // Tóquio
    [34.0522, -118.2437],    // Los Angeles
    [51.5074, -0.1278]       // Londres
  ]
}

Como Manipular Arrays JSON em Linguagens Populares?

Depois de analisar uma string JSON em uma estrutura de dados nativa, você pode facilmente iterar, filtrar, mapear ou modificar arrays usando as ferramentas integradas da linguagem.

Abaixo estão exemplos em algumas das linguagens mais populares:

1. Manipular Arrays JSON em JavaScript/TypeScript

Arrays JSON são amplamente utilizados em JavaScript e TypeScript para lidar com dados estruturados — especialmente ao trabalhar com respostas de API, armazenamento local, bancos de dados ou renderização dinâmica de UI. Entender como manipulá-los de forma eficaz é fundamental para escrever um código limpo e eficiente.

Aqui estão algumas operações comuns que você frequentemente precisará ao trabalhar com arrays JSON:

// Exemplo de array JSON de objetos
const users = [
  { name: "Alice", active: true },
  { name: "Bob", active: false },
  { name: "Carol", active: true }
];

// 1. Iterar pelo array
users.forEach(user => {
  console.log("Nome do usuário:", user.name);
});

// 2. Filtrar itens
const activeUsers = users.filter(user => user.active);
console.log("Usuários ativos:", activeUsers);

// 3. Ordenar por nome
const sortedUsers = [...users].sort((a, b) => a.name.localeCompare(b.name));
console.log("Usuários ordenados:", sortedUsers);

// 4. Adicionar um novo item
users.push({ name: "Dave", active: true });
console.log("Após adicionar Dave:", users);

// 5. Remover um item pelo índice (por exemplo, remover o segundo usuário)
users.splice(1, 1);
console.log("Após remover o segundo usuário:", users);

// 6. Encontrar um usuário pelo nome
const foundUser = users.find(user => user.name === "Alice");
console.log("Usuário encontrado:", foundUser);

// 7. Atualizar um objeto no array (por exemplo, definir Bob como ativo se ele existir)
const updatedUsers = users.map(user =>
  user.name === "Bob" ? { ...user, active: true } : user
);
console.log("Usuários atualizados:", updatedUsers);

// 8. Converter array para string JSON
const jsonString = JSON.stringify(users);
console.log("String JSON:", jsonString);

// 9. Analisar string JSON de volta para array
const parsedUsers = JSON.parse(jsonString);
console.log("Usuários analisados:", parsedUsers);

2. Manipular Arrays JSON em Python

Em Python, arrays JSON são tipicamente representados como listas, e objetos JSON como dicionários. O módulo json embutido do Python facilita o trabalho com dados JSON — seja consumindo respostas de API, lendo arquivos de configuração ou preparando dados estruturados para exportação.

Usar listas de dicionários (ou seja, arrays JSON de objetos) é um padrão comum ao lidar com dados em Python. Essa estrutura é flexível e poderosa, permitindo que você realize operações como filtragem, ordenação, atualização e serialização facilmente com recursos nativos do Python, como compreensões de lista, sorted() e desempacotamento de dicionários.

import json

# Exemplo de array JSON de objetos (lista Python de dicionários)
users = [
    { "name": "Alice", "active": True },
    { "name": "Bob", "active": False },
    { "name": "Carol", "active": True }
]

# 1. Iterar pelo array
for user in users:
    print("Nome do usuário:", user["name"])

# 2. Filtrar itens
active_users = [user for user in users if user["active"]]
print("Usuários ativos:", active_users)

# 3. Ordenar por nome
sorted_users = sorted(users, key=lambda user: user["name"])
print("Usuários ordenados:", sorted_users)

# 4. Adicionar um novo item
users.append({ "name": "Dave", "active": True })
print("Após adicionar Dave:", users)

# 5. Remover um item pelo índice (por exemplo, remover o segundo usuário)
users.pop(1)
print("Após remover o segundo usuário:", users)

# 6. Encontrar um usuário pelo nome
found_user = next((user for user in users if user["name"] == "Alice"), None)
print("Usuário encontrado:", found_user)

# 7. Atualizar um objeto no array (por exemplo, definir Bob como ativo se ele existir)
updated_users = [
    { **user, "active": True } if user["name"] == "Bob" else user
    for user in users
]
print("Usuários atualizados:", updated_users)

# 8. Converter array para string JSON
json_string = json.dumps(users)
print("String JSON:", json_string)

# 9. Analisar string JSON de volta para array
parsed_users = json.loads(json_string)
print("Usuários analisados:", parsed_users)

3. Manipular Arrays JSON em Java

Em Java, arrays JSON são comumente representados usando List<Map<String, Object>> ao trabalhar com bibliotecas como Jackson, Gson ou org.json. Essas bibliotecas permitem que você analise, gere e manipule dados JSON com facilidade.

Manipular arrays JSON em Java é essencial ao lidar com respostas de API REST, armazenamento de dados ou arquivos de configuração. Como Java é uma linguagem estaticamente tipada, você frequentemente precisará mapear dados JSON para POJOs (Plain Old Java Objects) ou usar tipos flexíveis como List e Map quando a estrutura for dinâmica.

Exemplo (Usando Jackson)

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.*;
import java.util.stream.Collectors;

public class JsonArrayExample {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();

        // Exemplo de string JSON
        String json = "[{\"name\":\"Alice\",\"active\":true},{\"name\":\"Bob\",\"active\":false},{\"name\":\"Carol\",\"active\":true}]";

        // 1. Analisar string JSON em List de Map
        List<Map<String, Object>> users = mapper.readValue(json, new TypeReference<List<Map<String, Object>>>() {});
        System.out.println("Usuários originais: " + users);

        // 2. Iterar pelo array
        for (Map<String, Object> user : users) {
            System.out.println("Nome do usuário: " + user.get("name"));
        }

        // 3. Filtrar usuários ativos
        List<Map<String, Object>> activeUsers = users.stream()
                .filter(user -> Boolean.TRUE.equals(user.get("active")))
                .collect(Collectors.toList());
        System.out.println("Usuários ativos: " + activeUsers);

        // 4. Ordenar por nome
        users.sort(Comparator.comparing(user -> (String) user.get("name")));
        System.out.println("Usuários ordenados: " + users);

        // 5. Adicionar um novo usuário
        Map<String, Object> newUser = new HashMap<>();
        newUser.put("name", "Dave");
        newUser.put("active", true);
        users.add(newUser);
        System.out.println("Após adicionar Dave: " + users);

        // 6. Remover um usuário pelo índice
        users.remove(1);
        System.out.println("Após remover o segundo usuário: " + users);

        // 7. Encontrar um usuário pelo nome
        Map<String, Object> found = users.stream()
                .filter(user -> "Alice".equals(user.get("name")))
                .findFirst()
                .orElse(null);
        System.out.println("Usuário encontrado: " + found);

        // 8. Atualizar Bob para ativo (se existir)
        for (Map<String, Object> user : users) {
            if ("Bob".equals(user.get("name"))) {
                user.put("active", true);
            }
        }

        // 9. Converter lista de volta para string JSON
        String updatedJson = mapper.writeValueAsString(users);
        System.out.println("String JSON atualizada: " + updatedJson);
    }
}

4. Manipular Arrays JSON em PHP

Em PHP, arrays JSON são tipicamente decodificados em arrays associativos (para objetos JSON) ou arrays indexados (para listas JSON). O PHP fornece funções integradas como json_decode() e json_encode() para analisar e serializar dados JSON, facilitando a manipulação direta de estruturas JSON.

Trabalhar com arrays de objetos (ou seja, um array JSON de arrays associativos) é um padrão comum ao lidar com respostas de API, arquivos de configuração ou chamadas AJAX. A estrutura de array flexível do PHP torna muito conveniente realizar operações como filtragem, ordenação, atualização e serialização de arrays JSON.

<?php

// Exemplo de string JSON
$json = '[{"name":"Alice","active":true},{"name":"Bob","active":false},{"name":"Carol","active":true}]';

// 1. Decodificar string JSON para array PHP
$users = json_decode($json, true);
echo "Usuários originais:\n";
print_r($users);

// 2. Iterar pelo array
foreach ($users as $user) {
    echo "Nome do usuário: " . $user['name'] . "\n";
}

// 3. Filtrar usuários ativos
$activeUsers = array_filter($users, function ($user) {
    return $user['active'] === true;
});
echo "Usuários ativos:\n";
print_r($activeUsers);

// 4. Ordenar usuários por nome
usort($users, function ($a, $b) {
    return strcmp($a['name'], $b['name']);
});
echo "Usuários ordenados:\n";
print_r($users);

// 5. Adicionar um novo usuário
$users[] = ["name" => "Dave", "active" => true];
echo "Após adicionar Dave:\n";
print_r($users);

// 6. Remover um usuário pelo índice (por exemplo, remover o segundo usuário)
array_splice($users, 1, 1);
echo "Após remover o segundo usuário:\n";
print_r($users);

// 7. Encontrar um usuário pelo nome
$foundUser = null;
foreach ($users as $user) {
    if ($user['name'] === 'Alice') {
        $foundUser = $user;
        break;
    }
}
echo "Usuário encontrado:\n";
print_r($foundUser);

// 8. Atualizar Bob para ativo se existir
foreach ($users as &$user) {
    if ($user['name'] === 'Bob') {
        $user['active'] = true;
    }
}
unset($user); // quebrar referência

// 9. Codificar de volta para JSON
$updatedJson = json_encode($users, JSON_PRETTY_PRINT);
echo "JSON atualizado:\n";
echo $updatedJson;

5. Manipular Arrays JSON em Ruby

Em Ruby, arrays JSON são tipicamente analisados em arrays de hashes usando a biblioteca json embutida. Essa estrutura é ideal para trabalhar com respostas de API, arquivos de configuração e qualquer troca de dados estruturados. A sintaxe expressiva do Ruby e os métodos enumeráveis (each, select, sort_by, map, etc.) tornam muito conveniente manipular arrays JSON.

require 'json'

# Exemplo de string JSON
json = '[{"name":"Alice","active":true},{"name":"Bob","active":false},{"name":"Carol","active":true}]'

# 1. Analisar string JSON em array Ruby de hashes
users = JSON.parse(json)
puts "Usuários originais:"
puts users

# 2. Iterar pelo array
users.each do |user|
  puts "Nome do usuário: #{user['name']}"
end

# 3. Filtrar usuários ativos
active_users = users.select { |user| user['active'] }
puts "Usuários ativos:"
puts active_users

# 4. Ordenar usuários por nome
sorted_users = users.sort_by { |user| user['name'] }
puts "Usuários ordenados:"
puts sorted_users

# 5. Adicionar um novo usuário
users << { 'name' => 'Dave', 'active' => true }
puts "Após adicionar Dave:"
puts users

# 6. Remover um usuário pelo índice (por exemplo, remover o segundo usuário)
users.delete_at(1)
puts "Após remover o segundo usuário:"
puts users

# 7. Encontrar um usuário pelo nome
found_user = users.find { |user| user['name'] == 'Alice' }
puts "Usuário encontrado:"
puts found_user

# 8. Atualizar Bob para ativo (se existir)
users.map! do |user|
  user['name'] == 'Bob' ? user.merge('active' => true) : user
end

# 9. Converter de volta para string JSON
updated_json = JSON.pretty_generate(users)
puts "String JSON atualizada:"
puts updated_json

6. Manipular Arrays JSON em Golang

Em Go, arrays JSON são tipicamente decodificados em slices de structs ou []map[string]interface{} para estruturas dinâmicas. O pacote encoding/json fornece ferramentas poderosas e flexíveis para codificar/decodificar JSON. A manipulação de JSON é comum em Go ao lidar com APIs REST, arquivos de configuração ou transformação de dados.

A tipagem rigorosa e o desempenho do Go o tornam ideal para um manuseio robusto de JSON, especialmente ao definir tipos personalizados para dados estruturados. Abaixo está um exemplo completo demonstrando como manipular arrays JSON em Go, cobrindo análise, iteração, filtragem, ordenação, atualização e conversão de volta para JSON.

package main

import (
	"encoding/json"
	"fmt"
	"sort"
)

type User struct {
	Name   string `json:"name"`
	Active bool   `json:"active"`
}

func main() {
	// Exemplo de array JSON
	jsonStr := `[{"name":"Alice","active":true},{"name":"Bob","active":false},{"name":"Carol","active":true}]`

	// 1. Analisar string JSON para slice de structs
	var users []User
	err := json.Unmarshal([]byte(jsonStr), &users)
	if err != nil {
		panic(err)
	}
	fmt.Println("Usuários originais:", users)

	// 2. Iterar pelo array
	for _, user := range users {
		fmt.Println("Nome do usuário:", user.Name)
	}

	// 3. Filtrar usuários ativos
	var activeUsers []User
	for _, user := range users {
		if user.Active {
			activeUsers = append(activeUsers, user)
		}
	}
	fmt.Println("Usuários ativos:", activeUsers)

	// 4. Ordenar usuários por nome
	sort.Slice(users, func(i, j int) bool {
		return users[i].Name < users[j].Name
	})
	fmt.Println("Usuários ordenados:", users)

	// 5. Adicionar um novo usuário
	users = append(users, User{Name: "Dave", Active: true})
	fmt.Println("Após adicionar Dave:", users)

	// 6. Remover usuário pelo índice (por exemplo, remover o segundo usuário)
	if len(users) > 1 {
		users = append(users[:1], users[2:]...)
	}
	fmt.Println("Após remover o segundo usuário:", users)

	// 7. Encontrar usuário pelo nome
	var found *User
	for i := range users {
		if users[i].Name == "Alice" {
			found = &users[i]
			break
		}
	}
	fmt.Println("Usuário encontrado:", found)

	// 8. Atualizar Bob para ativo se existir
	for i := range users {
		if users[i].Name == "Bob" {
			users[i].Active = true
		}
	}

	// 9. Converter slice de volta para JSON
	updatedJSON, err := json.MarshalIndent(users, "", "  ")
	if err != nil {
		panic(err)
	}
	fmt.Println("JSON atualizado:")
	fmt.Println(string(updatedJSON))
}

Ferramentas Online Úteis para Trabalhar com Arrays JSON

1. CodeUtility: Visualizador/Embelezador JSON

• Autoformatação com números de linha.
• Alternar entre visualização compacta e bonita.
• Validação embutida.

Link: https://beautifyjson.codeutility.io

2. CodeUtility: JSON para Yaml

• Converter array JSON para YAML.
• Filtrar ou extrair campos do array.

Link: https://json2yaml.codeutility.io

3. JSONLint: Validador JSON

• Validar e formatar JSON.
• Verifica se seu array JSON está sintaticamente correto.
• Auto-indentação e destaque de erros.

Link: https://jsonlint.com