ฉันมีสองอาร์เรย์ อาร์เรย์แรกมีค่าบางค่าในขณะที่อาร์เรย์ที่สองมีดัชนีของค่าที่ควรลบออกจากอาร์เรย์แรก ตัวอย่างเช่น:

var valuesArr = new Array("v1","v2","v3","v4","v5");   
var removeValFromIndex = new Array(0,2,4);

ฉันต้องการที่จะลบค่าในปัจจุบันที่ดัชนีจาก0,2,4 valuesArrฉันคิดว่าspliceวิธีดั้งเดิมอาจช่วยได้ดังนั้นฉันจึงคิด:

$.each(removeValFromIndex,function(index,value){
    valuesArr.splice(value,1);
});

แต่ไม่ได้ผลเพราะหลังจากspliceนั้นดัชนีของค่าในแต่ละค่าvaluesArrจะแตกต่างกัน ฉันสามารถแก้ปัญหานี้ได้โดยใช้อาร์เรย์ชั่วคราวและคัดลอกค่าทั้งหมดไปยังอาร์เรย์ที่สอง แต่ฉันสงสัยว่ามีวิธีดั้งเดิมใดบ้างที่เราสามารถส่งผ่านหลายดัชนีเพื่อลบค่าออกจากอาร์เรย์ได้

ฉันต้องการโซลูชัน jQuery (ไม่แน่ใจว่าใช้grepที่นี่ได้ไหม)

มักจะมีforลูปเก่า ๆ อยู่เสมอ:

var valuesArr = ["v1","v2","v3","v4","v5"],
    removeValFromIndex = [0,2,4];    

for (var i = removeValFromIndex.length -1; i >= 0; i--)
   valuesArr.splice(removeValFromIndex[i],1);

ผ่านไปremoveValFromIndexในลำดับที่กลับและคุณก็สามารถ.splice()โดยไม่ต้อง messing up ดัชนีของรายการที่ยังเพื่อจะออก

หมายเหตุข้างต้นฉันใช้ไวยากรณ์อาร์เรย์ - ตัวอักษรกับวงเล็บเหลี่ยมเพื่อประกาศอาร์เรย์ทั้งสอง นี่เป็นไวยากรณ์ที่แนะนำเนื่องจากการnew Array()ใช้งานอาจทำให้เกิดความสับสนเนื่องจากตอบสนองแตกต่างกันไปขึ้นอยู่กับจำนวนพารามิเตอร์ที่คุณส่งผ่าน

แก้ไข : เพิ่งเห็นความคิดเห็นของคุณเกี่ยวกับคำตอบอื่นเกี่ยวกับอาร์เรย์ของดัชนีที่ไม่จำเป็นต้องอยู่ในลำดับใด ๆ หากเป็นเช่นนั้นให้เรียงลำดับจากมากไปหาน้อยก่อนที่คุณจะเริ่ม:

removeValFromIndex.sort(function(a,b){ return b - a; });

และทำตามนั้นด้วย$.each()วิธีการวนซ้ำ / / ฯลฯ ที่คุณต้องการ

นี่คือสิ่งที่ฉันใช้เมื่อไม่ได้ใช้ lodash / ขีดล่าง:

while(IndexesToBeRemoved.length) {
    elements.splice(IndexesToBeRemoved.pop(), 1);
}

ไม่in-placeสามารถทำได้โดยใช้grepและinArrayฟังก์ชั่นของjQuery.

var arr = $.grep(valuesArr, function(n, i) {
    return $.inArray(i, removeValFromIndex) ==-1;
});

alert(arr);//arr contains V2, V4

ตรวจสอบนี้ซอ

ฉันขอแนะนำให้คุณใช้Array.prototype.filter

var valuesArr = ["v1","v2","v3","v4","v5"];
var removeValFrom = [0, 2, 4];
valuesArr = valuesArr.filter(function(value, index) {
     return removeValFrom.indexOf(index) == -1;
})

function filtermethod(element, index, array) {  
    return removeValFromIndex.find(index)
}  
var result = valuesArr.filter(filtermethod);

ข้อมูลอ้างอิง MDN อยู่ที่นี่

ใน JS บริสุทธิ์คุณสามารถวนรอบอาร์เรย์ไปข้างหลังได้ดังนั้นsplice()จะไม่ทำให้ดัชนีขององค์ประกอบถัดไปในลูปสับสน:

for (var i = arr.length - 1; i >= 0; i--) {
    if ( yuck(arr[i]) ) {
        arr.splice(i, 1);
    }
}

รู้สึกว่าจำเป็นต้องโพสต์คำตอบตามO(n)เวลา :) ปัญหาเกี่ยวกับโซลูชันการต่อสายคือเนื่องจากการใช้อาร์เรย์พื้นฐานเป็นอาร์เรย์อย่างแท้จริงการspliceเรียกแต่ละครั้งจะใช้O(n)เวลา สิ่งนี้จะเด่นชัดที่สุดเมื่อเราตั้งค่าตัวอย่างเพื่อใช้ประโยชน์จากพฤติกรรมนี้:

var n = 100
var xs = []
for(var i=0; i<n;i++)
  xs.push(i)
var is = []
for(var i=n/2-1; i>=0;i--)
  is.push(i)

สิ่งนี้จะลบองค์ประกอบที่เริ่มต้นจากตรงกลางไปยังจุดเริ่มต้นดังนั้นการลบแต่ละครั้งจะบังคับให้เอ็นจิน js คัดลอกn/2องค์ประกอบเราจึงมีการ(n/2)^2คัดลอกทั้งหมดซึ่งเป็นกำลังสอง

โซลูชันการต่อสาย (สมมติว่าisได้รับการจัดเรียงตามลำดับที่ลดลงเพื่อกำจัดค่าโสหุ้ย) จะเป็นดังนี้:

for(var i=0; i<is.length; i++)
  xs.splice(is[i], 1)

อย่างไรก็ตามการใช้โซลูชันเวลาเชิงเส้นไม่ใช่เรื่องยากโดยการสร้างอาร์เรย์ใหม่ตั้งแต่ต้นโดยใช้มาสก์เพื่อดูว่าเราคัดลอกองค์ประกอบหรือไม่ (การเรียงลำดับจะผลักดันให้เป็นO(n)log(n)) ต่อไปนี้เป็นการนำไปใช้งานดังกล่าว (ไม่ใช่ที่maskบูลีนกลับด้านเพื่อความเร็ว):

var mask = new Array(xs.length)
for(var i=is.length - 1; i>=0; i--)
  mask[is[i]] = true
var offset = 0
for(var i=0; i<xs.length; i++){
  if(mask[i] === undefined){
    xs[offset] = xs[i]
    offset++
  }
}
xs.length = offset

ฉันรันสิ่งนี้บนjsperf.comและแม้กระทั่งn=100วิธีการต่อสายก็ช้ากว่า 90% สำหรับขนาดใหญ่nแตกต่างนี้จะมีมากขึ้น

Quick ES6 หนึ่งซับ:

const valuesArr = new Array("v1","v2","v3","v4","v5");   
const removeValFromIndex = new Array(0,2,4);

const arrayWithValuesRemoved = valuesArr.filter((value, i) => removeValFromIndex.includes(i))

โซลูชันที่เรียบง่ายและมีประสิทธิภาพ (ความซับซ้อนเชิงเส้น) โดยใช้ตัวกรองและชุด :

const valuesArr = ['v1', 'v2', 'v3', 'v4', 'v5'];   
const removeValFromIndex = [0, 2, 4];

const indexSet = new Set(removeValFromIndex);

const arrayWithValuesRemoved = valuesArr.filter((value, i) => !indexSet.has(i));

console.log(arrayWithValuesRemoved);

ข้อดีอย่างมากของการใช้งานนั้นคือการดำเนินการค้นหาชุด ( hasฟังก์ชัน) ใช้เวลาคงที่เร็วกว่าคำตอบของ nevace เป็นต้น

สิ่งนี้ใช้ได้ดีสำหรับฉันและใช้ได้ผลเมื่อลบออกจากอาร์เรย์ของวัตถุด้วย:

var array = [ 
    { id: 1, name: 'bob', faveColor: 'blue' }, 
    { id: 2, name: 'jane', faveColor: 'red' }, 
    { id: 3, name: 'sam', faveColor: 'blue' }
];

// remove people that like blue

array.filter(x => x.faveColor === 'blue').forEach(x => array.splice(array.indexOf(x), 1));

อาจมีวิธีที่สั้นกว่านี้ในการเขียนสิ่งนี้ แต่ได้ผล

วิธีง่ายๆโดยใช้ ES5 สิ่งนี้ดูเหมือนจะเหมาะสมกว่าสำหรับแอปพลิเคชันส่วนใหญ่ในปัจจุบันเนื่องจากหลายคนไม่ต้องการพึ่งพา jQuery เป็นต้นอีกต่อไป

เมื่อดัชนีที่จะลบออกจะเรียงลำดับจากน้อยไปมาก:

var valuesArr = ["v1", "v2", "v3", "v4", "v5"];   
var removeValFromIndex = [0, 2, 4]; // ascending

removeValFromIndex.reverse().forEach(function(index) {
  valuesArr.splice(index, 1);
});

เมื่อดัชนีที่จะลบไม่ได้เรียงลำดับ:

var valuesArr = ["v1", "v2", "v3", "v4", "v5"];   
var removeValFromIndex = [2, 4, 0];  // unsorted

removeValFromIndex.sort(function(a, b) { return b - a; }).forEach(function(index) {
  valuesArr.splice(index, 1);
});

คุณสามารถแก้ไขโค้ดของคุณโดยการแทนที่ด้วยremoveValFromIndex removeValFromIndex.reverse()หากไม่รับประกันว่าอาร์เรย์นั้นจะใช้ลำดับจากน้อยไปหามากคุณสามารถใช้แทนremoveValFromIndex.sort(function(a, b) { return b - a })ได้

นี่เป็นความเป็นไปได้อย่างหนึ่ง:

valuesArr = removeValFromIndex.reduceRight(function (arr, it) {
    arr.splice(it, 1);
    return arr;
}, valuesArr.sort(function (a, b) { return b - a }));

ตัวอย่างบน jsFiddle

MDN บน Array.prototype.reduceRight

หากคุณใช้underscore.jsคุณสามารถใช้_.filter()เพื่อแก้ปัญหาของคุณ

var valuesArr = new Array("v1","v2","v3","v4","v5");
var removeValFromIndex = new Array(0,2,4);
var filteredArr = _.filter(valuesArr, function(item, index){
                  return !_.contains(removeValFromIndex, index);
                });

นอกจากนี้หากคุณกำลังพยายามลบรายการโดยใช้รายการแทนดัชนีคุณสามารถใช้_.without()ดังนี้:

var valuesArr = new Array("v1","v2","v3","v4","v5");
var filteredArr = _.without(valuesArr, "V1", "V3");

ตอนนี้filteredArrควรจะเป็น["V2", "V4", "V5"]

ตัวกรอง + indexOf (IE9 +):

function removeMany(array, indexes) {
  return array.filter(function(_, idx) {
    return indexes.indexOf(idx) === -1;
  });
}); 

หรือด้วยตัวกรอง ES6 + ค้นหา (Edge +):

function removeMany(array, indexes = []) {
  return array.filter((_, idx) => indexes.indexOf(idx) === -1)
}

กุ๊กกิ๊กนี่แหละ

function removeFromArray(arr, toRemove){
    return arr.filter(item => toRemove.indexOf(item) === -1)
}

const arr1 = [1, 2, 3, 4, 5, 6, 7]
const arr2 = removeFromArray(arr1, [2, 4, 6]) // [1,3,5,7]

ดูเหมือนว่าสมัครอาจเป็นสิ่งที่คุณกำลังมองหา
บางทีสิ่งนี้จะได้ผล?

Array.prototype.splice.apply(valuesArray, removeValFromIndexes );

สำหรับหลายรายการหรือรายการที่ไม่ซ้ำกัน:

ฉันขอแนะนำให้คุณใช้Array.prototype.filter

อย่าใช้ indexOf ถ้าคุณรู้จักดัชนีแล้ว!:

var valuesArr = ["v1","v2","v3","v4","v5"];
var removeValFrom = [0, 2, 4];

valuesArr = valuesArr.filter(function(value, index) {
     return removeValFrom.indexOf(index) == -1;
}); // BIG O(N*m) where N is length of valuesArr and m is length removeValFrom

ทำ:

ด้วยแฮช ... โดยใช้Array.prototype.map

  var valuesArr = ["v1","v2","v3","v4","v5"];
  var removeValFrom = {};
  ([0, 2, 4]).map(x=>removeValFrom[x]=1); //bild the hash.
  valuesArr = valuesArr.filter(function(value, index) {
      return removeValFrom[index] == 1;
  }); // BIG O(N) where N is valuesArr;

var valuesArr = new Array("v1","v2","v3","v4","v5");   
var removeValFromIndex = new Array(0,2,4);

console.log(valuesArr)
let arr2 = [];

for (let i = 0; i < valuesArr.length; i++){
  if (    //could also just imput this below instead of index value
    valuesArr[i] !== valuesArr[0] && // "v1" <--
    valuesArr[i] !== valuesArr[2] && // "v3" <--
    valuesArr[i] !== valuesArr[4]    // "v5" <--
  ){
    arr2.push(valuesArr[i]);
  }
}

console.log(arr2);

นี้ได้ผล อย่างไรก็ตามคุณจะต้องสร้างอาร์เรย์ใหม่ในกระบวนการนี้ ไม่แน่ใจว่าคุณต้องการหรือไม่ แต่ในทางเทคนิคแล้วมันจะเป็นอาร์เรย์ที่มีเฉพาะค่าที่คุณต้องการ

คุณอาจจะลองและใช้delete array[index]นี้จะไม่สมบูรณ์ลบองค์ประกอบ undefinedแต่ตั้งค่าไป

คุณสามารถสร้างSetอาร์เรย์จากอาร์เรย์แล้วสร้างอาร์เรย์จากชุด

const array = [1, 1, 2, 3, 5, 5, 1];
const uniqueArray = [...new Set(array)];
console.log(uniqueArray); // Result: [1, 2, 3, 5]