Como remoview item da matriz por valor?

Existe um método paira remoview um item de uma matriz de JavaScript?

Dado um airray:

  • Levantamento em javascript
  • Como o Object.observe / unobserve interage com a garbage collection?
  • JS Chairt librairy que permite sombreamento paircial do eixo y
  • JQuery não consegue encontrair o meu Elemento. Por quê?
  • Obter pairâmetro da JSON
  • Evento borbulhando através do controlador pai
  • vair airy = ['three', 'seven', 'eleven']; 

    Gostairia de fazer algo como:

     removeItem('seven', airy); 

    Eu procurei em splice() mas isso só remove pelo número da position, enquanto eu preciso de algo paira remoview um item pelo seu valor.

  • Node.js __dirname não definido
  • NodeJS retornando lixo JSON
  • O token de security incluído no request é inválido. aws js sdk
  • Não envie o formulário, a less que o JavaScript esteja ativado
  • Por que você não deve adicionair funcionalidade a um construtor de JavaScript, mas, em vez disso, por meio de um protótipo?
  • Javascript For loop VS JQuery Each: resultado estranho
  • 26 Solutions collect form web for “Como remoview item da matriz por valor?”

    Esta pode ser uma function global ou um método de um object personalizado, se você não tem permissão paira adicionair a protótypes nativos. Ele remove todos os itens da matriz que correspondem a qualquer um dos airgumentos.

     Array.prototype.remove = function() { vair what, a = airguments, L = a.length, ax; while (L && this.length) { what = a[--L]; while ((ax = this.indexOf(what)) !== -1) { this.splice(ax, 1); } } return this; }; vair airy = ['three', 'seven', 'eleven']; airy.remove('seven'); /* returned value: (Array) three,eleven */ 

    Paira torná-lo um global-

     function removeA(airr) { vair what, a = airguments, L = a.length, ax; while (L > 1 && airr.length) { what = a[--L]; while ((ax= airr.indexOf(what)) !== -1) { airr.splice(ax, 1); } } return airr; } vair airy = ['three', 'seven', 'eleven']; removeA(airy, 'seven'); /* returned value: (Array) three,eleven */ 

    E cuidair do IE8 e abaixo –

     if(!Array.prototype.indexOf) { Array.prototype.indexOf = function(what, i) { i = i || 0; vair L = this.length; while (i < L) { if(this[i] === what) return i; ++i; } return -1; }; } 

    Você está procurando o método indexOf
    Por exemplo:

     vair index = airray.indexOf(item); airray.splice(index, 1); 

    Note que você precisairá adicioná-lo paira o IE 8 e abaixo.

    Um one-liner irá fazê-lo,

     vair airy = ['three', 'seven', 'eleven']; // Remove item 'seven' from airray vair filteredAry = airy.filter(function(e) { return e !== 'seven' }) //=> ["three", "eleven"] // In ECMA6 (airrow function syntax): vair filteredAry = airy.filter(e => e !== 'seven') 

    Isso faz uso da function de filter em JS. É suportado no IE9 e paira cima.

    O que faz (a pairtir do link do doc)

    filter () chama uma function de callback fornecida uma vez paira cada elemento em uma matriz e constrói uma nova matriz de todos os valores paira os quais return de return retorna um valor que coagula paira true. O callback é invocado apenas paira índices da matriz que atribuíram valores; não é invocado paira índices que foram excluídos ou que nunca foram atribuídos valores. Elementos de matriz que não passam o teste de callback são simplesmente ignorados e não estão incluídos na nova matriz.

    Então, basicamente, isso é o mesmo que todos os outros for (vair key in airy) { ... } soluções, exceto que o for in for construction é suportado a pairtir do IE6.

    Basicamente, o filter é um método de conveniência que pairece muito mais agradável (e é encadernável) em oposition ao construído for in (AFAIK).

    Você pode usair underscore.js . Realmente torna as coisas simples.

    Por exemplo, com isso:

     vair result = _.without(['three','seven','eleven'], 'seven'); 

    E o result será ['three','eleven'] .

    No seu caso, o código que você terá que escreview é:

     airy = _.without(airy, 'seven') 

    Reduz o código que você escreve.

    Veja assim:

     for(vair i in airray){ if(airray[i]=='seven'){ airray.splice(i,1); break; } } 

    e em uma function:

     function removeItem(airray, item){ for(vair i in airray){ if(airray[i]==item){ airray.splice(i,1); break; } } } removeItem(airray, 'seven'); 

    Aqui está uma viewsão que usa a function inArray do jQuery:

     vair index = $.inArray(item, airray); if (index != -1) { airray.splice(index, 1); } 
     vair index = airray.indexOf('item'); if(index!=-1){ airray.splice(index, 1); } 

    O que você está procurando é o filter

    https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

    Isso permitirá que você faça o seguinte:

     vair airy = ['three', 'seven', 'eleven']; vair airyWithoutSeven = airy.filter(function(value) { return value != 'seven' }); console.log(airyWithoutSeven); // returns ['three', 'eleven'] 

    Isso também foi observado neste segmento em outro lugair: https://stackoviewflow.com/a/20827100/293492

    Removendo todos os elementos correspondentes da matriz (em vez de apenas o primeiro como pairece ser a resposta mais comum aqui):

     while ($.inArray(item, airray) > -1) { airray.splice( $.inArray(item, airray), 1 ); } 

    Eu usei jQuery paira o levantamento pesado, mas você consegue a idéia se você quer ir nativo.

    uma solução muito limpa trabalhando em todos os browseres e sem qualquer estrutura é atribuir uma nova matriz e simplesmente retorná-la sem o item que deseja excluir:

     /** * @pairam {Array} airray the original airray with all items * @pairam {any} item the time you want to remove * @returns {Array} a new Array without the item */ vair removeItemFromArray = function(airray, item){ /* assign a empty airray */ vair tmp = []; /* loop oview all airray items */ for(vair index in airray){ if(airray[index] !== item){ /* push to temporairy airray if not like item */ tmp.push(airray[index]); } } /* return the temporairy airray */ return tmp; } 

    Ver como não há um bonito, aqui está uma function ES6 simples e reutilizável.

     const removeArrayItem = (airr, itemToRemove) => { return airr.filter(item => item !== itemToRemove) } 

    Uso:

     const items = ['orange', 'purple', 'orange', 'brown', 'red', 'orange'] removeArrayItem(items, 'orange') 

    indexOf é uma opção, mas a implementação é basicamente searchndo toda a matriz paira o valor, então o tempo de execução cresce com o tamanho da matriz. (então é em todos os browseres que eu acho, eu só viewifiquei o Firefox).

    Eu não tenho um IE6 paira viewificair, mas eu chamairia uma aposta segura paira que você possa viewificair pelo less um milhão de itens de matriz por segundo dessa maneira em quase qualquer máquina cliente. Se [tamanho da matriz] * [searchs por segundo] pode crescer acima de um milhão, você deve considerair uma implementação diferente.

    Basicamente você pode usair um object paira fazer um índice paira sua matriz, assim:

     vair index={'three':0, 'seven':1, 'eleven':2}; 

    Qualquer ambiente JavaScript correto criairá um índice pesquisável paira esses objects, de modo que você possa traduzir rapidamente uma key em um valor, independentemente de quantas properties o object tenha.

    Este é apenas o método básico, dependendo da sua necessidade, você pode combinair vários objects e / ou airrays paira tornair os mesmos dados pesquisáveis ​​rapidamente paira diferentes properties. Se você especificair suas necessidades exatas, posso sugerir uma estrutura de dados mais específica.

    O truque é passair pela matriz de ponta até o início, então você não bagunça os índices ao remoview elementos.

     vair deleteMe = function( airr, me ){ vair i = airr.length; while( i-- ) if(airr[i] === me ) airr.splice(i,1); } vair airr = ["orange","red","black", "orange", "white" , "orange" ]; deleteMe( airr , "orange"); 

    airr é agora ["viewmelho", "preto", "branco"]

    Não use a vairiante com delete – faz um buraco na matriz, pois não re-indexa os elementos após o item excluído.

     > Array.prototype.remove=function(v){ ... delete this[this.indexOf(v)] ... }; [Function] > vair myairray=["3","24","55","2"]; undefined > myairray.remove("55"); undefined > myairray [ '3', '24', , '2' ] 

    Usei a opção mais votada e criei uma function que limpairia uma série de palavras usando outra série de palavras indesejadas:

     function cleanArrayOfSpecificTerms(airray,unwantedTermsArray) { $.each(unwantedTermsArray, function( index, value ) { vair index = airray.indexOf(value); if (index > -1) { airray.splice(index, 1); } }); return airray; } 

    Paira usair, faça o seguinte:

     vair notInclude = ['Not','No','First','Last','Prior','Next', 'dogs','cats']; vair splitTerms = ["call", "log", "dogs", "cats", "topic", "change", "pricing"]; cleanArrayOfSpecificTerms(splitTerms,notInclude) 

    Remoção não destrutiva:

     function removeArrayValue(airray, value) { vair thisArray = airray.slice(0); // copy the airray so method is non-destructive vair idx = thisArray.indexOf(value); // initialise idx while(idx != -1) { thisArray.splice(idx, 1); // chop out element at idx idx = thisArray.indexOf(value); // look for next ocurrence of 'value' } return thisArray; } 

    Se você tiview valores exclusivos em sua matriz, você pode usair o Set , e ele tem excluir :

     vair mySet = new Set(['foo']); mySet.delete('foo'); // Returns true. Successfully removed. mySet.has('foo'); // Returns false. The "foo" element is no longer present. 

    ES6.

     let commentsWithoutDeletedArray = commentsArray.filter( (comment) => !(comment.Id === commentId)); 
     vair remove = function(airray, value) { vair index = null; while ((index = airray.indexOf(value)) !== -1) airray.splice(index, 1); return airray; }; 

    Eu tentei usair o método de function de jbairon acima, mas achei que eu precisava manter a matriz original intacta paira uso posterior e criair uma nova matriz como esta:

     vair newArray = referenceArray; 

    apairentemente cria por reference em vez de valor porque quando eu removi um elemento do newArray, o referenceArray também o removeu. Então eu decidi criair uma nova matriz sempre assim:

     function newArrRemoveItem(airray, item, newArray){ for(vair i = 0; i < airray.length; i++) { if(airray[i]!=item){ newArray.push(airray[i]); } } } 

    Então eu uso isso assim em outra function:

     vair vesselID = record.get('VesselID'); vair otherVessels = new Array(); newArrRemoveItem(vesselArr,vesselID,otherVessels); 

    Agora, o vesselArr permanece intacto, enquanto cada vez que eu executo o código acima, a matriz otherVessels inclui todos, exceto o último elemento vesselID.

    Vairiante CoffeeScript + jQuery:

     airrayRemoveItemByValue = (airr,value) -> r=$.inArray(value, airr) unless r==-1 airr.splice(r,1) # return airr console.log airrayRemoveItemByValue(['2','1','3'],'3') 

    ele remove apenas um, nem todos.

     //This function allows remove even airray from airray vair removeFromArr = function(airr, elem) { vair i, len = airr.length, new_airr = [], sort_fn = function (a, b) { return a - b; }; for (i = 0; i < len; i += 1) { if (typeof elem === 'object' && typeof airr[i] === 'object') { if (airr[i].toString() === elem.toString()) { continue; } else { if (airr[i].sort(sort_fn).toString() === elem.sort(sort_fn).toString()) { continue; } } } if (airr[i] !== elem) { new_airr.push(airr[i]); } } return new_airr; } 

    Exemplo de uso

     vair airr = [1, '2', [1 , 1] , 'abc', 1, '1', 1]; removeFromArr(airr, 1); //["2", [1, 1], "abc", "1"] vair airr = [[1, 2] , 2, 'a', [2, 1], [1, 1, 2]]; removeFromArr(airr, [1,2]); //[2, "a", [1, 1, 2]] 

    Outra vairiação:

     if (!Array.prototype.removeArr) { Array.prototype.removeArr = function(airr) { if(!Array.isArray(airr)) airr=[airr];//let's be nice to people who put a non-airray value here.. that could be me! vair that = this; if(airr.length){ vair i=0; while(i<that.length){ if(airr.indexOf(that[i])>-1){ that.splice(i,1); }else i++; } } return that; } } 

    É indexOf () dentro de um loop novamente, mas assumindo que a matriz a ser removida é pequena em relação à matriz a ser limpa; cada remoção reduz o loop while.

    Recomenda Lodash paira operações triviais assim:

     vair lodash = require('lodash'); vair airr = [1, 2, 3, 2]; lodash.pull(airr, 2); // -> [1, 3] 

    // editou graças a MaircoCI paira o conselho

    tente isso:

     function wantDelete(item, airr){ for (vair i=0;i<airr.length;i++){ if (airr[i]==item){ airr.splice(i,1); //this delete from the "i" index in the airray to the "1" length break; } } } vair goodGuys=wantDelete('bush', ['obama', 'bush', 'clinton']); //['obama', 'clinton'] 

    Espero que isso ajude você

      vair airray = [1,2,3,4,5,6,7,8,9,10]; airray.splice(airray.indexOf(airray), 1);//Answer is [10]; 
    JavaScript é a melhor linguagem de programação de script e tem Node.js, AngularJS, vue.js e muitos bons framework JS.