数値の配列があり、それに.push()メソッドを使用して要素を追加しています。

配列から特定の要素を削除する簡単な方法はありますか？

私は次のようなものと同等のものを探しています：

array.remove(number);

コア JavaScript を使用する必要があります。フレームワークは許可されていません。

をindex使用して削除する配列要素のを検索し、indexOf次にそのインデックスを削除しますsplice。

splice（）メソッドは、既存の要素を削除したり、新しい要素を追加したりして、配列の内容を変更します。

const array = [2, 5, 9];

console.log(array);

const index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}

// array = [2, 9]
console.log(array); 

の2番目のパラメータspliceは、削除する要素の数です。ご了承くださいsplice配列適切に変更し、削除された要素を含む新しい配列を返す。

完全性のために、ここに関数があります。最初の関数は単一のオカレンスのみを削除します（つまり、5fromの最初の一致を[2,5,9,1,5,8,5]削除します）、2番目の関数はすべてのオカレンスを削除します。

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

function removeItemAll(arr, value) {
    var i = 0;
    while (i < arr.length) {
        if(arr[i] === value) {
            arr.splice(i, 1);
        } else {
            ++i;
        }
    }
    return arr;
}

あなたがどのようarray.remove(int)に行動することを期待しているのか、私にはわかりません。あなたが望むかもしれないと私が考えることができる3つの可能性があります。

インデックスの配列の要素を削除するにはi：

array.splice(i, 1);

number配列から値を持つすべての要素を削除する場合：

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

インデックスiの要素をもう存在させたくないが、他の要素のインデックスを変更したくない場合：

delete array[i];

2016年10月に編集

• シンプルで直感的で明確なことをしてください（Occamのかみそり）
• 不変ですか（元の配列は変更されません）
• ブラウザがサポートしていない場合は、標準のJavaScript関数を使用してください- ポリフィルを使用してください

このコード例では、「array.filter（...）」関数を使用して、不要なアイテムを配列から削除しています。この関数は元の配列を変更せず、新しい配列を作成します。ご使用のブラウザーがこの機能をサポートしていない場合（例えば、バージョン9より前のInternet Explorer、またはバージョン1.5より前のFirefox）、Mozillaのフィルターポリフィルの使用を検討してください。。

アイテムの削除（ECMA-262 Edition 5コード、別名oldstyle JavaScript）

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 ]

アイテムの削除（ECMAScript 6コード）

let value = 3

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

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

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

重要 ECMAScript 6 "（）=> {}"矢印関数構文は、Internet Explorer、45より前のバージョンのChrome、22より前のバージョンのFirefox、および10より前のバージョンのSafariではサポートされていません。古いブラウザーでECMAScript 6構文を使用するには、BabelJSを使用できます。

複数のアイテムの削除（ECMAScript 7コード）

この方法の追加の利点は、複数のアイテムを削除できることです

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 ]

重要「array.includes（...）」関数はInternet Explorer、47バージョンより前のChrome、43バージョンより前のFirefox、9バージョンより前のSafari、および14バージョンより前のEdgeではまったくサポートされていないため、Mozillaからのポリフィルます。

複数のアイテムの削除（将来的には）

「This-Binding Syntax」の提案が受け入れられた場合、これを行うことができます。

// 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 ]

BabelJSで試してみてください:)

参照

• Array.prototype.includes
• 機能構成

空のスポットを維持するかどうかによって異なります。

空のスロットが必要な場合は、削除しても問題ありません。

delete array[index];

そうでない場合は、spliceメソッドを使用する必要があります。

array.splice(index, 1);

そして、その項目の値が必要な場合は、返された配列の要素を格納するだけです。

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

ある順序で実行したい場合array.pop()は、最後の1つまたはarray.shift()最初の1 つに使用できます（両方ともアイテムの値も返します）。

また、アイテムのインデックスがわからない場合は、を使用array.indexOf(item)して取得できます（aでif()1つのアイテムを取得するか、aでwhile()すべてを取得します）。array.indexOf(item)インデックスを返すか、見つからない場合は-1を返します。 

友人がInternet Explorer 8で問題を抱えていて、彼が何をしたかを見せてくれました。私はそれが間違っていると彼に言った、そして彼はここで答えを得たと私に言った。現在の上位の回答は、すべてのブラウザー（Internet Explorer 8など）では機能せず、アイテムの最初の出現のみを削除します。

配列からすべてのインスタンスを削除する

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

（項目が削除されるとインデックスと長さが変わるため）配列を逆方向にループし、見つかった場合はその項目を削除します。すべてのブラウザで動作します。

2つの主要なアプローチがあります。

1. splice（）：anArray.splice(index, 1);

2. 削除：delete anArray[index];

配列の削除を使用するときは注意してください。オブジェクトの属性の削除には適していますが、配列にはあまり適していません。使う方がいいsplice配列をお勧めします。

delete配列に使用すると、に対して誤った結果が得られる可能性があることに注意してくださいanArray.length。言い換えると、delete要素は削除されますが、長さプロパティの値は更新されません。

また、削除を使用した後、インデックス1、3、4、8、9、および11と長さを持つことになる可能性があります。その場合、forインデックスがシーケンシャルではなくなるため、すべてのインデックス付きループがクラッシュします。

delete何らかの理由で強制的に使用for eachする場合は、配列をループする必要があるときにループを使用する必要があります。実際のところ、for可能であれば、常にインデックス付きループの使用は避けてください。そうすれば、コードはより堅牢になり、インデックスに関する問題が発生しにくくなります。

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)

indexOfまたはを使用する必要はありませんsplice。ただし、要素を1つだけ削除したい場合は、パフォーマンスが向上します。

検索して移動（移動）：

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;
}

indexOfおよびsplice（indexof）の使用：

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

のみ使用splice（スプライス）：

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

1000個の要素を持つ配列のnodejsでの実行時間（平均10000回を超える実行）：

indexofはmoveよりも約10倍遅くなります。indexOfin spliceへの呼び出しを削除することで改善されたとしても、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

これは、値の代わりに述語を提供します。

注：指定された配列を更新し、影響を受ける行を返します。

使用法

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

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

定義

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;
    }
};

あなたはfilterメソッドでそれを簡単に行うことができます：

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

これは、配列からすべての要素を削除しても、の組み合わせよりも速く動作しますsliceとindexOf。

John Resig は良い実装を投稿しました：

// 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);
};

グローバルオブジェクトを拡張したくない場合は、代わりに次のようなことができます：

// 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);
};

しかし、これを投稿する主な理由は、そのページのコメント（2007年12月14日）で提案されている代替実装に対してユーザーに警告するためです。

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;
};

最初はうまく機能しているように見えますが、配列内の最後から2番目の要素を削除しようとすると失敗することがわかりました。たとえば、10要素の配列があり、これを使用して9番目の要素を削除しようとすると、次のようになります。

myArray.remove(8);

結局、8要素の配列になります。理由はわかりませんが、ジョンの元の実装にはこの問題がないことを確認しました。

Underscore.jsは、複数のブラウザーの問題を解決するために使用できます。存在する場合は、組み込みのブラウザメソッドを使用します。古いバージョンのInternet Explorerの場合のように存在しない場合は、独自のカスタムメソッドを使用します。

配列から要素を削除する簡単な例（ウェブサイトから）：

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

ES6を使用できます。たとえば、この場合に値「3」を削除するには、次のようにします。

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

出力：

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

削除された位置が削除された新しい配列が必要な場合は、いつでも特定の要素を削除して、配列をフィルターで除外できます。filterメソッドを実装していないブラウザーの場合は、配列オブジェクトの拡張が必要になる可能性がありますが、長期的には、これを行うだけなので簡単です。

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

表示されるはず[1, 2, 3, 4, 6]です。

このコードを確認してください。すべての主要なブラウザで動作します。

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

この関数を呼び出す

remove_item(array,value);

lodash _.pull（変異配列）、_。pullAt（変異配列）または_.without（変異配列ではない）を使用できます。

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']

ES6＆変異なし：（2016年10月）

const removeByIndex = (list, index) =>
      [
        ...list.slice(0, index),
        ...list.slice(index + 1)
      ];
         
output = removeByIndex([33,22,11,44],1) //=> [33,11,44]
      
console.log(output)

配列から特定の要素/文字列を削除することはワンライナーで行うことができます：

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

どこ：

theArray：特定のものを削除する配列

stringToRemoveFromArray：削除する文字列。1は削除する要素の量です。

注：「stringToRemoveFromArray」が配列内にない場合、これは配列の最後の要素を削除します。

要素を削除する前に、まず要素が配列に存在するかどうかを確認することをお勧めします。

if (theArray.indexOf("stringToRemoveFromArray") >= 0){
   theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);
}

クライアントのコンピューターで新しいEcmascriptバージョンにアクセスできる場合（警告、古いステーションでは機能しない可能性があります）：

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

ここで、「3」は配列から削除する値です。その後、配列は次のようになります。['1','2','4','5','6']

JavaScriptを使用して配列から項目を削除するいくつかの方法を次に示します。

説明されているすべてのメソッドは元の配列を変更しません、代わりに新しいを作成します。

アイテムのインデックスを知っている場合

配列があり、位置のアイテムを削除したいとしますi。

1つの方法は使用することslice()です：

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

console.log(filteredItems)

slice()受け取ったインデックスで新しい配列を作成します。最初から削除するインデックスまでの新しい配列を作成し、削除した配列に続く最初の位置から配列の最後まで別の配列を連結します。

価値を知っているなら

この場合、1つの適切なオプションはを使用することですfilter()。これは、より宣言的なアプローチを提供します。

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

console.log(filteredItems)

ES6の矢印関数を使用します。従来の関数を使用して、古いブラウザーをサポートできます。

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

console.log(filteredItems)

または、Babelを使用してES6コードをES5にトランスパイルして、古いブラウザーでよりわかりやすくし、コードに最新のJavaScriptを記述できます。

複数のアイテムを削除する

単一のアイテムではなく、多くのアイテムを削除したい場合はどうなりますか？

最も簡単な解決策を見つけましょう。

インデックス別

関数を作成して、アイテムを順番に削除するだけです。

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)

値で

コールバック関数内の包含を検索できます。

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)

元の配列を変更しないでください

splice()（と混同しないでくださいslice()）は元の配列を変更するため、回避する必要があります。

（元々はhttps://flaviocopes.com/how-to-remove-item-from-array/に投稿されています）

OK、例えばあなたは以下の配列を持っています：

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

そして、番号4を削除します。以下のコードを使用するだけです。

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

この関数を再利用する場合は、次のようにネイティブ配列関数にアタッチされる再利用可能な関数を記述します。

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];
}

しかし、配列にいくつかの[5]を含む以下の配列がある場合はどうでしょうか？

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

すべてをチェックするためのループが必要ですが、組み込みのJavaScript関数を使用する方が簡単で効率的な方法なので、代わりに以下のようなフィルターを使用する関数を記述します。

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]

また、LodashやUnderscoreなど、これを行うのに役立つサードパーティのライブラリもあります。詳細については、lodash _.pull、_。pullAt、または_.withoutを参照してください。

私はJavaScriptにかなり慣れていないため、この機能が必要でした。私はこれを書いただけです：

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

次に、それを使用したい場合：

//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");

出力-予想どおり。["item1"、 "item1"]

あなたは私とは異なるニーズがあるかもしれないので、それらに合うように簡単に変更することができます。これが誰かの役に立つことを願っています。

配列に複雑なオブジェクトがある場合、フィルターを使用できますか？$ .inArrayまたはarray.spliceが使いにくい状況で。特にオブジェクトが配列内でおそらく浅い場合。

たとえば、Idフィールドを持つオブジェクトがあり、そのオブジェクトを配列から削除したい場合は、次のようにします。

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

ECMAScript 6に基づいて回答したいと思います。次のような配列があるとします。

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

のような特別なインデックスで削除したい場合は2、以下のコードを記述してください：

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

ただし、などの特別なアイテムを削除したい3が、そのインデックスがわからない場合は、以下のようにします。

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

ヒント：空の配列を取得しない限り、フィルターコールバックには矢印関数を使用してください。

更新：この方法は、ECMAScript 2015（旧称ES6）を使用できない場合にのみお勧めします。あなたがそれを使うことができるなら、ここでの他の答えはもっとすっきりした実装を提供します。

この要点は問題を解決し、1（または指定した値）だけでなく、引数のすべての出現を削除します。

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;
}

使用法：

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]

パフォーマンス

今日（2019-12-09）選択したソリューションのmacOS v10.13.6（High Sierra）でパフォーマンステストを実施します。見せますdelete（A）いますが、配列に空のスペースが残っているため、他の方法と比較して使用していません。

結論

• 最速の解決策はarray.splice（C）です（2回目の小さなアレイのSafariを除く）
• 大きな配列の場合、array.slice+splice（H）はFirefoxとSafariの最速の不変ソリューションです。Array.from（B）Chromeで最速
• 可変ソリューションは通常、不変ソリューションより1.5倍から6倍高速です。
• Safariの小さなテーブルの場合、驚くべきことに、可変ソリューション（C）は不変ソリューション（G）よりも遅い

細部

テストでは、さまざまな方法で配列から中央の要素を削除します。A、Cのソリューションは、インプレースです。B、D、E、F、G、Hソリューションは不変です。

10要素の配列の結果

Chromeでは、array.splice（C）が最速のインプレースソリューションです。array.filter（D）は、最速不変溶液です。最も遅いのはarray.slice（F）です。ここでマシンのテストを実行できます。

1.000.000要素の配列の結果

Chromeでは、array.splice（C）が最速のインプレースソリューションです（delete（C）も同様に高速ですが、配列に空のスロットが残っています（したがって、「完全な削除」は実行されません））。array.slice-splice（H）は、最速の不変のソリューションです。最も遅いのはarray.filter（DおよびE）です。ここでマシンのテストを実行できます。

var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letter,array) => console.log(letter, array.join `,`);

function A(array) {
  var index = array.indexOf(5);
  delete array[index];
  log('A', array);
}

function B(array) {
  var index = array.indexOf(5);
  var arr = Array.from(array);
  arr.splice(index, 1)
  log('B', arr);
}

function C(array) {
  var index = array.indexOf(5);
  array.splice(index, 1);
  log('C', array);
}

function D(array) {
  var arr = array.filter(item => item !== 5)
  log('D', arr);
}

function E(array) {
  var index = array.indexOf(5);
  var arr = array.filter((item, i) => i !== index)
  log('E', arr);
}

function F(array) {
  var index = array.indexOf(5);
  var arr = array.slice(0, index).concat(array.slice(index + 1))
  log('F', arr);
}

function G(array) {
  var index = array.indexOf(5);
  var arr = [...array.slice(0, index), ...array.slice(index + 1)]
  log('G', arr);
}

function H(array) {
  var index = array.indexOf(5);
  var arr = array.slice(0);
  arr.splice(index, 1);
  log('H', arr);
}

A([...a]);
B([...a]);
C([...a]);
D([...a]);
E([...a]);
F([...a]);
G([...a]);
H([...a]);

This snippet only presents code used in performance tests - it does not perform tests itself.

ブラウザーの比較：Chrome v78.0.0、Safari v13.0.4、Firefox v71.0.0

配列を変更しないでください。これは関数型プログラミングパターンに反するためです。ECMAScript 6メソッドを使用して、データを変更する配列を参照せずに新しい配列を作成できますfilter。

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

5配列から削除したい場合は、次のようにするだけです。

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

これにより、削除したい値を含まない新しい配列が得られます。したがって、結果は次のようになります。

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

詳細については、Array.filterの MDNドキュメントを参照してください。

より近代的なECMAScript 2015（旧称HarmonyまたはES 6）アプローチ。与えられた：

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

次に：

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

収量：

[1, 2, 4]

あなたは使用することができバベルとポリフィルサービスをこれがうまくブラウザでサポートされていることを確認します。

配列に1から9があり、5を削除します。以下のコードを使用します。

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);

複数の値にしたい場合。例：-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, 1,7 and 8 removed", newNumberArray);

配列内の配列値を削除する場合。例：[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);

サポートされているブラウザが含まれているリンクです。

私はすでに多くの答えがあることを知っていますが、それらの多くは問題を過度に複雑にしているようです。キーのすべてのインスタンスを削除する簡単な再帰的な方法を次に示します。インデックスが見つからなくなるまで自分自身を呼び出します。はい、これはを使用するブラウザでのみ機能しますがindexOf、シンプルで簡単にポリフィルできます。

スタンドアロン機能

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

    if(index === -1) return;

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

プロトタイプ方式

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

    if(index === -1) return;

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

要素のインスタンスが複数ある場合は、逆方向ループを実行して、インデックスを台無しにしないようにすることができます。

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);
}

ライブデモ