Remove value from js array. Javascript - remove - js arrays

I described only some of the methods for working with arrays.

Here we will talk about adding and removing array elements. About flipping and sorting an array, as well as about slicing, replacing and combining arrays.

You can use the length property to add new elements to the 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 starting from zero, and length is one more. Length is always equivalent to 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, this will add 95 empty slots and the element "Lindsey Buckingham" to the end of the array. After this we will get a length of 100. Another way to add a new element to the array is to use the push() method:

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

The push() method always returns the new array length (5 in our case). You can add an element using 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, it 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, you can use pop():

Var myArray = ["7-up", "Sprite", "Ginger Ale", "Lemonade"]; myArray.pop(); console.log(myArray); // ["7-up", "Sprite", "Ginger Ale"]

The pop() method always removes the last element in the array and returns it.

You can also use the splice() method:

Var myArray = ["cassava", "nutmeg", "lupin", "rhubarb"]; myArray.splice(2, 1); // remove element with index 2 console.log(myArray); // ["cassava", "nutmeg", "rhubarb"]

Unlike the splice() method, 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 in this case The "lupin" element was removed.

You can delete an array element using the delete operator:

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 deleting an element (even if it was the last element in the array). Second: delete() changes the value of the element being deleted to undefined, so when called myArray = undefined .

A good way to remove an element from an array is to use John Resig's Array.remove. Below is a usage example 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 Viral Patel's solution, one of the functions in Underscore.js, or jQuery's grep().

Additionally, JavaScript has a shift() method that removes the first element in an array and returns its value. Let's look at 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 shift() method we removed the element but stored its value in our firstItem variable. The array length changed from 4 to 3.

This method can be useful in conjunction with the push() method. Using them together we can efficiently queue elements in an array. We maintain the length of the array by removing an element from the beginning and adding a new one to the end.

Conversely, we can use the unshift() method to add an element to the beginning of the 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"]

By using the unshift() method with the pop() method, you can create reverse queues by adding elements to the beginning and removing elements 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 array elements in alphabetical order using the sort() method:

Var myArray = ["xylophones", "zebras", "juggernauts", "avocados"]; console.log(myArray); // ["xylophones", "zebras", "juggernauts", "avocados"] myArray = myArray.sort(); console.log(myArray); // ["avocados", "juggernauts", "xylophones", "zebras"]

But this 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 into sort(), the array containing numbers will be sorted correctly.

We can combine 2 or more arrays and get 1 array that contains the elements of the joined arrays. To do this we use the concat() method:

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 slice() function:

Var myArray = ["Vocals", "Bass", "Guitar", "Drums", "Apples", "Oranges"]; var myNewArray = myArray.slice(4); console.log(myNewArray); // ["Apples", "Oranges"]

The slice() method 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 this index. If 2 arguments are passed, 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 look at 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 the array with new elements:

Var myArray = ["Rivers Cuomo", "Patrick Wilson", "Brian Bell", "Matt Sharp"]; myArray.splice(3, 1, "Scott Shriner"); // replace 1 element with index 3 console.log(myArray); // ["Rivers Cuomo", "Patrick Wilson", "Brian Bell", "Scott Shriner"]

The splice() method always returns an array containing the elements that were removed. Line 2 will return 1 element "Brian Bell".

These articles described methods for working with arrays in JavaScript. There are some additional items you can look at on MDN that I didn't include in this post. They only work in IE9+, so they may not be useful.

Anything to add? Or do you know any interesting library that will help manage arrays? Please comment!

Use .shift to remove the first element of an array.

For example:

Var array = ; array.shift();

the array results in:

For example:

Var array = ; array.pop();

the array results in:

Both methods return the removed element;

Use .splice() to remove a series of elements from an array. .splice() takes two parameters, a starting index and an optional number of elements to remove. If the second parameter is not .splice() will remove all elements from the starting index through the end of the array.

For example:

Var array = ; array.splice(1, 2);

leaves an array containing:

array.splice() returns is a new array containing the removed elements. In the above example the return would be:

So omitting the second parameter effectively splits the array into two arrays with the original ending at the specified index:

Var array = ; array.splice(2);

Leaves array containing and returns .

Use delete to remove an element from an array without changing the length of the array:

Var array = ; console.log(array.length); // 5 delete array; console.log(array); // console.log(array.length); // 5

Assigning a value array length changes the length to the specified value. If the new value is less than the length of the array, elements will be removed from the end of the value.

Array = ; array.length = 2; console.log(array); //

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? Equivalent to something like array.remove(int); ,

I should use base JavaScript - none frames are not allowed.

RemoveByIndex(,1) //=>

• Make it simple, intuitive and explicit (https://en.wikipedia.org/wiki/Occam%27s_razor)
• Make it immutable (the original array will remain unchanged)
• Do this with standard JS functions, if your browser doesn't support them - use a polyfill

In this code example, I am using the "array.filter(...)" function to remove unnecessary elements from an array, this function does not change the original array and creates a new one. If your browser does not support this function (for example, IE before version 9 or Firefox before version 1.5), consider using the polyfill filter 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 additional 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 to remove an element from an array using JavaScript.

All the methods described do not change the original array and instead create a new one.

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 start to the index we want to delete, and concatenate another array from the first position following the one we deleted to the end of the array.

In this case, one good option is to 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 ES6 arrow functions. You can use traditional functions 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 delete many elements?

Let's find the simplest solution.

You can simply 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 inclusion inside the 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 also works faster than the slice and indexOf combination

You should never mutate an array of an array. Because it goes against the functional programming pattern. You can create a new array without a reference to the array you want to modify using the es6 method filter;

Var myArray = ;

Let's say you want to remove 5 from an array, you can simply 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 a new array with positions removed, you can always remove a specific element and filter the array. It might be necessary to extend the array object for browsers that don't implement the filter method, but in the long run it's easier since all you're doing is this:

Var my_array = ; delete my_array; console.log(my_array.filter(function(a)(return typeof a !== "undefined";)));

Should be displayed

If you have complex objects in an array, can you use filters? In situations where $.inArray or array.splice are not so 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 using 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 the code below.

var numberArray = ; var newNumberArray = numberArray.filter(m => ( return m !== 5; )); console.log("new Array, 5 removed", newNumberArray);

If you want to use multiple ex values: - 1,7,8

var numberArray = ; 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 ex array:-

var numberArray = ; var removebleArray = ; 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's a simple, recursive way to remove all instances of a key - call self until the index is found. Yes, it only works in browsers indexOf , 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");

// edited thanks to MarcoCI for the advice

try it:

Function wantDelete(item, arr)( for (var i=0;i !(comment.Id === commentId));

Here's a 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 Lodash _.remove function.

var array = ["three", "seven", "eleven"]; var evens = _.remove(array, function(e) ( return e !== "seven"; )); console.log(evens);

Const _ = require("lodash"); _.without(, 2); // ->

Really, 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-1)( that.splice(i,1); )else i++; ) ) return that; ) )

This is indexOf() inside the loop again, but under the assumption that the array to be deleted 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 elsewhere: 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 of all values ​​for which the callback returns a value that evaluates to true. callback is called only for array indices that have assigned values; it is not called for indexes that have been dropped or that were never assigned values. 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 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, as seems to be the most general answer here):

While ($.inArray(item, array) > -1) ( array.splice($.inArray(item, array), 1); )

I used jQuery for the heavy lifting, 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 indices 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 needed to keep the original array unchanged for use later 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 everything except the last CAID element.

indexOf is an option, but its implementation basically searches the entire array for a value, so the execution time increases with the size of the array. (so it's in every browser, I think, I only checked Firefox).

I don't have IE6 to test with, but I'd call it a safe bet that you can test at least a million array elements per second this way on almost any client machine. If [array size] * [search queries per second] is likely to grow beyond a million, you should consider a different implementation.

Basically you can use an object to create an index on your array, like this:

Var index=("three":0, "seven":1, "eleven":2);

Any normal JavaScript framework will create a search index for such objects so that 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 combine 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 you to 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); )