json数据怎么循环

JSON数据循环全攻略：从基础到实战，轻松遍历嵌套结构

在Web开发和数据处理中，JSON（JavaScript Object Notation）因其轻量、易读、易解析的特性，已成为前后端数据交互的主流格式，无论是从API获取的响应数据，还是配置文件、日志记录，JSON无处不在，而循环遍历JSON数据，则是处理这些数据的核心操作——提取值、筛选信息、转换格式，都离不开它，本文将从JSON的基础结构出发，详解不同场景下的循环方法，包含代码示例和注意事项，帮你彻底“JSON数据怎么循环”。

先搞懂：JSON数据的基本结构

要循环JSON数据，得先知道它的“长相”，JSON数据本质上是由键值对（Key-Value Pair）构成的结构，主要包含两种核心结构：

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

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

2. 数组（Array）：用 [] 包裹，由多个值（Value）组成，值可以是任意JSON数据类型（包括对象或数组）。

   [
     {"id": 1, "name": "苹果", "price": 5},
     {"id": 2, "name": "香蕉", "price": 3},
     {"id": 3, "name": "橙子", "price": 4}
   ]

实际应用中，JSON数据往往是对象嵌套数组、数组嵌套对象的复杂结构,循环时需要根据结构选择合适的遍历方式。

核心场景：不同JSON结构的循环方法

场景1：遍历JSON对象（键值对）

当数据是JSON对象时，核心是获取每个键（Key）和对应的值（Value），主流编程语言（如JavaScript、Python、Java）都提供了内置方法。

JavaScript：for...in 循环或 Object 方法

JavaScript中，遍历对象最常用的是 for...in 循环，它会遍历对象可枚举的属性（包括原型链上的属性），因此需配合 hasOwnProperty() 判断是否为对象自身的属性。

const user = {
  name: "张三",
  age: 25,
  isStudent: false,
  address: { city: "北京" }
};
// 方法1：for...in 循环（遍历键）
for (let key in user) {
  if (user.hasOwnProperty(key)) { // 过滤掉原型链上的属性
    console.log(`键: ${key}, 值:`, user[key]);
  }
}
// 输出：
// 键: name, 值: 张三
// 键: age, 值: 25
// 键: isStudent, 值: false
// 键: address, 值: { city: "北京" }
// 方法2：Object.keys() + forEach（遍历自身键）
Object.keys(user).forEach(key => {
  console.log(`键: ${key}, 值:`, user[key]);
});
// 输出同上（仅遍历自身属性）
// 方法3：Object.entries() + forEach（遍历键值对数组）
Object.entries(user).forEach(([key, value]) => {
  console.log(`键: ${key}, 值:`, value);
});

Python：for...in 遍历字典

Python中，JSON对象对应字典（dict），直接用 for...in 遍历默认获取键，或通过 .items() 同时获取键值对。

import json
# JSON字符串转Python字典
json_str = '{"name": "张三", "age": 25, "isStudent": false, "address": {"city": "北京"}}'
user = json.loads(json_str)
# 方法1：遍历键
for key in user:
    print(f"键: {key}, 值: {user[key]}")
# 方法2：遍历键值对（推荐）
for key, value in user.items():
    print(f"键: {key}, 值: {value}")

场景2：遍历JSON数组（列表）

当数据是JSON数组时，核心是按索引访问每个元素，数组遍历相对简单，几乎所有语言都支持 for 循环、forEach（JavaScript）、列表推导式（Python）等方式。

JavaScript：for 循环、forEach、for...of

const courses = ["数学", "英语", "编程"];
// 方法1：普通for循环（带索引）
for (let i = 0; i < courses.length; i++) {
  console.log(`索引 ${i}:`, courses[i]);
}
// 方法2：forEach（无索引，直接遍历元素）
courses.forEach((course, index) => {
  console.log(`索引 ${index}:`, course);
});
// 方法3：for...of（现代JS推荐，直接遍历元素值）
for (const course of courses) {
  console.log("课程:", course);
}

Python：for 循环、enumerate

courses = ["数学", "英语", "编程"]
# 方法1：直接遍历元素
for course in courses:
    print("课程:", course)
# 方法2：遍历元素和索引（推荐）
for index, course in enumerate(courses):
    print(f"索引 {index}: {course}")

场景3：遍历嵌套JSON（对象嵌套数组/数组嵌套对象）

实际数据往往是嵌套的，用户对象包含课程数组”“商品数组包含属性对象”，此时需要循环中嵌套循环,或用递归处理深层嵌套。

示例1：对象嵌套数组（如用户课程）

const student = {
  name: "李四",
  courses: [
    { name: "数学", score: 90 },
    { name: "英语", score: 85 }
  ]
};
// 遍历对象，再遍历其中的数组
console.log("学生:", student.name);
student.courses.forEach(course => {
  console.log(`课程: ${course.name}, 分数: ${course.score}`);
});

student = {
  "name": "李四",
  "courses": [
    {"name": "数学", "score": 90},
    {"name": "英语", "score": 85}
  ]
}
print(f"学生: {student['name']}")
for course in student["courses"]:
    print(f"课程: {course['name']}, 分数: {course['score']}")

示例2：数组嵌套对象（如商品列表）

const products = [
  { id: 1, name: "手机", price: 2999, specs: { color: "黑色", storage: "128G" } },
  { id: 2, name: "笔记本", price: 5999, specs: { color: "银色", storage: "512G" } }
];
// 遍历数组，再遍历对象属性
products.forEach(product => {
  console.log(`商品ID: ${product.id}, 名称: ${product.name}`);
  console.log("规格:", `颜色-${product.specs.color}, 存储-${product.specs.storage}`);
});

products = [
  {"id": 1, "name": "手机", "price": 2999, "specs": {"color": "黑色", "storage": "128G"}},
  {"id": 2, "name": "笔记本", "price": 5999, "specs": {"color": "银色", "storage": "512G"}}
}
for product in products:
    print(f"商品ID: {product['id']}, 名称: {product['name']}")
    print(f"规格: 颜色-{product['specs']['color']}, 存储-{product['specs']['storage']}")

示例3：深层嵌套（递归遍历）

如果JSON嵌套层级很深（如3层以上），用多层嵌套循环会非常臃肿，此时可以用递归：递归遍历每个值，如果是对象或数组,则继续调用遍历方法。

// 递归遍历任意JSON结构（打印所有路径和值）
function printJSON(data, path = "") {
  if (typeof data === "object" && data !== null) {
    if (Array.isArray(data)) {
      data.forEach((item, index) => {
        printJSON(item, `${path}[${index}]`);
      });
    } else {
      for (