How can I remove a specific element from an array in JavaScript? (twenty)
I have an array of integers and I am using the .push () method to add items to it.
Is there an easy way to remove a specific element from an array? Equivalent to something like array.remove (int); ,
I have to use base JavaScript - none no frames are allowed.
ES6 and No Mutation: (Oct 2016)
const removeByIndex = (list, index) => [... list.slice (0, index), ... list.slice (index + 1)];RemoveByIndex (, 1) // =>
Edited October 2016
- Make it simple, intuitive and explicit (https://en.wikipedia.org/wiki/Occam%27s_razor)
- Make it unchanged (original array will remain unchanged)
- Do it with standard JS functions if your browser doesn't support them - use polyfill
In this example code, I am using function array.filter (...) " 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 feature (e.g. IE prior to 9 or Firefox prior to 1.5), consider using polyfill filter from Mozilla .
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]Delete item (ES2015 code)
let value = 3 let arr = arr = arr.filter (item => item! == value) console.log (arr) // [1, 2, 4, 5]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
Removing multiple items (ES2016 code)
An added benefit of this method is that you can remove multiple items
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 prior to version 47, Firefox prior to version 43, Safari prior to version 9 and Edge prior to version 14, so
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]Here are some ways remove element from array using javascript .
All described methods do not modify the original array and instead create a new one.
If you know the index of the element
Suppose 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 delete, and concatenate another array from the first position following the one we deleted to the end of the array.
If you know the meaning
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 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 your ES6 code back to ES5 to make it more digestible for older browsers, but write modern JavaScript in your code.
Removing multiple items
What if you want to delete many elements instead of one element?
Let's find the simplest solution.
By index
You can simply create a function and remove items 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)
By value
You can look for the 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)
Avoid mutating the original array
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 slice and indexOf combination
You should never mutate an array of an array. As this is contrary to the functional programming pattern. You can create a new array without referencing the array you want to modify using the es6 method filter;
Var myArray =;
Suppose 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 delete. 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 a specific element and filter the array. It might need to extend the array object for browsers that don't implement the filtering 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";)));
Should be displayed
If you have complex objects in an array, can you use filters? For situations where $ .inArray or array.splice is not that easy to use. Especially if the objects are possibly 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 splice parameter 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 you want to delete 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 delete an 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 a 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 delete all instances of a key - calls self until the index is found. Yes, it only works in indexOf browsers, but it is simple and can be easily populated.
Standalone 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");
How to remove an element from an array by value? (twenty)
// edited thanks to MarcoCI for advice
try this:
Function wantDelete (item, arr) (for (var i = 0; i hope this helps you Is there a way to remove an element from a JavaScript array? Given the array: Var ary = ["three", "seven", "eleven"]; I would like to do something like: RemoveItem ("seven", ary); I looked at splice () but that only removes the position number, whereas I need something to remove an element by its value. Let commentsWithoutDeletedArray = commentsArray.filter ((comment) =>! (Comment.Id === commentId)); Here is 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 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 do not understand why this cannot 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 This is indexOf () inside the loop again, but assuming the array to be deleted is small relative to the array to be cleaned; each removal 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 has also been noted in this thread somewhere else: https: //.com/a/20827100/293492 Don't use the delete option - it makes a hole in the array, as 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 is using the filter function in JS. It is supported in IE9 and up. filter () calls the provided callback function once for each element in the array and creates a new array from all the values for which the callback returns a value that evaluates to true. callback is called only for array indices that have been assigned values; it is not called for indexes that have been dropped or that have never been assigned values. Array elements that fail the callback test are simply skipped and not included in the new array. So it's basically the same as all the other for (var key in ary) (...) solutions, except that for in is supported as IE6. Basically the filter is a convenience method that looks much better (and is chained) as opposed to the 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 matched 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've used jQuery for some hard work, but you get the idea if you want to go to your native language. The trick is to loop through the array from start to start, so you don't mess up the indices when deleting 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 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 shipArr remains intact, and every time I execute the above code, the otherVessels array includes everything but the last CAID element. indexOf is an option, but its implementation basically searches the entire array for a value, so the runtime grows with the size of the array. (so this is in every browser, I think I only tested Firefox). I don't have IE6 to check, but I would 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] * [searches per second] could grow over a million, you should consider another implementation. Basically you can use an object to create an index for your array, for example: 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 to 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 provide 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);) V Javascript remove array element you can use several methods. These include the pop and shift methods. The pop method removes the first element from behind given array... The shift method removes the last element from the given array. You can set the length of the array to 0 if you want to remove all elements from the given array. But what, do you need to delete a specific element? For example: Array_name.splice (index); Array_name.delete The splice method can be used. It returns a new array of the 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. 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 noticed that I used two parameters for JavaScript to remove an array element. The first indicates the index of the element to be removed. The second is how many elements to remove after the specified key. The following demo shows a case where we use the second parameter. 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 items before the specified index number have been deleted here as well. In addition, the splice method returns an array of the removed items. JavaScript code: You can also use the delete function to delete an element in 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. Let's look at a demo version that uses the delete function: View online demo and code JavaScript code: You can see that undefined is displayed for the third element after deleting it using the delete function. The JavaScript delete operator removes a property from an object; if no more references to the same property are held, it is eventually released automatically. The source for this interactive example is stored in a GitHub repository. If you "d like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request. Any variable defined with var is marked as non-configurable. In the following example, salary is non-configurable and cannot be deleted. In non-strict mode, the delete operation will return false. Function Employee () (delete salary; var salary;) Employee (); Let "s see how the same code behaves in strict mode. Instead of returning false, the statement raises a SyntaxError. "use strict"; function Employee () (delete salary; // SyntaxError var salary;) // Similarly, any direct access to a function // with delete will raise a SyntaxError function DemoFunction () (// some code) delete DemoFunction; // SyntaxError In the following example, we delete an own property of an object while a property with the same name is available on the prototype chain: Function Foo () (this.bar = 10;) Foo.prototype.bar = 42; var foo = new Foo (); // foo.bar is associated with the // own property. console.log (foo.bar); // 10 // Delete the own property within the // foo object. delete foo.bar; // returns true // foo.bar is still available in the // prototype chain. console.log (foo.bar); // 42 // Delete the property on the prototype. delete Foo.prototype.bar; // returns true // The "bar" property can no longer be // inherited from Foo since it has been // deleted. console.log (foo.bar); // undefined When you delete an array element, the array length is not affected. This holds even if you delete the last element of the array. When the delete operator removes an array element, that element is no longer in the array. In the following example, trees is removed with delete. Var trees = ["redwood", "bay", "cedar", "oak", "maple"]; delete trees; if (3 in trees) (// this is not executed) If you want an array element to exist but have an undefined value, use the undefined value instead of the delete operator. In the following example, trees is assigned the value undefined, but the array element still exists: Var trees = ["redwood", "bay", "cedar", "oak", "maple"]; trees = undefined; if (3 in trees) (// this is executed) If instead, you want to remove an array element by changing the contents of the array, use the splice method. In the following example, trees is removed from the array completely using splice: Var trees = ["redwood", "bay", "cedar", "oak", "maple"]; trees.splice (3,1); console.log (trees); // ["redwood", "bay", "cedar", "maple"] The compatibility table on this page is generated from structured data. If you "d like to contribute to the data, please check out https://github.com/mdn/browser-compat-data and send us a pull request. Update compatibility data on GitHub Although ECMAScript makes iteration order of objects implementation-dependent, it may appear that all major browsers support an iteration order based on the earliest added property coming first (at least for properties not on the prototype). However, in the case of Internet Explorer, when one uses delete on a property, some confusing behavior results, preventing other browsers from using simple objects like object literals as ordered associative arrays. In Explorer, while the property value is indeed set to undefined, if one later adds back a property with the same name, the property will be iterated in its old position - not at the end of the iteration sequence as one might expect after having deleted the property and then added it back. I have described only a part of the methods for working with arrays. Here we will talk about adding, removing array elements. About inverting and sorting an array, as well as 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 from zero, and length one more. Length always equivalent index + 1 so it is very easy to add a new element to the end of the array. Strange, but 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 and a "Lindsey Buckingham" element will be added to the end of the array. After that, we get the length 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 (in our case 5). You can add an item 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, 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 of an array using the operator delete: Var myArray = ["Byte Bandit", "Eliza", "Jeefo", "Michelangelo"]; console.log (myArray.length); // 4 delete myArray; // remove 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 removed element to undefined, so when reversing 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 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 removed the item, but saved its value in our firstItem variable. The length of the array has changed from 4 to 3. This method can be useful in conjunction with the method push (). By using them together, we can efficiently queue up the elements in an array. We keep the length of the array by removing an element from the beginning and adding a new one to the end. On the contrary, we can use the method unshift () 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"] Using the method unshift () with method pop (), you can queue backwards by adding elements to the beginning and removing from the end of the array. To flip 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"] Sorting the elements of an array alphabetically is possible 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 that won't work with numbers. Var myArray =; console.log (myArray); // myArray = myArray.sort (); console.log (myArray); // If you need to sort the numbers, then 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 pasted in sort (), the array containing the numbers will be sorted correctly. You can concatenate 2 or more arrays and get 1 array that contains the elements of the concatenated arrays. For this, we use the method concat (): 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"] You 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 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 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 with index 3 console.log (myArray); // ["Rivers Cuomo", "Patrick Wilson", "Brian Bell", "Scott Shriner"] Method splice () always returns an array containing the elements that have been removed. Line 2 will return 1 item "Brian Bell". These articles have described methods for working with arrays in JavaScript. Some additional elements can be viewed on MDN that I have not included in this post. They only work in IE9 +, so they might not be useful. Anything to add? Or do you know any interesting library that will help you manage arrays? Please comment!Demonstration of removing a specific element using the splice method
What if the second parameter is not specified in the JavaScript splice method?
Using the delete function to delete an array element
Syntax
delete expression
Examples
// Creates the property adminName on the global scope. adminName = "xyz"; // Creates the property empCount on the global scope. // Since we are using var, this is marked as non-configurable. The same is true of let and const. var empCount = 43; EmployeeDetails = (name: "xyz", age: 5, designation: "Developer"); // adminName is a property of the global scope. // It can be deleted since it is created without var, // and is therefore configurable. delete adminName; // returns true // On the contrary, empCount is not configurable // since var was used. delete empCount; // returns false // delete can be used to remove properties from objects. delete EmployeeDetails.name; // returns true //
Even when the property does not exist, delete returns "true". delete EmployeeDetails.salary; // returns true // delete does not affect built-in static properties. delete Math.PI; // returns false // EmployeeDetails is a property of the global scope. // Since it was defined without "var", it is marked configurable. delete EmployeeDetails; // returns true function f () (var z = 44; // delete doesn "t affect local variable names delete z; // returns false) delete and the prototype chain
Deleting array elements
Specifications
Specification
Status
Comment
ECMAScript Latest Draft (ECMA-262)
Draft
ECMAScript 2015 (6th Edition, ECMA-262)
The definition of "The delete Operator" in that specification.Standard
ECMAScript 5.1 (ECMA-262)
The definition of "The delete Operator" in that specification.Standard
ECMAScript 1st Edition (ECMA-262)
The definition of "The delete Operator" in that specification.Standard
Initial definition. Implemented in JavaScript 1.2.
Browser compatibility
Desktop Mobile Server
Chrome Edge Firefox Internet Explorer
Opera Safari Android webview Chrome for Android Firefox for Android Opera for Android Safari on iOS Samsung Internet Node.js
delete Chrome Full support 1 Edge Full support 12 Firefox Full support 1 IE Full support 4 Opera Full support Yes Safari Full support Yes WebView Android Full support 1 Chrome Android Full support 18 Firefox Android Full support 4 Opera Android Full support Yes Safari iOS Full support Yes Samsung Internet Android Full support 1.0 nodejs Full support Yes
Legend
Full support Full support Cross-browser notes
Adding elements to an array.
Removing elements from an array
Reversal and sorting of array elements.
Combining arrays.
Splitting an array.
Replacing elements in an array.
Conclusion
