如何遍历json串

如何遍历JSON串：从基础到实践的全面指南

JSON（JavaScript Object Notation）作为一种轻量级的数据交换格式，因其易读、易解析的特性，已成为前后端数据交互、API响应、配置文件存储等场景的主流选择，在实际开发中，我们经常需要从复杂的JSON数据中提取特定信息，这就涉及对JSON串的遍历，本文将系统介绍JSON串的遍历方法，从基础概念到不同编程语言的实践技巧，帮助你高效处理JSON数据。

JSON串的基础结构

在遍历JSON之前,我们需要先明确其数据结构，JSON本质上是一个键值对（Key-Value Pair）的集合，支持以下两种核心结构：

对象（Object）

以包裹，由多个键值对组成，键（Key）必须是字符串（需用双引号包裹），值（Value）可以是字符串、数字、布尔值、数组、对象或null。

{
  "name": "张三",
  "age": 25,
  "isStudent": false,
  "courses": ["数学", "英语"],
  "address": {
    "city": "北京",
    "district": "海淀区"
  }
}

数组（Array）

以 [] 包裹，由多个值（Value）组成，值的数据类型与对象中的Value一致。

[
  {"id": 1, "name": "商品A"},
  {"id": 2, "name": "商品B"},
  {"id": 3, "name": "商品C"}
]

遍历JSON的核心思路

遍历JSON的本质是递归地访问其所有键和值，根据JSON的结构（对象或数组），遍历逻辑可分为两类：

遍历对象（Object）

获取所有键（Key），再通过键访问对应的值（Value）。
如果Value是对象或数组,则递归遍历该Value。

遍历数组（Array）

遍历数组中的每个元素（Element）。
如果元素是对象或数组,则递归遍历该元素。

不同语言的JSON遍历实践

JavaScript（原生与框架）

JavaScript作为JSON的“母语”，提供了多种遍历方式，适用于不同场景。

（1）原生方法：`for...in`（遍历对象）、`forEach`/`for...of`（遍历数组）

遍历对象：使用for...in循环获取所有键，再通过obj[key]访问值：

const jsonObj = {
  "name": "张三",
  "age": 25,
  "address": {"city": "北京"}
};
for (let key in jsonObj) {
  if (jsonObj.hasOwnProperty(key)) { // 过滤掉原型链上的属性
    const value = jsonObj[key];
    console.log(`Key: ${key}, Value: ${value}`);
    if (typeof value === "object" && value !== null) {
      console.log(`嵌套对象:`, value); // 进一步遍历嵌套对象
    }
  }
}

遍历数组：使用forEach或for...of遍历元素：

const jsonArr = [
  {"id": 1, "name": "商品A"},
  {"id": 2, "name": "商品B"}
];
jsonArr.forEach((item, index) => {
  console.log(`Index: ${index}, Item:`, item);
  for (let key in item) {
    console.log(`  Key: ${key}, Value: ${item[key]}`);
  }
});

（2）递归遍历（处理复杂嵌套结构）

对于多层嵌套的JSON,递归是最直观的方式：

function traverseJSON(data) {
  if (typeof data !== "object" || data === null) {
    console.log(data); // 基本类型（字符串、数字等）直接输出
    return;
  }
  if (Array.isArray(data)) {
    data.forEach((item, index) => {
      console.log(`Array Index: ${index}`);
      traverseJSON(item); // 递归遍历数组元素
    });
  } else {
    for (let key in data) {
      console.log(`Object Key: ${key}`);
      traverseJSON(data[key]); // 递归遍历对象值
    }
  }
}
const complexJSON = {
  "a": 1,
  "b": [2, {"c": 3}],
  "d": {"e": {"f": 4}}
};
traverseJSON(complexJSON);

（3）现代框架：`JSON.parse()` + `Object.keys()`/`Object.values()`

通过JSON.parse()将JSON字符串转为对象后，可使用Object.keys()（获取键数组）、Object.values()（获取值数组）或Object.entries()（获取键值对数组）遍历：

const jsonString = '{"name": "李四", "hobbies": ["reading", "coding"]}';
const jsonObj = JSON.parse(jsonString);
// 遍历键
Object.keys(jsonObj).forEach(key => {
  console.log(`Key: ${key}`);
});
// 遍历值
Object.values(jsonObj).forEach(value => {
  console.log(`Value: ${value}`);
});
// 遍历键值对
Object.entries(jsonObj).forEach(([key, value]) => {
  console.log(`${key}: ${value}`);
});

Python（`json`模块 + 递归）

Python通过内置的json模块解析JSON字符串，再结合字典和列表的特性遍历。

（1）`json.loads()`解析 + 循环遍历

import json
json_string = '''
{
  "name": "王五",
  "age": 30,
  "courses": ["Python", "JavaScript"],
  "info": {"city": "上海", "job": "engineer"}
}
'''
json_data = json.loads(json_string)
# 遍历对象（字典）
for key, value in json_data.items():
    print(f"Key: {key}, Value: {value}")
    if isinstance(value, (dict, list)):
        print(f"嵌套结构: {value}") # 进一步处理嵌套结构

（2）递归遍历（处理复杂嵌套）

def traverse_json(data):
    if isinstance(data, dict):
        for key, value in data.items():
            print(f"Key: {key}")
            traverse_json(value) # 递归遍历字典值
    elif isinstance(data, list):
        for index, item in enumerate(data):
            print(f"List Index: {index}")
            traverse_json(item) # 递归遍历列表元素
    else:
        print(f"Value: {data}") # 基本类型直接输出
complex_json = {
    "a": 1,
    "b": [2, {"c": 3}],
    "d": {"e": {"f": 4}}
}
traverse_json(complex_json)

（3）第三方库：`jsonpath`（按路径提取）

如果JSON结构复杂且需要按特定路径提取数据,可使用jsonpath库（需安装：pip install jsonpath）：

import json
import jsonpath
json_data = {
    "store": {
        "book": [
            {"category": "reference", "author": "Nigel Rees"},
            {"category": "fiction", "author": "Evelyn Waugh"}
        ],
        "bicycle": {"color": "red", "price": 19.95}
    }
}
# 提取所有作者
authors = jsonpath.jsonpath(json_data, '$.store.book[*].author')
print("Authors:", authors) # 输出: ['Nigel Rees', 'Evelyn Waugh']
# 提取所有价格
prices = jsonpath.jsonpath(json_data, '$..price')
print("Prices:", prices) # 输出: [19.95]

Java（`org.json`库/Gson）

Java中需借助第三方库（如org.json、Gson、Jackson）解析JSON，以下是org.json的示例。

（1）`JSONObject`/`JSONArray`遍历

import org.json.JSONArray;
import org.json.JSONObject;
public class JSONTraversal {
    public static void main(String[] args) {
        String jsonString = "{\"name\":\"赵六\",\"hobbies\":[\"游泳\",\"编程\"],\"address\":{\"city\":\"广州\"}}";
        JSONObject jsonObj = new JSONObject(jsonString);
        // 遍历对象
        for (String key : jsonObj.keySet()) {
            Object value = jsonObj.get(key);
            System.out.println("Key: " + key + ", Value: " + value);
            if (value instanceof JSONObject || value instanceof JSONArray) {
                System.out.println("嵌套结构: " +

正文

如何遍历json串