Question

我有一个对象数组。每个对象都有很多键（超过100个），其中一些键可以具有我要删除的特殊字符。

我尝试以这种方式做我想做的事：

const result = data.map(datum => {
  const keys = Object.keys(datum)
  const replacedKeys = keys.map(key => {
    const newKey = key.replace(/[.|&;$%@%"<>+]/g, '')
  })
  // ??
})

但是我确信这不是正确的方法。

Answer 1

您可以使用新键映射新对象，并使用Object.assign创建单个对象。

const result = data.map(datum => Object.assign(...Object
    .keys(datum)
    .map(key => ({ [key.replace(/[.|&;$%@%"<>+]/g, '')]: datum[key] }))
));

Answer 2

使用已在FireFox中找到方法的ES8 Object.fromEntries方法，您可以执行以下操作：

Object.fromEntries = arr => Object.assign({}, ...arr.map( ([k, v]) => ({[k]: v}) ));

如果尚未实现，则为polyfill：

{{1}}

Answer 3

您可以使用JSON将纯JavaScript对象转换为JSON.stringify()并使用JSON匹配有效String.prototype.replace()的属性，然后使用{转换回纯JavaScript对象{1}}。

从字符类中删除的JSON.parse()作为有效的"属性用双引号JSON包围。

"

RegExp

创建一个包含字符类的捕获组，并与字符类匹配，后跟一个或多个不在字符类中的字符，然后用属性名([.|&;$%@%<>+]+)(?=([^\1]+|)":)的双引号引起来，然后用冒号或双引号引起来冒号字符。

匹配的字符类可以用空字符串"或任何其他字符替换。

''

Answer 4

请考虑使用Array#reduce()来汇总输入对象的键的值。这样做的原因是，对键进行清理（即从键中删除不需要的字符）可能会导致输入对象的不同键/值对“减少”，因此经过清理的键实际上与多个值相关。例如输入对象，例如：

const data = {
  'key' : 'value0',
  'key&&&' : 'value1',
  'key$%<>' : 'value2'
}

（根据您的卫生状况）将产生一个输出对象，其中包含与多个值相关的单个key：

const data = {
  'key' : 'value0', // what about value1, value2 ?
}

要解决此问题，您可以考虑使用常见的经过清理的键将值汇总到数组中，如下所示：

const data = {
  'key' : 'value0',
  'key&&&' : 'value1',
  'key$%<>' : 'value2',
  'foo' : 'value3'
}

const result = Object.entries(data).reduce((obj, [ key, value ]) => {
  
  const sanitizedKey = key.replace(/[.|&;$%@%"<>+]/g, '');
  const objValue = obj[ sanitizedKey ]
  
  /* 
  Account for conflicting keys after santizing by grouping
  values in a nested array
  */
  if(objValue) {
    obj[ sanitizedKey ] = [value].concat(objValue)
  }
  else {
    obj[ sanitizedKey ] = value
  }
  
  return obj;
  
}, {});

console.log(result)

Answer 5

此解决方案依赖于String.prototype.replace()，因此它可以使用String或RegExp作为源，并可以进行替换。请记住，它的性能不是很高，但是仅使用纯函数：

const data = {
  someKey:   1,
  some0Key:  1,
  some1Key:  1,
  some2Key:  1,
  some3Key:  1,
  some4Key:  1,
  some5Key:  1,
  some6Key:  1,
  some7Key:  1,
  some8Key:  1,
  some9Key:  1,
  some10Key: 1,
  some11Key: 1,
  some12Key: 1,
  some13Key: 1,
  some14Key: 1,
  some15Key: 1,
};

// simple equivalent of proposed Object.fromEntries()
const fromEntries = (entries) =>
      entries.reduce((obj, [key, value]) => ({
        [key]: value,
        ...obj
      }), {});

const replaceObjectKeys = (obj, from, to) =>
      fromEntries(
        Object.entries(obj)
          .map(([key, value]) => [key.replace(from, to), value]));

console.log(replaceObjectKeys(data, /Key$/, 'prop'));

fromEntries可以很容易地重写为更快的实现，而无需引入可变变量。

Answer 6

要扩展@Nina的答案，以下是完整的表示形式：

data = [
  {someKey:   1},
  {some0Key:  1},
  {some1Key:  1,
    some2Key:  1},
  {some3Key:  1,
    some4Key:  1,
    some5Key:  1,
    some6Key:  1,
    some7Key:  1,
    some8Key:  1,
    some9Key:  1,
    some10Key: 1,
  },
  {some11Key: 1,
    some12Key: 1,
    some13Key: 1,
    some14Key: 1,
    some15Key: 1,}
];
result = data.map(datum => Object.assign(...Object
    .keys(datum)
    .map(key => ({ [key.replace(/some/g, 'bum')]: datum[key] }))
));

结果：

result === [
  {bumKey:   1},
  {bum0Key:  1},
  {bum1Key:  1,
    bum2Key:  1},
  {bum3Key:  1,
    bum4Key:  1,
    bum5Key:  1,
    bum6Key:  1,
    bum7Key:  1,
    bum8Key:  1,
    bum9Key:  1,
    bum10Key: 1,
  },
  {bum11Key: 1,
    bum12Key: 1,
    bum13Key: 1,
    bum14Key: 1,
    bum15Key: 1,}
];

使用正则表达式重命名对象数组的键

6 个答案: