How do I iterate over a JSON structure?

Strictly speaking, JSON is just a text format for data interchange. Once you parse a JSON string into your language’s native data structure (e.g., an object in JavaScript, a dictionary in Python, etc.), you can iterate over it just like any other object or array. Below, we’ll explore some common ways to iterate over JSON data in popular programming languages.

1. JavaScript

A. Parsing JSON into a JavaScript Object

First, convert the JSON string into a JavaScript object or array:

const jsonString = '{"name":"Alice","age":25,"languages":["JavaScript","Python"]}';
const data = JSON.parse(jsonString);

• If data is an object (like {"name":"Alice","age":25}), you can iterate over its keys or values.
• If data is an array (like ["JavaScript","Python"]), you can use loop structures like for, for...of, or array methods like forEach().

B. Iterating Over Objects

for (let key in data) {
  if (data.hasOwnProperty(key)) {
    console.log(`Key: ${key}, Value: ${data[key]}`);
  }
}

Alternatively, use Object.keys, Object.values, or Object.entries:

Object.entries(data).forEach(([key, value]) => {
  console.log(`Key: ${key}, Value: ${value}`);
});

C. Iterating Over Arrays

If your JSON structure is an array, you can do:

const arrayData = JSON.parse('["JavaScript","Python","C++"]');
arrayData.forEach((item, index) => {
  console.log(`Index: ${index}, Value: ${item}`);
});

Or use a for...of loop:

for (const item of arrayData) {
  console.log(item);
}

2. Python

In Python, convert the JSON string to a native Python object (often a dictionary or list) using the built-in json library:

import json

json_string = '{"name": "Alice", "age": 25, "languages": ["Python", "JavaScript"]}'
data = json.loads(json_string)

• If data is a dictionary (dict), you can iterate over keys, values, or items.
• If data is a list, you can iterate with a for loop.

A. Iterating Over a Dictionary

if isinstance(data, dict):
    for key, value in data.items():
        print(f"Key: {key}, Value: {value}")

B. Iterating Over a List

if isinstance(data, list):
    for item in data:
        print(item)

3. C# (.NET)

In C#, you typically parse JSON into objects using either System.Text.Json or Newtonsoft.Json. If you want to handle truly dynamic (unknown) structures, you might parse into a Dictionary<string, object> or JsonDocument (in System.Text.Json) or JObject (in Newtonsoft.Json).

A. Using System.Text.Json

using System;
using System.Text.Json;
using System.Collections.Generic;

public class Program
{
    public static void Main()
    {
        string jsonString = @"{ ""name"":""Alice"", ""age"":25, ""skills"":[""C#"",""SQL""] }";

        // Parse into a Dictionary
        var data = JsonSerializer.Deserialize<Dictionary<string, object>>(jsonString);

        // Iterate
        foreach (var kvp in data)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
}

If you need to further handle nested structures (like arrays or objects), you can cast or parse them again, but it requires some manual checks.

B. Using Newtonsoft.Json and JObject

using System;
using Newtonsoft.Json.Linq;

public class Program
{
    public static void Main()
    {
        string jsonString = @"{ ""name"":""Alice"", ""age"":25, ""skills"":[""C#"",""SQL""] }";
        JObject data = JObject.Parse(jsonString);

        foreach (var property in data.Properties())
        {
            Console.WriteLine($"Key: {property.Name}, Value: {property.Value}");
        }

        // If you know 'skills' is an array:
        JArray skills = (JArray)data["skills"];
        foreach (var skill in skills)
        {
            Console.WriteLine(skill);
        }
    }
}

4. Java (Gson Example)

Using Gson:

import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonArray;

public class IterateJson {
    public static void main(String[] args) {
        String jsonString = "{\"name\":\"Alice\",\"age\":25,\"skills\":[\"Java\",\"Kotlin\"]}";
        Gson gson = new Gson();
        JsonElement element = gson.fromJson(jsonString, JsonElement.class);

        if (element.isJsonObject()) {
            JsonObject jsonObject = element.getAsJsonObject();
            for (String key : jsonObject.keySet()) {
                System.out.println("Key: " + key + ", Value: " + jsonObject.get(key));
            }
        }

        // If a field is an array
        JsonArray skills = jsonObject.getAsJsonArray("skills");
        for (JsonElement skill : skills) {
            System.out.println(skill.getAsString());
        }
    }
}

Additional Tips & Best Practices

1. Check for Data Type

   • If you don’t know whether your parsed JSON is an array or object, verify its type before iterating.
   • In dynamically typed languages (like JavaScript, Python), check if the data is an array or dictionary before looping.

2. Handle Nested Structures

   • JSON can have objects nested within objects or arrays. You may need recursive approaches or library-specific functions to handle multi-level data.

3. Error Handling

   • Always handle potential parsing errors (e.g., invalid JSON).
   • Validate data if you expect specific fields or types.

4. Performance Considerations

   • For large JSON payloads, you might consider streaming or chunking the data instead of loading it all into memory at once.

Level Up Your System Design & Coding Skills

Handling JSON is a day-to-day task for most software engineers. If you want to refine not just your JSON manipulation but also your overall development and system design skills, check out these courses from DesignGurus.io:

1. Grokking the System Design Interview

   • Learn how to build robust, scalable, and maintainable systems that frequently rely on JSON-based APIs.

2. Grokking the Coding Interview: Patterns for Coding Questions

   • Develop pattern-based thinking for tackling coding challenges effectively, including those involving JSON transformations and parsing.

Final Thoughts

Iterating over a JSON structure is simply iterating over your language’s equivalent data type once JSON is parsed. Whether that’s an object, dictionary, or array, the specific loop mechanics vary by language—but the core idea remains the same. By understanding how to parse, traverse, and optionally validate or transform your JSON data, you’ll unlock the full potential of working with this universal data format.