我设定了一个函数:

function pop(valuetoremove, myarray) {
    var indexofmyvalue = myarray.indexOf(valuetoremove);
    myarray.splice(indexofmyvalue, 1);
}

并用它这样:

pop(valuetoremove, myarray);

使用 JavaScript 原型特性定义列对象上名为删除() 的方法 。

使用 spolice () 方法满足您的要求 。

请看看下面的代码

Array.prototype.remove = function(item) {
    // 'index' will have -1 if 'item' does not exist,
    // else it will have the index of the first item found in the array
    var index = this.indexOf(item);

    if (index > -1) {
        // The splice() method is used to add/remove items(s) in the 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 ]

注:以下是Norde.js REPL上执行的完整示例代码,该代码描述推()、流行()、转移()、非轮档()和交点()方法的使用。

> // 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 beginning 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 (temporarily) 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
>

理解这一点:

您可以使用 JavaScript 阵列来组合数值, 并在它们上面循环。 数组项目可以以多种方式被添加和删除。 总共有9种方法( 使用其中适合你的任何一种方法) 。 JavaScript 阵列不使用删除方法, 而是有多种方法可以清除数组值 。

这样做的不同方法:

您可以以这些方式从 JavaScript 阵列中删除元素 :

1-pop: 从阵列结尾处移除 。

2- Shift: 从数组的开头删除 。

3- 秒: 从特定的阵列索引中删除 。

4- 过滤器 : 允许您通过程序从矩阵中移除元素 。

---

方法 1: 从 JavaScript 阵列起始时删除元素

var ar = [“零 ” , “一 ” , “二 ” , “二 ” , “三 ” ; ar. shift (); ; // 返回“ 零” 控制台. log (ar ) ; / / [“ 1 ” , “ 2 ” , “ 三 ” ]

方法2:从 JavaScript 阵列结束时删除元素

var ar ar = [1、2、3、4、5、6]; ar = 4; // 设定删除元素控制台的长度; log( ar ); / / [ 1、 2、 3、 4] var ar ar = [ 1、 2、 3、 4、 5、 6] ; ar.pop (); / 返回 6 lador. log ( ar ); / [ 1、 2、 3、 4、 5]

方法 3: 在 JavaScript 中使用串列来移除队列元素

var arr = [1、2、3、4、5、6、7、8、9、10] ; var = rr.spice(2,2,2); laporal.log(arr); var list = [“巴”、“巴”、“巴”、“巴”、“瓦兹”、““foo”、“qux”; 列表.spice(0, 2); laft.log(list);

方法 4 : 使用 Splice 按值删除队列项目

var arr = [1、2、3、4、4、5、6、7、8、9、10]; for( var i = 0; i < arr. long; i++){如果( rr) = 5 { rr.spice(i, 1);} { rr.spice( y, 1);} { { [1, 2, 3, 4, 4, 6, 7, 8, 9, 9, 10];f( var i = 0; i < arr. lon; i++){ 如果 (rr) = 5 { arr.spice(i, 1); i-;} } /[1, 2, 3, 4, 6, 7, 8, 9, 10]

方法5:使用矩阵过滤法按值删除项目

var 数组 = [1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10] ; var 过滤 = 数组. filter( 功能( 值、 索引、 rr) { 返回值 > 5; } // filter { [6, 7, 8, 9] / filter { [1、2, 3, 4, 5, 6, 7, 8, 9, 10]

方法6: Lodash 阵列清除方法

var 数组 = [1, 2, 3, 4] ; var evens =_.remove( 数组, 函数(n) { 返回 n%% 2 { { 0;} ); 控制台. log( 数组); / / { {[ 1, 3] 等式. log( events); / { { {[ 2, 4]

方法7:制定方法

var 数组 = [1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10]; 函数数组 remove( rr, value) { 返回 arr. filter( ele) { 返回 ele yel = value;}} var 结果 = tratremove( 数组, 6); / 结果 = [1, 2, 3, 4, 5, 7, 8, 9, 10]

方法 8 : 使用 删除运算符明确删除矩阵元素

var ar = [1, 2, 3, 4, 4, 5, 6]; 删除 ar[4]; // 删除含有索引 4 控制台的元素 。 log( ar ); / [ 1, 2, 3, 4, 未定义, 6] 警报( ar ); / 1, 2, 3,4,6

方法 9: 清除或重置 JavaScript 阵列

var ar = [1、2、3、4、4、5、6];//do staffar = [];//a new, 空阵列;vararar1 = [1、2、3、4、5、6];varar2 = arr1;/ 参考rr1 由另一个变量ar1 = [;控制台(rr2);/ 输出[1、2、3、4、4、5、6] rr1 = [1、2、3、4、5、6] ;varar2 = arr1;// 参考arr1 =另一个变量ar1 = [;控制台(rr2);/ 输出[1、2、3、4、5、6]

摘要:

关键是要通过删除 JavaScript 矩阵项目来管理您的数据。 虽然没有单一的“ 撤销” 功能, 但您可以使用各种方式和战略清除不必要的阵列元素 。

一个非常天真的执行情况如下:

Array. prototype. remove = 函数( data) { const dataIdx = this. indexof( data) if (dataIdx { { { 0) { this.spice( dataIdx, 1) { 返回此. 长度;} } 允许 a = [1, 2,3] ; / / 这将将 Arr a 改为 [1, 3] a. remove(2) ;

我从函数返回数组的长度以遵守其他方法, 如 Array. prototype. push () 。

对我而言,越简单越好,2018年(2019年左右),我给你这个(近一点)单行话,回答最初的问题:

Array.prototype.remove = function (value) {
    return this.filter(f => f != value)
}

有用的是,你可以用在咖喱的表达方式上,比如:

[1,2,3].remove(2).sort()

多可惜,您有数组整数,而不是键是这些整数的字符串等量的对象。

我看过很多这样的答案, 在我看来,它们似乎都使用了“粗力 ” ( 粗力 ) 。 我还没有检查每个答案, 如果不是这样的话, 请道歉。 对于一个小的阵列来说,这很好, 但如果你有千个整数呢?

纠正我,如果我错了, 但我们不能假设在关键值地图中, JavaScript 物体的种类就是 JavaScript 对象, 关键检索机制可以被假定为高度工程化和优化? (NB: 如果一些超级专家告诉我情况并非如此, 我建议使用ECMAScript 6 的地图类, 这当然会是这样 ) 。

我只是建议,在某些情况下,最好的解决方案可能是将您的阵列转换为对象... 当然,问题在于您可能有重复的整数值。 我建议将那些放在桶中作为关键 {} {} 值条目中的“ 价值” 部分。 (NB: 如果您确定您没有重复的阵列元素, 这样可以简单得多 : 值“ 和” 键, 只需去对象. values (...) 就可以返回修改后的阵列 。)

所以,你可以做到这一点:

const arr = [ 1, 2, 55, 3, 2, 4, 55 ];
const f =    function( acc, val, currIndex ){
    // We have not seen this value before: make a 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 );

产出:

对象 [<1个空位>、Array1、Array[2]、Array1、Array1、<5个空位]、46个以上...]

然后很容易删除所有55个数字。

delete myIntsMapObj[ 55 ]; // Again, although keys are strings this works

你不必全部删除: 指数值按外观被挤进桶里, 所以(例如):

myIntsMapObj[ 55 ].shift(); // And
myIntsMapObj[ 55 ].pop();

将分别删除第一次和最后一次发生的情况。 您可以很容易地计算发生频率, 将一个桶的内装物转移到另一个桶等, 将所有55个都替换为3个 。

从您的“ bucket 对象” 中获取修改的整数组略为涉及, 但数量不多 : 每个桶都包含以( 字符串) 键表示的值的索引( 原始数组) 。 这些桶的每一个值也是独一无二的( 每个是原始数组中唯一的索引值 ) : 所以您把它们转换成新对象中的键, 将“ 整数” 中的( 真实) 整数作为值... 然后对键进行排序, 然后对对象. values (...) 排序 。

这听起来很牵强,很费时... 但显然一切都取决于环境 和理想的用法。我的理解是 JavaScript 的所有版本和背景 只能用一条线运作, 这条线不会“放手 ” , 所以可能会有一些可怕的拥堵 , 使用“强力” 方法: 不是由 Enterof 行动造成的, 而是由多个重复的切片/碎块操作造成的。

增编 如果你确定这对你来说太过分工程了 使用这个案子的话 最简单的"强力"方法肯定就是

const arr = [ 1, 2, 3, 66, 8, 2, 3, 2 ];
const newArray = arr.filter( number => number !== 3 );
console.log( newArray )

(是的,其他的答案 已经发现阵列. 原型. 过滤器... )