it-swarm-eu.dev

Jak odstraním určitý prvek z pole v JavaScriptu?

Mám řadu čísel a používám metodu .Push(), abych k ní přidala prvky.

Existuje jednoduchý způsob, jak odstranit určitý prvek z pole? Ekvivalent něčeho jako array.remove(number);.

Musím použít core JavaScript - no frameworks jsou povoleny.

6816
Walker

Najděte index elementu pole, který chcete odstranit, a tento index odeberte pomocí splice .

Metoda splice () mění obsah pole odstraněním existujících prvků A/nebo přidáním nových prvků.

var array = [2, 5, 9];
console.log(array)
var index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}
// array = [2, 9]
console.log(array);

Druhým parametrem splice je počet prvků, které mají být odstraněny. Všimněte si, že splice modifikuje pole na místě a vrací nové pole obsahující prvky, které byly odstraněny.

9908
Tom Wadley

Nevím, jak se očekává, že se array.remove(int) bude chovat. Existují tři možnosti, na které si myslím, že byste chtěli.

Odebrání prvku pole v indexu i:

array.splice(i, 1);

Chcete-li z pole odebrat každý prvek s hodnotou number:

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

Pokud chcete, aby prvek již nebyl v indexu i již existován, ale nechcete, aby se indexy ostatních prvků změnily:

delete array[i];
1011
Peter Olson

Upraveno v říjnu 2016

  • Udělejte to jednoduše, intuitivně a explicitně ( https://en.wikipedia.org/wiki/Occam%27s_razor )
  • Udělej to neměnný (původní pole zůstane nezměněno)
  • Udělejte to se standardními JS funkcemi, pokud je Váš prohlížeč nepodporuje - použití polyfill

V tomto příkladu kódu používám funkci "array.filter (...)" k odstranění nežádoucích položek z pole, tato funkce nezmění původní pole a vytvoří novou. Pokud váš prohlížeč tuto funkci nepodporuje (např. IE před verzí 9 nebo Firefox před verzí 1.5), zvažte použití filtru polyfill z Mozilly .

Odstranění položky (ECMA-262 Edition 5 code aka oldstyle JS)

var value = 3

var arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(function(item) { 
    return item !== value
})

console.log(arr)
// [ 1, 2, 4, 5 ]

Odstranění položky (kód ES2015)

let value = 3

let arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(item => item !== value)

console.log(arr)
// [ 1, 2, 4, 5 ]

IMPORTANT ES2015 "() => {}" syntaxe funkce šipky není v IE vůbec podporována, Chrome před verzí 45, Firefox před verzí 22, Safari před verzí 10. Pro použití syntaxe ES2015 ve starých prohlížečích můžete použít BabelJS


Odstranění více položek (kód ES2016)

Další výhodou této metody je, že můžete odebrat více položek

let forDeletion = [2, 3, 5]

let arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(item => !forDeletion.includes(item))
// !!! Read below about array.includes(...) support !!!

console.log(arr)
// [ 1, 4 ]

IMPORTANT Funkce "array.includes (...)" není podporována v IE vůbec, Chrome před 47 verzemi, Firefox před 43 verzemi, Safari před verzí 9 a Edge před 14 verzemi, takže zde je polyfill z Mozilly

Odebrání více položek (experimentální JavaScript ES2018?)

// array-lib.js

export function remove(...forDeletion) {
    return this.filter(item => !forDeletion.includes(item))
}

// main.js

import { remove } from './array-lib.js'

let arr = [1, 2, 3, 4, 5, 3]

// :: This-Binding Syntax Proposal
// using "remove" function as "virtual method"
// without extending Array.prototype
arr = arr::remove(2, 3, 5)

console.log(arr)
// [ 1, 4 ]

Vyzkoušejte sami v BabelJS :)

Odkaz

831
Ujeenator

Záleží na tom, zda chcete ponechat prázdné místo nebo ne.

Pokud chcete prázdný slot, smazat je v pořádku:

delete array[ index ];

Pokud ne, měli byste použít metodu splice :

array.splice( index, 1 );

Pokud potřebujete hodnotu této položky, můžete jednoduše uložit prvek vráceného pole:

var value = array.splice( index, 1 )[0];

V případě, že to chcete provést v nějakém pořadí, můžete použít array.pop() pro poslední nebo array.shift() pro první (a oba vrátit hodnotu položky také).

A pokud neznáte index položky, můžete použít array.indexOf( item ) k jejímu získání (v if() k získání jedné položky nebo v while() k získání všech z nich). array.indexOf( item ) vrací buď index nebo -1, pokud nebyl nalezen.

383
xavierm02

Přítel měl problémy s aplikací Internet Explorer 8 a ukázal mi, co udělal. Řekl jsem mu, že je to špatně, a on mi řekl, že tu dostal odpověď. Aktuální odpověď nebude fungovat ve všech prohlížečích (například Internet Explorer 8) a odstraní pouze první výskyt položky.

Odebrat VŠECHNY instance z pole

function remove(arr, item) {
    for (var i = arr.length; i--;) {
        if (arr[i] === item) {
            arr.splice(i, 1);
        }
    }
}

Prochází přes pole zpět (protože indexy a délka se změní s odstraněnými položkami) a odstraní položku, pokud je nalezena. Funguje ve všech prohlížečích.

251
Ben Lesh

Existují dva hlavní přístupy:

  1. splice (): anArray.splice(index, 1);

  2. delete: delete anArray[index];

Buďte opatrní, když používáte mazání pro pole. To je dobré pro mazání atributů objektů, ale ne tak dobré pro pole. Je lepší použít splice pro pole.

Mějte na paměti, že při použití delete pro pole můžete dostat špatné výsledky pro anArray.length. Jinými slovy, delete by tento prvek odstranil, ale nehodnotil by hodnotu vlastnosti length.

Můžete také očekávat, že po použití smazat, např. můžete skončit s indexy 1,3,4,8,9,11 a délkou, jak tomu bylo před použitím mazání. V tomto případě by všechny indexované smyčky for selhaly, protože indexy již nejsou sekvenční.

Pokud jste z nějakého důvodu nuceni použít delete, měli byste použít smyčky for each loops, pokud potřebujete smyčku přes pole. Pokud je to možné, vždy se vyhněte použití indexovaných smyček. Tak by byl kód robustnější a méně náchylný k problémům s indexy.

142
Sasa
Array.prototype.remByVal = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}
//Call like
[1, 2, 3, 4].remByVal(3);

Array.prototype.remByVal = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}

var rooms = ['hello', 'something']

rooms = rooms.remByVal('hello')

console.log(rooms)

118
Zirak

Není třeba používat indexOf nebo splice. Je však lepší, pokud chcete odstranit pouze jeden výskyt prvku. 

Najít a přesunout (přesunout):

function move(arr, val) {
  var j = 0;
  for (var i = 0, l = arr.length; i < l; i++) {
    if (arr[i] !== val) {
      arr[j++] = arr[i];
    }
  }
  arr.length = j;
}

Použít indexOf a splice (indexof):

function indexof(arr, val) {
  var i;
  while ((i = arr.indexOf(val)) != -1) {
    arr.splice(i, 1);
  }
}

Použít pouze splice (splice):

function splice(arr, val) {
  for (var i = arr.length; i--;) {
    if (arr[i] === val) {
      arr.splice(i, 1);
    }
  }
}

Běh na nodejs pro pole s 1000 prvky (průměrně přes 10000 běhů):

indexof je přibližně o 10x pomalejší než move. I když je vylepšeno odstraněním volání indexOf v splice, je mnohem horší než move

Remove all occurrences:
    move 0.0048 ms
    indexof 0.0463 ms
    splice 0.0359 ms

Remove first occurrence:
    move_one 0.0041 ms
    indexof_one 0.0021 ms
87
slosd

Příliš starý na odpověď, ale může to někomu pomoci tím, že místo hodnoty poskytne predikát.

POZNÁMKA: bude aktualizovat dané pole a vrátí postižené řádky

Používání

var removed = helper.removeOne(arr, row => row.id === 5 );

var removed = helper.remove(arr, row => row.name.startsWith('BMW'));

Definice

var helper = {

    // Remove and return the first occurrence     

    removeOne: function(array, predicate) {
        for (var i = 0; i < array.length; i++) {
            if (predicate(array[i])) {
                return array.splice(i, 1);
            }
        }
    },

    // Remove and return all occurrences  

    remove: function(array, predicate) {
        var removed = [];

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

            if (predicate(array[i])) {
                removed.Push(array.splice(i, 1));
                continue;
            }

            i++;                
        }

        return removed;
    }
};
59
amd

John Resig zveřejnil dobrou implementaci :

// Array Remove - By John Resig (MIT Licensed)
Array.prototype.remove = function(from, to) {
  var rest = this.slice((to || from) + 1 || this.length);
  this.length = from < 0 ? this.length + from : from;
  return this.Push.apply(this, rest);
};

Pokud nechcete rozšířit globální objekt, můžete místo toho provést něco jako:

// Array Remove - By John Resig (MIT Licensed)
Array.remove = function(array, from, to) {
    var rest = array.slice((to || from) + 1 || array.length);
    array.length = from < 0 ? array.length + from : from;
    return array.Push.apply(array, rest);
};

Hlavním důvodem, proč jsem to zveřejnil, je varovat uživatele před alternativní implementací navrženou v komentářích na této stránce (14. prosince 2007):

Array.prototype.remove = function(from, to){
  this.splice(from, (to=[0,from||1,++to-from][arguments.length])<0?this.length+to:to);
  return this.length;
};

Zdá se, že to funguje na prvním místě, ale díky bolestivému procesu, který jsem zjistil, selže při pokusu o odstranění druhého až posledního prvku v poli. Pokud máte například pole s 10 prvky a pokusíte se odebrat 9. prvek s tímto:

myArray.remove(8);

Skončíte s 8-prvkovým polem. Nevím proč, ale potvrdil jsem, že Johnova původní implementace nemá tento problém.

56
Roger

Underscore.js lze použít k řešení problémů s více prohlížeči. Používá in-build metody prohlížeče, pokud existují. Pokud chybí jako v případě starších verzí aplikace Internet Explorer, používá vlastní vlastní metody.

Jednoduchý příklad pro odstranění prvků z pole (z webu):

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]
54
vatsal

Můžete to udělat snadno pomocí filter method:

function remove(arrOriginal, elementToRemove){
    return arrOriginal.filter(function(el){return el !== elementToRemove});
}
console.log( remove([1, 2, 1, 0, 3, 1, 4], 1) );

Tím odstraníte všechny prvky z pole a také rychleji než kombinace řezu a indexu

53
Salvador Dali

Pokud chcete, aby nové pole s odstraněnými pozicemi bylo odstraněno, můžete daný prvek vždy smazat a pole odfiltrovat. Může být potřeba rozšíření array objektu pro prohlížeče, které neimplementují metodu filtru, ale z dlouhodobého hlediska je to jednodušší, protože vše, co děláte, je toto:

var my_array = [1,2,3,4,5,6];
delete my_array[4];
console.log(my_array.filter(function(a){return typeof a !== 'undefined';}));

Zobrazí [1, 2, 3, 4, 6]

42
Loupax

Můžete použít ES6. 

var array=['1','2','3','4','5','6']
var index = array.filter((value)=>value!='3');

Výstup : 

["1", "2", "4", "5", "6"]
38
rajat44

Podívejte se na tento kód. Funguje v každém hlavním prohlížeči .

remove_item = function (arr, value) {
    var b = '';
    for (b in arr) {
        if (arr[b] === value) {
            arr.splice(b, 1);
            break;
        }
    }
    return arr;
}

Zavolejte tuto funkci 

remove_item(array,value);
35
Ekramul Hoque

Můžete použít lodash _.pull (mutate array), _.pullAt (mutate array) nebo _.without (nemutuje pole), 

var array1 = ['a', 'b', 'c', 'd']
_.pull(array1, 'c')
console.log(array1) // ['a', 'b', 'd']

var array2 = ['e', 'f', 'g', 'h']
_.pullAt(array2, 0)
console.log(array2) // ['f', 'g', 'h']

var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without(array3, 'i') // ['j', 'k', 'l']
console.log(array3) // ['i', 'j', 'k', 'l']
33
Chun Yang

OK, například máte pole níže:

var num = [1, 2, 3, 4, 5];

A chceme vymazat číslo 4, můžete jednoduše udělat následující kód:

num.splice(num.indexOf(4), 1); //num will be [1, 2, 3, 5];

Pokud tuto funkci znovu použijete, zapíšete opakovaně použitelnou funkci, která bude připojena k funkci Nativní pole:

Array.prototype.remove = Array.prototype.remove || function(x) {
  const i = this.indexOf(x);
  if(i===-1) return;
  this.splice(i, 1); //num.remove(5) === [1, 2, 3];
}

Ale co takhle, pokud místo toho máte pole níže s několika [5] v poli?

var num = [5, 6, 5, 4, 5, 1, 5];

Abychom je mohli zkontrolovat všechny, potřebujeme smyčku, ale jednodušší a efektivnější způsob je použití vestavěných funkcí JavaScriptu, takže píšeme funkci, která používá filtr jako níže:

const _removeValue = (arr, x) => arr.filter(n => n!==x);
//_removeValue([1, 2, 3, 4, 5, 5, 6, 5], 5) //return [1, 2, 3, 4, 6]

Také tam jsou knihovny třetích stran, které vám pomohou udělat, jako Lodash nebo Underscore, pro více informací se podívejte na lodash _.pull, _.pullAt nebo _.without.

32
Alireza

Jsem docela nový JavaScript a potřeboval jsem tuto funkci. Pouze jsem napsal:

function removeFromArray(array, item, index) {
  while((index = array.indexOf(item)) > -1) {
    array.splice(index, 1);
  }
}

Když ho chci použít:

//Set-up some dummy data
var dummyObj = {name:"meow"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];

//Remove the dummy data
removeFromArray(dummyArray, dummyObj);
removeFromArray(dummyArray, "item2");

Výstup - podle očekávání ["Item1", "item1"]

Můžete mít jiné potřeby než já, takže je můžete snadno upravit tak, aby jim vyhovovaly. Doufám, že to někomu pomůže.

27
sofiax

ES6 a bez mutace: (říjen 2016)

const removeByIndex = (list, index) =>
  [
    ...list.slice(0, index),
    ...list.slice(index + 1)
  ];

Pak : 

removeByIndex([33,22,11,44],1) //=> [33,11,44]
24
Abdennour TOUMI

Update: Tato metoda se doporučuje pouze v případě, že nemůžete použít ECMAScript 2015 (dříve známý jako ES6). Pokud ho můžete použít, další odpovědi zde poskytují mnohem rozsáhlejší implementace.


To Gist zde bude vyřešit váš problém, a také odstraní všechny výskyty argumentu místo jen 1 (nebo zadanou hodnotu).

Array.prototype.destroy = function(obj){
    // Return null if no objects were found and removed
    var destroyed = null;

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

        // Use while-loop to find adjacent equal objects
        while(this[i] === obj){

            // Remove this[i] and store it within destroyed
            destroyed = this.splice(i, 1)[0];
        }
    }

    return destroyed;
}

Používání:

var x = [1, 2, 3, 3, true, false, undefined, false];

x.destroy(3);         // => 3
x.destroy(false);     // => false
x;                    // => [1, 2, true, undefined]

x.destroy(true);      // => true
x.destroy(undefined); // => undefined
x;                    // => [1, 2]

x.destroy(3);         // => null
x;                    // => [1, 2]
22
zykadelic

Máte-li v poli komplexní objekty, můžete použít filtry? V situacích, kdy $ .inArray nebo array.splice není tak snadné. Zejména pokud jsou objekty v poli pravděpodobně mělké.

Např. pokud máte objekt s polem Id a chcete, aby byl objekt odstraněn z pole:

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});
21
flurdy

Zde je několik způsobů, jak odebrat položku z pole pomocí JavaScriptu.

Všechny metody popsané nemutují původní pole a místo toho vytvořte nový.

Pokud znáte index položky

Předpokládejme, že máte pole a chcete odebrat položku v pozici i.

Jednou z metod je použití slice():

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const i = 3
const filteredItems = items.slice(0, i-1).concat(items.slice(i, items.length))

console.log(filteredItems)

slice() vytvoří nové pole s přijatými indexy. Jednoduše vytvoříme nové pole, od začátku až po index, který chceme odstranit, a zřetězíme další pole od první pozice následující po té, kterou jsme odstranili na konec pole.

Pokud znáte hodnotu

V tomto případě je vhodné použít filter(), který nabízí více deklarativní přístup:

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(item => item !== valueToRemove)

console.log(filteredItems)

To využívá funkce šipek ES6. Pro podporu starších prohlížečů můžete použít tradiční funkce:

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(function(item) {
  return item !== valueToRemove
})

console.log(filteredItems)

nebo můžete použít Babel a transpile ES6 kód zpět do ES5, aby bylo více stravitelné do starých prohlížečů, ale napsat moderní JavaScript ve vašem kódu.

Odstranění více položek

Co když místo jedné položky chcete odstranit mnoho položek?

Najdeme nejjednodušší řešení.

Podle indexu

Můžete pouze vytvořit funkci a odebrat položky v sérii:

const items = ['a', 'b', 'c', 'd', 'e', 'f']

const removeItem = (items, i) =>
  items.slice(0, i-1).concat(items.slice(i, items.length))

let filteredItems = removeItem(items, 3)
filteredItems = removeItem(filteredItems, 5)
//["a", "b", "c", "d"]

console.log(filteredItems)

Podle hodnoty

Můžete zahrnout vložení do funkce zpětného volání:

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valuesToRemove = ['c', 'd']
const filteredItems = items.filter(item => !valuesToRemove.includes(item))
// ["a", "b", "e", "f"]

console.log(filteredItems)

Vyvarujte se mutování původního pole

splice() (nezaměňovat s slice()) mutuje původní pole a mělo by se mu vyhnout.

(původně zveřejněno na adrese https://flaviocopes.com/how-to-remove-item-from-array/ )

20
Flavio Copes

Nikdy byste neměli mutovat své pole. Protože je to proti funkčnímu programování. Co můžete udělat, je vytvořit nové pole bez odkazování na pole, které chcete změnit pomocí metody es6 filter;

var myArray = [1,2,3,4,5,6];

Předpokládejme, že chcete 5 z pole odstranit, můžete to jednoduše udělat.

myArray = myArray.filter(value => value !== 5);

To vám dá nové pole bez hodnoty, kterou jste chtěli odstranit. Takže výsledek bude

 [1,2,3,4,6]; // 5 has been removed from this array

Pro další porozumění si můžete přečíst dokumentaci MDN na Array.filter https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

19
Adeel Imran

Modernější, ECMAScript 2015 (dříve známý jako Harmony nebo ES 6) přístup. Vzhledem k:

const items = [1, 2, 3, 4];
const index = 2;

Pak:

items.filter((x, i) => i !== index);

Poddajný: 

[1, 2, 4]

Můžete použít službu Babel a a polyfill , aby bylo zajištěno, že je tato funkce v prohlížečích dobře podporována.

18
bjfletcher

Vím, že už existuje mnoho odpovědí, ale mnoho z nich je zřejmě komplikováno. Zde je jednoduchý, rekurzivní způsob odstranění všech instancí klíče - volání sebe, dokud není nalezen index. Ano, funguje pouze v prohlížečích s indexOf, ale je to jednoduché a může být snadno vyplněno.

Samostatná funkce

function removeAll(array, key){
    var index = array.indexOf(key);

    if(index === -1) return;

    array.splice(index, 1);
    removeAll(array,key);
}

Metoda prototypu

Array.prototype.removeAll = function(key){
    var index = this.indexOf(key);

    if(index === -1) return;

    this.splice(index, 1);
    this.removeAll(key);
}
16
wharding28

Mám další dobré řešení pro odstranění z pole:

var words = ['spray', 'limit', 'Elite', 'exuberant', 'destruction', 'present'];

const result = words.filter(Word => Word.length > 6);

console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

15
Aram Grigoryan

Můžete provést zpětnou smyčku, abyste se ujistili, že se nezašroubují indexy, pokud existuje více instancí prvku.

var myElement = "chocolate";
var myArray = ['chocolate', 'poptart', 'poptart', 'poptart', 'chocolate', 'poptart', 'poptart', 'chocolate'];

/* Important code */
for (var i = myArray.length - 1; i >= 0; i--) {
    if (myArray[i] == myElement) myArray.splice(i, 1);
}

Live Demo

15
Jeff Noel

Na základě všech odpovědí, které byly převážně správné a s přihlédnutím k doporučeným osvědčeným postupům (zejména ne přímo s použitím Array.prototype), jsem přišel s níže uvedeným kódem:

function arrayWithout(arr, values) {
  var isArray = function(canBeArray) {
    if (Array.isArray) {
      return Array.isArray(canBeArray);
    }
    return Object.prototype.toString.call(canBeArray) === '[object Array]';
  };

  var excludedValues = (isArray(values)) ? values : [].slice.call(arguments, 1);
  var arrCopy = arr.slice(0);

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

  return arrCopy;
}

Přezkoumání výše uvedené funkce, navzdory skutečnosti, že funguje dobře, jsem si uvědomil, že by mohlo dojít ke zlepšení výkonu. Použití ES6 místo ES5 je mnohem lepší přístup. Za tímto účelem se jedná o vylepšený kód:

const arrayWithoutFastest = (() => {
  const isArray = canBeArray => ('isArray' in Array) 
    ? Array.isArray(canBeArray) 
    : Object.prototype.toString.call(canBeArray) === '[object Array]';

  let mapIncludes = (map, key) => map.has(key);
  let objectIncludes = (obj, key) => key in obj;
  let includes;

  function arrayWithoutFastest(arr, ...thisArgs) {
    let withoutValues = isArray(thisArgs[0]) ? thisArgs[0] : thisArgs;

    if (typeof Map !== 'undefined') {
      withoutValues = withoutValues.reduce((map, value) => map.set(value, value), new Map());
      includes = mapIncludes;
    } else {
      withoutValues = withoutValues.reduce((map, value) => { map[value] = value; return map; } , {}); 
      includes = objectIncludes;
    }

    const arrCopy = [];
    const length = arr.length;

    for (let i = 0; i < length; i++) {
      // If value is not in exclude list
      if (!includes(withoutValues, arr[i])) {
        arrCopy.Push(arr[i]);
      }
    }

    return arrCopy;
  }

  return arrayWithoutFastest;  
})();

Jak používat:

const arr = [1,2,3,4,5,"name", false];

arrayWithoutFastest(arr, 1); // will return array [2,3,4,5,"name", false]
arrayWithoutFastest(arr, 'name'); // will return [2,3,4,5, false]
arrayWithoutFastest(arr, false); // will return [2,3,4,5]
arrayWithoutFastest(arr,[1,2]); // will return [3,4,5,"name", false];
arrayWithoutFastest(arr, {bar: "foo"}); // will return the same array (new copy)

V současné době píšu příspěvek do blogu, ve kterém jsem bez problémů vyřešil několik řešení pro Array a porovnal čas potřebný ke spuštění. Po dokončení tohoto příspěvku aktualizuji tuto odpověď odkazem. Jen abych vás informoval, porovnal jsem výše uvedené s ubytováním bez toho, aby v případě, že prohlížeč podporuje Map, to bije! Všimněte si, že nepoužívám Array.prototype.indexOf nebo Array.prototype.includes jako zabalení exlcudeValues ​​v Map nebo Object dělá dotazování rychlejší!

15
Ardi

Máte 1 až 9 pole a chcete odstranit 5 pod kódem.

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return m !== 5;
});

console.log("new Array, 5 removed", newNumberArray);


Pokud chcete více hodnot ex: - 1,7,8

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return (m !== 1) && (m !== 7) && (m !== 8);
});

console.log("new Array, 5 removed", newNumberArray);


Pokud chcete odstranit hodnotu pole v poli ex: - [3,4,5]

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];

var newNumberArray = numberArray.filter(m => {
    return !removebleArray.includes(m);
});

console.log("new Array, [3,4,5] removed", newNumberArray);

obsahuje podporovaný prohlížeč je link

14
Thilina Sampath
  Array.prototype.removeItem = function(a) {
            for (i = 0; i < this.length; i++) {
                if (this[i] == a) {
                    for (i2 = i; i2 < this.length - 1; i2++) {
                        this[i2] = this[i2 + 1];
                    }
                    this.length = this.length - 1
                    return;
                }
            }
        }

    var recentMovies = ['Iron Man', 'Batman', 'Superman', 'Spiderman'];
    recentMovies.removeItem('Superman');
13

Odebrat podle indexu

Funkce, která vrátí kopii pole bez prvku v indexu.

/**
* removeByIndex
* @param {Array} array
* @param {Number} index
*/
function removeByIndex(array, index){
    return array.filter(function(elem, _index){
        return index != _index;
    });
}
l = [1,3,4,5,6,7];
console.log(removeByIndex(l, 1));

$> [ 1, 4, 5, 6, 7 ]

Odebrat podle hodnoty

Funkce, která vrátí kopii pole bez hodnoty.

/**
* removeByValue
* @param {Array} array
* @param {Number} value
*/
function removeByValue(array, value){
    return array.filter(function(elem, _index){
        return value != elem;
    });
}
l = [1,3,4,5,6,7];
console.log(removeByValue(l, 5));

$> [ 1, 3, 4, 6, 7]
13
nsantana

Chci odpovědět na základěES6. Předpokládejme, že máte pole jako níže:

let arr = [1,2,3,4];

Pokud chcete smazat speciální index jako 2, napište níže kód:

arr.splice(2, 1); //=> arr became [1,2,4]

Pokud ale chcete smazat speciální položku, jako je 3 a vy nevíte, že její index funguje takto:

arr = arr.filter(e => e !== 3); //=> arr became [1,2,4]

Tip : prosím použijte funkci šipky pro zpětné volání filtru, pokud nedostanete prázdné pole.

11
AmerllicA

Vytvořit nové pole:

var my_array = new Array();

Přidat prvky do tohoto pole:

my_array.Push("element1");

Funkce indexOf (Vrátí index nebo -1, když nebyl nalezen):

var indexOf = function(needle) 
{
    if(typeof Array.prototype.indexOf === 'function') // newer browsers
    {
        indexOf = Array.prototype.indexOf;
    } 
    else // older browsers
    {
        indexOf = function(needle) 
        {
            var index = -1;

            for(var i = 0; i < this.length; i++) 
            {
                if(this[i] === needle) 
                {
                    index = i;
                    break;
                }
            }
            return index;
        };
    }

    return indexOf.call(this, needle);
};

Kontrola indexu tohoto prvku (testováno s firefoxem a IE8 +):

var index = indexOf.call(my_array, "element1");

Odebrat 1 prvek umístěný v indexu z pole

my_array.splice(index, 1);
11
Enrico

Také jsem běžel v situaci, kdy jsem musel odstranit prvek z Array. .indexOf nefunguje v IE*, takže sdílím mé pracovní jQuery.inArray() řešení.

var index = jQuery.inArray(val,arr);
if (index > -1) {
    arr.splice(index, 1);
    //console.log(arr);
}
10
NullPointer

2017-05-08

Většina daných odpovědí pracuje pro striktní srovnání, což znamená, že oba objekty odkazují na přesný stejný objekt v paměti (nebo jsou primitivní typy), ale často chcete odstranit nepůvodní objekt z pole, které má určitou hodnotu. Pokud například voláte na server a chcete zkontrolovat načtený objekt proti místnímu objektu.

const a = {'field': 2} // Non-primitive object
const b = {'field': 2} // Non-primitive object with same value
const c = a            // Non-primitive object that reference the same object as "a"

assert(a !== b) // Don't reference the same item, but have same value
assert(a === c) // Do reference the same item, and have same value (naturally)

//Note: there are many alternative implementations for valuesAreEqual
function valuesAreEqual (x, y) {
   return  JSON.stringify(x) === JSON.stringify(y)
}


//filter will delete false values
//Thus, we want to return "false" if the item
// we want to delete is equal to the item in the array
function removeFromArray(arr, toDelete){
    return arr.filter(target => {return !valuesAreEqual(toDelete, target)})
}

const exampleArray = [a, b, b, c, a, {'field': 2}, {'field': 90}];
const resultArray = removeFromArray(exampleArray, a);

//resultArray = [{'field':90}]

Existují alternativní/rychlejší implementace pro valueAreEqual, ale to dělá práci. Vlastní komparátor můžete také použít, pokud máte určité pole ke kontrole (například některé načtené identifikátory UUID a místní identifikátor UUID).

Všimněte si také, že se jedná o funkční operaci, což znamená, že nezmění původní pole.

9
Aidan Hoolachan

Myslím, že mnoho instrukcí JavaScriptu není dobře promyšleno pro funkční programování. Splice vrátí odstraněný prvek, kde většinu času potřebujete redukované pole. Je to špatné.

Představte si, že děláte rekurzivní volání a musíte předat pole s jednou menší položkou, pravděpodobně bez aktuální indexované položky. Nebo si představte, že děláte další rekurzivní volání a musí projít maticí s posunutým prvkem.

V žádném z těchto případů nemůžete dělat myRecursiveFunction(myArr.Push(c)) nebo myRecursiveFunction(myArr.splice(i,1)). První idiot ve skutečnosti projde délkou pole a druhý idiot předá smazaný prvek jako parametr.

Takže to, co dělám ve skutečnosti ... Pro smazání elementu pole a předávání výsledné funkce jako parametru současně dělám následovně

myRecursiveFunction(myArr.slice(0,i).concat(a.slice(i+1)))

Když přijde na Push to je hloupější ... Mám rád,

myRecursiveFunction((myArr.Push(c),myArr))

Věřím, že ve správném funkčním jazyce musí metoda, která mutuje objekt, který nazývá, vrátit odkaz na samotný objekt jako výsledek.

9
Redu

V CoffeeScript :

my_array.splice(idx, 1) for ele, idx in my_array when ele is this_value
8

Použít funkci InArray aplikace jQuery:

A = [1, 2, 3, 4, 5, 6];
A.splice($.inArray(3, A), 1);
//It will return A=[1, 2, 4, 5, 6]`   

Poznámka: inArray vrátí hodnotu -1, pokud nebyl prvek nalezen.

7
Do Hoa Vinh

Vanilla JavaScript (ES5.1) - na místě vydání

Podpora prohlížeče: Internet Explorer 9 nebo novější ( podrobná podpora prohlížeče )

/**
 * Removes all occurences of the item from the array.
 *
 * Modifies the array “in place”, i.e. the array passed as an argument
 * is modified as opposed to creating a new array. Also returns the modified
 * array for your convenience.
 */
function removeInPlace(array, item) {
    var foundIndex, fromIndex;

    // Look for the item (the item can have multiple indices)
    fromIndex = array.length - 1;
    foundIndex = array.lastIndexOf(item, fromIndex);

    while (foundIndex !== -1) {
        // Remove the item (in place)
        array.splice(foundIndex, 1);

        // Bookkeeping
        fromIndex = foundIndex - 1;
        foundIndex = array.lastIndexOf(item, fromIndex);
    }

    // Return the modified array
    return array;
}

Vanilla JavaScript (ES5.1) - nezměnitelné vydání

Podpora prohlížeče: Stejná jako Vanilla JavaScript v edici míst

/**
 * Removes all occurences of the item from the array.
 *
 * Returns a new array with all the items of the original array except
 * the specified item.
 */
function remove(array, item) {
    var arrayCopy;

    arrayCopy = array.slice();

    return removeInPlace(arrayCopy, item);
}

Vanilla ES6 - nezměnitelný vydání

Podpora prohlížeče: Chrome 46, Edge 12, Firefox 16, Opera 37, Safari 8 ( podrobná podpora prohlížeče )

/**
 * Removes all occurences of the item from the array.
 *
 * Returns a new array with all the items of the original array except
 * the specified item.
 */
function remove(array, item) {
    // Copy the array
    array = [...array];

    // Look for the item (the item can have multiple indices)
    let fromIndex = array.length - 1;
    let foundIndex = array.lastIndexOf(item, fromIndex);

    while (foundIndex !== -1) {
        // Remove the item by generating a new array without it
        array = [
            ...array.slice(0, foundIndex),
            ...array.slice(foundIndex + 1),
        ];

        // Bookkeeping
        fromIndex = foundIndex - 1;
        foundIndex = array.lastIndexOf(item, fromIndex)
    }

    // Return the new array
    return array;
}

Odstraňte prvek v indexu i, aniž by došlo k mutaci původního pole:

/**
* removeElement
* @param {Array} array
* @param {Number} index
*/
function removeElement(array, index) {
   return Array.from(array).splice(index, 1);
}

// Another way is
function removeElement(array, index) {
   return array.slice(0).splice(index, 1);
}
6
alejandro

Líbí se mi tato verze splice, odstranění prvku pomocí jeho hodnoty pomocí $.inArray:

$(document).ready(function(){
    var arr = ["C#","Ruby","PHP","C","C++"];
    var itemtoRemove = "PHP";
    arr.splice($.inArray(itemtoRemove, arr),1);
});
6
mboeckle

Je možné iterovat jednotlivé array- položky a splice, pokud existují v array.

function destroy(arr, val) {
    for (var i = 0; i < arr.length; i++) if (arr[i] === val) arr.splice(i, 1);
    return arr;
}
6
yckart

Právě jsem vytvořil polyfill na Array.prototype přes Object.defineProperty, aby se odstranil požadovaný prvek v poli, aniž by to vedlo k chybám při iteraci přes něj později prostřednictvím for .. in ..

if (!Array.prototype.remove) {
  // Object.definedProperty is used here to avoid problems when iterating with "for .. in .." in Arrays
  // https://stackoverflow.com/questions/948358/adding-custom-functions-into-array-prototype
  Object.defineProperty(Array.prototype, 'remove', {
    value: function () {
      if (this == null) {
        throw new TypeError('Array.prototype.remove called on null or undefined')
      }

      for (var i = 0; i < arguments.length; i++) {
        if (typeof arguments[i] === 'object') {
          if (Object.keys(arguments[i]).length > 1) {
            throw new Error('This method does not support more than one key:value pair per object on the arguments')
          }
          var keyToCompare = Object.keys(arguments[i])[0]

          for (var j = 0; j < this.length; j++) {
            if (this[j][keyToCompare] === arguments[i][keyToCompare]) {
              this.splice(j, 1)
              break
            }
          }
        } else {
          var index = this.indexOf(arguments[i])
          if (index !== -1) {
            this.splice(index, 1)
          }
        }
      }
      return this
    }
  })
} else {
  var errorMessage = 'DANGER ALERT! Array.prototype.remove has already been defined on this browser. '
  errorMessage += 'This may lead to unwanted results when remove() is executed.'
  console.log(errorMessage)
}

Odstranění celé hodnoty

var a = [1, 2, 3]
a.remove(2)
a // Output => [1, 3]

Odstranění hodnoty řetězce

var a = ['a', 'ab', 'abc']
a.remove('abc')
a // Output => ['a', 'ab']

Odstranění logické hodnoty

var a = [true, false, true]
a.remove(false)
a // Output => [true, true]

Je také možné odstranit objekt uvnitř pole prostřednictvím této metody Array.prototype.remove. Stačí zadat key => valueObject, který chcete odstranit.

Odstranění hodnoty objektu

var a = [{a: 1, b: 2}, {a: 2, b: 2}, {a: 3, b: 2}]
a.remove({a: 1})
a // Output => [{a: 2, b: 2}, {a: 3, b: 2}]
5
Victor

Udělal jsem poměrně účinné rozšíření na základní pole JavaScriptu:

Array.prototype.drop = function(k) {
  var valueIndex = this.indexOf(k);
  while(valueIndex > -1) {
    this.removeAt(valueIndex);
    valueIndex = this.indexOf(k);
  }
};
5
Shawn Deprey

Díky mému řešení můžete odstranit jeden nebo více než jednu položku v poli díky čistému JavaScriptu. Další knihovna JavaScript není nutná.

var myArray = [1,2,3,4,5]; // First array

var removeItem = function(array,value) {  // My clear function
    if(Array.isArray(value)) {  // For multi remove
        for(var i = array.length - 1; i >= 0; i--) {
            for(var j = value.length - 1; j >= 0; j--) {
                if(array[i] === value[j]) {
                    array.splice(i, 1);
                };
            }
        }
    }
    else { // For single remove
        for(var i = array.length - 1; i >= 0; i--) {
            if(array[i] === value) {
                array.splice(i, 1);
            }
        }
    }
}

removeItem(myArray,[1,4]); // myArray will be [2,3,5]
5
Kamuran Sönecek

Odstraňte jednu hodnotu pomocí volného porovnání, bez mutace původního pole, ES6

/**
 * Removes one instance of `value` from `array`, without mutating the original array. Uses loose comparison.
 * 
 * @param {Array} array Array to remove value from
 * @param {*} value Value to remove
 * @returns {Array} Array with `value` removed
 */
export function arrayRemove(array, value) {
    for(let i=0; i<array.length; ++i) {
        if(array[i] == value) {
            let copy = [...array];
            copy.splice(i, 1);
            return copy;
        }
    }
    return array;
}
4
mpen

Ještě další odpověď, pro mě je jednodušší, tím lépe, a jak jsme v roce 2018 (blízko roku 2019), dávám vám tuto (blízkou) jednu linku, která má odpovědět na původní otázku:

Array.prototype.remove = function (value) { 
    return this.filter(f => f != value) 
}

Užitečné je, že jej můžete použít v kari výrazu jako:

[1,2,3].remove(2).sort()

4
Sebastien H.

Zatímco většina odpovědí na tuto otázku odpovídá, není dostatečně jasné, proč metoda slice() nebyla použita. Ano, filter() splňuje kritéria neměnnosti, ale jak postupovat podle následujícího kratšího ekvivalentu:

const myArray = [1,2,3,4];

A teď řekněme, že bychom měli odstranit druhý prvek z pole, můžeme jednoduše udělat: const newArray = myArray.slice(0,1).concat(myArray.slice(2,4));// [1,3,4]

Tento způsob vymazání prvku z pole je dnes v komunitě silně podporován díky své jednoduché a neměnné povaze. Obecně je třeba se vyhnout metodám, které způsobují mutaci. Doporučujeme například nahradit Push() pomocí concat() a splice() pomocí slice() 

4
Stelios Voskos

Použít jQuery.grep () :

var y = [1, 2, 3, 9, 4]
var removeItem = 9;

y = jQuery.grep(y, function(value) {
  return value != removeItem;
});
console.log(y)
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.2/jquery.min.js"></script>

4

Odstranění určitého prvku/řetězce z pole lze provést v jedné linii: Stále si myslím, že je to nejelegantnější jedna vložka, kterou můžete získat pro tento typ problému: 

theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);

kde 'theArray' je pole, ze kterého chcete odstranit něco konkrétního.

4

Zveřejněte můj kód, který odstraní prvek pole a sníží délku pole.

function removeElement(idx, arr) {
    // check the index value
    if (idx < 0 || idx >= arr.length) {
        return;
    }
    // shift the elements
    for (var i = idx; i > 0; --i) {
        arr[i] = arr[i - 1];
    }
    // remove the first element in array
    arr.shift();
}
3
hailong

Existuje mnoho fantastických odpovědí zde, ale pro mě to, co fungovalo nejvíce prostě nebylo odstranění mého prvku z pole úplně, ale jednoduše nastavení hodnoty na null. To funguje pro většinu případů, které mám, a je to dobré řešení, protože budu používat proměnnou později a nechci, aby byla pryč. Tento přístup je také plně kompatibilní s různými prohlížeči.

array.key = null;
3
rncrtr

Odstranit poslední výskyt nebo všechny výskyty nebo první výskyt? 

var array = [2, 5, 9, 5];

// Remove last occurrence (or all occurrences)
for (var i = array.length; i--;) {
  if (array[i] === 5) {
     array.splice(i, 1);
     break; // Remove this line to remove all occurrences
  }
}

nebo

var array = [2, 5, 9, 5];

// Remove first occurrence
for (var i = 0; array.length; i++) {
  if (array[i] === 5) {
     array.splice(i, 1);
     break; // Do not remove this line
  }
}
3
MEC

Pro každého, kdo hledá replikaci metody, která vrátí nové pole, které má duplicitní čísla nebo řetězce odstraněny, bylo toto sestaveno z existujících odpovědí:

function uniq(array) {
  var len = array.length;
  var dupFree = [];
  var tempObj = {};

  for (var i = 0; i < len; i++) {
    tempObj[array[i]] = 0;
  }

  console.log(tempObj);

  for (var i in tempObj) {
    var element = i;
    if (i.match(/\d/)) {
      element = Number(i);
    }
    dupFree.Push(element);
  }

  return dupFree;
}
3
cjjenkinson

Udělal jsem funkci 

function pop(valuetoremove, myarray) {
var indexofmyvalue = myarray.indexOf(valuetoremove);
myarray.splice(indexofmyvalue, 1);
}

A takhle.

pop(valuetoremove,myarray);

Na zdraví!

3
Ali Akram

Velmi naivní implementace by byla následující:

Array.prototype.remove = function(data) {
    const dataIdx = this.indexOf(data)
    if(dataIdx >= 0) {
        this.splice(dataIdx ,1);
    }
    return this.length;
}

let a = [1,2,3];
// this will change arr a to [1, 3]
a.remove(2);

Vrátím délku pole z funkce, aby vyhovovala ostatním metodám, jako je Array.prototype.Push().

3
Gaurang Patel

Měl jsem tento problém sám (v situaci, kdy bylo nahrazení pole přijatelné) a vyřešeno jednoduchým:

var filteredItems = this.items.filter(function (i) {
    return i !== item;
});

Chcete-li dát výše uvedený úryvek trochu kontextu:

self.thingWithItems = {
        items: [],
        removeItem: function (item) {
            var filteredItems = this.items.filter(function (i) {
                return i !== item;
            });

            this.items = filteredItems;
        }
    };

Toto řešení by mělo pracovat s referenčními i hodnotovými položkami. Vše záleží na tom, zda potřebujete zachovat odkaz na původní pole, zda je toto řešení použitelné. 

2
Phil
var array = [2, 5, 9];
array.splice(array.findIndex(x => x==5), 1);

Pomocí Array.findindex můžeme snížit počet řádků kódu.

developer.mozilla.org

2
sujithklr93
var index,
    input = [1,2,3],
    indexToRemove = 1;
    integers = [];

for (index in input) {
    if (input.hasOwnProperty(index)) {
        if (index !== indexToRemove) {
            integers.Push(result); 
        }
    }
}
input = integers;

Toto řešení bude mít pole vstupu a bude vyhledávat vstup pro hodnotu, kterou chcete odstranit. To bude smyčka přes celé vstupní pole a výsledek bude celá pole celá čísla, která měla konkrétní index odstraněn. Pole celých čísel se pak zkopíruje zpět do vstupního pole. 

2
penguin

Vaše otázka neindikovala, zda požadavek nebo odlišné hodnoty jsou požadavkem.

Pokud se nestaráte o objednávku a nebudete mít stejnou hodnotu v kontejneru více než jednou, použijte sadu. Bude to rychlejší a stručnější. 

var aSet = new Set();

aSet.add(1);
aSet.add(2);
aSet.add(3);

aSet.delete(2);
2
Steven Spungin
[2,3,5].filter(i => ![5].includes(i))

Odstranění hodnoty indexem a spojením!

function removeArrValue(arr,value) {
    var index = arr.indexOf(value);
    if (index > -1) {
        arr.splice(index, 1);
    }
    return arr;
}
2
Nejc Lepen

odstranit prvek z poslední 

arrName.pop();

nejprve odstranit prvek 

arrName.shift();

smazat od středu

arrName.splice(starting index,number of element you wnt to delete);

Ex: arrName.splice(1,1);

smazat jeden prvek z poslední

arrName.splice(-1);

Smazat pomocí indexového čísla pole

 delete arrName[1];
2
Srikrushna Pal

Co je to škoda, že máte pole celých čísel, ne objekt, kde klíče jsou řetězec ekvivalenty těchto celých čísel.

Prohlédl jsem si spoustu těchto odpovědí a zdá se, že všichni používají "hrubou sílu", jak vidím. Nezkoumal jsem každou z nich, omlouvám se, pokud tomu tak není. Pro menší pole je to v pořádku, ale co když v něm máte 000 celých čísel?

Opravte mě, když se mýlím, ale nemůžeme předpokládat, že v mapě key => value, jaké je objektem JS, lze předpokládat, že mechanismus vyhledávání klíčů je vysoce konstruovaný a optimalizovaný? (Všimněte si, že pokud mi někdo super-expert řekne, že tomu tak není, mohu navrhnout použití třídy ES6 Mapová třída místo toho, která určitě bude).

Já jen navrhuji, že za určitých okolností by bylo nejlepším řešením převést pole na objekt ... Problémem je samozřejmě opakování celočíselných hodnot. Navrhuji, aby se ty do kbelíků jako "hodnota" část key => value položek. (Pokud jste si jisti, že nemáte žádné opakující se prvky pole, může to být mnohem jednodušší: hodnoty "stejné jako" klíče, a stačí jít Object.values(...) vrátit zpět své upravené pole).

Takže můžete udělat:

const arr = [ 1, 2, 55, 3, 2, 4, 55 ];
const f =   function( acc, val, currIndex ){ 
    // not seen this val before: make bucket... NB although val's typeof is 'number'
    // there is seamless equivalence between the object key (always string)
    // and this variable val 
    ! ( val in acc ) ? acc[ val ] = []: 0;
    // drop another array index in the bucket
    acc[ val ].Push( currIndex );
    return acc; 
}
const myIntsMapObj = arr.reduce( f, {});

console.log( myIntsMapObj );

výstup:

Objekt [<1 prázdný slot>, Array 1 , Array [2], Array 1 , Array 1 , <5 Prázdné sloty>, 46 více…]

pak je snadné vymazat všechna čísla 55

delete myIntsMapObj[ 55 ]; // again, although keys are strings this works

Nemusíte je smazat všechny: hodnoty indexu se vkládají do jejich bucketů v pořadí podle vzhledu (např.):

myIntsMapObj[ 55 ].shift(); // and
myIntsMapObj[ 55 ].pop(); 

odstraní první a poslední výskyt. Můžete snadno spočítat četnost výskytu, nahradit všechny 55s 3s přenosem obsahu jednoho segmentu do druhého atd.

... návrat zpět do modifikovaného int pole je mírně zapojen: ale každý kbelík obsahuje index (v původním poli) hodnoty reprezentované klíčem (řetězec). Každá z těchto hodnot bucketu je také jedinečná: takže je změníte na klíče v novém objektu, s (reálným) celým číslem z "integerového řetězce" jako hodnotu ... pak seřadíte klíče a přejdete Object.values( ... ).

To zní velmi angažovaně a časově náročně ... ale samozřejmě vše závisí na okolnostech a požadovaném použití. Moje chápání je, že všechny verze a kontexty JS fungují pouze v jednom vláknu, a vlákno "pustí", takže by mohla existovat nějaká hrozná přetížení metodou "brutální síly", která není způsobena tolik indexOf ops , ale několik opakovaných slice/splice ops.

Addendum
Pokud jste jistě je to příliš mnoho techniky pro váš případ použití jistě nejjednodušší přístup "brutální síly"

const arr = [ 1, 2, 3, 66, 8, 2, 3, 2 ];
const newArray = arr.filter( number => number !== 3 );
console.log( newArray )

(ano, další odpovědi zaznamenaly Array.prototype.filter...)

2
mike rodent

Následující metoda odstraní všechny položky dané hodnoty z pole bez vytvoření nového pole a pouze s jednou iterací, která je superfast. Funguje to ve starém Internet Explorer 5.5 prohlížeči:

function removeFromArray(arr, removeValue) {
  for (var i = 0, k = 0, len = arr.length >>> 0; i < len; i++) {
    if (k > 0)
      arr[i - k] = arr[i];

    if (arr[i] === removeValue)
      k++;
  }

  for (; k--;)
    arr.pop();
}

var a = [0, 1, 0, 2, 0, 3];

document.getElementById('code').innerHTML =
  'Initial array [' + a.join(', ') + ']';
//Initial array [0, 1, 0, 2, 0, 3]

removeFromArray(a, 0);

document.getElementById('code').innerHTML +=
  '<br>Resulting array [' + a.join(', ') + ']';
//Resulting array [1, 2, 3]
<code id="code"></code>

2
Eugene Tiurin

Chcete-li odebrat určitý prvek nebo následující prvky, funguje metoda Array.splice () method. Metoda splice () mění obsah pole odstraněním nebo nahrazením existujících prvků a/nebo přidáním nových prvků a vrátí odstraněné položky.

Syntaxe: _ ​​array.splice (index, deleteCount, item1, ....., itemX)

Zde je index povinné a zbytkové argumenty jsou nepovinné.

Například:

let arr = [1, 2, 3, 4, 5, 6];
arr.splice(2,1);
console.log(arr);
// [1, 2, 4, 5, 6]

Poznámka:Array.splice () method lze použít, pokud znáte index prvku, který chcete smazat. Můžeme však mít několik dalších případů, jak je uvedeno níže.

  1. Pokud chcete smazat pouze poslední prvek, můžete použít Array.pop ()

  2. V případě, že chcete smazat pouze první prvek, můžete použít Array.shift ()

  3. Pokud znáte element sám, ale ne pozici (nebo index) prvku, a chcete odstranit všechny odpovídající elementy pomocí Array.filter () method:

    let arr = [1, 2, 1, 3, 4, 1, 5, 1];
    
    let newArr = arr.filter(function(val){
        return val !== 1;
     });
     //newArr => [2, 3, 4, 5]
    

NEBO pomocí metody splice ()

let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
    for( let i = 0; i < arr.length-1; i++){
       if ( arr[i] === 11) {
         arr.splice(i, 1); 
       }
    }
    console.log(arr);
    // [1, 2, 3, 4, 5, 6]

Nebo Předpokládejme, že chceme odstranit del z Array arr:

let arr = [1, 2, 3, 4, 5, 6];
let del = 4;
if(arr.indexOf(4) >= 0) {
arr.splice(arr.indexOf(4), 1)
}

OR

let del = 4;
for(var i = arr.length - 1; i >= 0; i--) {
    if(arr[i] === del) {
       arr.splice(i, 1);
    }
}
  1. Pokud znáte element sám, ale ne pozici (nebo index) elementu, a chcete smazat právě první prvek odpovídající metodě splice ():

    let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
    
    for( let i = 0; i < arr.length-1; i++){
      if ( arr[i] === 11) {
        arr.splice(i, 1);
        break;
      }
    }
    console.log(arr);
    // [1, 11, 2, 11, 3, 4, 5, 11, 6, 11]
    
1
Chang

Pokud musíte podporovat starší verze aplikace Internet Explorer, doporučuji použít následující polyfill (poznámka: toto je ne framework). Je to 100% zpětně kompatibilní náhrada všech moderních metod pole (JavaScript 1.8.5/ECMAScript 5 Array Extras), která funguje pro Internet Explorer 6+, Firefox 1.5+, Chrome, Safari a Opera.

https://github.com/plusdude/array-generics

1
Matt Brock

Často je lepší vytvořit nové pole s funkcí filtru.

const array = [1,2,3,4];
array = array.filter(i => i !== 4); // [1,2,3]

To také zlepšuje čitelnost imho. Nejsem fanoušek plátek, i když ví, že bys měl jít na to.

1
codepleb

Definujte metodu pojmenovanou remove () na objektech pole pomocí prototying funkce JavaScriptu.

Použijte splice () method ke splnění vašeho požadavku.

Podívejte se prosím na níže uvedený kód.

Array.prototype.remove = function(item) {
    // index will have -1 if item does not exist
    // else it will have the index of 1st item found in array
    var index = this.indexOf(item); 

    if (index > -1) {
        // splice() method is used to add/remove items(s) in array
        this.splice(index, 1); 
    }

    return index;
}


var arr = [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];

// Printing array
// [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
console.log(arr)

// Removing 67 (getting its index i.e. 2)
console.log("Removing 67")
var index = arr.remove(67)

if (index > 0){
    console.log("Item 67 found at ", index)
} else {
    console.log("Item 67 does not exist in array")
}

// Printing updated array
// [ 11, 22, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
console.log(arr)

// ............... Output ................................
// [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4 ]
// Removing 67
// Item 67 found at  2
// [ 11, 22, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4 ]

Poznámka: Níže je uveden úplný příklad kódu provedený na Node.js REPL který popisuje použití Push (), pop (), shift (), unshift () a splice () metody.

> // Defining an array
undefined
> var arr = [12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34];
undefined
> // Getting length of array
undefined
> arr.length;
16
> // Adding 1 more item at the end i.e. pushing an item
undefined
> arr.Push(55);
17
> arr
[ 12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34, 55 ]
> // Popping item from array (i.e. from end)
undefined
> arr.pop()
55
> arr
[ 12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> // Remove item from beginning
undefined
> arr.shift()
12
> arr
[ 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> // Add item(s) at beginning
undefined
> arr.unshift(67); // Add 67 at begining of the array and return number of items in updated/new array
16
> arr
[ 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> arr.unshift(11, 22); // Adding 2 more items at the beginning of array
18
> arr
[ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> // Define a method on array (temorarily) to remove an item and return the index of removed item; if it is found else return -1
undefined
> Array.prototype.remove = function(item) {
... var index = this.indexOf(item);
... if (index > -1) {
..... this.splice(index, 1); // splice() method is used to add/remove items in array
..... }
... return index;
... }
[Function]
>
> arr
[ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(45);   // Remove 45 (You will get the index of removed item)
3
> arr
[ 11, 22, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(22)    // Remove 22
1
> arr
[ 11, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> arr.remove(67)    // Remove 67
1
> arr
[ 11, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(89)    // Remove 89
2
> arr
[ 11, 67, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(100);  // 100 doesn't exist, remove() will return -1
-1
>

Dík.

1
hygull

Splice, filtrování a mazání pro odstranění elementu z pole

Každé pole má svůj index a pomáhá odstranit určitý prvek s jejich indexem.

Metoda splice () 

array.splice (index, 1 ); První parametr je index a druhým je číslo prvku

chcete odstranit z tohoto indexu.

Takže pro jeden prvek používáme 1. 

Metoda mazání

smazat pole [index]

Metoda filtru ()

Pokud chcete odstranit prvek, který se opakuje v poli, pak filtr pole.

removeAll = array.filter (e => e! = elem);

kde elem je prvek, který chcete odstranit z pole a pole je název pole

1
ashish

Metoda splice () mění obsah pole odstraněním nebo nahrazením existujících prvků a/nebo přidáním nových prvků.

array.splice (start [ deleteCount [ item1 [ item2 [ ...]]]])

Start

Index, ve kterém se má začít měnit pole (s počátkem 0). Pokud je větší než délka pole, bude aktuální počáteční index nastaven na délku pole. Pokud je záporná, začne, že mnoho prvků z konce pole (s počátkem -1) a bude nastaveno na 0, pokud je absolutní hodnota větší než délka pole.

deleteCount Volitelné

Celé číslo udávající počet starých prvků pole, které mají být odstraněny. Pokud je parametr deleteCount vynechán, nebo je-li jeho hodnota větší než pole array.length - start (tj. Pokud je větší než počet prvků, které zůstaly v poli pole, počínaje startem), pak budou všechny elementy od začátku do konce pole vymazány. Je-li deleteCount 0 nebo negativní, nebudou odstraněny žádné elementy. V tomto případě byste měli zadat alespoň jeden nový prvek (viz níže).

item1, item2, ... Volitelné

Prvky, které mají být přidány do pole, začínají začátkem indexu. Pokud nezadáte žádné prvky, splice () odstraní pouze prvky z pole.

Pro více referen laskavě projděte:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice

0
ashish

Existuje už mnoho odpovědí, ale protože to ještě nikdo neudělal s jednou vložkou, myslel jsem, že ukážu svou metodu. Využívá skutečnosti, že funkce string.split () při vytváření pole odstraní všechny zadané znaky. Zde je příklad: 

var ary = [1,2,3,4,1234,10,4,5,7,3];
out = ary.join("-").split("-4-").join("-").split("-");
console.log(out);

V tomto příkladu jsou všechny 4's odstraněny z pole ary. Je však důležité poznamenat, že jakékoli pole obsahující znak "-" způsobí problémy s tímto příkladem. Stručně řečeno, způsobí, že funkce spojení ("-") složí řetězec dohromady nesprávně. V takové situaci mohou být všechny řetězce "-" ve výše uvedeném úryvku nahrazeny řetězcem, který nebude použit v původním poli. Zde je další příklad: 

var ary = [1,2,3,4,'-',1234,10,'-',4,5,7,3];
out = ary.join("[email protected]#").split("[email protected]#[email protected]#").join("[email protected]#").split("[email protected]#");
console.log(out);

0
Partial Science

Využití metody snížení zisku následovně:

případ a) pokud u potřebujete odstranit prvek podle indexu:

function remove(arr, index) {
  return arr.reduce((prev, x, i) => prev.concat(i !== index ? [x] : []), []);
}

případ b) pokud u potřebujete odstranit prvek hodnotou prvku (int):

function remove(arr, value) {
  return arr.reduce((prev, x, i) => prev.concat(x !== value ? [x] : []), []);
}

Tímto způsobem můžeme vrátit nové pole (bude to chladný funkční způsob - mnohem lepší než použití Push nebo splice) s odstraněným prvkem.

0
alejoko
Array.prototype.remove = function(x) {
    var y=this.slice(x+1);
    var z=[];
    for(i=0;i<=x-1;i++) {
        z[z.length] = this[i];
    }

    for(i=0;i<y.length;i++){
        z[z.length]=y[i];
    }

    return z;
}
0
user4109793
var arr =[1,2,3,4,5];

arr.splice(0,1)

console.log(arr)

Výstup [2, 3, 4, 5];

0
Shahriar Ahmad