JavaScriptで配列から特定の要素を削除する方法
私はNumbersの配列を持っており、それに要素を追加するために.Push()メソッドを使っています。
配列から特定の要素を削除する簡単な方法はありますか？ array.remove(number);のようなものと同等です。
core JavaScript - no フレームワークは許可されています。
削除したい配列要素のindexを探し、それから splice でそのインデックスを削除します。
Splice（）メソッドは既存の要素を削除したり新しい要素を追加したりすることで配列の内容を変更します。
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);spliceの2番目のパラメータは削除する要素の数です。 spliceはその場で配列を変更し、削除された要素を含む新しい配列を返します。
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月に編集
- シンプルで直感的かつ明確にしてください（ https://en.wikipedia.org/wiki/Occam%27s_razor ）
- 不変か（元の配列は変更されない）
- あなたのブラウザがそれらをサポートしていないなら、標準のJS関数でそれをしてください - polyfillを使用してください
このコード例では、配列から不要な項目を削除するために "array.filter（...）" 関数を使用します。この関数は元の配列を変更せずに新しいものを作成します。お使いのブラウザがこの機能をサポートしていない場合（たとえば、バージョン9より前のIE、バージョン1.5より前のFirefox）、 Mozillaからのフィルタpolyfill の使用を検討してください。
アイテムを削除する（ECMA-262 Edition 5コード別名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 ]
アイテムの削除（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 "（）=> {}"矢印関数の構文はIEではまったくサポートされていません。Chromeは45バージョンより前、Firefoxは22バージョンより前、Safariは10バージョンより前です。古いブラウザでES2015のシンタックスを使うには BabelJS を使います。
複数のアイテムを削除する（ES2016コード）
この方法のもう1つの利点は、複数のアイテムを削除できることです。
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 _ "array.includes（...）"関数はIEではまったくサポートされていません、47以前のChrome、43以前のFirefox、9以前のSafari、Edge 14以前のバージョンなので これはMozillaからのpolyfillです
複数のアイテムを削除する（最先端の実験用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 ]
参照
あなたが空の場所を維持したいかどうかに依存します。
空のスロットが必要な場合は、削除しても問題ありません。
delete array[ index ];
そうでなければ、 splice メソッドを使うべきです：
array.splice( index, 1 );
その項目の値が必要な場合は、返された配列の要素を格納するだけです。
var value = array.splice( index, 1 )[0];
何らかの順序でそれを実行したい場合は、最後のものにarray.pop()を、または最初のものにarray.shift()を使用することができます（そして両方ともアイテムの値も返します）。
そして、アイテムのインデックスがわからない場合は、array.indexOf( item )を使用して取得できます（1つのアイテムを取得するにはif()、すべてを取得するには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つあります。
splice（） ：
anArray.splice(index, 1);削除 ：
delete anArray[index];
配列にdeleteを使うときは注意してください。オブジェクトの属性を削除するのには適していますが、配列には適していません。配列にはspliceを使用することをお勧めします。
配列にdeleteを使用すると、anArray.lengthの結果が正しくなくなる可能性があることに注意してください。つまり、deleteは要素を削除しますが、lengthプロパティの値は更新しません。
Deleteを使用した後にインデックス番号に穴が開いていることも予想できます。削除を使用する前と同じように、インデックス1,3,4,8,9,11と長さを持つことになる可能性があります。 その場合、インデックスはもはやシーケンシャルではないので、すべてのインデックス付きforループはクラッシュするでしょう。
何らかの理由でdeleteを使わざるを得ない場合は、配列をループ処理する必要があるときに for each loopsを使用してください。実際問題として、可能であれば、常にインデックス付き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（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倍遅くなります。 splice でindexOfへの呼び出しを削除することで改善されたとしても、 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;
}
};
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要素の配列になってしまいます。理由はわかりませんが、Johnの最初の実装にはこの問題がないことを確認しました。
Underscore.js は複数のブラウザの問題を解決するために使用できます。存在する場合は、組み込みのブラウザメソッドを使用します。古いバージョンのInternet Explorerの場合のようにそれらが存在しない場合は、独自のカスタムメソッドが使用されます。
（Webサイトから）配列から要素を削除する簡単な例：
_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]
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) );
これは配列からすべての要素を削除し、またsliceとindexOfの組み合わせよりも速く動作します
削除した位置を削除した新しい配列が必要な場合は、いつでも特定の要素を削除して配列を除外できます。 filterメソッドを実装していないブラウザの場合は array object の拡張が必要になるかもしれませんが、長期的にはこれが簡単なので簡単です。
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]を表示する必要があります
ES6が使えます。
var array=['1','2','3','4','5','6']
var index = array.filter((value)=>value!='3');
出力：
["1", "2", "4", "5", "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']
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"]
あなたは私とは異なるニーズがあるかもしれないので、あなたはそれらに合うようにそれを簡単に修正することができます。これが誰かに役立つことを願っています。
ES6＆変異なし：（2016年10月）
const removeByIndex = (list, index) =>
[
...list.slice(0, index),
...list.slice(index + 1)
];
その後：
removeByIndex([33,22,11,44],1) //=> [33,11,44]
更新： この方法は、ECMAScript 2015（旧称ES6）を使用できない場合にのみ推奨されます。あなたがそれを使うことができれば、ここの他の答えははるかに良い実装を提供します。
This Gist here はあなたの問題を解決するでしょう、そしてまた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]
もしあなたが配列の中に複雑なオブジェクトを持っているなら、あなたはフィルタを使うことができますか？ $ .inArrayまたはarray.spliceの使い方がそれほど簡単ではない場合。特にオブジェクトが配列内でおそらく浅い場合。
例えば。 Idフィールドを持つオブジェクトがあり、そのオブジェクトを配列から削除したい場合は、次のようにします。
this.array = this.array.filter(function(element, i) {
return element.id !== idToRemove;
});
ここにJavaScriptを使って配列から項目を削除する）のいくつかの方法があります。
すべてのメソッドは元の配列を変更しないで、代わりに新しいものを作成します。
あなたがアイテムのインデックスを知っているなら
配列があり、位置iにある項目を削除したいとします。
一つの方法は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()は受け取ったインデックスで新しい配列を作成します。最初から削除するインデックスまで新しい配列を作成し、削除した位置に続く最初の位置から最後の位置まで別の配列を連結します。
あなたが価値を知っていれば
この場合、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/ に投稿されています）
あなたは自分の配列を自分の配列に変更してはいけません。これは関数型プログラミングパターンに反するものです。 es6メソッド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ドキュメントを読むことができます https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter
より現代的な、 ECMAScript 2015 （以前はHarmonyまたはES 6として知られていた）アプローチ。与えられた：
const items = [1, 2, 3, 4];
const index = 2;
その後：
items.filter((x, i) => i !== index);
収量：
[1, 2, 4]
Babel と polyfill service を使うことで、ブラウザ間でこれを確実にサポートすることができます。
私はすでにたくさんの答えがあることを知っていますが、それらの多くは問題を過度に複雑にしているようです。これはキーのすべてのインスタンスを削除する簡単で再帰的な方法です。インデックスが見つからなくなるまでselfを呼び出します。はい、それはindexOfを持つブラウザでのみ動作しますが、それはシンプルで簡単にpolyfilledすることができます。
スタンドアロン機能
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 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
要素のインスタンスが複数ある場合は、インデックスを壊さないようにするために逆方向のループを実行できます。
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);
}
ライブデモ
主に正解であり、提案されたベストプラクティス（特にArray.prototypeを直接使用しない）を考慮に入れたすべての回答に基づいて、以下のコードを思い付きました。
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;
}
上記の機能を検討すると、うまく機能しているにもかかわらず、パフォーマンスがいくらか改善される可能性があることに気付きました。 ES5の代わりにES6を使用することも、はるかに優れたアプローチです。そのために、これは改良されたコードです。
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;
})();
使い方：
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)
私は現在、私が問題なくArrayのためのいくつかの解決策をベンチマークし、それが実行するのにかかる時間を比較したブログ投稿を書いています。この投稿が終わったら、この回答をリンクで更新します。あなたに知らせるために、私はlodashのものと上記のものを比較しました、そして、ブラウザがMapをサポートするならば、それはlodashを打ちます！ MapまたはObjectにexlcudeValuesをラップするとクエリが速くなるので、Array.prototype.indexOfまたはArray.prototype.includesを使用していないことに注意してください。
あなたは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);多値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);配列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);サポートされているブラウザが含まれています リンク
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');
インデックスで削除
Indexの要素なしで配列のコピーを返す関数。
/**
* 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 ]
値で削除
Valueなしで配列のコピーを返す関数。
/**
* 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]
ES6に基づいて答えたいのですが。以下のような配列があるとします。
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]
ヒント ：空の配列にならない限り、フィルタコールバックには矢印関数を使ってください。
新しい配列を作成します。
var my_array = new Array();
この配列に要素を追加します。
my_array.Push("element1");
関数indexOf（見つからなかった場合はindexまたは-1を返す）：
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);
};
この要素のインデックスをチェックする（FirefoxおよびIE8 +でテスト済み）：
var index = indexOf.call(my_array, "element1");
インデックスからindexにある要素を1つ削除する
my_array.splice(index, 1);
私はArrayから要素を削除しなければならない状況でも走りました。 .indexOfはIE*で機能していなかったので、私の有効なjQuery.inArray()ソリューションを共有しました。
var index = jQuery.inArray(val,arr);
if (index > -1) {
arr.splice(index, 1);
//console.log(arr);
}
2017-05-08
与えられた答えの大部分は厳密な比較のために働きます。つまり、両方のオブジェクトがメモリ内のまったく同じオブジェクトを参照する（またはプリミティブ型である）ことを意味します。たとえば、サーバーを呼び出して、取得したオブジェクトをローカルオブジェクトと照合したい場合などです。
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}]
ValuesAreEqualのための代替の/より速い実装があります、しかしこれは仕事をします。確認する特定のフィールドがある場合は、カスタムコンパレータを使用することもできます（たとえば、取得したUUIDとローカルUUIDの一部）。
これは機能的な操作であり、元の配列を変更しないことを意味します。
私はJavaScriptの命令の多くが関数型プログラミングのためによく考えられていないと思います。ほとんどの場合、縮小配列が必要な場所で、Spliceは削除された要素を返します。これは悪いです。
あなたが再帰的な呼び出しをしていて、おそらく現在の添字付き項目なしで、1つ少ない項目で配列を渡さなければならないと想像してください。あるいは、別の再帰呼び出しを行っていて、要素がプッシュされた状態で配列を渡す必要があると想像してください。
どちらの場合も、myRecursiveFunction(myArr.Push(c))またはmyRecursiveFunction(myArr.splice(i,1))を実行することはできません。最初のばかは実際には配列の長さを渡し、2番目のばかはパラメータとして削除された要素を渡します。
だから私は実際に何をしています...配列要素を削除し、同時にパラメータとして関数に結果を渡すために私は次のようにします
myRecursiveFunction(myArr.slice(0,i).concat(a.slice(i+1)))
プッシュに関しては、それはもっとばかげています...私は好きです、
myRecursiveFunction((myArr.Push(c),myArr))
適切な関数型言語では、呼び出されるオブジェクトを変更するメソッドは、結果としてそのオブジェクト自体への参照を返さなければならないと思います。
CoffeeScript ：に
my_array.splice(idx, 1) for ele, idx in my_array when ele is this_value
JQueryのInArrayを使う：
A = [1, 2, 3, 4, 5, 6];
A.splice($.inArray(3, A), 1);
//It will return A=[1, 2, 4, 5, 6]`
注：要素が見つからなかった場合、inArrayは-1を返します。
バニラジャバスクリプト（ES5.1） - インプレース edition
ブラウザのサポート： Internet Explorer 9 またはそれ以降（ ブラウザの詳細サポート ）
/**
* 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;
}
バニラJavaScript（ES5.1） - 不変 edition
ブラウザのサポート：プレース版のVanilla JavaScriptと同じ
/**
* 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);
}
バニラES6 - 不変版
ブラウザのサポート：Chrome 46、Edge 12、Firefox 16、Opera 37、Safari 8（ ブラウザの詳細サポート ）
/**
* 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;
}
元の配列を変更せずに、インデックスiの要素を削除します。
/**
* 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);
}
私は$.inArrayを使ってその値で要素を削除する、このバージョンのspliceが好きです。
$(document).ready(function(){
var arr = ["C#","Ruby","PHP","C","C++"];
var itemtoRemove = "PHP";
arr.splice($.inArray(itemtoRemove, arr),1);
});
array内に存在する場合は、各splice-itemとarray項目を反復処理できます。
function destroy(arr, val) {
for (var i = 0; i < arr.length; i++) if (arr[i] === val) arr.splice(i, 1);
return arr;
}
Array.prototypeを介して反復処理するときにエラーになることなく配列内の目的の要素を削除するために、Object.definePropertyを介してfor .. in ..上にpolyfillを作成しました。
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)
}
整数値を削除する
var a = [1, 2, 3]
a.remove(2)
a // Output => [1, 3]
文字列値を削除する
var a = ['a', 'ab', 'abc']
a.remove('abc')
a // Output => ['a', 'ab']
ブール値を削除する
var a = [true, false, true]
a.remove(false)
a // Output => [true, true]
このArray.prototype.removeメソッドを介して配列内のオブジェクトを削除することも可能です。削除したいObjectのkey => valueを指定するだけです。
オブジェクト値を削除する
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}]
基本のJavaScript配列をかなり効率的に拡張しました。
Array.prototype.drop = function(k) {
var valueIndex = this.indexOf(k);
while(valueIndex > -1) {
this.removeAt(valueIndex);
valueIndex = this.indexOf(k);
}
};
私のソリューションでは、純粋なJavaScriptのおかげで、配列内の1つまたは複数の項目を削除できます。他のJavaScriptライブラリは必要ありません。
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]
元の配列を変更せずに、緩やかな比較を使用して1つの値を削除
/**
* 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;
}
さらにもう一つの答えは、私にとっては単純な方が良いことであり、そして2018年（2019年近く）にいるように、私はあなたに元の質問に答えるためにこの（近い）ライナーを与えます。
Array.prototype.remove = function (value) {
return this.filter(f => f != value)
}
便利なのは、次のようなカレー表現で使うことができるということです。
[1,2,3].remove(2).sort()
上記の回答の大部分はこの質問に答えますが、なぜslice()メソッドが使われていないのか十分には明らかではありません。はい、filter()は不変性の基準を満たしていますが、次のような短い等価物を実行してみてください。
const myArray = [1,2,3,4];
それでは、配列から2番目の要素を削除する必要があるとしましょう。 const newArray = myArray.slice(0,1).concat(myArray.slice(2,4));// [1,3,4]
配列から要素を削除するこの方法は、その単純で不変の性質のために今日コミュニティで強く推奨されています。一般に、突然変異を引き起こす方法は避けるべきです。たとえば、Push()をconcat()に、splice()をslice()に置き換えることをお勧めします。
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>配列から特定の要素/文字列を削除することは、ワンライナーで行うことができます。
theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);
'theArray'は特定のものを削除したい配列です。
その場で配列要素を削除するコードを投稿し、同様に配列の長さを短くします。
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();
}
ここには素晴らしい答えがたくさんありますが、私にとって最もうまくいったのは、配列から要素を完全に削除するのではなく、単にその値をnullに設定することでした。これは私が持っているほとんどの場合にうまくいきます、そして私が後で変数を使うことになり、それがなくなって欲しくないので、良い解決策です。また、この方法はブラウザ間で完全に互換性があります。
array.key = null;
最後の出現またはすべての出現、または最初の出現を削除しますか？
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
}
}
または
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
}
}
重複した数字や文字列が削除された新しい配列を返すメソッドを複製しようとする人のために、これは既存の答えからまとめられています。
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;
}
機能を作りました
function pop(valuetoremove, myarray) {
var indexofmyvalue = myarray.indexOf(valuetoremove);
myarray.splice(indexofmyvalue, 1);
}
そしてこんな感じ。
pop(valuetoremove,myarray);
乾杯！
非常に素朴な実装は次のようになります。
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);Array.prototype.Push()のような他のメソッドに準拠するために、関数から配列の長さを返します。
私は自分自身でこの問題を抱えていて（配列の置き換えが受け入れられる状況で）、それを簡単な方法で解決しました。
var filteredItems = this.items.filter(function (i) {
return i !== item;
});
上記のスニペットに少し文脈を与えるために：
self.thingWithItems = {
items: [],
removeItem: function (item) {
var filteredItems = this.items.filter(function (i) {
return i !== item;
});
this.items = filteredItems;
}
};
この解決策は、参照項目と値項目の両方で機能します。この解決策が適用可能かどうかに関して、元の配列への参照を維持する必要があるかどうかは、すべて異なります。
var array = [2, 5, 9];
array.splice(array.findIndex(x => x==5), 1);
Array.findindexを使うと、コードの行数を減らすことができます。
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;
このソリューションは入力の配列を受け取り、削除する値を入力で検索します。これは入力配列全体をループし、結果は特定のインデックスが削除された2番目の配列整数になります。整数配列はその後入力配列にコピーされます。
あなたの質問は、順序や個別の値が必要条件であるかどうかを示していませんでした。
順序を気にせず、コンテナ内で同じ値を複数回使用しない場合は、Setを使用します。それはずっと速く、そしてもっと簡潔になるでしょう。
var aSet = new Set();
aSet.add(1);
aSet.add(2);
aSet.add(3);
aSet.delete(2);
[2,3,5].filter(i => ![5].includes(i))
インデックスとスプライスで値を削除する
function removeArrValue(arr,value) {
var index = arr.indexOf(value);
if (index > -1) {
arr.splice(index, 1);
}
return arr;
}
最後から要素を削除
arrName.pop();
最初から要素を削除
arrName.shift();
途中から削除
arrName.splice(starting index,number of element you wnt to delete);
Ex: arrName.splice(1,1);
最後から1要素削除
arrName.splice(-1);
配列インデックス番号を使用して削除する
delete arrName[1];
キーがこれらの整数に相当する文字列であるオブジェクトではなく、整数の配列を持っているのは何と残念です。
私はこれらの答えの多くに目を通しました、そして、彼らはすべて、私が見ることができる限り「強引な」力を使用するようです。私はすべてを一つ一つ調べたわけではありませんが、そうでなければおaびします。小さな配列の場合、これは問題ありませんが、何千もの整数が含まれている場合はどうでしょうか？
私が間違っている場合、私を修正しますが、JSオブジェクトのようなkey => valueマップで、キー取得メカニズムは高度に設計され最適化されていると想定できませんか？ （ただし、一部の超専門家がそうではないことを教えてくれた場合、ES6の Map class を代わりに使用することをお勧めします。
特定の状況において、最善の解決策は配列をオブジェクトに変換することであることをお勧めしているだけです。もちろん、問題は整数値が繰り返される可能性があることです。これらをkey => valueエントリの「値」部分としてバケットに入れることをお勧めします。 （NB繰り返し配列要素がないことが確かな場合、これははるかに簡単です。値は「同じ」キーで、変更された配列を取得するためにObject.values(...)に移動します）。
だからあなたができる：
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 );
出力：
これで、すべての番号を簡単に削除できます55
delete myIntsMapObj[ 55 ]; // again, although keys are strings this works
それらをすべて削除する必要はありません：インデックス値は、出現順にバケットにプッシュされるため、たとえば：
myIntsMapObj[ 55 ].shift(); // and
myIntsMapObj[ 55 ].pop();
最初と最後の出現をそれぞれ削除します。発生頻度を簡単に数えたり、1つのバケットの内容を別のバケットに転送するなどして、55をすべて3に置き換えることができます。
...変更したint配列を取り戻すことはわずかに関係します：ただし、各バケットには（文字列）キーで表される値のインデックス（元の配列内）が含まれます。これらの各バケット値も一意です。したがって、値として「整数文字列キー」からの（実際の）整数を使用して、新しいオブジェクトのキーに変換します。その後、キーをソートしてObject.values( ... )に進みます。
これは非常に複雑で時間がかかるように思えますが、明らかにすべてが状況と望ましい使用法に依存します。私の理解では、JSのすべてのバージョンとコンテキストは1つのスレッドでのみ動作し、スレッドは「解放」されないため、「ブルートフォース」メソッドで恐ろしい輻輳が発生する可能性があります：indexOf ops 、複数のslice/splice opsが繰り返されます。
補遺
あなたがsureである場合、これはユースケースにとってはエンジニアリングが多すぎます。確かに最も単純な「ブルートフォース」アプローチは
const arr = [ 1, 2, 3, 66, 8, 2, 3, 2 ];
const newArray = arr.filter( number => number !== 3 );
console.log( newArray )
（はい、他の回答はArray.prototype.filter...を発見しました）
次のメソッドは、新しい配列を作成せずに、 superfast という反復を1回実行して、指定された値のすべてのエントリを配列から削除します。そしてそれは古代で動作します Internet Explorer 5.5 browser：
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>特定の要素またはそれ以降の要素を削除するには、 Array.splice（） methodを使用します。 splice（）メソッドは、既存の要素を削除または置換したり、新しい要素を追加したりして配列の内容を変更します削除されたアイテムを返します。
構文： array.splice（index、deleteCount、item1、.....、itemX）
ここでindexは必須で、rest引数はオプションです。
例えば：
let arr = [1, 2, 3, 4, 5, 6];
arr.splice(2,1);
console.log(arr);
// [1, 2, 4, 5, 6]
注： Array.splice（） メソッドは、削除したい要素のインデックスがわかっている場合に使用できます。しかし、以下に述べるように、さらにいくつかのケースがあります -
最後の要素だけを削除したい場合は、 Array.pop（） を使用します。
最初の要素だけを削除したい場合は、 Array.shift（） を使用します。
要素だけを知っていても要素の位置（またはインデックス）はわかっておらず、 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]
または、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]
OR 配列arrからdelを削除したいとします。
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);
}
}
要素だけを知っていて要素の位置（またはインデックス）はわかっておらず、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]
古いバージョンのInternet Explorerをサポートする必要がある場合は、次のpolyfillを使用することをお勧めします（注：これは ではなく フレームワークです）。これは、Internet Explorer 6以降、Firefox 1.5以降、Chrome、Safari、およびOperaで機能するすべての最新の配列メソッド（JavaScript 1.8.5/ECMAScript 5 Array Extras）の100％下位互換の代替品です。
多くの場合、filter関数を使って新しい配列を作成するほうが良いでしょう。
const array = [1,2,3,4];
array = array.filter(i => i !== 4); // [1,2,3]
これも読みやすさを向上させます。私はスライスのファンではありません、それは時々あなたがそれのために行くべきであることを知っていますが。
JavaScriptのプロトタイピング機能を使用して、配列オブジェクトにremove（）という名前のメソッドを定義します。
あなたの要求を満たすために splice（） methodを使ってください。
以下のコードを見てください。
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 ]
注： 以下は、 Node.js REPL で実行される完全なコード例です。これは、Push（）、pop（）、shift（）、unshift（）、およびspliceの使用方法を説明します。 （）メソッド.
> // 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
>
ありがとう。
配列から要素を削除するためのスプライス、フィルタ、削除
すべての配列にはインデックスがあり、特定の要素をインデックスから削除するのに役立ちます。
splice（）メソッド
array.splice（index、 1 ）; 1番目のパラメータはindex、2番目のパラメータはあなたが使った要素の数です。
そのインデックスから削除したい。
したがって、単一の要素に対しては1を使用します。
削除メソッド
配列を削除する[インデックス]
filter（）メソッド
配列内で繰り返されている要素を削除したい場合は、配列をフィルタリングします。
removeAll = array.filter（e => e！= elem）;
elemは配列から削除したい要素、arrayはあなたの配列名です。
splice（）メソッドは、既存の要素を削除または置き換えたり、新しい要素を追加したりすることによって、配列の内容を変更します。
array.splice（開始[、deleteCount [、item1 [、item2 [、...]]]]））
start
（Origin 0で）配列の変更を開始する位置のインデックス。配列の長さより大きい場合、実際の開始インデックスは配列の長さに設定されます。負の値の場合、（Origin -1で）配列の末尾からその要素数だけ開始し、絶対値が配列の長さより大きい場合は0に設定されます。
deleteCountオプション
削除する古い配列要素の数を示す整数。 deleteCountが省略されている場合、またはその値がarray.length - startより大きい場合（つまり、配列の残りの要素数よりも大きい場合） array、startから始まり、arrayのstartからendまでのすべての要素が削除されます。 deleteCountが0または負の値の場合、要素は削除されません。この場合、少なくとも1つの新しい要素を指定する必要があります（下記参照）。
item1、item2、...オプション
開始インデックスから始まる、配列に追加する要素。要素を指定しないと、splice（）は配列から要素を削除するだけです。
より多くの参照のために親切に通過しなさい：
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice
すでにたくさんの答えがありますが、1人のライナーではまだ誰もやっていないので、私は自分の方法を示したいと思いました。これは、string.split（）関数が配列を作成するときに指定された文字をすべて削除するという事実を利用しています。これが一例です。
var ary = [1,2,3,4,1234,10,4,5,7,3];
out = ary.join("-").split("-4-").join("-").split("-");
console.log(out);この例では、4のすべてが配列aryから削除されています。ただし、文字 " - "を含むすべての配列でこの例で問題が発生することに注意することが重要です。つまり、join（ " - "）関数があなたの文字列を不適切につなぎ合わせることになります。このような状況では、上記のスニペットの " - "文字列はすべて、元の配列で使用されない文字列に置き換えることができます。これは別の例です。
var ary = [1,2,3,4,'-',1234,10,'-',4,5,7,3];
out = ary.join("!@#").split("!@#4!@#").join("!@#").split("!@#");
console.log(out);非インプレースソリューション
arr.slice(0,i).concat(arr.slice(i+1));
let arr = [10, 20, 30, 40, 50]
let i = 2 ; // position to remove (starting from 0)
let r = arr.slice(0,i).concat(arr.slice(i+1));
console.log(r);配列オブジェクトを拡張して、次のようにカスタム削除関数を定義できます。
let numbers = [1,2,4,4,5,3,45,9];
numbers.delete = function(value){
var indexOfTarget = this.indexOf(value)
if(indexOfTarget !== -1)
{
console.log("array before delete " + this)
this.splice(indexOfTarget, 1)
console.log("array after delete " + this)
}else{
console.error("element " + value + " not found")
}
}
numbers.delete(888)
//expected output:
//element 888 not found
numbers.delete(1)
//expected output;
//array before delete 1,2,4,4,5,3,45,9
//array after delete 2,4,4,5,3,45,9それがお役に立てば幸いです
以下のようにreduceメソッドの利益を取る：
a）インデックスによって要素を削除する必要がある場合
function remove(arr, index) {
return arr.reduce((prev, x, i) => prev.concat(i !== index ? [x] : []), []);
}
ケースb）uがelement（int）の値だけ要素を削除する必要がある場合：
function remove(arr, value) {
return arr.reduce((prev, x, i) => prev.concat(x !== value ? [x] : []), []);
}
したがって、このようにして、要素を削除した状態で新しい配列を返すことができます（クールで機能的な方法になります - Pushまたはspliceを使用するよりもはるかに優れています）。
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;
}
var arr =[1,2,3,4,5];
arr.splice(0,1)
console.log(arr)
出力[2、3、4、5]。