在数组JS中更改许多字符串的资源密集程度较少

Question

我试图改变很多字符串，但还没有找到一种“好”的方式。 我想做的是根据不同的标准删除一些字符串。 确切：

1. 将'PD-111 S/A'更改为“ PD-111”＆lt;当字符串以'pd-
2. 'change'kl.otherstuff'开头的所有实例“ s/a”的所有实例为'klotherstuff'＆lt＆lt;删除所有“”实例。当字符串以“ kl”
3. 更改'BD5000-50'开头时，到'bd5000'＆lt;删除所有“ -50”的实例，当字符串以'bd'开头时，

我尝试了.startswith（）和.replace（），而没有任何运气和差异迭代器（例如.map）尝试创建一个函数以根据标准删除函数。

我最终做了一个foreach，但它的资源密集程度非常大（因为总的变化大约是4K字符串）。它有效，但真的很糟糕，我认为我是一个非常认真的菜鸟。

接下来，我将进行可重现的代码：

let firstArr = [{
    sku: 'PD-123-A S/A',
    stock: '0'
  },
  {
    sku: 'PD-123-B S/A',
    stock: '1'
  },
  {
    sku: 'PD-123-C S/A',
    stock: '1'
  }
]

let repl = {
  'PD-123-A S/A': 'PD-123-A',
  'PD-123-B S/A': 'PD-123-B',
  'PD-123-C S/A': 'PD-123-C',
}

firstArr.forEach(element => {
  let keys = Object.keys(repl);
  let values = Object.values(repl);
  for (let i = 0; i < keys.length; i++) {
    if (keys[i] === element.sku) {
      element.sku = values[i];
    }
  }
});
console.log(firstArr);

Answer 1

最可行的解决方案很可能是基于单个可重复使用的映射器函数，该函数获取Regex Lookup（字符串值的启动序列的键值对及其基于REGEX的替换模式）以 map 方法href =“ https://developer.mozilla.org/en-us/docs/web/javascript/reference/reference/global_obignts/array/array/map#parameters_in_in_detail” /a>。

映射功能是一般实现的，因此对任何项目属性不可知。它操作所有原始物品的 ，以仅仅是字符串类型值执行替换，并创建最初处理项目的浅副本。因此，原始数据结构不会被突变。

function createSanitizedEntriesFromBoundRegMap(item) {
  const regMap = this;

  return Object
    .fromEntries(
      Object
        .entries(item)
        .map(([key, value]) => [
          key,
          // target string values only.
          ('string' === typeof value)
            ? value.replace(
                regMap[value.slice(0, 3)] ??
                regMap[value.slice(0, 2)] ??
                '', ''
              )
            : value
        ])
    );
}

const sampleArray = [{
  asu: 'BD5000-50',
  sku: 'PD-123-A S/A',
  tvz: 'KL.OTHERSTUFF',
  stock: '0',
}, {
  tvz: 'KL.EVE.R.STUFF',
  sku: 'PD-123-B S/A',
  stock: '1',
}, {
  sku: 'PD-123-C S/A',
  asu: 'BD300-5000-5000',
  stock: '1',
}];

const resultArray = sampleArray
  .map(createSanitizedEntriesFromBoundRegMap, {
    // provide the regex lookup as `thisArg`.
    'PD-': /\s*S\/A\s*/g,
    KL: /\.+/g,
    BD: /-50/g,
  });

console.log({
  resultArray,
  sampleArray,
});

.as-console-wrapper { min-height: 100%!important; top: 0; }

以上实现的核心功能之一是基于查找的正则访问，该访问支持长度不同的键。下一个提供的测试代码演示了该解决方案的主要想法。

const regMap = {
  'PD-': /\s*S\/A\s*/g,
  KL: /\.+/g,
  BD: /-50/g,
};
const pdValue = 'PD-123-A S/A';
const klValue = 'KL.OTHERSTUFF';
const bdValue = 'BD5000-50';

console.log({
  regXSearch_pdTest:
    regMap[pdValue.slice(0, 3)] ?? regMap[pdValue.slice(0, 2)],
  regXSearch_klTest:
    regMap[klValue.slice(0, 3)] ?? regMap[klValue.slice(0, 2)],
  regXSearch_bdTest:
    regMap[bdValue.slice(0, 3)] ?? regMap[bdValue.slice(0, 2)],
  uncoveredSearch:
    regMap['uncovered'.slice(0, 3)] ?? regMap['uncovered'.slice(0, 2)] ?? '',
});

.as-console-wrapper { min-height: 100%!important; top: 0; }

但是，如果OP只想映射现有的简单结构，例如提供的一个仅具有两个已知/固定属性的结构，则可以将上述通用解决方案归结为更有效的效率（“少资源密集” 用op的话）映射器实现...

function createSanitizedItemFromBoundRegMap({ sku, stock }) {
  const regMap = this;
  return {
    sku: sku.replace(
      regMap[sku.slice(0, 3)] ??
      regMap[sku.slice(0, 2)] ??
      '', ''
    ),
    stock
  };
}

const sampleArray = [{
  sku: 'BD5000-50', stock: '0',
}, {
  sku: 'PD-123-A S/A', stock: '0',
}, {
  sku: 'KL.OTHERSTUFF', stock: '0',
}, {
  sku: 'KL.EVE.R.STUFF', stock: '1',
}, {
  sku: 'PD-123-B S/A', stock: '1',
}, {
  sku: 'PD-123-C S/A', stock: '1',
}, {
  sku: 'BD300-5000-5000', stock: '1',
}];

const resultArray = sampleArray
  .map(createSanitizedItemFromBoundRegMap, {
    'PD-': /\s*S\/A\s*/g,
    KL: /\.+/g,
    BD: /-50/g,
  });

console.log({
  resultArray,
  sampleArray,
});

const firstArr = [{
  sku: 'PD-123-A S/A', stock: '0'
}, {
  sku: 'PD-123-B S/A', stock: '1'
}, {
  sku: 'PD-123-C S/A', stock: '2'
}, {
  sku: 'PD-123-D', stock: '3'
}, {
  sku: 'BD111-50', stock: '0'
}, {
  sku: 'BD222-50', stock: '1'
}, {
  sku: 'BD333-50', stock: '2'
}, {
  sku: 'BD444', stock: '3'
}, {
  sku: 'KL.111', stock: '0'
}, {
  sku: 'KL.222', stock: '1'
}, {
  sku: 'KL.333', stock: '2'
}, {
  sku: 'KL444', stock: '3'
}];

console.log({
  resultArray: firstArr
    .map(createSanitizedItemFromBoundRegMap, {
      'PD-': /\s*S\/A\s*/g,
      KL: /\.+/g,
      BD: /-50/g,
    }),
  firstArr,
});

.as-console-wrapper { min-height: 100%!important; top: 0; }

Answer 2

我还不了解很多，但我没有尝试使用 .filter 和 .map 做类似的事情，试图走更多 .startswith（）。替换（），但我真的无法使其起作用。

在尝试重现我无法做的事情的同时，我实际上做到了。
我仍然会发布答案，也许希望有一种更好的方法可以做到这一点。

解决的

let firstArr = [{
    sku: 'PD-123-A S/A',
    stock: '0'
  },
  {
    sku: 'PD-123-B S/A',
    stock: '1'
  },
  {
    sku: 'PD-123-C S/A',
    stock: '2'
  },
  {
    sku: 'PD-123-D',
    stock: '3'
  },
  {
    sku: 'BD111-50',
    stock: '0'
  },
  {
    sku: 'BD222-50',
    stock: '1'
  },
  {
    sku: 'BD333-50',
    stock: '2'
  },
  {
    sku: 'BD444',
    stock: '3'
  },
  {
    sku: 'KL.111',
    stock: '0'
  },
  {
    sku: 'KL.222',
    stock: '1'
  },
  {
    sku: 'KL.333',
    stock: '2'
  },
  {
    sku: 'KL444',
    stock: '3'
  }
]

let b = firstArr.map(e => {
  if (e.sku.startsWith('PD-')) {
    return ({
      sku: e.sku.replace('S/A','').trim(),
      stock: e.stock
    })
  } if (e.sku.startsWith('BD')){
    return ({
      sku: e.sku.replace('-50','').trim(),
      stock: e.stock
    })
  } if (e.sku.startsWith('KL')) {
    return ({
      sku: e.sku.replace('.','').trim(),
      stock: e.stock
    })
  } 
})

console.log(b)