json怎么去掉空值

JSON数据去空值：实用方法与最佳实践

在数据处理中,JSON（JavaScript Object Notation）因其轻量、易读的特性被广泛使用，但实际场景中，JSON数据常因数据源不规范、接口返回异常等问题出现空值（如null、空字符串、[]空数组、空对象等），这些空值不仅占用存储空间，还可能导致数据处理逻辑错误（如前端渲染异常、后端计算偏差），JSON去空值的方法是开发中的必备技能，本文将介绍不同场景下去除JSON空值的实用方法，并附具体代码示例。

明确“空值”的定义：哪些值需要被去掉？

在去空值前,需先明确“空值”的范围，根据业务需求，常见的空值包括：

• null：JavaScript中的空值类型；
• 空字符串；
• []：空数组；
• 空对象；
• undefined：未定义值（通常出现在JSON解析不彻底的场景）。

注意：部分场景可能需要保留特定空值（如空字符串可能表示“未填写”），需结合业务逻辑判断。

JavaScript：前端去空值的常用方法

JavaScript是处理JSON最常用的语言,无论是前端直接操作还是Node.js后端处理，都有多种去空值的方式。

方法1：递归遍历 + 对象/数组重建（通用方案）

通过递归遍历JSON对象的每个属性,跳过空值，重新构建一个不含空值的新对象，这种方法可以处理嵌套层级较深的JSON数据。

function removeEmptyValues(obj) {
  // 处理非对象类型（如字符串、数字、布尔值等，直接返回）
  if (obj === null || typeof obj !== 'object') {
    return obj;
  }
  // 处理数组：遍历元素，过滤掉空值元素，重建数组
  if (Array.isArray(obj)) {
    return obj
      .map(item => removeEmptyValues(item)) // 递归处理每个元素
      .filter(item => item !== null && item !== undefined && item !== '' && 
              !(Array.isArray(item) && item.length === 0) && 
              !(typeof item === 'object' && Object.keys(item).length === 0));
  }
  // 处理对象：遍历属性，跳过空值属性，重建对象
  const result = {};
  for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
      const value = removeEmptyValues(obj[key]); // 递归处理属性值
      // 检查处理后是否为非空值
      if (value !== null && value !== undefined && value !== '' && 
          !(Array.isArray(value) && value.length === 0) && 
          !(typeof value === 'object' && Object.keys(value).length === 0)) {
        result[key] = value;
      }
    }
  }
  return result;
}
// 示例使用
const jsonData = {
  name: "张三",
  age: null,
  address: {
    city: "北京",
    district: "",
    details: {}
  },
  hobbies: [],
  score: undefined,
  info: { valid: "数据" }
};
const cleanedData = removeEmptyValues(jsonData);
console.log(cleanedData);
// 输出：{ name: '张三', address: { city: '北京' }, info: { valid: '数据' } }

方法2：使用JSON.parse + JSON.stringify + 正则（简单场景，仅适用于扁平JSON）

对于扁平层级（无嵌套）的JSON，可通过序列化为字符串后用正则替换空值，再解析回对象。注意：此方法无法处理嵌套对象和数组中的空值。

function removeEmptyValuesFlat(jsonStr) {
  // 先替换undefined（JSON.stringify会忽略undefined，但需处理原始数据中的undefined）
  let processedStr = JSON.stringify(jsonStr, (key, value) => 
    value === undefined ? null : value
  );
  // 用正则替换null、空字符串、空数组、空对象
  processedStr = processedStr.replace(/"?\s*(null|"{}"|"[]")\s*"?/g, '');
  return JSON.parse(processedStr);
}
// 示例使用
const flatJsonData = {
  name: "李四",
  age: null,
  email: "",
  tags: [],
  gender: "男"
};
const cleanedFlatData = removeEmptyValuesFlat(JSON.stringify(flatJsonData));
console.log(cleanedFlatData);
// 输出：{ name: '李四', gender: '男' }

方法3：使用第三方库（如lodash，高效便捷）

lodash是JavaScript工具库，提供了_.omitBy和_.isEmpty方法，可快速过滤空值。

const _ = require('lodash');
function removeEmptyValuesLodash(obj) {
  return _.omitBy(obj, _.isEmpty);
}
// 示例使用
const jsonData = {
  name: "王五",
  age: null,
  address: { city: "上海", district: "" },
  hobbies: [],
  valid: { data: 123 }
};
const cleanedData = removeEmptyValuesLodash(jsonData);
console.log(cleanedData);
// 输出：{ name: '王五', address: { city: '上海' }, valid: { data: 123 } }

说明：_.isEmpty会判断null、undefined、、[]、为空值，_.omitBy会移除这些值对应的属性，适合快速处理，但需引入第三方库。

Python：后端去空值的常用方法

Python处理JSON数据时,常用json模块解析，结合字典操作或递归函数去空值。

方法1：递归遍历字典重建（通用方案）

与JavaScript类似,通过递归遍历字典，跳过空值，重建新字典。

import json
def remove_empty_values(obj):
    if obj is None:
        return None
    if isinstance(obj, dict):
        return {k: remove_empty_values(v) for k, v in obj.items() 
                if remove_empty_values(v) not in (None, "", [], {})}
    elif isinstance(obj, list):
        return [remove_empty_values(item) for item in obj 
                if remove_empty_values(item) not in (None, "", [], {})]
    else:
        return obj
# 示例使用
json_data = {
    "name": "赵六",
    "age": None,
    "address": {
        "city": "广州",
        "district": "",
        "details": {}
    },
    "hobbies": [],
    "score": "100"
}
cleaned_data = remove_empty_values(json_data)
print(json.dumps(cleaned_data, ensure_ascii=False))
# 输出：{"name": "赵六", "address": {"city": "广州"}, "score": "100"}

方法2：使用json模块 + 数据清洗（适合结构化JSON）

对于已解析为字典的JSON数据,可通过字典推导式或循环过滤空值。

def remove_empty_values_simple(data):
    if isinstance(data, dict):
        return {k: v for k, v in data.items() 
                if v not in (None, "", [], {}) and not (isinstance(v, (dict, list)) and not v)}
    elif isinstance(data, list):
        return [item for item in data 
                if item not in (None, "", [], {}) and not (isinstance(item, (dict, list)) and not item)]
    else:
        return data
# 示例使用
json_data = {
    "id": 1,
    "desc": None,
    "tags": [],
    "meta": {"version": "1.0", "empty": {}}
}
cleaned_data = remove_empty_values_simple(json_data)
print(cleaned_data)
# 输出：{'id': 1, 'meta': {'version': '1.0'}}

方法3：使用pandas（适合批量JSON数据处理）

若JSON数据量较大（如从文件读取的批量数据），可用pandas的dropna方法处理。

import pandas as pd
import json
# 示例：JSON数组（列表嵌套字典）
json_array = [
    {"name": "A", "value": None},
    {"name": "B", "value": 0},
    {"name": "", "value": []},
    {"name": "C", "value": "data"}
]
# 转为DataFrame
df = pd.DataFrame(json_array)
# 删除全为空值的列（如"value"为null的行），或过滤空值行
df_cleaned = df.replace({"": None, "[]": None, "{}": None}).dropna()
# 转回JSON列表
cleaned_json = df_cleaned.to_dict(orient='records')
print(json.dumps(cleaned_json, ensure_ascii=False))
# 输出：