如何修改json对象的键

如何修改 JSON 对象的键：实用技巧与代码示例

在处理 JSON 数据时，我们经常需要修改对象的键名（key），这可能是因为需要符合特定的命名规范、适应不同的 API 要求，或者仅仅是为了提高代码的可读性，本文将介绍几种在 JavaScript 中修改 JSON 对象键的方法,并提供实用的代码示例。

直接修改键名的基本方法

使用对象解构和属性简写

对于简单的对象,可以使用对象解构和属性简写来重命名键：

const originalJson = {
  old_key1: 'value1',
  old_key2: 'value2',
  old_key3: 'value3'
};
const {
  old_key1: new_key1,
  old_key2: new_key2,
  old_key3: new_key3
} = originalJson;
const modifiedJson = {
  new_key1,
  new_key2,
  new_key3
};
console.log(modifiedJson);
// 输出: { new_key1: 'value1', new_key2: 'value2', new_key3: 'value3' }

使用 Object.keys() 和 reduce 方法

对于更动态的场景，可以使用 Object.keys() 结合 reduce 方法：

const originalJson = {
  name: 'John',
  age: 30,
  email: 'john@example.com'
};
const modifiedJson = Object.keys(originalJson).reduce((acc, key) => {
  // 将键转换为小写并添加前缀
  const newKey = `user_${key.toLowerCase()}`;
  acc[newKey] = originalJson[key];
  return acc;
}, {});
console.log(modifiedJson);
// 输出: { user_name: 'John', user_age: 30, user_email: 'john@example.com' }

处理嵌套 JSON 对象

当 JSON 对象包含嵌套结构时,我们需要递归地处理每个层级：

function renameKeys(obj, keyMap) {
  return Object.keys(obj).reduce((acc, key) => {
    const newKey = keyMap[key] || key;
    acc[newKey] = typeof obj[key] === 'object' && obj[key] !== null 
      ? renameKeys(obj[key], keyMap) 
      : obj[key];
    return acc;
  }, {});
}
const nestedJson = {
  user: {
    first_name: 'John',
    last_name: 'Doe',
    contact: {
      email: 'john@example.com',
      phone: '1234567890'
    }
  },
  status: 'active'
};
const keyMap = {
  first_name: 'firstName',
  last_name: 'lastName',
  email: 'emailAddress',
  phone: 'phoneNumber'
};
const renamedJson = renameKeys(nestedJson, keyMap);
console.log(renamedJson);
/*
输出:
{
  user: {
    firstName: 'John',
    lastName: 'Doe',
    contact: {
      emailAddress: 'john@example.com',
      phoneNumber: '1234567890'
    }
  },
  status: 'active'
}
*/

使用 Lodash 库简化操作

Lodash 提供了强大的工具函数来简化对象操作,包括键的重命名：

// 首先安装 lodash: npm install lodash
const _ = require('lodash');
const originalJson = {
  old_key1: 'value1',
  old_key2: 'value2',
  old_key3: 'value3'
};
const keyMap = {
  'old_key1': 'new_key1',
  'old_key2': 'new_key2',
  'old_key3': 'new_key3'
};
const renamedJson = _.mapKeys(originalJson, (value, key) => keyMap[key] || key);
console.log(renamedJson);
// 输出: { new_key1: 'value1', new_key2: 'value2', new_key3: 'value3' }

处理数组中的 JSON 对象

当 JSON 数据是一个对象数组时，我们可以使用 map 方法来处理每个元素：

const jsonArray = [
  { id: 1, product_name: 'Laptop', price: 999 },
  { id: 2, product_name: 'Phone', price: 699 },
  { id: 3, product_name: 'Tablet', price: 399 }
];
const renamedArray = jsonArray.map(item => ({
  itemId: item.id,
  productName: item.product_name,
  itemPrice: item.price
}));
console.log(renamedArray);
/*
输出:
[
  { itemId: 1, productName: 'Laptop', itemPrice: 999 },
  { itemId: 2, productName: 'Phone', itemPrice: 699 },
  { itemId: 3, productName: 'Tablet', itemPrice: 399 }
]
*/

动态键名转换（如大小写转换）

有时我们需要动态转换键名,例如将所有键转换为驼峰命名法：

function toCamelCase(str) {
  return str.replace(/_([a-z])/g, (g) => g[1].toUpperCase());
}
const snakeCaseJson = {
  user_id: 123,
  first_name: 'John',
  last_name: 'Doe',
  contact_info: {
    home_phone: '1234567890',
    work_email: 'john@work.com'
  }
};
const camelCaseJson = Object.keys(snakeCaseJson).reduce((acc, key) => {
  const newKey = toCamelCase(key);
  acc[newKey] = typeof snakeCaseJson[key] === 'object' && snakeCaseJson[key] !== null
    ? Object.keys(snakeCaseJson[key]).reduce((nestedAcc, nestedKey) => {
        const nestedNewKey = toCamelCase(nestedKey);
        nestedAcc[nestedNewKey] = snakeCaseJson[key][nestedKey];
        return nestedAcc;
      }, {})
    : snakeCaseJson[key];
  return acc;
}, {});
console.log(camelCaseJson);
/*
输出:
{
  userId: 123,
  firstName: 'John',
  lastName: 'Doe',
  contactInfo: {
    homePhone: '1234567890',
    workEmail: 'john@work.com'
  }
}
*/