Cómo usar Arrays en JSON (Con Ejemplos en Código)

Introducción

JSON (JavaScript Object Notation) es uno de los formatos de datos más utilizados para transmitir información estructurada entre sistemas. Entre sus bloques de construcción principales se encuentra el array, que te permite representar listas ordenadas de datos como cadenas, números, objetos o incluso otros arrays.

Ya sea que estés definiendo archivos de configuración, enviando datos a una API o procesando respuestas del servidor, entender cómo usar arrays en JSON es esencial. Esta guía cubre cómo funcionan los arrays, cómo definirlos, acceder a ellos en el código y manejar casos más complejos como arrays de objetos.

¿Qué es un Array en JSON?

Un array JSON es una lista ordenada encerrada en corchetes []. Puede contener cualquier combinación de valores, incluyendo:

• Cadenas
• Números
• Booleanos
• Objetos
• Otros arrays
• null

Ejemplo: Array de cadenas

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

Array JSON de Objetos

Uno de los patrones más poderosos en JSON es el array de objetos. Esto se utiliza para representar colecciones de datos estructurados, como listas de usuarios, productos u órdenes.

Ejemplo: Array de Objetos

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

Array JSON de Arrays

Un array JSON de arrays es una estructura de datos anidada donde cada elemento dentro del array exterior es a su vez un array. Esta estructura se utiliza a menudo para representar datos tabulares, matrices o conjuntos de coordenadas, donde cada array interno contiene un grupo relacionado de valores.

Ejemplo: Matriz (Rejilla 2D)

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

Ejemplo: Coordenadas

{
  "coordinates": [
    [35.6895, 139.6917],     // Tokio
    [34.0522, -118.2437],    // Los Ángeles
    [51.5074, -0.1278]       // Londres
  ]
}

¿Cómo manipular arrays JSON en lenguajes populares?

Una vez que hayas analizado una cadena JSON en una estructura de datos nativa, puedes fácilmente recorrer, filtrar, mapear o modificar arrays usando las herramientas integradas del lenguaje.

A continuación se presentan ejemplos en algunos de los lenguajes más populares:

1. Manipular Arrays JSON en JavaScript/TypeScript

Los arrays JSON son ampliamente utilizados en JavaScript y TypeScript para manejar datos estructurados, especialmente al trabajar con respuestas de API, almacenamiento local, bases de datos o renderizado dinámico de UI. Entender cómo manipularlos de manera efectiva es clave para escribir código limpio y eficiente.

Aquí hay algunas operaciones comunes que a menudo necesitarás al trabajar con arrays JSON:

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

// 1. Recorrer el array
users.forEach(user => {
  console.log("Nombre de usuario:", user.name);
});

// 2. Filtrar elementos
const activeUsers = users.filter(user => user.active);
console.log("Usuarios activos:", activeUsers);

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

// 4. Agregar un nuevo elemento
users.push({ name: "Dave", active: true });
console.log("Después de agregar a Dave:", users);

// 5. Eliminar un elemento por índice (por ejemplo, eliminar el segundo usuario)
users.splice(1, 1);
console.log("Después de eliminar el segundo usuario:", users);

// 6. Encontrar un usuario por nombre
const foundUser = users.find(user => user.name === "Alice");
console.log("Usuario encontrado:", foundUser);

// 7. Actualizar un objeto en el array (por ejemplo, activar a Bob si existe)
const updatedUsers = users.map(user =>
  user.name === "Bob" ? { ...user, active: true } : user
);
console.log("Usuarios actualizados:", updatedUsers);

// 8. Convertir el array a cadena JSON
const jsonString = JSON.stringify(users);
console.log("Cadena JSON:", jsonString);

// 9. Analizar la cadena JSON de vuelta a un array
const parsedUsers = JSON.parse(jsonString);
console.log("Usuarios analizados:", parsedUsers);

2. Manipular Arrays JSON en Python

En Python, los arrays JSON se representan típicamente como listas, y los objetos JSON como diccionarios. El módulo json integrado de Python facilita trabajar con datos JSON, ya sea que estés consumiendo respuestas de API, leyendo archivos de configuración o preparando datos estructurados para exportación.

Usar listas de diccionarios (es decir, arrays JSON de objetos) es un patrón común al manejar datos en Python. Esta estructura es tanto flexible como poderosa, permitiéndote realizar operaciones como filtrar, ordenar, actualizar y serializar fácilmente con características nativas de Python como comprensiones de listas, sorted() y desempaquetado de diccionarios.

import json

# Array JSON de ejemplo de objetos (lista de diccionarios de Python)
users = [
    { "name": "Alice", "active": True },
    { "name": "Bob", "active": False },
    { "name": "Carol", "active": True }
]

# 1. Recorrer el array
for user in users:
    print("Nombre de usuario:", user["name"])

# 2. Filtrar elementos
active_users = [user for user in users if user["active"]]
print("Usuarios activos:", active_users)

# 3. Ordenar por nombre
sorted_users = sorted(users, key=lambda user: user["name"])
print("Usuarios ordenados:", sorted_users)

# 4. Agregar un nuevo elemento
users.append({ "name": "Dave", "active": True })
print("Después de agregar a Dave:", users)

# 5. Eliminar un elemento por índice (por ejemplo, eliminar el segundo usuario)
users.pop(1)
print("Después de eliminar el segundo usuario:", users)

# 6. Encontrar un usuario por nombre
found_user = next((user for user in users if user["name"] == "Alice"), None)
print("Usuario encontrado:", found_user)

# 7. Actualizar un objeto en el array (por ejemplo, activar a Bob si existe)
updated_users = [
    { **user, "active": True } if user["name"] == "Bob" else user
    for user in users
]
print("Usuarios actualizados:", updated_users)

# 8. Convertir el array a cadena JSON
json_string = json.dumps(users)
print("Cadena JSON:", json_string)

# 9. Analizar la cadena JSON de vuelta a un array
parsed_users = json.loads(json_string)
print("Usuarios analizados:", parsed_users)

3. Manipular Arrays JSON en Java

En Java, los arrays JSON se representan comúnmente usando List<Map<String, Object>> al trabajar con bibliotecas como Jackson, Gson o org.json. Estas bibliotecas te permiten analizar, generar y manipular datos JSON con facilidad.

Manipular arrays JSON en Java es esencial al tratar con respuestas de API REST, almacenamiento de datos o archivos de configuración. Dado que Java es un lenguaje de tipo estático, a menudo necesitarás mapear datos JSON a POJOs (Plain Old Java Objects), o usar tipos flexibles como List y Map cuando la estructura es dinámica.

Ejemplo (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();

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

        // 1. Analizar cadena JSON en List de Map
        List<Map<String, Object>> users = mapper.readValue(json, new TypeReference<List<Map<String, Object>>>() {});
        System.out.println("Usuarios originales: " + users);

        // 2. Recorrer el array
        for (Map<String, Object> user : users) {
            System.out.println("Nombre de usuario: " + user.get("name"));
        }

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

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

        // 5. Agregar un nuevo usuario
        Map<String, Object> newUser = new HashMap<>();
        newUser.put("name", "Dave");
        newUser.put("active", true);
        users.add(newUser);
        System.out.println("Después de agregar a Dave: " + users);

        // 6. Eliminar un usuario por índice
        users.remove(1);
        System.out.println("Después de eliminar el segundo usuario: " + users);

        // 7. Encontrar un usuario por nombre
        Map<String, Object> found = users.stream()
                .filter(user -> "Alice".equals(user.get("name")))
                .findFirst()
                .orElse(null);
        System.out.println("Usuario encontrado: " + found);

        // 8. Actualizar a Bob a activo (si existe)
        for (Map<String, Object> user : users) {
            if ("Bob".equals(user.get("name"))) {
                user.put("active", true);
            }
        }

        // 9. Convertir lista de vuelta a cadena JSON
        String updatedJson = mapper.writeValueAsString(users);
        System.out.println("Cadena JSON actualizada: " + updatedJson);
    }
}

4. Manipular Arrays JSON en PHP

En PHP, los arrays JSON se decodifican típicamente en arrays asociativos (para objetos JSON) o arrays indexados (para listas JSON). PHP proporciona funciones integradas como json_decode() y json_encode() para analizar y serializar datos JSON, facilitando la manipulación de estructuras JSON directamente.

Trabajar con arrays de objetos (es decir, un array JSON de arrays asociativos) es un patrón común al manejar respuestas de API, archivos de configuración o llamadas AJAX. La estructura de array flexible de PHP hace que sea muy conveniente realizar operaciones como filtrar, ordenar, actualizar y serializar arrays JSON.

<?php

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

// 1. Decodificar cadena JSON a array PHP
$users = json_decode($json, true);
echo "Usuarios originales:\n";
print_r($users);

// 2. Recorrer el array
foreach ($users as $user) {
    echo "Nombre de usuario: " . $user['name'] . "\n";
}

// 3. Filtrar usuarios activos
$activeUsers = array_filter($users, function ($user) {
    return $user['active'] === true;
});
echo "Usuarios activos:\n";
print_r($activeUsers);

// 4. Ordenar usuarios por nombre
usort($users, function ($a, $b) {
    return strcmp($a['name'], $b['name']);
});
echo "Usuarios ordenados:\n";
print_r($users);

// 5. Agregar un nuevo usuario
$users[] = ["name" => "Dave", "active" => true];
echo "Después de agregar a Dave:\n";
print_r($users);

// 6. Eliminar un usuario por índice (por ejemplo, eliminar el segundo usuario)
array_splice($users, 1, 1);
echo "Después de eliminar el segundo usuario:\n";
print_r($users);

// 7. Encontrar un usuario por nombre
$foundUser = null;
foreach ($users as $user) {
    if ($user['name'] === 'Alice') {
        $foundUser = $user;
        break;
    }
}
echo "Usuario encontrado:\n";
print_r($foundUser);

// 8. Actualizar a Bob a activo si existe
foreach ($users as &$user) {
    if ($user['name'] === 'Bob') {
        $user['active'] = true;
    }
}
unset($user); // romper referencia

// 9. Codificar de vuelta a JSON
$updatedJson = json_encode($users, JSON_PRETTY_PRINT);
echo "JSON actualizado:\n";
echo $updatedJson;

5. Manipular Arrays JSON en Ruby

En Ruby, los arrays JSON se analizan típicamente en arrays de hashes usando la biblioteca json integrada. Esta estructura es ideal para trabajar con respuestas de API, archivos de configuración y cualquier intercambio de datos estructurados. La sintaxis expresiva de Ruby y los métodos enumerables (each, select, sort_by, map, etc.) hacen que sea muy conveniente manipular arrays JSON.

require 'json'

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

# 1. Analizar cadena JSON en array de hashes de Ruby
users = JSON.parse(json)
puts "Usuarios originales:"
puts users

# 2. Recorrer el array
users.each do |user|
  puts "Nombre de usuario: #{user['name']}"
end

# 3. Filtrar usuarios activos
active_users = users.select { |user| user['active'] }
puts "Usuarios activos:"
puts active_users

# 4. Ordenar usuarios por nombre
sorted_users = users.sort_by { |user| user['name'] }
puts "Usuarios ordenados:"
puts sorted_users

# 5. Agregar un nuevo usuario
users << { 'name' => 'Dave', 'active' => true }
puts "Después de agregar a Dave:"
puts users

# 6. Eliminar un usuario por índice (por ejemplo, eliminar el segundo usuario)
users.delete_at(1)
puts "Después de eliminar el segundo usuario:"
puts users

# 7. Encontrar un usuario por nombre
found_user = users.find { |user| user['name'] == 'Alice' }
puts "Usuario encontrado:"
puts found_user

# 8. Actualizar a Bob a activo (si existe)
users.map! do |user|
  user['name'] == 'Bob' ? user.merge('active' => true) : user
end

# 9. Convertir de vuelta a cadena JSON
updated_json = JSON.pretty_generate(users)
puts "Cadena JSON actualizada:"
puts updated_json

6. Manipular Arrays JSON en Golang

En Go, los arrays JSON se decodifican típicamente en slices de structs o []map[string]interface{} para estructuras dinámicas. El paquete encoding/json proporciona herramientas poderosas y flexibles para codificar/decodificar JSON. La manipulación de JSON es común en Go al tratar con APIs REST, archivos de configuración o transformación de datos.

La tipificación estricta y el rendimiento de Go lo hacen ideal para un manejo robusto de JSON, especialmente al definir tipos personalizados para datos estructurados. A continuación se presenta un ejemplo completo que demuestra cómo manipular arrays JSON en Go, cubriendo análisis, recorrido, filtrado, ordenación, actualización y conversión de vuelta a JSON.

package main

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

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

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

	// 1. Analizar cadena JSON a slice de structs
	var users []User
	err := json.Unmarshal([]byte(jsonStr), &users)
	if err != nil {
		panic(err)
	}
	fmt.Println("Usuarios originales:", users)

	// 2. Recorrer el array
	for _, user := range users {
		fmt.Println("Nombre de usuario:", user.Name)
	}

	// 3. Filtrar usuarios activos
	var activeUsers []User
	for _, user := range users {
		if user.Active {
			activeUsers = append(activeUsers, user)
		}
	}
	fmt.Println("Usuarios activos:", activeUsers)

	// 4. Ordenar usuarios por nombre
	sort.Slice(users, func(i, j int) bool {
		return users[i].Name < users[j].Name
	})
	fmt.Println("Usuarios ordenados:", users)

	// 5. Agregar un nuevo usuario
	users = append(users, User{Name: "Dave", Active: true})
	fmt.Println("Después de agregar a Dave:", users)

	// 6. Eliminar usuario por índice (por ejemplo, eliminar el segundo usuario)
	if len(users) > 1 {
		users = append(users[:1], users[2:]...)
	}
	fmt.Println("Después de eliminar el segundo usuario:", users)

	// 7. Encontrar usuario por nombre
	var found *User
	for i := range users {
		if users[i].Name == "Alice" {
			found = &users[i]
			break
		}
	}
	fmt.Println("Usuario encontrado:", found)

	// 8. Actualizar a Bob a activo si existe
	for i := range users {
		if users[i].Name == "Bob" {
			users[i].Active = true
		}
	}

	// 9. Convertir slice de vuelta a JSON
	updatedJSON, err := json.MarshalIndent(users, "", "  ")
	if err != nil {
		panic(err)
	}
	fmt.Println("JSON actualizado:")
	fmt.Println(string(updatedJSON))
}

Herramientas Útiles en Línea para Trabajar con Arrays JSON

1. CodeUtility: Visor/Beautifier JSON

• Autoformato con números de línea.
• Alternar entre vista compacta y bonita.
• Validación incorporada.

Enlace: https://beautifyjson.codeutility.io

2. CodeUtility: JSON a Yaml

• Convertir array JSON a YAML.
• Filtrar o extraer campos de array.

Enlace: https://json2yaml.codeutility.io

3. JSONLint: Validador JSON

• Validar y formatear JSON.
• Verifica si tu array JSON es sintácticamente correcto.
• Auto-indentado y resalta errores.

Enlace: https://jsonlint.com