最直接的方法是使用Array.prototype.map()结合对象重构。1. 对于固定键名转换，可直接在map中返回新对象，手动映射每个键值；2. 对于动态或大量键名转换，可定义keymapping表，遍历对象属性并根据映射表生成新键名；3. 处理嵌套对象时，可编写递归函数深度转换所有层级的键名，结合键名处理逻辑如下划线转驼峰；4. 性能方面，在大型数据集上应避免不必要的属性拷贝，只提取所需键以减少开销，确保操作不会成为性能瓶颈；JavaScript没有内置mapkeys方法，因其设计哲学倾向于提供基础工具让开发者灵活组合，而非封装特定功能，理解这一点有助于写出更高效、可维护的代码。
在JavaScript中，如果你想修改对象数组里每个对象的键名，最直接且常用的方法是利用
Array.prototype.map()
方法，结合对单个对象的重构。JavaScript原生并没有一个名为
mapKeys
的内置方法（这通常是像Lodash这类库提供的功能），但我们可以通过遍历并创建新对象的方式来达到相同的效果。
解决方案
核心思路是遍历数组中的每个对象，然后为每个对象创建一个新对象，在新对象中，我们将旧的键名映射到新的键名上。
假设我们有这样的数据：
const products = [ { product_id: 'P001', product_name: 'Laptop', price_usd: 1200, stock_quantity: 50 }, { product_id: 'P002', product_name: 'Mouse', price_usd: 25, stock_quantity: 200 }, { product_id: 'P003', product_name: 'Keyboard', price_usd: 75, stock_quantity: 100 } ];
我们希望将
product_id
改为
id
，
product_name
改为
name
，
price_usd
改为
price
，
stock_quantity
改为
stock
。
方法一：直接映射（适用于键名数量固定且已知）
这是最直观的方式，你明确知道要转换哪些键。
const transformedProducts = products.map(item => { return { id: item.product_id, name: item.product_name, price: item.price_usd, stock: item.stock_quantity // 如果还有其他不需要修改键名的属性，可以用展开运算符 (...item) 包含进来 // 但要注意，如果旧键名和新键名有重叠，展开运算符可能会覆盖你手动设置的新键名 // 例如：如果你想把 'oldKey' 改成 'newKey'，同时保留 'oldKey'，这会冲突 // 所以，通常建议手动列出所有需要的属性 }; }); console.log(transformedProducts); /* [ { id: 'P001', name: 'Laptop', price: 1200, stock: 50 }, { id: 'P002', name: 'Mouse', price: 25, stock: 200 }, { id: 'P003', name: 'Keyboard', price: 75, stock: 100 } ] */
方法二：使用键名映射表（适用于动态或大量键名转换）
当需要转换的键名较多，或者转换规则可以抽象成一个映射表时，这种方法更灵活。
const keyMapping = { product_id: 'id', product_name: 'name', price_usd: 'price', stock_quantity: 'stock' }; const transformedProductsDynamic = products.map(item => { const newItem = {}; for (const oldKey in item) { if (Object.prototype.hasOwnProperty.call(item, oldKey)) { // 确保是对象自身的属性 const newKey = keyMapping[oldKey] || oldKey; // 如果在映射表中找到新键名，就用新键名，否则保持不变 newItem[newKey] = item[oldKey]; } } return newItem; }); console.log(transformedProductsDynamic); /* [ { id: 'P001', name: 'Laptop', price: 1200, stock: 50 }, { id: 'P002', name: 'Mouse', price: 25, stock: 200 }, { id: 'P003', name: 'Keyboard', price: 75, stock: 100 } ] */
这种方法通过遍历原对象的键，根据
keyMapping
来决定新对象的键名，非常适合处理需要批量或条件性转换键名的场景。
为什么JavaScript没有内置的
mapKeys
mapKeys
方法？
其实，JavaScript本身并没有一个像Lodash库里那样直接的
mapKeys
方法，这确实让一些刚接触JS或习惯了其他语言/库的开发者感到疑惑。我个人觉得，这可能跟JavaScript对象设计的哲学有关。JS的对象本质上就是键值对的集合，键名是字符串（或symbol），访问和操作都非常直接。如果需要改变键名，通常意味着你要么是想创建一个新对象，要么是想在现有对象上做一些转换。
内置方法往往倾向于提供更基础、更通用的操作，比如数组的
map
、
、
reduce
，它们处理的是集合的“元素”本身，而不是元素内部的“结构”。对于对象内部的结构性改变，JS更倾向于提供
Object.keys()
、
Object.values()
、
Object.entries()
这些工具，让你自己组合它们来达到目的。比如，你想重命名键，实际上就是遍历键值对，然后用新键名重新构建一个对象。这听起来有点“手动”，但它赋予了开发者极大的灵活性，可以处理各种复杂的键名转换逻辑，而不仅仅是简单的映射。
这种设计哲学，在我看来，也促使开发者更深入地理解数据结构和转换的底层逻辑，而不是仅仅依赖一个黑箱函数。虽然Lodash的
mapKeys
用起来很方便，但它的实现原理也无非是遍历对象、创建新对象的过程。理解了这一点，即便没有
mapKeys
，我们也能用原生JS写出同样优雅甚至更定制化的解决方案。
处理复杂键名转换或嵌套对象时有哪些技巧？
当键名转换规则比较复杂，或者数据结构是嵌套对象时，问题就变得有趣起来了。我见过不少实际项目中，后端返回的数据结构可能不尽如人意，前端需要做大量适配。
一种常见场景是，键名需要根据某种模式来转换，比如把所有下划线命名的键 (
user_name
) 转换成驼峰命名 (
userName
)。这时候，你可能需要一个辅助函数来处理键名的转换逻辑：
function toCamelCase(str) { return str.replace(/_([a-z])/g, (g) => g[1].toUpperCase()); } // 假设我们有嵌套数据 const rawNestedData = [ { user_id: 1, user_name: 'Alice', profile_info: { email_address: 'alice@example.com', phone_number: '123-456-7890' }, order_details: [ { item_id: 'A1', quantity_num: 2 }, { item_id: 'B2', quantity_num: 1 } ] }, { user_id: 2, user_name: 'Bob', profile_info: { email_address: 'bob@example.com', phone_number: '987-654-3210' }, order_details: [] } ]; // 一个通用的递归函数来处理所有层级的键名转换 function transformKeysDeep(obj) { if (typeof obj !== 'object' || obj === null) { return obj; } if (Array.isArray(obj)) { return obj.map(item => transformKeysDeep(item)); } const newObj = {}; for (const oldKey in obj) { if (Object.prototype.hasOwnProperty.call(obj, oldKey)) { const newKey = toCamelCase(oldKey); newObj[newKey] = transformKeysDeep(obj[oldKey]); // 递归处理值 } } return newObj; } const transformedNestedData = rawNestedData.map(item => transformKeysDeep(item)); console.log(transformedNestedData); /* [ { userId: 1, userName: 'Alice', profileInfo: { emailAddress: 'alice@example.com', phoneNumber: '123-456-7890' }, orderDetails: [ { itemId: 'A1', quantityNum: 2 }, { itemId: 'B2', quantityNum: 1 } ] }, { userId: 2, userName: 'Bob', profileInfo: { emailAddress: 'bob@example.com', phoneNumber: '987-654-3210' }, orderDetails: [] } ] */
这段代码里，我特意加入了对嵌套对象和数组的递归处理。在实际应用中，如果嵌套层级很深或者结构更复杂，你需要一个更健壮的递归函数来深度遍历并转换所有键名。这有点像写一个定制化的深拷贝函数，只不过在拷贝的同时对键名做了处理。
我个人在处理这类问题时，会先分析数据结构的特点：是固定层级还是不固定？键名转换规则是简单的映射还是需要函数处理？然后选择最适合的方法。有时候，为了代码的可读性和可维护性，即便多写几行代码，也会比过度优化一个“万能”函数要好。
性能考量：在大型数据集上修改键名是否会成为瓶颈？
谈到性能，这确实是任何数据操作都绕不开的话题。在大型数据集上修改键名，本质上就是遍历数组中的每个对象，然后为每个对象创建一个新对象。这个过程涉及内存分配和属性拷贝。
从我的经验来看，对于绝大多数前端应用场景，比如处理几百到几千条数据，
map
加
reduce
或者直接的键名映射方式，性能瓶颈通常不会出现在这里。现代JavaScript引擎对这类操作已经做了大量优化。
但是，如果你正在处理数万、数十万甚至更多条数据，并且每个对象都有几十个键，那么这个操作的开销就会变得显著。这时候，你需要考虑：
- 是否真的需要所有键？ 如果你只需要转换其中几个键，而其他键完全不需要，那么在构建新对象时，只包含你需要的键，而不是
Object.keys().reduce
或者
...item
这种方式。这能减少不必要的拷贝。
- **是否可以分
