Javascript 如何将数组中的某些元素删除到新数组中，而将其他元素保留为原始数组？

如何编写一个函数，将某些元素删除到新数组中，并只保留原始数组中的其余元素

第一部分很容易使用for循环将偶数推送到一个新数组中，但很难改变原始数组以只留下奇数

function remove(arr, cb){

 var removed = [];
 var newArr = [];

 for(var i = 0; i < arr.length; i++) {

   if(cb(arr[i], i, arr)) {
     removed.push(arr[i]);

    } 

 }

 return removed;

} 

功能删除（arr、cb）{
移除的var=[]；
var newArr=[]；
对于（变量i=0；i

欢迎来到Stackoverflow

就我个人而言，我会避免任何改变输入参数的事情，因为这会增加代码的复杂性，并且很难从调用端推断发生了什么

相反，我将编写一个返回两个数组的数组的方法。在调用端，可以使用数组分解轻松地将其拆分为两个变量

请参见下面的示例：

const splitArr=（arr，pred）=>
arr.reduce(
（上一个、当前、idx）=>{
前置[+pred（当前、idx、arr）]。推送（当前）；
返回上一个；
}, [[], []]
);
//用法//
常量myArr=[1,2,3,4]；
常数[arr1，arr2]=splitArr（myArr，x=>x>2）；
控制台日志（arr1）；
控制台日志（arr2）欢迎来到Stackoverflow

就我个人而言，我会避免任何改变输入参数的事情，因为这会增加代码的复杂性，并且很难从调用端推断发生了什么

相反，我将编写一个返回两个数组的数组的方法。在调用端，可以使用数组分解轻松地将其拆分为两个变量

请参见下面的示例：


const splitArr=（arr，pred）=>
arr.reduce(
（上一个、当前、idx）=>{
前置[+pred（当前、idx、arr）]。推送（当前）；
返回上一个；
}, [[], []]
);
//用法//
常量myArr=[1,2,3,4]；
常数[arr1，arr2]=splitArr（myArr，x=>x>2）；
控制台日志（arr1）；
控制台日志（arr2）
使用
else
语句用应保留在原始
arr
中的值填充
newArr
，然后在将
newArr
中的项目复制回
newArr
之前将其清空

function remove (arr, cb) {
  var removed = [];
  var newArr = [];

  for (var i = 0; i < arr.length; i++) {
    if (cb(arr[i], i, arr)) {
      removed.push(arr[i]);
    } else {
      newArr.push(arr[i]);
    }
  }

  arr.splice(0);

  for (var i = 0; i < newArr.length; i++) {
    arr.push(newArr[i]);
  }

  return removed;
}

功能删除（arr、cb）{
移除的var=[]；
var newArr=[]；
对于（变量i=0；i
使用
else
语句用应保留在原始
arr
中的值填充
newArr
，然后在将
newArr
中的项目复制回
newArr
之前将其清空

function remove (arr, cb) {
  var removed = [];
  var newArr = [];

  for (var i = 0; i < arr.length; i++) {
    if (cb(arr[i], i, arr)) {
      removed.push(arr[i]);
    } else {
      newArr.push(arr[i]);
    }
  }

  arr.splice(0);

  for (var i = 0; i < newArr.length; i++) {
    arr.push(newArr[i]);
  }

  return removed;
}

功能删除（arr、cb）{
移除的var=[]；
var newArr=[]；
对于（变量i=0；i
在现代JavaScript应用程序中，我们不改变数组，而是创建新数组，这避免了副作用，所以我们要做的是创建两个新数组

const split = (source, conditionFunc) = [ source.filter(i => conditionFunc(i)), source.filter(i => !conditionFunc(i))];

然后你们有一个由两个数组组成的数组，其中一个是符合条件的，另一个是不符合条件的，并且你们并没有引起任何副作用

const odssAndEvens = split(source, i => i % 2 === 1);

或者使用reduce，这样就不会重复数组两次

const split = (source, conditionFunc) = source.reduce((results, item) => {
  if (conditionFunc(item)) {
    results[0].push(item);
  } else {
    results[1].push(item);
  }
  return results;
}, [[],[]]);

在现代JavaScript应用程序中，我们不改变数组，而是创建新数组，这避免了副作用，所以我们要做的是创建两个新数组

const split = (source, conditionFunc) = [ source.filter(i => conditionFunc(i)), source.filter(i => !conditionFunc(i))];

然后你们有一个由两个数组组成的数组，其中一个是符合条件的，另一个是不符合条件的，并且你们并没有引起任何副作用

const odssAndEvens = split(source, i => i % 2 === 1);

或者使用reduce，这样就不会重复数组两次

const split = (source, conditionFunc) = source.reduce((results, item) => {
  if (conditionFunc(item)) {
    results[0].push(item);
  } else {
    results[1].push(item);
  }
  return results;
}, [[],[]]);

您的解决方案确实走在了正确的轨道上，进行了一些调整，我们可以使其非常可读，也非常易于使用。我试着保持你所做的样子

我确实利用了这里的解构，它可以作为一个对象返回，然后引用属性

const myArr = [0,1,2,3,4,5,6,7,8,9,10];

const splitItems = (arr, logicFunc) => {
    let secondSet = []

    const firstSet = arr.filter(v => {
      if (logicFunc(v)) return true
      else secondSet.push(v)
    })

    return { firstSet, secondSet }
}

const myLogicFunc = v => (v < 3 || v == 9)
const { firstSet, secondSet } = splitItems(myArr, myLogicFunc)

console.log(`My first set: ${firstSet}`) // My first set: 0,1,2,9
console.log(`My second set: ${secondSet}`) // My second set: 3,4,5,6,7,8,10

/* OR without destructuring:
const myArrays = splitItems(myArr, myLogicFunc)

console.log(`My first set: ${myArrays.firstSet}`)
console.log(`My second set: ${myArrays.secondSet}`)
*/

const myArr=[0,1,2,3,4,5,6,7,8,9,10]；
常量拆分项=（arr，logicFunc）=>{
设secondSet=[]
const firstSet=arr.filter（v=>{
if（logicFunc（v））返回true
否则，第二次设置。按下（v）
})
返回{firstSet，secondSet}
}
常量myLogicFunc=v=>（v<3 | | v==9）
const{firstSet，secondSet}=splitItems（myArr，myLogicFunc）
log（`My first set:${firstSet}`）//我的第一个集合：0,1,2,9
log（`My second set:${secondSet}`）///My second set:3,4,5,6,7,8,10
/*或者不进行分解：
常量myArrays=splitItems（myArr、myLogicFunc）
log（`My first set:${myArrays.firstSet}`）
log（`mysecondset:${myArrays.secondSet}`）
*/

如果您有任何问题，请告诉我，您的解决方案肯定是正确的，经过一些调整，我们可以使其非常可读，也非常容易使用。我试着保持你所做的样子

我确实利用了这里的解构，它可以作为一个对象返回，然后引用属性

const myArr = [0,1,2,3,4,5,6,7,8,9,10];

const splitItems = (arr, logicFunc) => {
    let secondSet = []

    const firstSet = arr.filter(v => {
      if (logicFunc(v)) return true
      else secondSet.push(v)
    })

    return { firstSet, secondSet }
}

const myLogicFunc = v => (v < 3 || v == 9)
const { firstSet, secondSet } = splitItems(myArr, myLogicFunc)

console.log(`My first set: ${firstSet}`) // My first set: 0,1,2,9
console.log(`My second set: ${secondSet}`) // My second set: 3,4,5,6,7,8,10

/* OR without destructuring:
const myArrays = splitItems(myArr, myLogicFunc)

console.log(`My first set: ${myArrays.firstSet}`)
console.log(`My second set: ${myArrays.secondSet}`)
*/

const myArr=[0,1,2,3,4,5,6,7,8,9,10]；
常量拆分项=（arr，logicFunc）=>{
设secondSet=[]
const firstSet=arr.filter（v=>{
if（logicFunc（v））返回true
否则，第二次设置。按下（v）
})
返回{firstSet，secondSet}
}
常量myLogicFunc=v=>（v<3 | | v==9）
const{firstSet，secondSet}=splitItems（myArr，myLogicFunc）
log（`My first set:${firstSet}`）//我的第一个集合：0,1,2,9
log（`My second set:${secondSet}`）///My second set:3,4,5,6,7,8,10
/*或者不进行分解：
常量myArrays=splitItems（myArr、myLogicFunc）
log（`My first set:${myArrays.firstSet}`）
log（`mysecondset:${myArrays.secondSet}`）
*/

如果你有问题，请告诉我