Tengo un array de números, y estoy usando el .push() método para agregar elementos a la misma.

Hay una forma sencilla de quitar un elemento específico de una matriz? El equivalente de algo como array.remove(number);.

Tengo que usar núcleo JavaScript – marcos no están permitidos.

  • Si usted necesita apoyo <IE9 (suspiro), a continuación, compruebe de este MODO la pregunta con respecto a indexOf en IE.
  • (lodash) array = [‘a’, ‘b’, ‘c’]; _.tire(array, ‘a’) // array => [‘b’, ‘c’]; Ver también stackoverflow.com/questions/5767325/…
  • método de filtro puede hacer lo que quiera.
  • Usted puede utilizar eliminar pero no rearange el índice en lugar de ello establecer esta ranura para ‘undefined × 1’. Por ejemplo: var lista = [1,2,3,4,5,6] -> eliminar de la lista[1] -> [1, indefinido × 1, 3, 4, 5, 6].
  • delete debe ser más eficientes en el corto plazo, porque no va a tener que pasar la tarde de los elementos. forEach, map y filter automáticamente omitir el procesamiento de indefinido (borrado) de los elementos. Pero probablemente no es ideal si va a añadir un montón de cosas a su matriz, en el futuro, o leer muchas veces.
  • Aquí una comparativa del rendimiento de los dos grandes posibilidades: jsben.ch/#/b4Ume
  • Yo uso este que con seguridad se extiende a la matriz nativa objeto y maneja casos de borde.

InformationsquelleAutor Walker | 2011-04-23

88 Comentarios

  1. 10968

    Encontrar el index de la matriz de elemento que desea eliminar el uso de indexOf y, a continuación, quitar ese índice con empalme.

    El método splice() cambia el contenido de una matriz mediante la eliminación de
    de los elementos existentes y/o la adición de nuevos elementos.

    JS:

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

    El segundo parámetro de splice es el número de elementos a eliminar. Tenga en cuenta que splice modifica la matriz en su lugar y devuelve una nueva matriz que contiene los elementos que se han eliminado.

    • sí, usted podría estar en lo correcto. En este artículo se explica más y una solución para los navegadores incompatibles: developer.mozilla.org/en/JavaScript/Reference/Global_Objects/…
    • Puede la facilidad de uso de este mediante la adición de un delete función de la matriz de prototipo. Me he tomado el uso de su ejemplo en un gist que elimina todos los elementos de la matriz en lugar de sólo 1.
    • Es demasiado tarde para editar mi último comentario, pero solo quiero corregir a mí mismo. Llamar delete en una matriz es no ir en IE 8. He actualizado la esencia utilizar destroy lugar.
    • Peligroso! Si usted está trabajando con valores dinámicos (agregar y quitar dinámico de los valores de la matriz) y el valor no existe en la matriz (el índice de convertirse -1) el código anterior se retire el último elemento de la matriz.
    • ¿Empalme preservar la matriz de orden??
    • Por supuesto que preserva el orden, si no sería absolutamente inútil
    • Usted puede superar el navegador IE problema de soporte, incluyendo el código de dado aquí
    • indexOf volvía -1 en mi versión de Firefox (30.0). Terminé de escribir un simple bucle for para encontrar el índice y funciona bien…
    • Relacionadas con la pregunta: ¿Cómo hacerlo con jQuery (jQuery.grep). stackoverflow.com/questions/3596089/…
    • Pensé que es claro: tener una variedad llena de forma dinámica significa que a veces tienes un array vacío. Con esta solución usted puede tratar de eliminar el último elemento que no existe. El resultado es un error de JS. Si usted tiene el mismo número de elementos de esta matriz, a continuación, todo es bueno. Usted puede utilizar.
    • en conjunto vacío será -1, y si estás probando para que luego no de empalme. Tal vez la respuesta ha cambiado desde entonces.
    • Y tenga en cuenta que si usted está trabajando con los no-de los tipos primitivos, Array.indexOf() no prueba por objeto la igualdad. Sólo funciona si pasa exactamente el mismo objeto de referencia. Ver: jsfiddle.net/b0e7zsm3
    • devuelve el elemento eliminado, no la nueva matriz. jsfiddle.net/bB7Ey/85
    • Este no es un buen método a utilizar cuando se itera matrices. Lo que pasa en mi caso es que no es el elemento en cuestión que se quita pero uno después. También he utilizado esto con jQuery .cada función y causa problemas como el de la matriz se hace más pequeño, pero la duración es todavía iterada (lo que significa que se trate del acceso de los valores vacíos en el final). No pude reproducir el error pasado, pero la primera me puede mostrar en este JSBin (jsbin.com/xufovopoji/edit?html,js,salida)
    • No utilice este método con un bucle for, en lugar de utilizar while(myarry.lenth--). La razón es «la matriz es volver a ser indexados al hacer una .splice(), que significa que usted va a saltar encima de un índice cuando uno se retira, y su caché .la longitud es obsoleto.» stackoverflow.com/a/9882349/922522
    • IE 7, IE8, IE9, IE10 ar no admitido por la propia Microsoft, ¿por qué los desarrolladores de la web de soporte de los navegadores antiguos? Sólo mostrar la notificación sobre la actualización del navegador! support.microsoft.com/en-us/lifecycle/…
    • ¿Por qué no usar método delete directamente como delete arname [index]; ?
    • que deja una indefinido en la matriz. jsfiddle.net/dsup87xL
    • Esto nunca es y nunca ha sido un desarrollador de elección. Cuando se dirige a un público específico, como las organizaciones públicas que no se puede actualizar por razones internas o no NOS/los países de la UE (que todavía tienen un montón de usuarios en WinXP), usted tendrá que proporcionar el soporte para IE8 para los usuarios. Sólo depende de para quien su sitio, usted no puede tener un enfoque genérico sobre este asunto.
    • ¿Alguien puede explicar cómo el relleno realmente funciona? El código se ve muy interesante. Estás comparando el infinito (observación de tipo de variable) para Math.abs(a) && (a = 0) y haciendo algo increíble otras cosas que implican >>>?
    • array.splice() función no funciona si mi índice es símbolo con una longitud de 16 y delete arname [index]; está trabajando para mí
    • Actualización: he encontrado este post stackoverflow.com/questions/8173210/…. y ahora sé la diferencia de empalme y eliminar.
    • Para obtener el índice de un objeto en una Matriz por su propiedad, puede utilizar TheArray.map(function(e) {return e.property;}).indexOf(PROPERTY_VALUE_TO_SEARCH)(IE 9+), o TheArray.map(e => e.property).indexOf(PROPERTY_VALUE_TO_SEARCH) si tu navegador soporta Flecha Functons.
    • Como @klenium dijo, el método splice() cambia el contenido de un array, no devuelve una nueva matriz.
    • arr = [1,2,3,4,5] var filtrada = arr.filtro(function(ele){ return ele != 3; }); //filtrada = [1,2,4,5];
    • OPs siempre spec no especifica una matriz de enteros únicos. indexOf sólo devolverá la posición de la primera encontrado coincidencia (de opcional «fromIndex»).
    • No estoy seguro si vale la pena una nota, pero hay que ser conscientes de que el comportamiento en el caso de elementos duplicados. Sólo el primero es removido en este enfoque.
    • En la era de la inmutabilidad, la mejor utilización de la Matriz.filter() o de la Matriz.slice() ejemplo
    • No es cambio de la matriz de Índice de nivel inferior y posterior del elemento no estarán disponibles en la lista si estamos en bucle a través de una matriz.
    • Empalme es la mejor, con delete mi JSON.stringify tiene un valor null en lugar de que se eliminan los
    • por qué la primera si la condición es (índice > -1) en lugar de (índice != -1) ?
    • a partir de la documentación, parece indexOf() nunca devolverá un número negativo otros que -1 así != -1 o !== -1 estaría perfectamente bien. Sin ninguna razón en particular para el uso de > -1.
    • El empalme puede ser mejor utilizado cuando se conoce el índice y todos los valores deseados a eliminar, están en una secuencia. Si usted no sabe el índice, aquí hay algunas buenas alterna el uso de empalme, filtro, cambio, pop- stackoverflow.com/a/54390552/8958729
    • En una pequeña matriz, ¿por qué no usar simplemente un simple bucle for?
    • Empalme no está funcionando como se espera si la matriz contiene elementos con índices negativos.

  2. 1157

    No sé de qué estás esperando array.remove(int) comportarse. Hay tres posibilidades que puedo pensar que usted podría querer.

    Para eliminar un elemento de un array en un índice i:

    array.splice(i, 1);

    Si desea eliminar todos los elementos con valor number de la matriz:

    for(var i = array.length - 1; i >= 0; i--) {
        if(array[i] === number) {
           array.splice(i, 1);
        }
    }

    Si lo que desea es hacer el elemento en el índice i ya no existen, pero no desea que los índices de los otros elementos para el cambio:

    delete array[i];
    • delete no es la manera correcta de eliminar un elemento de un array!
    • Depende, funciona si usted desea hacer que array.hasOwnProperty(i) devuelve false y tiene un elemento en esa posición de retorno undefined. Pero debo admitir que eso no es algo muy común que queramos hacer.
    • delete no actualización de la longitud de la matriz ni realmente elimina el elemento, sólo se reemplaza con el valor especial undefined.
    • No sé a qué te refieres cuando dices que en realidad no borrar el elemento. Además, se hace más que simplemente sustituyendo el valor en el índice con undefined: elimina el índice y el valor de la matriz, es decir, después de delete array[0], "0" in array devolverá false.
    • for(var i=matriz.longitud; i>=0; i–) debe ser for(var i=matriz.length-1; i>=0; i–) debido a que la indexación se inicia en 0 (no hay ningún elemento al array[de la matriz.longitud])
    • Empalme es la operación en rango. Recuerde que las operaciones con rangos puede ser caro (utiliza más recursos de la CPU). En este ejemplo se trata de dos bucles en el hecho. Debemos elegir la más barata de las funciones de si es posible.
    • delete es un buen mecanismo, si se trata de propiedades con nombre var array=[];array['red']=1;array['green']=2;array['blue']=3;delete array['green'];
    • No ser demasiado avergonzado. Una vez leí un libro publicado en JS que se describe como «matrices asociativas» en JavaScript exactamente igual que tu comentario describió. Es un error fácil de hacer y si te acercas a JavaScript de otro idioma.
    • en la moderna js motores, usando: array[i] = null es favorecido en lugar de delete array[i]
    • puede proporcionar una referencia o dos para que esa declaración, o al menos explicar por qué es favorecido?
    • Que no tiene sentido: que hagan cosas diferentes, ¿cómo se puede ser favorecido?
    • se hace referencia a muchos lugares(por ejemplo, smashingmagazine.com/2012/11/…). Pero los fundamentos son que el subyacente JS motor va a ser más rápido en la recolección de basura, que si se intenta manualmente, y su código será más fácil de comprender si se establece de forma explícita el valor. Puede ser un error fácil para alguien de la lectura de su código si ven delete array[i] para asumir los índices de los elementos restantes se han actualizado
    • tu enlace no dirección de las matrices en todo (creo? Es una gran página, yo miraba a la sección a la que está enlazado) sólo habla de anulación de las referencias a espacios de nombres. Anulación de los elementos de una matriz mantener la referencia viva (recolección de basura había mejor nunca se vienen para mi vacío de la matriz de valores)…
    • Índice de bucle no iba a funcionar para todas las matrices. Si ha utilizado previamente en eliminar en la matriz, entonces el bucle for se bloqueará.
    • Votada abajo, porque algunas personas se descremada sobre la respuesta, ver el delete operación, y sólo copiar ciegamente en su código, ya que se ve sobre el derecho a ellas. Eso no es bueno! Votada abajo.
    • Que parte de la respuesta está en la parte inferior. No es mi culpa si la gente salte a la parte inferior y omitir la descripción de describir lo que hace.
    • No dar una advertencia (no digamos en negrita), que esta no es la forma de quitar las cosas a partir de matrices. La existencia de esa línea de código en esta respuesta no es útil. Aquí, permítanme hacer una edición. Me acaba de recomendar la eliminación total de ella, aunque. No añadir nada de sentido práctico.
    • Lo siento, no estoy de acuerdo. No veo la necesidad de que esta sea eliminado. El texto anterior se explica claramente lo que hace, y que ayuda a las personas que no saben lo que delete hace entender por qué no funciona como se espera.
    • hay mejores maneras de hacer esto, eliminar es una mala práctica en una matriz
    • Remítase a la respuesta de @ujeenator, tiene más óptima forma de hacer la acción
    • En modo estricto, eliminar no iba a funcionar.

  3. 1027

    Editado en el año 2016 octubre

    • Hacer es simple, intuitiva y explícito (La navaja de Occam)
    • Hacer es inmutable (matriz original permanecer sin cambios)
    • Hacerlo con el estándar de funciones de JavaScript, si su navegador no los apoyan – uso polyfil

    En este ejemplo de código que uso «de la matriz.filtro(…)» función para eliminar elementos no deseados de la matriz. Esta función no cambia la matriz original y crea una nueva. Si su navegador no soporta esta función (por ejemplo, Internet Explorer anteriores a la versión 9, o Firefox antes de la versión 1.5), considere el uso de el filtro relleno de Mozilla.

    La eliminación de elemento (ECMA-262 Edición 5 código aka oldstyle JavaScript)

    var value = 3
    
    var arr = [1, 2, 3, 4, 5, 3]
    
    arr = arr.filter(function(item) {
        return item !== value
    })
    
    console.log(arr)
    //[ 1, 2, 4, 5 ]

    La eliminación de elemento (ECMAScript 6 código)

    let value = 3
    
    let arr = [1, 2, 3, 4, 5, 3]
    
    arr = arr.filter(item => item !== value)
    
    console.log(arr)
    //[ 1, 2, 4, 5 ]

    IMPORTANTE ECMAScript 6 «() => {}» flecha sintaxis de la función no se admite en Internet Explorer a todos, Chrome antes de los 45 versión, Firefox antes del 22 de versión, y Safari antes de las 10 de la versión. El uso de ECMAScript 6 sintaxis en navegadores antiguos, puede utilizar BabelJS.


    La eliminación de elementos múltiples (ECMAScript 7 código)

    Una ventaja adicional de este método es que puede eliminar varios elementos

    let forDeletion = [2, 3, 5]
    
    let arr = [1, 2, 3, 4, 5, 3]
    
    arr = arr.filter(item => !forDeletion.includes(item))
    //!!! Read below about array.includes(...) support !!!
    
    console.log(arr)
    //[ 1, 4 ]

    IMPORTANTE «de la matriz.incluye(…)» la función no se admite en Internet Explorer a todos, Chrome antes de 47 versión, Firefox antes de 43 versión, Safari antes de las 9 de la versión, y el Borde antes de las 14 versión para aquí está relleno de Mozilla.

    La eliminación de varios elementos (en el futuro, tal vez)

    Si el «Esta Unión De La Sintaxis» propuesta es cada vez aceptado, usted será capaz de hacer esto:

    //array-lib.js
    
    export function remove(...forDeletion) {
        return this.filter(item => !forDeletion.includes(item))
    }
    
    //main.js
    
    import { remove } from './array-lib.js'
    
    let arr = [1, 2, 3, 4, 5, 3]
    
    //:: 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 ]

    Pruebe usted mismo en BabelJS 🙂

    Referencia

    • pero, a veces, nos quieren quitar el elemento de la matriz original(no inmutable), por ejemplo de la matriz utilizada en Angular 2 *ngFor directiva
    • Mejor que la solución aceptada porque no se supone sólo una ocurrencia de un partido y la inmutabilidad es preferible
    • filter debe ser mucho más lento para una gran variedad, aunque?
    • ¿Cuál es el punto de inmutabilidad menciona si se utiliza la asignación de la misma variable en sus ejemplos? 🙂
    • porque sería demasiado complejo ejemplo, si yo uso ambas hacen referencia a la inmutabilidad de datos y la inmutabilidad. Yo sería entonces necesario utilizar algún tipo de estado del contenedor. También los datos de la inmutabilidad es suficiente para evitar la mayoría de los efectos secundarios de los errores.
    • Esto no es una buena respuesta, porque se crea una nueva matriz, por lo tanto, se crea una nueva referencia. No retire sus elementos. Se crea una nueva Matriz y se la asigna. Así, por ejemplo, tener let arr = arr2 = [1,3,2]; y haciendo que el filtro arr = arr.filter(el => el !==3) resultará en ninguna modificación en arr2, mientras se hace el empalme, ambas matrices tendrán que ser modificadas.
    • Super lento el método.
    • en comparación con qué método y qué escenario?
    • en comparación con qué método y qué escenario? Por más lento que la media de tiempo de ejecución?
    • el filtro es super lenta si usted necesita para eliminar un elemento de una matriz
    • Esto no funciona si sólo desea quitar una aparición de un valor en una matriz. por ejemplo, [1,2,3,3,4,5].filter(num => num == 3) se retire ambos valores de 3
    • Hay un pequeño error en aquí. Como por Array.el prototipo.incluye (a), includes es ECMAScript 2016 Spec
    • Me encanta el razonamiento detrás de esta respuesta. Quitar elementos mediante la filtración de la que no quiere. Genial!
    • Esta es una gran respuesta. Splice es una función especializada para la mutación no filtrado. filter puede tener un rendimiento más lento, pero es más seguro y mejor código. También, usted puede filtrar por índice especificando un segundo argumento en el lambda: arr.filter((x,i)=>i!==2)
    • Ser cauteloso con el filtro y la asignación cuando la matriz se hace referencia por muchos.

  4. 425

    Depende de si usted desea mantener un punto vacío o no.

    Si quieres una ranura vacía, eliminar esta bien:

    delete array[index];

    Si no, usted debe utilizar el empalme método:

    array.splice(index, 1);

    Y si se necesita el valor de ese elemento, sólo se puede almacenar el array devuelto del elemento:

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

    En caso de querer hacerlo en un poco de orden, puede utilizar array.pop() para los últimos uno o array.shift() para el primero (y devuelven el valor del elemento demasiado).

    Y si no sabes el índice del elemento, puede utilizar array.indexOf(item) conseguirlo (en un if() para obtener un artículo o en un while() para llegar a todos ellos). array.indexOf(item) devuelve el índice o -1 si no se encontró. 

    • Vale la pena señalar que var value no va a almacenar el valor, sino una matriz que contiene el valor.
    • delete no es la manera correcta de eliminar un elemento de un array!!
    • Si usted quiere «una ranura vacía», el uso de array[index] = undefined;. El uso de delete va a destruir la optimización.
    • muy buen comentario porque para entender que he perdido mucho tiempo y pensaba que mi código de la aplicación es de alguna manera rotos…
    • Último párrafo con la explicación de lo que se obtiene a partir de indexOf fue realmente útil
  5. 259

    Un amigo estaba teniendo problemas en Internet Explorer 8 y me mostró lo que él hizo. Yo le dije que estaba mal, y él me dijo que él tiene la respuesta aquí. Esta vez la respuesta no va a funcionar en todos los navegadores (Internet Explorer 8 por ejemplo), y que sólo va a quitar la primera ocurrencia del elemento.

    Eliminar TODAS las instancias de una matriz

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

    Recorre la matriz hacia atrás (desde índices de longitud y va a cambiar a medida que se eliminan los elementos) y se elimina el elemento, si se encuentra. Funciona en todos los navegadores.

    • no debe ser porque el bucle comienza a i = arr.length -1 o i-- lo que es igual a la de max índice. arr.length es sólo un valor inicial para i. i-- siempre será truthy (y la reducción de 1 en cada bucle op) hasta que equivale a 0 (un falsy valor) y el bucle se detendrá.
    • La segunda función es bastante ineficiente. En cada iteración «indexOf», se inicia la búsqueda de comienzo de la matriz.
    • usted está exactamente correcto. Sorprendido no he entendido que cuando me respondió: jsperf.com/remove-all-from-array
    • usted se preocupa de llamar a indexOf repetidas veces, que en realidad no es ni siquiera cerca de ser tan malo como llamar a empalme en cada iteración.
    • en una colección con más de 1 ocurrencia de elemento, es mucho mejor llamar a la filtro lugar el método arr.filter(function (el) { return el !== item }), evitando así la necesidad de mutar la matriz varias veces. Esto consume un poco más de memoria, pero opera de manera mucho más eficiente, ya que hay menos trabajo que necesita ser hecho.
    • sólo se encuentra disponible desde IE9+. Todavía hay una posibilidad de que no iba a funcionar.
    • eso no es un argumento válido en todos estos días, acaba de hacer lo que la función de filtro que hace o, mejor aún, simplemente incluir es5-shim.js en su aplicación.
    • Esta respuesta trabajado para mí porque necesitaba varios elementos eliminados, pero no en un orden particular. La progresión hacia atrás del bucle for que aquí se maneja la eliminación de elementos de la matriz a la perfección.
    • arr.filtro de quitar todas las instancias con la indeseada atributo o valor de
    • Esto es peligroso, ya que es de O(N^2), en términos de complejidad.

  6. 156

    Hay dos enfoques principales:

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

    2. eliminar: delete anArray[index];

    Tener cuidado cuando se utiliza para eliminar una matriz. Es bueno para eliminar los atributos de los objetos, pero no tan bueno para las matrices. Es mejor utilizar splice para las matrices.

    Tenga en cuenta que cuando se utiliza delete para una matriz se puede obtener malos resultados para anArray.length. En otras palabras, delete eliminaría el elemento, pero no actualizar el valor de la longitud de la propiedad.

    También se puede esperar a tener agujeros en los números de índice después de eliminar el uso de, por ejemplo, usted podría terminar encima de tener los índices de 1, 3, 4, 8, 9, y 11 y la longitud como estaba antes de utilizar eliminar. En ese caso, todos los indexados for bucles de accidente, ya que los índices no son secuenciales.

    Si se ve forzado a usar delete por alguna razón, entonces usted debe utilizar para cada bucles cuando usted necesita un bucle a través de matrices. Como cuestión de hecho, siempre evite el uso de indexado for bucles, si es posible. De esa manera, el código sería el más robusto y menos propensos a tener problemas con los índices.

  7. 131
    Array.prototype.remByVal = function(val) {
        for (var i = 0; i < this.length; i++) {
            if (this[i] === val) {
                this.splice(i, 1);
                i--;
            }
        }
        return this;
    }
    //Call like
    [1, 2, 3, 4].remByVal(3);

    JS:

    Array.prototype.remByVal = function(val) {
        for (var i = 0; i < this.length; i++) {
            if (this[i] === val) {
                this.splice(i, 1);
                i--;
            }
        }
        return this;
    }
    
    var rooms = ['hello', 'something']
    
    rooms = rooms.remByVal('hello')
    
    console.log(rooms)

  8. 94

    No hay necesidad de utilizar indexOf o splice. Sin embargo, funciona mejor si usted sólo desea quitar una ocurrencia de un elemento.

    Encontrar y mover (move):

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

    Uso indexOf y splice (porcentaje):

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

    Utilizar sólo splice (empalme):

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

    Los tiempos de ejecución en nodejs para la matriz con 1000 elementos (un promedio de más de 10000 carreras):

    indexof es aproximadamente 10 veces más lento que mover. Incluso si mejoró mediante la eliminación de la llamada a indexOf en empalme se realiza mucho peor que mover.

    Remove all occurrences:
        move 0.0048 ms
        indexof 0.0463 ms
        splice 0.0359 ms
    
    Remove first occurrence:
        move_one 0.0041 ms
        indexof_one 0.0021 ms
    • Se parece a la ‘mover’ el método que aquí se presenta debe trabajar en todos los navegadores, y también evita la creación de una serie extra; la mayoría de las otras soluciones aquí tienen uno o ambos de estos problemas. Creo que esta merece mucho más votos, incluso si no se ve como «bastante».
  9. 65

    Esto proporciona un predicado en lugar de un valor.

    NOTA: es la actualización de la matriz dada, y el retorno a las filas afectadas.

    Uso

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

    Definición

    var helper = {
    
        //Remove and return the first occurrence
    
        removeOne: function(array, predicate) {
            for (var i = 0; i < array.length; i++) {
                if (predicate(array[i])) {
                    return array.splice(i, 1);
                }
            }
        },
    
        //Remove and return all occurrences
    
        remove: function(array, predicate) {
            var removed = [];
    
            for (var i = 0; i < array.length;) {
    
                if (predicate(array[i])) {
                    removed.push(array.splice(i, 1));
                    continue;
                }
                i++;
            }
            return removed;
        }
    };
    • No sé que necesita el -1 de verificación (i > -1). También, creo que estas funciones actúan más como filtro de quitar. Si se pasa de la fila.id === 5, el resultado será una matriz con sólo 5 de id, por lo que se está haciendo lo contrario de quitar. Se vería bonito en ES2015: var resultado = ArrayHelper.quitar(myArray, fila => fila.id === 5);
    • esta función de modificar la matriz original, y devolver el elemento eliminado en lugar de copiar el resultado en una nueva matriz
  10. 59

    John Resig publicado una buena aplicación:

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

    Si usted no desea extender un objeto global, usted puede hacer algo como lo siguiente, en lugar de:

    //Array Remove - By John Resig (MIT Licensed)
    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);
    };

    Pero la principal razón por la que estoy publicando esto es para advertir a los usuarios frente a la alternativa de implementación sugerido en los comentarios en la página (Dec 14, 2007):

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

    Parece que funciona bien al principio, pero a través de un proceso doloroso que he descubierto se produce un error al intentar eliminar el último elemento de una matriz. Por ejemplo, si usted tiene un 10-elemento de la matriz y de intentar quitar el 9 de elemento con esto:

    myArray.remove(8);

    Usted termina con una de 8 elementos de la matriz. No sé por qué, pero me confirmó Juan de la implementación original no tiene este problema.

    • Acaba de aprender por el camino difícil ¿por qué es una buena idea utilizar Object.prototype.hasOwnProperty siempre
  11. 59

    Underscore.js puede ser usado para resolver problemas con varios navegadores. Se utiliza en construir métodos de explorador si está presente. Si están ausentes, como en el caso de mayores de Internet Explorer versiones usa sus propios métodos.

    Un ejemplo sencillo para eliminar elementos de la matriz (de la web):

    _.without([1, 2, 1, 0, 3, 1, 4], 0, 1); //=> [2, 3, 4]
  12. 59

    Usted puede hacerlo fácilmente con la filtro método:

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

    Esto elimina todos los elementos de la matriz y también funciona más rápido que una combinación de slice y indexOf.

    • ¿Tiene una fuente en que este es más rápido?
    • Solución agradable. Pero como usted señala, pero es importante hacer calvo, no produce el mismo resultado que en el sector y indexOf ya que se va a eliminar todas las apariciones de 1
    • esto es porque simplemente cortar y indexOf no hace lo que él quiere «quitar un elemento específico». Elimina el elemento sólo una vez, esto quitar un elemento específico, no importa cómo muchos de ellos le han
  13. 53

    Puede utilizar ES6. Por ejemplo, para eliminar el valor ‘3’ en este caso:

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

    De salida :

    ["1", "2", "4", "5", "6"]
    • La respuesta a esto es bueno porque crea una copia de la matriz original, en lugar de modificar el original directamente.
    • Nota: La Matriz.el prototipo.filtro de ECMAScript 5.1 (No IE8). para obtener más soluciones específicas: stackoverflow.com/a/54390552/8958729
  14. 48

    Si quieres un nuevo array con el borrado de las posiciones eliminado, siempre se puede eliminar el elemento específico y filtro de salida de la matriz. Es posible que tenga una extensión de la objeto array para los navegadores que no implementan el método de filtro, pero en el largo plazo es más fácil ya que todo lo que hago es esto:

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

    Debe mostrar [1, 2, 3, 4, 6].

  15. 38

    Echa un vistazo a este código. Funciona en todos los navegador principales.

    remove_item = function (arr, value) {
        var b = '';
        for (b in arr) {
            if (arr[b] === value) {
                arr.splice(b, 1);
                break;
            }
        }
        return arr;
    }

    Llamar a esta función

    remove_item(array,value);
    • Excepto el uso de un for inde bucle y el hecho de que el guión podría detuvo anteriormente, devolviendo el resultado del bucle directamente. El upvotes son razonables 😉
    • Este es un método excelente para pequeños arreglos. Funciona en todos los navegadores, utiliza un mínimo de e intuitiva código, y sin ningún complejo marcos, placas de apoyo, o polyfills.
    • También debo reiterar yckart comentario de que for( i = 0; i < arr.length; i++ ) sería un mejor enfoque, ya que se conserva la exacta índices frente a cualquier orden de la navegador decide almacenar los elementos (con for in). Al hacerlo, también te permite obtener el índice de la matriz de un valor si la necesita.
  16. 35

    Puede utilizar lodash _.tire (mutar matriz), _.pullAt (mutar matriz) o _.sin (no mutar matriz),

    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']
    • Ese es el núcleo de JS como el OP solicitado, no?
    • Estás en lo correcto. Pero una gran cantidad de usuarios como yo, vienen aquí en busca de una respuesta general, no sólo para el OP solo.
    • Tienes toda la razón. Yo ya estoy usando lodash, ¿por qué no utilizar si se ahorra tiempo.
  17. 31

    OK, por ejemplo, usted tiene la matriz a continuación:

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

    Y queremos eliminar el número 4. Usted puede simplemente utilizar el siguiente código:

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

    Si usted está utilizando esta función, se escribe una función reutilizable que se adjunta a la nativo función de matriz como la siguiente:

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

    Pero ¿y si tiene la siguiente matriz en su lugar con un par de [5]s en la matriz?

    var num = [5, 6, 5, 4, 5, 1, 5];

    Necesitamos un bucle para comprobar todos ellos, pero es más fácil y más eficiente es el uso integrado de las funciones de JavaScript, por lo que podemos escribir una función que utiliza un filtro como el de abajo, lugar:

    const _removeValue = (arr, x) => arr.filter(n => n!==x);
    //_removeValue([1, 2, 3, 4, 5, 5, 6, 5], 5) //Return [1, 2, 3, 4, 6]

    También hay bibliotecas de terceros que ayudan a hacer esto, como Lodash o Subrayado. Para obtener más información, busque en lodash _.tire, _.pullAt o _.sin.

    • Hay un pequeño error tipográfico. Por favor corregir. this.splice(num.indexOf(x), 1); => this.splice(this.indexOf(x), 1);
    • Por favor, no aumentar construido-ins (adjuntar funciones de la Matriz.prototipo) en JavaScript. Esto es ampliamente considerado como una mala práctica.
    • Estoy de acuerdo en que no es la mejor cosa que hacer en el mundo, pero en este caso cómo se podría pasar a la función?
    • Usted debe verificar el índice. Si index = -1, splice(-1,1) va a eliminar el último elemento
  18. 30

    Aquí están algunas maneras de quitar un elemento de una matriz mediante JavaScript.

    Todo el método descrito no mutan a la matriz original, y en lugar de crear uno nuevo.

    Si usted sabe que el índice de un elemento

    Supongamos que tenemos una matriz, y desea eliminar un elemento en la posición i.

    Un método es utilizar slice():

    JS:

    const items = ['a', 'b', 'c', 'd', 'e', 'f']
    const i = 3
    const filteredItems = items.slice(0, i).concat(items.slice(i+1, items.length))
    
    console.log(filteredItems)

    slice() crea un nuevo array con los índices que recibe. Simplemente debemos crear una nueva matriz, desde el inicio hasta el índice que desea eliminar, y concatenar otra matriz de la posición siguiente al de la que hemos eliminado al final de la matriz.

    Si sabe el valor

    En este caso, una buena opción es utilizar filter(), que ofrece una más declarativa enfoque:

    JS:

    const items = ['a', 'b', 'c', 'd', 'e', 'f']
    const valueToRemove = 'c'
    const filteredItems = items.filter(item => item !== valueToRemove)
    
    console.log(filteredItems)

    Para ello se utiliza el ES6 flecha funciones. Puede utilizar las funciones tradicionales para soportar los navegadores más antiguos:

    JS:

    const items = ['a', 'b', 'c', 'd', 'e', 'f']
    const valueToRemove = 'c'
    const filteredItems = items.filter(function(item) {
      return item !== valueToRemove
    })
    
    console.log(filteredItems)

    o puede utilizar Babel y transpile la ES6 código del ES5 para hacerla más digerible para los navegadores antiguos, sin embargo, la escritura moderna de JavaScript en el código.

    La eliminación de varios elementos

    ¿Y si en vez de un único elemento que desea eliminar muchos de los artículos?

    Vamos a encontrar la solución más simple.

    Por índice

    Usted puede crear una función y eliminar elementos en serie:

    JS:

    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)

    Por valor

    Usted puede buscar para su inclusión dentro de la función de devolución de llamada:

    JS:

    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)

    Evitar la mutación de la matriz original

    splice() (que no debe confundirse con slice()) muta a la matriz original, y debe ser evitado.

    (publicado originalmente en https://flaviocopes.com/how-to-remove-item-from-array/)

  19. 27

    Soy bastante nuevo en JavaScript y necesita esta funcionalidad. Simplemente me escribió esto:

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

    Entonces cuando quiero usarlo:

    //Set-up some dummy data
    var dummyObj = {name:"meow"};
    var dummyArray = [dummyObj, "item1", "item1", "item2"];
    
    //Remove the dummy data
    removeFromArray(dummyArray, dummyObj);
    removeFromArray(dummyArray, "item2");

    De salida – Como se esperaba.
    [«elemento1», «elemento1»]

    Usted puede tener diferentes necesidades que yo, así que usted puede modificar fácilmente para adaptarse a ellos. Espero que esto ayude a alguien.

    • Esto va a tener comportamiento terrible si su matriz es muy larga y hay varias instancias del elemento en ella. El método indexOf de la matriz será empezar por el principio cada vez, por lo que su costo va a ser O(n^2).
    • Tiene un nombre: Shlemiel el Pintor del Algoritmo
  20. 27

    ES6 & sin mutación: (octubre de 2016)

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

    A continuación :

    removeByIndex([33,22,11,44],1) //=> [33,11,44]
  21. 24

    Si tiene objetos complejos en la matriz puede utilizar filtros?
    En situaciones donde $.inArray o matriz.empalme no es tan fácil de usar. Especialmente si los objetos son, quizás, poca en la matriz.

    E. g. si tienes un objeto con un campo de Id y desea que el objeto se elimina de una matriz:

    this.array = this.array.filter(function(element, i) {
        return element.id !== idToRemove;
    });
    • Esta es la forma en que me gusta hacerlo. El uso de una función de flecha puede ser un one-liner. Soy curioso en cuanto a rendimiento. También vale la pena nada de lo que este reemplaza la matriz. Cualquier código con una referencia a la antigua matriz no va a notar el cambio.
  22. 23

    Actualización: se recomienda Este método sólo si no puede utilizar ECMAScript 2015 (anteriormente conocido como ES6). Si se puede usar, otras respuestas aquí es mucho más prolijo de las implementaciones.


    Esta esencia aquí va a resolver su problema, y también elimina todas las ocurrencias de la discusión en lugar de sólo 1 (o un valor especificado).

    Array.prototype.destroy = function(obj){
        //Return null if no objects were found and removed
        var destroyed = null;
    
        for(var i = 0; i < this.length; i++){
    
            //Use while-loop to find adjacent equal objects
            while(this[i] === obj){
    
                //Remove this[i] and store it within destroyed
                destroyed = this.splice(i, 1)[0];
            }
        }
    
        return destroyed;
    }

    Uso:

    var x = [1, 2, 3, 3, true, false, undefined, false];
    
    x.destroy(3);         //=> 3
    x.destroy(false);     //=> false
    x;                    //=> [1, 2, true, undefined]
    
    x.destroy(true);      //=> true
    x.destroy(undefined); //=> undefined
    x;                    //=> [1, 2]
    
    x.destroy(3);         //=> null
    x;                    //=> [1, 2]
  23. 23

    Quiero respuesta basada en la ECMAScript 6. Asumir, tiene una matriz como la siguiente:

    let arr = [1,2,3,4];

    Si desea eliminar en un índice especial como 2, escribir el siguiente código:

    arr.splice(2, 1); //=> arr became [1,2,4]

    Pero si desea eliminar un elemento especial como 3 y no sabe de su índice, hacer como la siguiente:

    arr = arr.filter(e => e !== 3); //=> arr became [1,2,4]

    Sugerencia: por favor, utilice una flecha función de filtro de devolución de llamada, a menos que usted conseguirá un array vacío.

  24. 21

    Nunca se debe mutar su matriz. Como esto está en contra de la programación funcional patrón. Puede crear una nueva matriz sin hacer referencia a la matriz que desea cambiar los datos de uso de la ECMAScript 6 método filter;

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

    Suponga que desea eliminar 5 de la matriz, puede simplemente hacer como este:

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

    Esto le dará una nueva matriz sin el valor que se desea eliminar. Así, el resultado será:

     [1, 2, 3, 4, 6]; //5 has been removed from this array

    Para un mayor entendimiento se puede leer el MDN documentación en De la matriz.filtro.

  25. 19

    Una más moderna, ECMAScript 2015 (anteriormente conocida como la Armonía o ES 6) enfoque. Dado:

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

    A continuación:

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

    Rendimiento:

    [1, 2, 4]

    Puede utilizar Babel y un relleno de servicio para asegurar que este está bien soportado en todos los navegadores.

    • Tenga en cuenta que .filter devuelve una nueva matriz, que no es exactamente el mismo como quitar el elemento de la misma matriz. La ventaja de este enfoque es que se puede de la cadena de la matriz de métodos juntos. por ejemplo: [1,2,3].filter(n => n%2).map(n => n*n) === [ 1, 9 ]
    • Genial, si tengo 600k elementos en la matriz y se desea eliminar primero 50k, te puedes imaginar que la lentitud? Esta no es la solución, no hay necesidad de que la función que se acaba de quitar elementos y no devuelve nada.
    • Por eso, quizás quieras usar splice o slice.
    • Eso es aún mejor, en el proceso de eliminación, sólo asignar 50K elementos y tirar en algún lugar. (con rebanada de 550K elementos, pero sin tirar de ellos desde la ventana).
    • Prefiero bjfletcher la respuesta, que puede ser tan corto como items= items.filter(x=>x!=3). Además, el protocolo facultativo no establece ningún requisito para el conjunto de datos grande.
  26. 18

    La eliminación de un elemento en particular/string a partir de una matriz se puede hacer en una sola línea:
    Todavía creo que este es el más elegante una línea que usted puede conseguir para este tipo de problema:

    theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);

    donde
    theArray es la matriz que desea quitar algo particular, stringToRemoveFromArray es la cadena que desea eliminar y 1 es la cantidad de elementos que desea quitar.

    • Esta es la respuesta que trabajó para mí al intentar actualizar una matriz basada en el botón de radio de la alternancia.
    • Ten cuidado, si "stringToRemoveFromArray" no se encuentra en su matriz, esto va a eliminar el último elemento de la matriz.
  27. 17

    Que tienen de 1 a 9 en la matriz, y desea quitar 5. Usar el siguiente código:

    JS:

    var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
    
    var newNumberArray = numberArray.filter(m => {
      return m !== 5;
    });
    
    console.log("new Array, 5 removed", newNumberArray);


    Si quieres múltiples valores. Ejemplo:- 1,7,8

    JS:

    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, 1,7 and 8 removed", newNumberArray);


    Si quieres eliminar un valor de matriz en una matriz. Ejemplo: [3,4,5]

    JS:

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

    Incluye navegador, es enlace.

  28. 16

    Sé que hay un montón de respuestas ya, pero muchos de ellos se parecen más a complicar el problema. Aquí es un simple, recursiva manera de eliminar todas las instancias de una clave – llama a sí mismo hasta el índice no se encuentra. Sí, sólo funciona en los navegadores con indexOf, pero es muy simple y puede ser fácilmente polyfilled.

    Independiente de la función

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

    Prototipo método

    Array.prototype.removeAll = function(key){
        var index = this.indexOf(key);
    
        if(index === -1) return;
    
        this.splice(index, 1);
        this.removeAll(key);
    }
    • Sólo una nota, de 1 de advertencia con este método es la posibilidad de desbordamientos de pila. A menos que estés trabajando con grandes matrices, usted no debería tener un problema.
    • Pero, ¿por qué un retorno en el medio? Efectivamente es una instrucción goto.
  29. 16

    Basado en todas las respuestas que eran principalmente correcta y teniendo en cuenta las mejores prácticas sugeridas (especialmente el uso de la Matriz.prototipo directamente), me encontré con el siguiente código:

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

    La revisión de la función anterior, a pesar del hecho de que funciona bien, me di cuenta de que podría haber algo de mejora en el rendimiento. También el uso de ES6 en lugar de ES5 es un enfoque mucho mejor. Con ese fin, este es el código mejorado:

    const arrayWithoutFastest = (() => {
      const isArray = canBeArray => ('isArray' in Array) 
        ? Array.isArray(canBeArray) 
        : Object.prototype.toString.call(canBeArray) === '[object Array]';
    
      let mapIncludes = (map, key) => map.has(key);
      let objectIncludes = (obj, key) => key in obj;
      let includes;
    
      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 value is not in exclude list
          if (!includes(withoutValues, arr[i])) {
            arrCopy.push(arr[i]);
          }
        }
    
        return arrCopy;
      }
    
      return arrayWithoutFastest;  
    })();

    Cómo utilizar:

    const arr = [1,2,3,4,5,"name", false];
    
    arrayWithoutFastest(arr, 1); //will return array [2,3,4,5,"name", false]
    arrayWithoutFastest(arr, 'name'); //will return [2,3,4,5, false]
    arrayWithoutFastest(arr, false); //will return [2,3,4,5]
    arrayWithoutFastest(arr,[1,2]); //will return [3,4,5,"name", false];
    arrayWithoutFastest(arr, {bar: "foo"}); //will return the same array (new copy)

    Actualmente estoy escribiendo un blog en el que he comparado varias soluciones para la Matriz sin problema y en comparación con el tiempo que se tarda en ejecutar. Voy a actualizar esta respuesta con el enlace una vez que termine ese post. Sólo para hacerle saber, he comparado los de arriba contra lodash del sin y en caso de que el navegador soporta Map, es mejor que lodash! Aviso que no estoy utilizando Array.prototype.indexOf o Array.prototype.includes como envolver el exlcudeValues en un Map o Object hace consultar más rápido!

  30. 15

    Usted puede hacer un bucle hacia atrás para asegurarse de no meter la pata hasta los índices, si hay varias instancias del elemento.

    var myElement = "chocolate";
    var myArray = ['chocolate', 'poptart', 'poptart', 'poptart', 'chocolate', 'poptart', 'poptart', 'chocolate'];
    
    /* Important code */
    for (var i = myArray.length - 1; i >= 0; i--) {
        if (myArray[i] == myElement) myArray.splice(i, 1);
    }

    Demostración En Vivo

  31. 14
      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[i2] = this[i2 + 1];
                        }
                        this.length = this.length - 1
                        return;
                    }
                }
            }
    
        var recentMovies = ['Iron Man', 'Batman', 'Superman', 'Spiderman'];
        recentMovies.removeItem('Superman');
  32. 14

    Quitar por el Índice de

    Una función que devuelve una copia de la matriz sin el elemento en el índice:

    /**
    * removeByIndex
    * @param {Array} array
    * @param {Number} index
    */
    function removeByIndex(array, index){
          return array.filter(function(elem, _index){
              return index != _index;
        });
    }
    l = [1,3,4,5,6,7];
    console.log(removeByIndex(l, 1));
    
    $> [ 1, 4, 5, 6, 7 ]

    Quitar por Valor

    Función que devuelve una copia de la matriz sin Valor.

    /**
    * removeByValue
    * @param {Array} array
    * @param {Number} value
    */
    function removeByValue(array, value){
          return array.filter(function(elem, _index){
              return value != elem;
        });
    }
    l = [1,3,4,5,6,7];
    console.log(removeByValue(l, 5));
    
    $> [ 1, 3, 4, 6, 7]
    • Son redundantes construcciones de la norma en torno a los desarrolladores web? Tengo a alguien en el trabajo de fumigación cosas como esta en todas partes. ¿Por qué no return value != elem?!
  33. 11

    Crear nueva matriz:

    var my_array = new Array();

    Agregar elementos a esta matriz:

    my_array.push("element1");

    La función indexOf (devuelve el índice o -1 cuando no se encuentra):

    var indexOf = function(needle)
    {
        if (typeof Array.prototype.indexOf === 'function') //Newer browsers
        {
            indexOf = Array.prototype.indexOf;
        }
        else //Older browsers
        {
            indexOf = function(needle)
            {
                var index = -1;
    
                for (var i = 0; i < this.length; i++)
                {
                    if (this[i] === needle)
                    {
                        index = i;
                        break;
                    }
                }
                return index;
            };
        }
    
        return indexOf.call(this, needle);
    };

    De verificación índice de este elemento (probado con Firefox y Internet Explorer 8 (y último):

    var index = indexOf.call(my_array, "element1");

    Quitar 1 elemento situado en el índice de la matriz

    my_array.splice(index, 1);
  34. 10

    También participé en la situación en la que tuve que quitar un elemento de Array. .indexOf no estaba trabajando en IE* para compartir mi trabajo jQuery.inArray() solución.

    var index = jQuery.inArray(val,arr);
    if (index > -1) {
        arr.splice(index, 1);
        //console.log(arr);
    }
    • jQuery es siempre bueno para cuidar de los problemas de compatibilidad del navegador de los diferentes Api de JavaScript.
  35. 9

    Creo que muchas de las instrucciones JavaScript no está bien pensado para la programación funcional. Empalme devuelve el borrado del elemento donde la mayoría del tiempo que necesita la reducción de la matriz. Esto es malo.

    Imagínese que usted está haciendo una llamada recursiva, y tienen que pasar una matriz con un menor elemento, probablemente sin la actual indexada artículo. O imagínese que usted está haciendo otra llamada recursiva, y tiene que pasar un array con un elemento empujado.

    En ninguno de estos casos se puede realizar myRecursiveFunction(myArr.push(c)) o myRecursiveFunction(myArr.splice(i,1)). El primer idiota en el hecho de pasar la longitud de la matriz y el segundo idiota va a pasar el borrado del elemento como un parámetro.

    Así que lo que hago en realidad… Para eliminar un elemento de la matriz y de paso de la resultante a una función como un parámetro en el mismo tiempo hago de la siguiente manera

    myRecursiveFunction(myArr.slice(0,i).concat(a.slice(i+1)))

    Cuando se trata de empuje que es más tonto… me gusta,

    myRecursiveFunction((myArr.push(c),myArr))

    Creo en un adecuado lenguaje funcional de un método de mutación del objeto es llamado debe devolver una referencia al objeto mismo como un resultado.

  36. 9

    2017-05-08

    La mayoría de las respuestas posibles de trabajo para la comparación estricta, lo que significa que tanto los objetos de referencia exactamente el mismo objeto en memoria (o son tipos primitivos), pero a menudo se desea eliminar un no-objeto primitivo de una matriz que tiene un cierto valor. Por ejemplo, si usted hace una llamada a un servidor y desea comprobar un objeto recuperado en contra de un objeto local.

    const a = {'field': 2} //Non-primitive object
    const b = {'field': 2} //Non-primitive object with same value
    const c = a            //Non-primitive object that reference the same object as "a"
    
    assert(a !== b) //Don't reference the same item, but have same value
    assert(a === c) //Do reference the same item, and have same value (naturally)
    
    //Note: there are many alternative implementations for valuesAreEqual
    function valuesAreEqual (x, y) {
       return  JSON.stringify(x) === JSON.stringify(y)
    }
    
    
    //filter will delete false values
    //Thus, we want to return "false" if the item
    //we want to delete is equal to the item in the array
    function removeFromArray(arr, toDelete){
        return arr.filter(target => {return !valuesAreEqual(toDelete, target)})
    }
    
    const exampleArray = [a, b, b, c, a, {'field': 2}, {'field': 90}];
    const resultArray = removeFromArray(exampleArray, a);
    
    //resultArray = [{'field':90}]

    Hay alternativa/implementaciones más rápidas para valuesAreEqual, pero esto no hace el trabajo. También puede usar un comparador de si usted tiene un campo específico de verificación (por ejemplo, algunos recuperados UUID frente a un local UUID).

    También tenga en cuenta que esta es una operación funcional, lo que significa que no mutar la matriz original.

    • Me gusta la idea, simplemente creo que es un poco lento para hacer dos stringify por cada elemento en la matriz. De todos modos hay casos en que la pena, gracias por compartir.
    • Gracias, he añadido una edición aclarar que valuesAreEqual puede ser sustituido. Estoy de acuerdo en que el JSON enfoque es lento, pero siempre va a funcionar. Definitivamente el mejor uso de la comparación cuando sea posible.
  37. 9

    Muchas veces es mejor crear un nuevo array con los filter función.

    let array = [1,2,3,4];
    array = array.filter(i => i !== 4); //[1,2,3]

    Esto también mejora la legibilidad en mi humilde opinión. Yo no soy un fan de slice, aunque sé que a veces hay que ir por ella.

    • ¿puede explicar por qué usted prefiere filtro de empalme y por qué cree que el filtro es más legible?
    • Aunque no se recomienda para el largo de las matrices.
    • Rebanada tiene un montón de opciones y que se confunde en mi humilde opinión. Usted puede, si lo desea, pasar de inicio y final de la variable y si bien el inicio índice se incluye, al final del índice es no, etc. Es más difícil la lectura de código de jugar con rebanada. Si no utilizas demasiado a menudo, que a menudo terminan la comprobación de la documentación durante las revisiones para comprobar si algo es correcto. Docs: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
  38. 7

    Uso de jQuery, InArray:

    A = [1, 2, 3, 4, 5, 6];
    A.splice($.inArray(3, A), 1);
    //It will return A=[1, 2, 4, 5, 6]`   

    Nota: inArray devolverá -1 si no se encontró el elemento.

    • pero el OP dijo: «good ol’ de moda JavaScript – no marcos permitido»
    • para google Chrome, 50.0, A. empalme(-1, 1); se eliminará el último en A.
  39. 6

    Se puede iterar sobre cada array-objeto y splice si existen en su array.

    function destroy(arr, val) {
        for (var i = 0; i < arr.length; i++) if (arr[i] === val) arr.splice(i, 1);
        return arr;
    }
    • destruir( [1,2,3,3,3,4,5], 3 ) devuelve [1,2,3,4,5]]. no debería ser incrementado cuando la matriz está empalmado.
    • esto podría funcionar si iterado yo hacia atrás en lugar de hacia adelante, aunque. for (var i = arr.longitud; i– > 0; ) [ editar ] ya publicado here
  40. 6

    Me gusta esta versión de empalme, la eliminación de un elemento por su valor de uso $.inArray:

    $(document).ready(function(){
        var arr = ["C#","Ruby","PHP","C","C++"];
        var itemtoRemove = "PHP";
        arr.splice($.inArray(itemtoRemove, arr),1);
    });
    • Elimina el último elemento si el elemento buscado no se encuentra
    • sí correcto, usted debe saber que el elemento que desea eliminar, como en los otros ejemplos.
    • Este es el uso de jQuery, en el núcleo de JavaScript.
    • cualquier otra forma por la repetición de algunos de valor de un máximo de 5 veces, a continuación, crear nueva matriz y eliminar el valor de la matriz? Tengo ESTE TIPO DE MATRIZ: [«información.specificAllergy», «info.specificAllergy», «info.specificAllergy», «info.specificAllergy», «info.specificAllergy», «info.existingMedicalCondition», «info.existingMedicalCondition», «info.existingMedicalCondition», «info.existingMedicalCondition», «info.existingMedicalCondition»]
  41. 6

    Retire el elemento en el índice i, sin la mutación de la matriz original:

    /**
    * removeElement
    * @param {Array} array
    * @param {Number} index
    */
    function removeElement(array, index) {
       return Array.from(array).splice(index, 1);
    }
    
    //Another way is
    function removeElement(array, index) {
       return array.slice(0).splice(index, 1);
    }
  42. 6

    JavaScript (ES5.1) – en lugar edición

    Soporte de los navegadores: Internet Explorer 9 o posterior (detallada de la compatibilidad del navegador)

    /**
     * Removes all occurences of the item from the array.
     *
     * Modifies the array “in place”, i.e. the array passed as an argument
     * is modified as opposed to creating a new array. Also returns the modified
     * array for your convenience.
     */
    function removeInPlace(array, item) {
        var foundIndex, fromIndex;
    
        //Look for the item (the item can have multiple indices)
        fromIndex = array.length - 1;
        foundIndex = array.lastIndexOf(item, fromIndex);
    
        while (foundIndex !== -1) {
            //Remove the item (in place)
            array.splice(foundIndex, 1);
    
            //Bookkeeping
            fromIndex = foundIndex - 1;
            foundIndex = array.lastIndexOf(item, fromIndex);
        }
    
        //Return the modified array
        return array;
    }

    JavaScript (ES5.1) – inmutable edición

    Soporte de los navegadores: lo Mismo que JavaScript en lugar de la edición

    /**
     * Removes all occurences of the item from the array.
     *
     * Returns a new array with all the items of the original array except
     * the specified item.
     */
    function remove(array, item) {
        var arrayCopy;
    
        arrayCopy = array.slice();
    
        return removeInPlace(arrayCopy, item);
    }

    Vainilla ES6 – inmutable edición

    Soporte de los navegadores: Chrome 46, Edge 12, Firefox 16, Opera 37, Safari 8 (detallada de la compatibilidad del navegador)

    /**
     * Removes all occurences of the item from the array.
     *
     * Returns a new array with all the items of the original array except
     * the specified item.
     */
    function remove(array, item) {
        //Copy the array
        array = [...array];
    
        //Look for the item (the item can have multiple indices)
        let fromIndex = array.length - 1;
        let foundIndex = array.lastIndexOf(item, fromIndex);
    
        while (foundIndex !== -1) {
            //Remove the item by generating a new array without it
            array = [
                ...array.slice(0, foundIndex),
                ...array.slice(foundIndex + 1),
            ];
    
            //Bookkeeping
            fromIndex = foundIndex - 1;
            foundIndex = array.lastIndexOf(item, fromIndex)
        }
    
        //Return the new array
        return array;
    }
  43. 5

    Por mi solución puede eliminar uno o más de un elemento en una matriz, gracias a JavaScript puro. No hay necesidad de otra biblioteca de JavaScript.

    var myArray = [1,2,3,4,5]; //First array
    
    var removeItem = function(array,value) {  //My clear function
        if(Array.isArray(value)) {  //For multi remove
            for(var i = array.length - 1; i >= 0; i--) {
                for(var j = value.length - 1; j >= 0; j--) {
                    if(array[i] === value[j]) {
                        array.splice(i, 1);
                    };
                }
            }
        }
        else { //For single remove
            for(var i = array.length - 1; i >= 0; i--) {
                if(array[i] === value) {
                    array.splice(i, 1);
                }
            }
        }
    }
    
    removeItem(myArray,[1,4]); //myArray will be [2,3,5]
  44. 5

    Hice una manera bastante eficiente de extensión a la base array de JavaScript:

    Array.prototype.drop = function(k) {
      var valueIndex = this.indexOf(k);
      while(valueIndex > -1) {
        this.removeAt(valueIndex);
        valueIndex = this.indexOf(k);
      }
    };
    • He leído que usted no debe modificar un Objeto no propio
    • Además, no removeAt en ES estándar. Supongo, que esto es algo, es decir sólo cosas? Que deben ser mencionados en la respuesta.
  45. 5

    Acabo de crear un polyfill en el Array.prototype a través de Object.defineProperty para eliminar un elemento deseado en una matriz sin dar lugar a errores cuando se itera sobre ella más tarde a través for .. in ..

    La eliminación de un valor entero

    Extracción de una cadena de valor

    La eliminación de un valor booleano

    También es posible eliminar un objeto en el interior de la matriz a través de este Array.prototype.remove método. Sólo necesitas especificar el key => value de la Object desea quitar.

    La eliminación de un objeto de valor

  46. 4

    Mientras que la mayoría de las respuestas anteriores responder a la pregunta, no es lo suficientemente claro por qué el slice() método no ha sido utilizado. Sí, filter() cumple con la inmutabilidad de los criterios, pero, ¿cómo hacer el siguiente corto equivalente?

    Y ahora vamos a decir que debemos eliminar el segundo elemento de la matriz, se puede hacer simplemente:

    Esta forma de eliminar un elemento de una matriz se anima hoy en día en la comunidad debido a su simple e inmutable de la naturaleza. En general, los métodos que causa la mutación debe ser evitado. Por ejemplo, se recomienda reemplazar push() con concat() y splice() con slice().

  47. 4

    Hice una función:

    Y utilizado como este:

    • Si vas a nombre pop, al menos, que es hacer lo que el nombre de método implica!
  48. 4

    Eliminar un valor, mediante sueltas de comparación, sin la mutación de la matriz original, ES6

    • export const arrayRemove = (array, value) => [...array.filter(item => item !== value)]; Tal vez esto podría ser más sencillo.
    • Simple, sí, pero no exactamente la misma cosa. También no creo que usted necesita el [....filter ya debería devolver una copia.
    • Mi primera impresión fue que podría ser una manera más simple de hacer esto, pero estoy de acuerdo no está haciendo la misma cosa. Y sí, el [... no es necesario en este caso de modo aún más sencillo 🙂 gracias por eso.
  49. 4

    Eliminar un elemento de última

    Eliminar un elemento de primer

    Eliminar del medio

    Eliminar un elemento de la última

    Eliminar mediante el uso de un número de índice de matriz

  50. 3

    Eliminando el valor con el índice y el empalme!

    • Sus 2 últimos comentarios fueron sólo reescritura aceptado la respuesta… por Favor responder a un problema resuelto sólo si tiene más información que proporcionan que la aceptación de uno. Si no, sólo upvote la aceptada respuesta.
  51. 3

    Quitar la última ocurrencia de una o todas las veces, o la primera aparición?

    o

  52. 3

    Post de mi código que elimina un elemento de la matriz en su lugar, y reducir la longitud de matriz así.

  53. 3

    Para todos los que buscan replicar un método que devuelve una nueva matriz que se ha duplicado números o cadenas de caracteres se retiran, este ha sido elaborado a partir de las respuestas:

  54. 3

    El Uso De La Matriz.findindex, podemos reducir el número de líneas de código.

    developer.mozilla.org

    • Es mejor estar seguro de que usted sabe que el elemento está en la matriz, de lo contrario findindex devuelve -1 y, en consecuencia, se elimina el 9.
  55. 3

    Su pregunta no indican si la orden o valores distintos son un requisito.

    Si usted no se preocupan por fin, y no tendrá el mismo valor en el contenedor más de una vez, el uso de un Conjunto. Será más rápido y más breve.

  56. 3

    Hay muchas fantásticas respuestas aquí, pero para mí, lo que funcionó la mayoría simplemente no estaba quitando el elemento de la matriz por completo, sino simplemente establecer el valor de a null.

    Esto funciona para la mayoría de los casos que tengo y es una buena solución, ya que voy a estar usando la variable más tarde y no quieres que se ha ido, sólo vacío por ahora. Además, este enfoque es completamente compatible con distintos navegadores.

  57. 3

    Una muy ingenuo aplicación sería el siguiente:

    JS:

    Puedo devolver la longitud de la matriz de la función a cumplir con los otros métodos, como la Array.prototype.push().

  58. 2

    Esta solución tendrá una matriz de entrada y búsqueda a través de la entrada para el valor de quitar. Este bucle a través de toda la matriz de entrada y el resultado será una segunda matriz de enteros que ha tenido el índice específico eliminado. Los enteros de la matriz a continuación, se copia de nuevo en la matriz de entrada.

    • Esto es muy ineficiente cuando la matriz es grande.
  59. 2

    El siguiente método será eliminar todas las entradas de un determinado valor de una matriz sin necesidad de crear una nueva matriz y con sólo una iteración que se superfast. Y funciona en la antigua Internet Explorer 5.5 navegador:

    JS:

    HTML:

    • Cuál es el significado de este código, yo no podía entender.
    • Este código elimina todos los 0s de la matriz dada
  60. 2

    Lo que es una vergüenza tiene una matriz de enteros, no un objeto, donde las claves son cadenas equivalentes de estos enteros.

    He mirado a través de una gran cantidad de estas respuestas, y todos ellos parecen uso de la «fuerza bruta», por lo que puedo ver. No he examinado cada uno de ellos, le pido disculpas si esto no es así. Para una pequeña matriz de esto está muy bien, pero lo que si tiene 000s de enteros en ella?

    Me corrija si estoy equivocado, pero no podemos asumir que en un key => value mapa, del tipo de los que un objeto JS es, que la clave del mecanismo de recuperación puede ser asumida como altamente diseñado y optimizado? (NOTA: si algunos super-experto me dice que este no es el caso, me puede sugerir el uso de ES6 del Mapa de la clase lugar, que sin duda va a ser).

    Sólo estoy sugiriendo que, en ciertas circunstancias, la mejor solución podría ser la de convertir la matriz a un objeto… el problema es, por supuesto, que usted podría tener la repetición de valores enteros. Sugiero poner aquellos en los cubos como el «valor» de la parte de la key => value entradas. (NOTA: si está seguro de que usted no tiene repetición de elementos de la matriz de esto puede ser mucho más simple: los valores de «igual» de las teclas, y sólo tiene que ir Object.values(...) de volver a su matriz modificada).

    Así que usted podría hacer:

    de salida:

    Objeto [ <1 ranura vacía>, Matriz deUno, Matriz[2], la Matriz deUno, Matriz deUno, <5
    las ranuras vacías>, de 46 años y más… ]

    esta forma, es fácil de eliminar todos los números de 55

    Usted no tiene que eliminar a todos ellos: los valores del índice son empujados en sus cubos en orden de aparición, así que (por ejemplo):

    borrará la primera y última aparición, respectivamente. Usted puede contar la frecuencia de ocurrencia fácilmente, vuelva a colocar todos de 55 años con 3s por transferir el contenido de un cubo a otro, etc.

    … volver a sus modificado int matriz es ligeramente involucrados: pero cada cubo contiene el índice (en la matriz original) del valor representado por el (string key). Cada uno de estos cubo de valores es también único: de modo que se convierten en las claves de un nuevo objeto, con el (verdadero) entero de la «integer clave de la cadena» como valor… luego ordenar las llaves e ir Object.values( ... ).

    Esto suena muy involucrados y consume mucho tiempo… pero obviamente todo depende de las circunstancias y de uso deseada. Mi entendimiento es que todas las versiones y contextos de la JS, solo funcionan en un hilo, y el hilo no «dejar ir», por lo que podría ser un horrible congestión con una «fuerza bruta» método: causadas no tanto por la indexOf ops, pero repetidos múltiples slice/splice ops.

    Anexo

    Si estás seguro esto es demasiado ingeniería para el caso de uso, seguramente la más simple «fuerza bruta» es

    (sí, otras respuestas han descubierto Array.prototype.filter…)

  61. 2

    Tuve este problema (en una situación en la que la sustitución de la matriz fue aceptable) y la resolvió con un simple:

    Para dar el fragmento anterior un poco de contexto:

    Esta solución debe trabajar con la información de referencia y el valor de los artículos. Todo depende de si usted necesita para mantener una referencia a la matriz original en cuanto a si esta solución es aplicable.

    • OP preguntó sobre la eliminación de un particular (un) elemento de una matriz. Esta función no termina cuando un elemento se encuentra, pero mantiene la comparación de cada elemento en la matriz hasta llegar al final.
  62. 2

    Para eliminar un determinado elemento o los elementos posteriores, De la matriz.splice() método funciona bien.

    El método splice() cambia el contenido de una matriz mediante la eliminación o sustitución de los elementos existentes y/o la adición de nuevos elementos, y devuelve el elemento eliminado(s).

    Sintaxis: matriz.splice(índice, deleteCount, artículo 1, ….., itemX)

    Aquí index es obligatorio y el resto de los argumentos son opcionales.

    Por ejemplo:

    Nota: De la matriz.splice() método puede ser usado si se conoce el índice del elemento que desea eliminar. Pero podemos tener un poco más de los casos que se mencionan a continuación:

    1. En caso de que desea eliminar sólo el último elemento, puede utilizar De la matriz.pop()

    2. En caso de que desea eliminar sólo el primer elemento, puede utilizar De la matriz.shift()

    3. Si sabe el elemento por sí solo, pero no la posición (o índice) del elemento, y desea eliminar todos los elementos coincidentes mediante De la matriz.filter() método:

      O mediante el método splice() como:

      O supongamos que queremos eliminar del de la matriz arr:

      O

    4. Si sabe el elemento por sí solo, pero no la posición (índice) del elemento, y desea eliminar sólo en muy primer elemento coincidente utilizando el método splice ():

    • Nota: La Matriz.el prototipo.filtro de ECMAScript 5.1 (No IE8)
    • Para la opción 4, si el bucle se ‘i < arr.longitud’ no ‘i < arr.longitud-1’?
  63. 2

    De empalme, filtrar y eliminar para eliminar un elemento de una matriz

    Cada matriz tiene su índice, y ayuda a eliminar un elemento en particular con su índice.

    El método splice ()

    matriz.splice(índice, 1);

    El primer parámetro es el índice y el segundo es el número de elementos que desea eliminar de ese índice.

    Modo para un solo elemento, se uso 1.

    El método delete

    eliminar de la matriz[índice]

    El método filter ()

    Si desea eliminar un elemento que se repite en una matriz, a continuación, el filtro de la matriz:

    Donde elem es el elemento que desea eliminar de la matriz y array es el nombre de la matriz.

  64. 1

    Si usted debe apoyar a las versiones anteriores de Internet Explorer, recomiendo usar la siguiente relleno (nota: este es no un marco). Es 100% compatible con la sustitución de todos los modernos de la matriz de métodos (JavaScript 1.8.5 /ECMAScript 5 Matriz de Extras) que funciona para Internet Explorer 6+, Firefox 1.5+, Chrome, Safari, & Ópera.

    https://github.com/plusdude/array-generics

    • Mientras que este vínculo puede responder a la pregunta, es mejor incluir a las partes esenciales de la respuesta aquí y proporcionar el enlace de referencia. Enlace-sólo respuestas puede ser válido si la página enlazada cambios.
    • Lamentablemente, el internet (y de Desbordamiento de Pila) están llenos de la mitad implementado parcialmente las versiones correctas del ES5 matriz de métodos. Que es enteramente el punto de la vinculación para el relleno. Para una verdadera reproducción completa de todo de los comportamientos correctos, no es lo suficientemente bueno para resumir «las partes esenciales.» Usted tiene que aplicar todas las de la las condiciones de borde también. Para reproducir su contenido en su totalidad es mucho más allá del alcance de Desbordamiento de Pila. Desbordamiento de pila no es GitHub.
  65. 1

    Definir un método llamado remove() en un array de objetos mediante la generación de prototipos de función de JavaScript.

    Uso splice() método para cumplir su requisito.

    Por favor, eche un vistazo a el siguiente código.

    Nota: El siguiente es el ejemplo completo código que se ejecuta en el Node.js REPL que describe el uso de push(), pop(), shift(), unshift () y splice() métodos.

    > //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
    >
  66. 1

    La mayoría de las respuestas que aquí se dan una solución con –

    1. indexOf y empalme
    2. eliminar
    3. filtro
    4. regular for loop

    A pesar de todas las soluciones que se debe trabajar con estos métodos, pensé que podía el uso de la manipulación de cadenas.

    Puntos a tener en cuenta acerca de esta solución –

    1. Va a salir de los agujeros en los datos. (podría ser quitado con filtro adicional)
    2. Esta solución obras no sólo primitiva de búsqueda de valores, pero también objetos.

    El truco es –

    1. stringify conjunto de datos de entrada y el valor de búsqueda
    2. reemplazar el valor de búsqueda en el conjunto de datos de entrada con la cadena vacía
    3. volver split datos sobre delimitador ,.
        remove = (input, value) => {
    const stringVal = JSON.stringify(value);
    const result = JSON.stringify(input)
    return result.replace(stringVal, "").split(",");
    }

    Un JS de violín con las pruebas para los objetos y los números se crea aquí – https://jsfiddle.net/4t7zhkce/33/

    Comprobar la remove método en el violín.

  67. 0
    Array.prototype.remove = function(x) {
    var y=this.slice(x+1);
    var z=[];
    for(i=0;i<=x-1;i++) {
    z[z.length] = this[i];
    }
    for(i=0;i<y.length;i++){
    z[z.length]=y[i];
    }
    return z;
    }
  68. 0

    Ya hay un montón de respuestas, pero porque nadie lo ha hecho con un forro sin embargo, pensé que había que mostrar mi método. Se aprovecha el hecho de que la cadena.split() de la función de eliminar todos los caracteres especificados al crear una matriz. Aquí está un ejemplo:

    JS:

    var ary = [1,2,3,4,1234,10,4,5,7,3];
    out = ary.join("-").split("-4-").join("-").split("-");
    console.log(out);

    En este ejemplo, todos los de la 4 están siendo retirados de la matriz de ary. Sin embargo, es importante tener en cuenta que cualquier matriz que contiene el carácter «-» va a causar problemas con este ejemplo. En definitiva, hará que el join(«-«) de la función a la pieza de su cadena junto incorrectamente. En tal situación, todos los «-» de las cadenas en el anterior snipet se puede reemplazar con cualquier cadena que no serán utilizados en la matriz original. Aquí está otro ejemplo:

    JS:

    var ary = [1,2,3,4,'-',1234,10,'-',4,5,7,3];
    out = ary.join("[email protected]#").split("[email protected]#[email protected]#").join("[email protected]#").split("[email protected]#");
    console.log(out);

    • Usted puede ver que no hay cadenas en el segundo ejemplo que he proporcionado? No estoy seguro de lo que quieres decir con esto? La única cuestión es si la cadena contiene uno de los fletadores se utiliza en la separación, como ya he mencionado en mi respuesta.
    • Interesante método, puede utilizar caracteres Unicode para la división (por ejemplo,'\uD842') en su lugar. Para hacer más claro y más corto para otros, solo quisiera agregar un par de cadenas más a los elementos de la matriz (incluyendo '4') y el primer fragmento/ejemplo (personas pueden tener votada abajo porque ni siquiera leer la 2ª parte).
  69. 0

    No en lugar de la solución de

    arr.slice(0,i).concat(arr.slice(i+1));

    JS:

    let arr = [10, 20, 30, 40, 50]
    let i = 2 ; //position to remove (starting from 0)
    let r = arr.slice(0,i).concat(arr.slice(i+1));
    console.log(r);

  70. 0

    Quitar único elemento

    function removeSingle(array, element) {
    const index = array.indexOf(element)
    if (index >= 0) {
    array.splice(index, 1)
    }
    }

    Eliminar varios elementos, en lugar

    Esto es más complicado para garantizar que el algoritmo se ejecuta en O(N) tiempo.

    function removeAll(array, element) {
    let newLength = 0
    for (const elem of array) {
    if (elem !== number) {
    array[newLength++] = elem
    }
    }
    array.length = newLength
    }

    Eliminar varios elementos, la creación de nuevos objetos

    array.filter(elem => elem !== number)
  71. 0

    La splice() método cambia el contenido de una matriz mediante la eliminación o sustitución de los elementos existentes y/o la adición de nuevos elementos.

    matriz.splice(start[, deleteCount[, elemento1[, item2[, …]]]])

    inicio

    El índice en el que se inicia el cambio de la matriz (con origen en 0). Si es mayor que la longitud de la matriz, el inicio real del índice será ajustado a la longitud de la matriz. Si es negativo, se empezará a que muchos de los elementos de la final de la matriz (con su origen, -1) y se establece en 0 si el valor absoluto es mayor que la longitud de la matriz.

    deleteCount Opcional

    Un entero que indica el número de antiguos elementos de la matriz a quitar.

    Si deleteCount se omite, o si su valor es mayor que la de la matriz.la longitud de inicio (es decir, si es mayor que el número de elementos a la izquierda de la matriz, a partir de inicio), todos los elementos, desde el inicio hasta el final de la matriz, será eliminado.
    Si deleteCount es 0 o negativo, sin elementos son eliminados. En este caso, debe especificar al menos un nuevo elemento (ver más abajo).

    item1, item2, … Opcional

    Los elementos a añadir a la matriz, desde el comienzo de índice. Si no se especifica alguno de los elementos, splice() sólo eliminar elementos de la matriz.

    Para más referencias, por favor vaya a través de:

    De la matriz.el prototipo.splice()

  72. 0

    Puede ampliar el objeto de matriz para definir una costumbre borrar la función de la siguiente manera:

    JS:

    let numbers = [1,2,4,4,5,3,45,9];
    numbers.delete = function(value){
    var indexOfTarget = this.indexOf(value)
    if(indexOfTarget !== -1)
    {
    console.log("array before delete " + this)
    this.splice(indexOfTarget, 1)
    console.log("array after delete " + this)
    }
    else{
    console.error("element " + value + " not found")
    }
    }
    numbers.delete(888)
    //Expected output:
    //element 888 not found
    numbers.delete(1)
    //Expected output;
    //array before delete 1,2,4,4,5,3,45,9
    //array after delete 2,4,4,5,3,45,9

  73. 0

    Tomar ventaja de reducir método de la siguiente manera:

    El caso a) si usted necesita para eliminar un elemento del índice:

    function remove(arr, index) {
    return arr.reduce((prev, x, i) => prev.concat(i !== index ? [x] : []), []);
    }

    caso b) si usted necesita para eliminar un elemento por el valor del elemento (int):

    function remove(arr, value) {
    return arr.reduce((prev, x, i) => prev.concat(x !== value ? [x] : []), []);
    }

    Así que de esta manera podremos regresar a una nueva matriz (será en un lugar fresco y funcional – mucho mejor que el uso de push o empalme) con el elemento eliminado.

  74. 0

    puede crear un índice con todos los accesors ejemplo

    <div >
    </div>

    JS:

    function getIndex($id){
    return (
    this.removeIndex($id)
    alert("This element was removed")
    )
    }
    function removeIndex(){
    const index = $id; 
    this.accesor.id.splice(index.id) //you can use splice for slice index on accesor id and return with message
    }

    HTML:

    <div>
    <fromList>
    <ul>
    {...this.array.map( accesors => {
    <li type="hidden"></li>
    <li>{...accesors}</li>
    }) 
    }
    </ul>
    </fromList>
    <form id="form" method="post">
    <input  id="{this.accesors.id}">
    <input type="submit" callbackforApplySend...getIndex({this.accesors.id}) name="sendendform" value="removeIndex" >
    </form>
    </div>

  75. 0

    Me gustaría sugerir para quitar un elemento de matriz utilizando eliminar y filtrar:

    var arr = [1,2,3,4,5,5,6,7,8,9];
    delete arr[5];
    arr = arr.filter(function(item){ return item != undefined; });
    //result: [1,2,3,4,5,6,7,8,9]

    Por lo tanto, podemos eliminar sólo uno específico de elemento de matriz en lugar de todos los elementos con el mismo valor.

  76. 0

    Puede crear un prototipo para que. Acaba de pasar el elemento de la matriz y el valor que desea quitar el elemento de la matriz

    JS:

    Array.prototype.removeItem = function(array,val){
    array.forEach((arrayItem,index)=>{
    if(arrayItem==val){
    array.splice(index,1);
    }
    });
    return array;
    }
    var DummyArray = [1,2,3,4,5,6];
    console.log(DummyArray.removeItem(DummyArray,3));

  77. -1
        Array.prototype.remove = function(start, end) {
    var n = this.slice((end || start) + 1 || this.length);
    return this.length = start < 0 ? this.length + start : start,
    this.push.apply(this, n)
    }

    start y end puede ser negativo. En ese caso, ellos, a contar desde el final de la matriz.

    Si sólo start se especifica, sólo un elemento es eliminado.

    La función devuelve la nueva longitud de matriz.

    z = [0,1,2,3,4,5,6,7,8,9];
    newlength = z.remove(2,6);

    (8) [0, 1, 7, 8, 9]

    z=[0,1,2,3,4,5,6,7,8,9];
    newlength = z.remove(-4,-2);

    (7) [0, 1, 2, 3, 4, 5, 9]

    z=[0,1,2,3,4,5,6,7,8,9];
    newlength = z.remove(3,-2);

    (4) [0, 1, 2, 9]

    • esto puede chocar con otro código, bibliotecas, más bien me gustaría implementar una función quitar para que cada matriz
  78. -2

    JS:

    var array = [1,2,3];
    console.log('Array-First',array); //Array-First 1,2,3
    array.splice(1,1);
    console.log('Array-Second',array); //Array-Second 1,3

  79. -4

    Quitar el particular elemento de matriz

    ¿Cómo puedo eliminar un determinado elemento de un array en JavaScript?

    var cars = ["Apple", "Banana", "Mango", "Orange", "Grapes"];
    document.getElementById("demo").innerHTML = cars;
    for( var i = 0; i < cars.length; i++){ 
    if ( cars[i] === "Banana") {
    cars.splice(i, 1); 
    i--;
    }
    }
    document.getElementById("demo2").innerHTML =  cars;
    p {
    font-size: 20px; 
    padding: 10px; 
    border: 1px dashed tan;
    color: brown;
    }
    <!DOCTYPE html>
    <html>
    <body>
    <h2>Before</h2>
    <p id="demo"></p>
    <h2>After</h2>
    <p id="demo2"></p>
    </body>
    </html>
  80. -9
    var ar1 = [1,2,3,4,5,6,7,8,9]
    var toBeRemoved = 2;
    ar1.splice( (ar1.length -toBeRemoved) , toBeRemoved);
    • Se te quite siempre total n elementos desde el último índice de la matriz. Si usted sabe que el índice del elemento a eliminar, hacer algo como – vamos a ar1 = [1,2,3,4,5,6,7,8,9]; ar1.splice(fromIndex, howManyToBeDelete); Para más aclaración siga el enlace: stackoverflow.com/a/54390552/8958729
  81. -13
    let array = [5,5,4,4,2,3,4]    
    let newArray = array.join(',').replace('5','').split(',')

    Este ejemplo funciona si desea eliminar un elemento actual.

Dejar respuesta

Please enter your comment!
Please enter your name here