当前位置 : 首页 » 互动问答 » 正文

如何从JavaScript中删除数组中的特定元素?

分类 : 互动问答 | 发布时间 : 2011-04-24 06:17:18 | 评论 : 30 | 浏览 : 5070367 | 喜欢 : 6374

我有一个整数数组,我正在使用.push()方法向它添加元素。

是否有一种简单的方法从数组中删除特定元素?等同于 array.remove(int); .

我必须使用core JavaScript - no框架。

回答(30)

  • 1楼
  • Find the index要删除的数组元素,然后使用splice.

    删除该索引splice()方法通过删除更改数组的内容   现有元素和/或添加新元素。

     var array = [2,5,9];
    的console.log(数组)
    var index = array.indexOf(5);
    if(index> -1){
      array.splice(index,1);
    }
    // array = [2,9]
    console.log(array); 

    splice的第二个参数是要删除的元素数。请注意,splice会修改数组并返回一个包含已删除元素的新数组。


    Note: 浏览器支持indexOf is limited; Internet Explorer 7和8不支持它。

    如果在不支持的浏览器中需要indexOf,请尝试以下polyfill。有关此polyfill here.

     Array.prototype.indexOf ||的更多信息(Array.prototype.indexOf = function(d,e){
        var a;
        if(null == this)抛出新的TypeError('“this”为null或未定义');
        var c = Object(this),
            b = c.length >>> 0;
        if(0 === b)返回-1;
        a = + e || 0;
        无穷大=== Math.abs(a)&&(a = 0);
        if(a> = b)返回-1;
        for(a = Math.max(0 <= a?a:b  -  Math.abs(a),0); a <b;){
            if(a c && c [a] === d)返回a;
            A ++
        }
        返回-1
    });
  • 2楼
  • 我不知道你是如何期望 array.remove(int)表现的。我可以想到你可能想要的三种可能性。

    在索引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];
  • 3楼
  • 编辑于2016年10月

    在此代码示例中,我使用“array.filter(...)”函数从数组中删除不需要的项,此函数不会更改原始数组并创建如果您的浏览器不支持此功能(例如版本9之前的IE或版本1.5之前的Firefox),请考虑使用来自Mozilla的过滤器polyfill .

    删除项目(ECMA-262 Edition 5 code aka oldstyle JS)

     var value = 3
    
    var arr = [1,2,3,4,5,3]
    
    arr = arr.filter(function(item){
        退货!==价值
    })
    
    执行console.log(ARR)
    // [1,2,4,5]
    

    删除项目(ES2015代码)

     let value = 3
    
    让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代码)

    此方法的另一个优点是您可以删除多个项目

     let forDeletion = [2,3,5]
    
    让arr = [1,2,3,4,5,3]
    
    arr = arr.filter(item =>!forDeletion.includes(item))
    // !!!阅读下面关于array.includes(...)支持!!!
    
    执行console.log(ARR)
    // [1,4]
    IE中根本不支持“array.includes(...)”功能,47版本之前的Chrome,43版本之前的Firefox,9版本之前的Safari以及14版本之前的Edge所以

    IMPORTANT这里是来自Mozilla的polyfill 删除多个项目(尖端实验性JavaScript ES2018?)

    // array-lib.js export function remove(... forDeletion){     return this.filter(item =>!forDeletion.includes(item)) } // main.js 从'./array-lib.js'导入{remove} 让arr = [1,2,3,4,5,3] // :: This-Binding Syntax Proposal //使用“删除”功能作为“虚方法” //没有扩展Array.prototype arr = arr :: remove(2,3,5) 执行console.log(ARR) // [1,4]

    在BabelJS中自己尝试:)

    Array.prototype.includes

    Reference

  • 4楼
  • 取决于你是否想保留一个空位。

    如果你想要一个空槽,删除就可以了:

     delete array [index];
    

    如果不这样做,则应使用splice method:

     array.splice(index,1);
    

    如果你需要该项的值,你可以只存储返回的数组的元素:

     var value = array.splice(index,1)[0];
    

    如果你想按某种顺序进行,你可以使用 array.pop ()作为最后一个,或者 array.shift()作为第一个(并且都返回项目的值)。

    如果您不知道项目的索引,可以使用 array.indexOf(item)来获取它(在if()中获取一个项目或在<notranslate中) >获得所有这些)。 while()返回索引,如果未找到则返回-1。 array.indexOf( item ) array.indexOf(item)

  • 5楼
  • 一位朋友在 Internet Explorer 8 中遇到了问题,并向我展示了他的所作所为。我告诉他这是错的,他告诉我他在这里得到了答案。当前的最佳答案不适用于所有浏览器(例如Internet Explorer 8),它只会删除第一次出现的项目。

    从数组中删除所有实例

     function remove (arr,item){
        for(var i = arr.length; i--;){
            if(arr [i] === item){
                arr.splice(i,1);
            }
        }
    }
    

    它向后循环遍历数组(因为索引和长度会随着项目的移除而改变)并删除项目(如果已找到)。它适用于所有浏览器。

  • 6楼
  • 有两种主要方法:

    1. splice(): anArray.splice(index,1);

    2. delete: delete anArray [index];

    对数组使用delete时要小心。删除对象的属性很好,但对数组不太好。最好对数组使用splice

    请记住,当你对数组使用delete时,你可能会得到 anArray.length 的错误结果。换句话说,delete将删除元素,但不会更新length属性的值。

    使用delete后,您还可能期望在索引号中有漏洞,例如你可能最终得到索引1,3,4,8,9,11和使用删除之前的长度。 在这种情况下,所有索引的for循环都会崩溃,因为索引不再是顺序的。

    如果由于某种原因被迫使用delete,那么在需要循环时应该使用for each循环阵列。事实上,如果可能的话,总是避免使用索引for循环。这样,代码将更加健壮,并且不易出现索引问题。

  • 7楼
  • Array.prototype.remByVal = function(val){
        for(var i = 0; i <this.length; i ++){
            if(this [i] === val){
                this.splice(i,1);
                一世 - ;
            }
        }
        归还这个;
    }
    //打电话给
    [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);
                一世 - ;
            }
        }
        归还这个;
    }
    
    var rooms = ['hello','something']
    
    rooms = rooms.remByVal('你好')
    
    执行console.log(室)

  • 8楼
  • 无需使用indexOf or splice。但是,如果您只想删除一个元素,它会表现得更好。

    查找并移动(移动):

     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;
    }
    

    Use indexOf and splice (indexof):

     function indexof(arr,val){
      var i;
      while((i = arr.indexOf(val))!= -1){
        arr.splice(i,1);
      }
    }
    

    Use only splice (splice):

     function splice(arr,val){
      for(var i = arr.length; i--;){
        if(arr [i] === val){
          arr.splice(i,1);
        }
      }
    }
    

    nodejs上运行时间为1000个元素(平均超过10000次运行)的数组:

    indexofmove慢大约10倍。即使通过删除对indexOf in splice的调用进行改进,它也会比move.

    更糟糕地删除所有出现的内容:
        移动0.0048毫秒
        指数0.0463毫秒
        拼接0.0359毫秒
    
    删除第一次出现:
        move_one 0.0041毫秒
        indexof_one 0.0021 ms
  • 9楼
  • 太旧了回复,但可能通过提供谓词而不是值来帮助某人。

    NOTE:它将更新给定的数组,并返回受影响的行

    Usage

     var removed = helper.removeOne(arr,row => row .id === 5);
    
    var removed = helper.remove(arr,row => row.name.startsWith('BMW'));
    

    Definition

     var helper = {
    
        //删除并返回第一个匹配项
    
        removeOne:function(array,predicate){
            for(var i = 0; i <array.length; i ++){
                if(predicate(array [i])){
                    return array.splice(i,1);
                }
            }
        },
    
        //删除并返回所有匹配项
    
        remove:function(array,predicate){
            var removed = [];
    
            for(var i = 0; i <array.length;){
    
                if(predicate(array [i])){
                    removed.push(array.splice(i,1));
                    继续;
                }
    
                我++;
            }
    
            退回;
        }
    };
  • 10楼
  • John Resig 发布了一个很好的实现:

     //数组删除 - 作者John Resig(MIT许可)
    Array.prototype.remove = function(from,to){
      var rest = this.slice((to || from)+ 1 || this.length);
      this.length =从<0? this.length + from:from;
      return this.push.apply(this,rest);
    };
    

    如果您不想扩展全局对象,可以执行以下操作:

     //数组删除 - 作者:John Resig(MIT许可)
    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;
    };
    

    一开始似乎运行良好,但是通过一个痛苦的过程我发现它在尝试删除数组中倒数第二个元素时失败了。例如,如果你有一个10个元素的数组,并尝试删除第9个元素:

     myArray.remove(8);
    

    最终得到一个8元素数组。不知道为什么,但我确认John的原始实现没有这个问题。

  • 11楼
  • Underscore.js 可用于解决多个浏览器的问题。它使用内置浏览器方法(如果存在)。如果它们不存在,就像旧的Internet Explorer版本一样,它使用自己的自定义方法。

    从数组中删除元素的简单示例(来自网站):

     _。without( [1,2,1,0,3,1,4],0,1); // => [2,3,4]
  • 12楼
  • 您可以使用filter method:

    函数remove(arrOriginal,elementToRemove){
        return arrOriginal.filter(function(el){return el!== elementToRemove});
    }
    console.log(remove([1,2,1,0,3,1,4],1));
    

    这将从数组中删除所有元素,并且比slice和indexOf的组合工作得更快

  • 13楼
  • 如果要删除已删除位置的新数组,可以始终删除特定元素并过滤掉数组。对于没有实现过滤方法的浏览器,可能需要扩展 array object ,但从长远来看,它更容易,因为你所做的就是:

     var my_array = [1,2, 3,4,5,6];
    删除my_array [4];
    console.log(my_array.filter(function(a){return typeof a!=='undefined';}));
    

    应显示 [1,2,3,4,6]

  • 14楼
  • 您可以使用ES6。

     var array = ['1','2','3','4','5','6']
    var index = array.filter((value)=> value!='3');
    

    Output :

     [“1”,“2”,“4”,“5”,“6”]
  • 15楼
  • 看看这段代码。它适用于每个主浏览器.

     remove_item = function(arr,value){
        var b ='';
        for(b in arr){
            if(arr [b] === value){
                arr.splice(b,1);
                打破;
            }
        }
        返回
    }
    

    调用此函数

     remove_item(array,value);
  • 16楼
  • 你可以使用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']
  • 17楼
  • OK,例如,你有以下数组:

     var num = [1,2,3,4,5];
    

    我们要删除4号,你可以简单地做下面的代码:

     num.splice(num.indexOf(4),1); // num将是[1,2,3,5];
    

    如果重用此函数,则编写一个可重用的函数,该函数将附加到Native数组函数,如下所示:

     Array.prototype.remove = Array.prototype.remove || function(x){
      const i = this.indexOf(x);
      if(i ===  -  1)返回;
      this.splice(i,1); //num.remove(5)=== [1,2,3];
    }
    

    但是如果你在数组中使用以下数组而不是[5] s怎么样?

     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)//返回[1,2,3,4,6]
    

    还有第三方库可以帮助你做这些,比如Lodash或Underscore,有关更多信息,请查看lodash _.pull,_.pullAt或_.without。

  • 18楼
  • 我是JavaScript的新手,需要这个功能。我只写了这个:

     function removeFromArray(array,item,index){
      while((index = array.indexOf(item))> -1){
        array.splice(index,1);
      }
    }
    

    然后当我想使用它时:

     //设置一些虚拟数据
    var dummyObj = {name:“meow”};
    var dummyArray = [dummyObj,“item1”,“item1”,“item2”];
    
    //删除虚拟数据
    removeFromArray(dummyArray,dummyObj);
    removeFromArray(dummyArray,“item2”);
    

    输出 - 正如所料。 [“item1”,“item1”]

    您可能有不同的需求,因此您可以轻松修改它以适应它们。我希望这可以帮助别人。

  • 19楼
  • ES6&无突变:( 2016年10月)

     const removeByIndex =(list,index)=>
      [
        ... list.slice(0,index),
        ... list.slice(index + 1)
      ]。
    

    Then :

     removeByIndex([33,22,11,44],1)// => [33,11,44]
  • 20楼
  • Update:仅当您不能使用ECMAScript 2015(以前称为ES6)时,才建议使用此方法。如果你可以使用它,这里的其他答案提供了更多更简洁的实现。


    这里的要点将解决你的问题,并且还删除所有出现的参数而不只是1(或指定的值)。

     Array.prototype.destroy = function(obj){
        //如果没有找到并删除任何对象,则返回null
        var destroyed = null;
    
        for(var i = 0; i <this.length; i ++){
    
            //使用while循环查找相邻的相等对象
            while(this [i] === obj){
    
                //删除此[i]并将其存储在销毁中
                destroyed = this.splice(i,1)[0];
            }
        }
    
        回归被毁;
    }
    

    Usage:

     var x = [1,2,3,3,true,false,undefined,false];
    
    x.destroy(3); // => 3
    x.destroy(假); // => false
    X; // => [1,2,true,undefined]
    
    x.destroy(真); // =>是的
    x.destroy(未定义); // =>未定义
    X; // => [1,2]
    
    x.destroy(3); // => null
    X; // => [1,2]
  • 21楼
  • 如果阵列中有复杂对象,可以使用过滤器吗? 在$ .inArray或array.splice不那么容易使用的情况下。特别是如果对象在数组中可能很浅。

    例如。如果你有一个带有Id字段的对象,并且你想从数组中删除该对象:

     this.array = this.array.filter(function(element,i){
        return element.id!== idToRemove;
    });
  • 22楼
  • 你永远不应该在你的数组中改变你的数组。因为这是针对功能编程模式的。您可以做的是创建一个新数组,而不引用要更改数据的数组使用es6方法filter;

     var myArray = [1,2,3,4,5,6];
    

    假设你要从数组中删除5,你就可以这样做。

     myArray = myArray.filter(value => value!== 5);
    

    这将为您提供一个没有您想要删除的值的新数组。所以结果将是

     [1,2,3,4,6]; // 5已从此数组中删除
    

    为了进一步理解,您可以阅读有关Array.filter https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter的MDN文档。

  • 23楼
  • 更现代的, ECMAScript 2015 (以前称为Harmony或ES 6)方法。鉴于:

     const items = [1,2,3,4];
    const index = 2;
    

    Then:

     items.filter((x,i)=> i!== index);
    

    Yielding:

    [1, 2, 4]
    

    您可以使用Babel and a polyfill service来确保跨浏览器支持此功能。

  • 24楼
  • 以下是使用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(),它提供更多声明 approach:

     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。

    删除多个项

    如果您想要删除多个项目而不是单个项目吗?

    让我们找到最简单的解决方案。

    By index

    您可以创建一个函数并删除系列中的项目:

     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

    您可以在回调函数中搜索包含:

     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/)

  • 25楼
  • 我知道已有很多答案,但其中许多似乎使问题复杂化。这是一种删除键的所有实例的简单递归方法 - 调用self直到找不到索引。是的,它仅适用于indexOf的浏览器,但它很简单,可以很容易地进行多边形填充。

    独立函数

     function removeAll(array,key){
        var index = array.indexOf(key);
    
        if(index === -1)return;
    
        array.splice(index,1);
        的removeAll(数组,密钥);
    }
    

    原型方法

     Array.prototype.removeAll = function(key){
        var index = this.indexOf(key);
    
        if(index === -1)return;
    
        this.splice(index,1);
        this.removeAll(键);
    }
  • 27楼
  • 如果元素有多个实例,则可以执行向后循环以确保不会搞砸索引。

     var myElement =“chocolate”;
    var myArray = ['chocolate','poptart','poptart','poptart','chocolate','poptart','poptart','chocolate'];
    
    / *重要代码* /
    for(var i = myArray.length  -  1; i> = 0; i--){
        if(myArray [i] == myElement)myArray.splice(i,1);
    }

    Live Demo

  • 28楼
  • 基于所有主要正确的答案并考虑到建议的最佳实践(特别是不直接使用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;
    }
    

    回顾上述功能,尽管它工作正常,但我意识到可能会有一些性能提升。使用ES6而不是ES5也是一种更好的方法。为此,这是改进的代码:

     const arrayWithoutFastest =(()=> {
      const isArray = canBeArray =>(数组中的'isArray')
        ? Array.isArray(canBeArray)
        :Object.prototype.toString.call(canBeArray)==='[object Array]';
    
      let mapIncludes =(map,key)=> map.has(key);
      让objectIncludes =(obj,key)=>键入obj;
      让包括;
    
      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(!includes(withoutValues,arr [i])){
            (ARR [I])arrCopy.push;
          }
        }
    
        return arrCopy;
      }
    
      return arrayWithoutFastest;
    })();
    

    如何使用:

     const arr = [1,2,3,4,5,“name”,false];
    
    arrayWithoutFastest(arr,1); //将返回数组[2,3,4,5,“name”,false]
    arrayWithoutFastest(arr,'name'); //将返回[2,3,4,5,false]
    arrayWithoutFastest(arr,false); //将返回[2,3,4,5]
    arrayWithoutFastest(ARR,[1,2]); //将返回[3,4,5,“name”,false];
    arrayWithoutFastest(arr,{bar:“foo”}); //将返回相同的数组(新副本)
    

    我目前正在撰写一篇博文,其中我对Array的几个解决方案进行了基准测试,没有问题,并比较了运行所需的时间。完成该帖后,我将使用链接更新此答案。只是为了让你知道,我已经将上面的内容与lodash进行了比较,如果浏览器支持Map,它就胜过了lodash!请注意,我没有使用 Array.prototype.indexOf or Array.prototype.includes ,因为在Map or Object中包含exlcudeValues会使查询更快! ( https://jsperf.com/array-without-benchmark-against-lodash)

  • 29楼
  • Array.prototype.removeItem = function(a){
                for(i = 0; i <this.length; i ++){
                    if(this [i] == a){
                        for(i2 = i; i2 <this.length  -  1; i2 ++){
                            这[i2] =这[i2 + 1];
                        }
                        this.length = this.length  -  1
                        返回;
                    }
                }
            }
    
        var recentMovies = ['钢铁侠','蝙蝠侠','超人','蜘蛛侠'];
        recentMovies.removeItem( '超人');
  • 30楼
  • 你有1到9个数组,你想删除5使用下面的代码。

     var numberArray = [1,2,3,4,5,6,7,8,9];
    
    var newNumberArray = numberArray.filter(m => {
      返回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); 

    包括支持的浏览器是link

相关阅读:

Remove duplicates from an array of objects in JavaScript

Remove duplicates from an array of objects in JavaScript

Can I call jquery click() to follow an <a> link if I haven't bound an event handler to it with bind or click already?

Check whether a string matches a regex in JS

jQuery event to trigger action when a div is made visible

Check if user is using IE with jQuery

Resize HTML5 canvas to fit window

How do I replace a character at a particular index in JavaScript?

JavaScript file upload size validation

Converting a string to a date in JavaScript