Javascript - Defined - How to remove an element from an array by value? How to remove a specific element of a JavaScript array? js removing from array.
AT javascript remove array element can be done in several ways. These include the pop and shift methods. The pop method removes the first element from the given array. The shift method removes the last element from the given array.
You can set the array length to 0 if you want to remove all elements from the given array. But what, do you need to remove a certain element?
For example:
Array_name.splice(index);
Array_name.delete
You can use the splice method. It returns a new array of removed elements. And the original array contains the remaining elements.
Check out the demo below to learn how to use the JavaScript splice method and other ways to remove specific elements.
Demonstration of removing a specific element using the splice method
This demo creates an array of numbers. Initially, five elements are added to the array. The splice method is then used to remove the third element. Similarly, in JavaScript, you can remove the first element of an array.
The elements of a numeric array are displayed before and after using the JavaScript splice method as follows:
JavaScript code with splice method:
You may have noticed that I used two parameters for the JavaScript to remove an array element. The first specifies the index of the element to be removed. The second is how many elements to remove after the specified key.
The following demo shows the case where we use the second parameter.
What if the second parameter is not specified in the JavaScript splice method?
Using the same code but without the second parameter in the splice method:
Arr_Numbers.splice(2);
Code and result:
View online demo and code
As you can see, all elements before the specified index number have been removed here as well. In addition, the splice method returns an array of removed elements.
JavaScript code:
Using the delete function to remove an array element
You can also use the delete function to remove an element from an array in JavaScript. But it saves empty space, and if you return this array after using the function, then the removed element will be displayed as undefined .
Consider a demo that uses the delete function:
View online demo and code
JavaScript code:
You can see that the third element is rendered undefined after it has been removed with the delete function.
remove specific element of js array(20)
Is there a way to remove an element from a JavaScript array?
Given an array:
Var ary = ["three", "seven", "eleven"];
I would like to do something like:
RemoveItem("seven", ary);
I have looked into splice() but that only removes the position number whereas I need something to remove the element by its value.
// edited thanks to MarcoCI for the tips
try it:
Function wantDelete(item, arr)( for (var i=0;i hope this helps you Let commentsWithoutDeletedArray = commentsArray.filter((comment) => !(comment.Id === commentId)); Here is the version that uses jQuery's inArray function: var index = $.inArray(item, array); if (index != -1) ( array.splice(index, 1); ) You can achieve this using the function lodash _.remove . var array = ["three", "seven", "eleven"]; var evens = _.remove(array, function(e) ( return e !== "seven"; )); console log(evens); Const _ = require("lodash"); _.without(, 2); // -> Indeed, I don't understand why this can't be solved with Arr = arr.filter(value => value !== "seven"); Or maybe you want to use vanilla JS Arr = arr.filter(function(value) ( return value !== "seven" )); Another variant: If (!Array.prototype.removeArr) ( Array.prototype.removeArr = function(arr) ( if(!Array.isArray(arr)) arr=;//let"s be nice to people who put a non-array value here.. that could be me! var that = this; if(arr.length)( var i=0; while(i It's indexOf() inside the loop again, but assuming the array to remove is small relative to the array to be cleared; each deletion shortens the while loop. This will allow you to do the following: Var ary = ["three", "seven", "eleven"]; var aryWithoutSeven = ary.filter(function(value) ( return value != "seven" )); console.log(aryWithoutSeven); // returns ["three", "eleven"] This was also noted in this thread somewhere else: https://.com/a/20827100/293492 Don't use the delete option - it makes a hole in the array since it doesn't reindex the elements after the deleted element. > Array.prototype.remove=function(v)( ... delete this ... ); > var myarray=["3","24","55","2"]; undefined > myarray.remove("55"); undefined > myarray [ "3", "24", "2" ] One liner will do it Var ary = ["three", "seven", "eleven"]; // Remove item "seven" from array var filteredAry = ary.filter(function(e) ( return e !== "seven" )) //=> ["three", "eleven"] // In ECMA6 (arrow function syntax): var filteredAry = ary.filter(e => e !== "seven") This uses the filter function in JS. It is supported in IE9 and above. filter() calls the provided callback function once for each element in the array, and creates a new array from all values for which the callback returns a value that results in true. callback is called only for array indexes that have been assigned values; it is not called for indexes that have been dropped or that have never been assigned a value. Array elements that fail the callback test are simply skipped and not included in the new array. So basically, it's the same as all the other for (var key in ary) ( ... ) solutions, except that for in is supported as of IE6. Basically, a filter is a convenience method that looks much nicer (and is chainable) as opposed to a for in constructor (AFAIK). Check it: For(var i in array)( if(array[i]=="seven")( array.splice(i,1); break; ) ) and in the function: Function removeItem(array, item)( for(var i in array)( if(array[i]==item)( array.splice(i,1); break; ) ) ) removeItem(array, "seven"); Removing all matching elements from an array (not just the first one seems to be the most general answer here): While ($.inArray(item, array) > -1) ( array.splice($.inArray(item, array), 1); ) I used jQuery for the hard work, but you get the idea if you want to go native. The trick is to go through the array from start to start so you don't mess up the indexes when you remove elements. Var deleteMe = function(arr, me)( var i = arr.length; while(i--) if(arr[i] === me) arr.splice(i,1); ) var arr = ["orange ","red","black", "orange", "white" , "orange" ]; deleteMe(arr , "orange"); arr is now ["red", "black", "white"] Function cleanArrayOfSpecificTerms(array,unwantedTermsArray) ( $.each(unwantedTermsArray, function(index, value) ( var index = array.indexOf(value); if (index > -1) ( array.splice(index, 1); ) ) ); return array; ) To use, follow these steps: Var notInclude = ["Not","No","First","Last","Prior","Next", "dogs","cats"]; var splitTerms = ["call", "log", "dogs", "cats", "topic", "change", "pricing"]; cleanArrayOfSpecificTerms(splitTerms,notInclude) I tried using the function method from jbaron above but found that I need to keep the original array intact for later use and create a new array like this: var newArray = referenceArray; Function newArrRemoveItem(array, item, newArray)( for(var i = 0; i< array.length; i++) {
if(array[i]!=item){
newArray.push(array[i]);
}
}
}
Then I use it like this: Var vesselID = record.get("VesselID"); var otherVessels = new Array(); newArrRemoveItem(vesselArr,vesselID,otherVessels); Now the vesselArr remains intact, and every time I execute the above code, the otherVessels array includes all but the last CAID element. indexOf is an option, but its implementation basically searches the entire array for the value, so the execution time grows with the size of the array. (so it's in every browser, I guess, I only checked Firefox). I don't have IE6 to check, but I'd call it a safe bet that you can check at least a million array elements per second this way on almost any client machine. If [array size] * [ search terms per second] can grow to more than a million, you should consider a different implementation. Basically you can use an object to create an index for your array like so: Var index=("three":0, "seven":1, "eleven":2); Any normal JavaScript environment will create a lookup index for such objects so you can quickly translate a key into a value, no matter how many properties the object has. This is just a basic method, depending on your needs, you can concatenate multiple objects and/or arrays to make the same data quickly searchable for different properties. If you specify your specific needs, I can suggest a more specific data structure. //This function allows remove even array from array var removeFromArr = function(arr, elem) ( var i, len = arr.length, new_arr = , sort_fn = function (a, b) ( return a - b; ); for ( i = 0 i< len; i += 1) {
if (typeof elem === "object" && typeof arr[i] === "object") {
if (arr[i].toString() === elem.toString()) {
continue;
} else {
if (arr[i].sort(sort_fn).toString() === elem.sort(sort_fn).toString()) {
continue;
}
}
}
if (arr[i] !== elem) {
new_arr.push(arr[i]);
}
}
return new_arr;
}
Usage example Var arr = , "abc", 1, "1", 1]; removeFromArr(arr, 1); //["2", , "abc", "1"] var arr = [ , 2, "a", , ]; removeFromArr(arr, ); //] Let arr = ; console log(arr); //result let index = arr.indexOf(30); if (index > -1) ( arr.splice(index, 1); ) console.log(arr); //result var index = array.indexOf("item"); if(index!=-1)( array.splice(index, 1); ) I have an array of integers and I am using the .push() method to add elements to it. Is there an easy way to remove a specific element from an array? The equivalent of something like array.remove(int); , I have to use base javascript- none frames are not allowed. RemoveByIndex(,1) //=> In this code example I am using "array.filter(...)" function to remove unwanted elements from an array, this function does not change the original array and creates a new one. If your browser does not support this feature (for example, IE prior to version 9 or Firefox prior to version 1.5), consider using filter polyfill from Mozilla . IMPORTANT ES2015 "() => ()" arrow function syntax is not supported in IE at all, Chrome before version 45, Firefox before version 22, Safari before version 10. To use ES2015 syntax in older browsers you can use BabelJS An added benefit of this method is that you can remove multiple elements Let forDeletion = let arr = arr = arr.filter(item => !forDeletion.includes(item)) // !!! Read below about array.includes(...) support !!! console.log(arr) // [ 1, 4 ] IMPORTANT"array.includes(...)" is not supported in IE at all, Chrome before version 47, Firefox before version 43, Safari before version 9 and Edge before version 14, so Here are some ways remove element from array JavaScript
. All described methods do not change the original array and create a new one instead. Let's say you have an array and you want to remove the element at position i . One way is to use 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() creates a new array with the indices it receives. We simply create a new array - from the beginning to the index we want to remove, and concatenate another array from the first position following the one we removed to the end of the array. In this case one a good option- use filter() which offers more declarative an approach: const items = ["a", "b", "c", "d", "e", "f"] const valueToRemove = "c" const filteredItems = items.filter(item => item !== valueToRemove) console.log(filteredItems) This uses the ES6 arrow functions. You can use traditional features to support older browsers: const items = ["a", "b", "c", "d", "e", "f"] const valueToRemove = "c" const filteredItems = items.filter(function(item) ( return item != = valueToRemove )) console.log(filteredItems) or you can use Babel and convert the ES6 code back to ES5 to make it more readable for older browsers, but write modern JavaScript in your code. What if instead of one element you want to remove many elements? Let's find the simplest solution. You can just create a function and remove elements sequentially: 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) You can look for an include inside a callback function: 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() (not to be confused with slice()) mutates the original array and should be avoided. You can use ES6. Var array=["1","2","3","4","5","6"] var index = array.filter((value)=>value!="3"); ["1", "2", "4", "5", "6"] You can do this easily with the filter method: Function remove(arrOriginal, elementToRemove)( return arrOriginal.filter(function(el)(return el !== elementToRemove)); ) console.log(remove(, 1)); This removes all elements from the array and is also faster than the combination of slice and indexOf You should never mutate an array of an array. Because it goes against the functional programming pattern. You can create a new array without referencing the array you want to change using the es6 method filter; Var myArray = ; Let's say you want to remove 5 from an array, you can just do it like this. MyArray = myArray.filter(value => value !== 5); This will give you a new array without the value you want to remove. So the result will be ; // 5 has been removed from this array For further understanding, you can read the MDN documentation on Array.filter filter If you want the new array with the positions removed, you can always remove the specific element and filter the array. It might need to extend the array object for browsers that don't implement a filter method, but it's easier in the long run since all you do is this: var my_array = ; delete my_array; console.log(my_array.filter(function(a)(return typeof a !== "undefined";))); Must be displayed If you have complex objects in an array, can you use filters? In situations where $.inArray or array.splice are not that easy to use. Especially if the objects are perhaps small in the array. For example, if you have an object with an Id field and you want the object to be removed from the array: This.array = this.array.filter(function(element, i) ( return element.id !== idToRemove; )); Find the index of the array element you want to remove, then remove that index with splice . The splice() method modifies the contents of an array by removing existing elements and/or adding new elements. var array = ; console.log(array) var index = array.indexOf(5); if (index > -1) ( array.splice(index, 1); ) // array = console.log(array); The second parameter to splice is the number of elements to remove. Note that splice modifies the array in place and returns a new array containing the removed elements. You have 1 to 9 arrays and want to remove 5 using below code. varnumberArray = ; var newNumberArray = numberArray.filter(m => ( return m !== 5; )); console.log("new Array, 5 removed", newNumberArray); If you want to use multiple values ex:- 1,7,8 varnumberArray = ; var newNumberArray = numberArray.filter(m => ( return (m !== 1) && (m !== 7) && (m !== 8); )); console.log("new Array, 5 removed", newNumberArray); If you want to remove array value in array ex:- varnumberArray = ; var removeableArray = ; var newNumberArray = numberArray.filter(m => ( return !removebleArray.includes(m); )); console.log("new Array, removed", newNumberArray); includes supported browser - link I know there are many answers already, but many of them seem to complicate the problem. Here is a simple, recursive way to remove all instances of a key - calls self until the index is found. Yes, it only works in indexOf browsers, but it's simple and can be filled in easily. Offline function Function removeAll(array, key)( var index = array.indexOf(key); if(index === -1) return; array.splice(index, 1); removeAll(array,key); ) Prototype method Array.prototype.removeAll = function(key)( var index = this.indexOf(key); if(index === -1) return; this.splice(index, 1); this.removeAll(key); ) 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 = this;
}
this.length = this.length - 1
return;
}
}
}
var recentMovies = ["Iron Man", "Batman", "Superman", "Spiderman"];
recentMovies.removeItem("Superman"); I described only a part of the methods for working with arrays. Here we will talk about adding, removing array elements. About flipping and sorting an array, as well as slicing, replacing and combining arrays. You can use the length property to add new elements to an array: Var myArray = ["Apple", "Microsoft", "Google", "Facebook"]; myArray = "Yahoo!"; console log(myArray); // ["Apple", "Microsoft", "Google", "Facebook", "Yahoo!"] This will work, because array elements are numbered from zero, and length one more. Length always equivalent index + 1, so it's very easy to add new element to the end of the array. Strangely, you can add an element at a position that is much larger than the length of the array itself: Var myArray = ["Jimi Hendrix", "Eric Clapton", "Jimmy Page", "Keith Richards"]; myArray = "Lindsey Buckingham"; console log(myArray); // ["Jimi Hendrix", "Eric Clapton", "Jimmy Page", "Keith Richards", undefined × 95, "Lindsey Buckingham"] console.log(myArray.length); // 100 As shown in the comments, 95 empty slots will be added and the element "Lindsey Buckingham" will be added to the end of the array. After that, we will get a length of 100. Another way to add a new element to the array is to use the method push(): Var myArray = ["Paul McCartney", "John Lennon", "George Harrison"]; myArray.push("Ringo Starr", "George Martin"); console log(myArray); // ["Paul McCartney", "John Lennon", "George Harrison", "Ringo Starr", "George Martin"] Method push() always returns the new length of the array (5 in our case). You can add an element with splice(): Var myArray = ["acorn", "beech", "mongongo", "macadamia"]; myArray.splice(2, 0, "cashew"); // adds "cashew" into index 2 console.log(myArray); // ["acorn", "beech", "cashew", "mongongo", "macadamia"] When the second argument is 0, this means that no element will be removed, and therefore any subsequent arguments will be added to the array at the position specified in the first argument. Removing an element is a little more difficult than adding it. To remove an element from the end of an array, one can use pop(): Var myArray = ["7-up", "Sprite", "Ginger Ale", "Lemonade"]; myArray.pop(); console log(myArray); // ["7-up", "Sprite", "Ginger Ale"] Method pop() always removes the last element in the array and returns it. You can also use splice() method: Var myArray = ["cassava", "nutmeg", "lupin", "rhubarb"]; myArray Splice(2, 1); // remove element at index 2 console.log(myArray); // ["cassava", "nutmeg", "rhubarb"] Unlike the method splice(), which is used to add elements, here the second argument is 1, which says that we want to remove the element with index 2 (or 3rd in a row). In this case, the "lupin" element has been removed. You can remove an element from an array using the operator delete: Var myArray = ["Byte Bandit", "Eliza", "Jeefo", "Michelangelo"]; console.log(myArray.length); // 4 delete myArray; // delete Eliza console.log(myArray.length); // 4 console.log(myArray); // ["Byte Bandit", undefined × 1, "Jeefo", "Michelangelo"] First important note: delete() does not change the length of the array after the element is removed (even if it was the last element in the array). Second: delete() changes the value of the element being removed to undefined, so when accessed myArray = undefined. A good way to remove an element from an array is to use John Resig's Array.remove . Below is an example of usage taken from his page: // 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);
};
// Удаление 2 элемента из массива
array.remove(1);
// Удаление 2-ого элемента с конца массива
array.remove(-2);
// Удаление второго и третьего элемента
array.remove(1,2);
// Удаление последнего и предпоследнего элемента
array.remove(-2,-1);
You might want to look at the solution by Viral Patel , one of the functions in Underscore.js , or jQuery's grep() . Additionally, in JavaScript there is a method shift(), which removes the first element in the array and returns its value. Let's see the code: Var myArray = ["Matt Kramer", "Jason Bieler", "Tom Defile", "Phil Varone"]; console.log(myArray.length); // 4 var firstItem = myArray.shift(); console.log(firstItem); // Matt Kramer console.log(myArray.length); // 3 console.log(myArray); // ["Jason Bieler", "Tom Defile", "Phil Varone"] Using the method shift() we've removed the item but stored its value in our firstItem variable. The length of the array has changed from 4 to 3. This method can be useful along with the method push(). By using them together, we can efficiently queue up the elements in an array. We store the length of an array by removing an element from the beginning and adding a new one to the end. Conversely, we can use the method unshift() to add an element to the beginning of an array: Var myArray = ["apito", "castanets", "maraca"]; console.log(myArray.length); // 3 myArray.unshift("chime bar", "tan-tan"); console.log(myArray.length); // 5 console.log(myArray); // ["chime bar", "tan-tan", "apito", "castanets", "maraca"] Using method unshift() with method pop(), you can create queues in the opposite direction by adding elements to the beginning and removing from the end of the array. To reverse the elements in an array, we can use reverse(): Var myArray = ["countdown", "final", "the"]; console log(myArray); // ["countdown", "final", "the"] myArray = myArray.reverse(); console log(myArray); // ["the", "final", "countdown"] It is possible to sort the elements of an array in alphabetical order using the method sort(): Var myArray = ["xylophones", "zebras", "juggernauts", "avocados"]; console log(myArray); // ["xylophones", "zebras", "juggernauts", "avocados"] myArray = myArray.sort(); console log(myArray); // ["avocados", "juggernauts", "xylophones", "zebras"] But it won't work with numbers. Var myArray = ; console log(myArray); // myArray = myArray.sort(); console log(myArray); // If you need to sort numbers, you can use the following code: Function compareNumbers(a, b) ( return a - b; ) var myArray = ; console log(myArray); // myArray = myArray.sort(compareNumbers); console log(myArray); // As shown above, with a simple function inserted in sort(), an array containing numbers will be sorted correctly. We can merge 2 or more arrays and get 1 array that contains the elements of the joined arrays. For this we use the method concate(): Var myArray = ["Jay Ferguson", "Andrew Scott"]; var myArray2 = ["Chris Murphy", "Patrick Pentland"]; var myNewArray = myArray.concat(myArray2); console.log(myNewArray); // ["Jay Ferguson", "Andrew Scott", "Chris Murphy", "Patrick Pentland"] Var myArray = ["Jay Ferguson", "Andrew Scott"]; var myNewArray = myArray.concat("Chris Murphy", "Patrick Pentland"); console.log(myNewArray); // ["Jay Ferguson", "Andrew Scott", "Chris Murphy", "Patrick Pentland"] We can create a new array containing 1 or more elements from an existing array using the function slice(): Var myArray = ["Vocals", "Bass", "Guitar", "Drums", "Apples", "Oranges"]; var myNewArray = myArray.slice(4); console.log(myNewArray); // ["Apples", "Oranges"] Method slice() takes 1 or 2 arguments. If 1 argument (index) is passed, then a new array is created from all elements of the old one, starting from the given index. If 2 arguments are given, then a new array is created from the elements starting from the first argument and up to the element with the index passed in the second parameter, not including the last one. To make it clearer, let's see the code below: Var myArray = ["Vocals", "Bass", "Guitar", "Drums", "Apples", "Oranges"]; var myNewArray = myArray.slice(0, 4); console.log(myNewArray); // ["Vocals", "Bass", "Guitar", "Drums"] We use splice() to remove elements from an array, but we can also replace an element in an array with new elements: Var myArray = ["Rivers Cuomo", "Patrick Wilson", "Brian Bell", "Matt Sharp"]; myArray.splice(3, 1, "Scott Shriner"); // replace 1 element at index 3 console.log(myArray); // ["Rivers Cuomo", "Patrick Wilson", "Brian Bell", "Scott Shriner"] Method splice() always returns an array containing the elements that were removed. Line 2 will return 1 item "Brian Bell". These articles have described methods for working with arrays in JavaScript. There are some additional items on MDN that I didn't include in this post. They only work in IE9+, so they might not be useful. Have something to add? Or do you know some interesting library that will help you manage arrays? Comment please!How to remove a specific element from an array in JavaScript? (twenty)
ES6 and no mutation: (Oct 2016)
const removeByIndex = (list, index) => [ ...list.slice(0, index), ...list.slice(index + 1) ]; Edited October 2016
Removing an element (ECMA-262 Edition 5 code aka oldstyle JS)
var value = 3 var arr = arr = arr.filter(function(item) ( return item !== value )) console.log(arr) // [ 1, 2, 4, 5 ] Removing an element (ES2015 code)
let value = 3 let arr = arr = arr.filter(item => item !== value) console.log(arr) // [ 1, 2, 4, 5 ] Removing multiple elements (ES2016 code)
Removing Multiple Elements (Advanced Experimental 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 = // :: 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 ] If you know the element index
If you know the meaning
Deleting multiple items
By index
By value
Avoid mutating the original array
Adding elements to an array.
Removing elements from an array
Flipping and sorting array elements.
Union of arrays.
Splitting an array.
Replacing elements in an array.
Conclusion
