In javascript, come si cerca una matrice per una corrispondenza di sottostringa

Ho bisogno di cercare un array in javascript. La ricerca dovrebbe corrispondere solo a una parte della stringa in modo che la stringa abbia numeri addizionali ad essa assegnati. Dovrei quindi restituire l’elemento dell’array con corrispondenza corretta con la stringa completa.

vale a dire

var windowArray = new Array ("item","thing","id-3-text","class"); 

Ho bisogno di cercare l’elemento dell’array con "id-" in esso e ho bisogno di inserire anche il resto del testo nell’elemento (ad esempio "id-3-text" ).

Grazie

Nel tuo caso specifico, puoi farlo solo con un vecchio contatore noioso:

 var index, value, result; for (index = 0; index < windowArray.length; ++index) { value = windowArray[index]; if (value.substring(0, 3) === "id-") { // You've found it, the full text is in `value`. // So you might grab it and break the loop, although // really what you do having found it depends on // what you need. result = value; break; } } // Use `result` here, it will be `undefined` if not found 

Ma se l'array è scarso , puoi farlo in modo più efficiente con un ciclo for..in appositamente progettato:

 var key, value, result; for (key in windowArray) { if (windowArray.hasOwnProperty(key) && !isNaN(parseInt(key, 10))) { value = windowArray[key]; if (value.substring(0, 3) === "id-") { // You've found it, the full text is in `value`. // So you might grab it and break the loop, although // really what you do having found it depends on // what you need. result = value; break; } } } // Use `result` here, it will be `undefined` if not found 

Fai attenzione ai cicli naive for..in che non hanno i controlli hasOwnProperty e !isNaN(parseInt(key, 10)) ; ecco perché


Off-topic :

Un altro modo di scrivere

 var windowArray = new Array ("item","thing","id-3-text","class"); 

è

 var windowArray = ["item","thing","id-3-text","class"]; 

... che è meno digitante per te, e forse (questo bit è soggettivo) un po 'più facilmente leggibile. Le due affermazioni hanno esattamente lo stesso risultato: una nuova matrice con quei contenuti.

Se sei in grado di utilizzare Underscore.js nel tuo progetto, la funzione di matrice _.filter () lo rende un gioco da ragazzi:

 // find all strings in array containing 'thi' var matches = _.filter( [ 'item 1', 'thing', 'id-3-text', 'class' ], function( s ) { return s.indexOf( 'thi' ) !== -1; } ); 

La funzione iteratore può fare tutto ciò che vuoi fintanto che ritorna vero per le partite. Funziona alla grande.

Aggiornamento 2017-12-03:
Questa è una risposta abbastanza antiquata ora. Forse non è l’opzione più performante in un grande batch, ma può essere scritta molto più in modo teso e usa i metodi nativi di array / stringa ES6 come .filter() e .includes() ora:

 // find all strings in array containing 'thi' const items = ['item 1', 'thing', 'id-3-text', 'class']; const matches = items.filter(s => s.includes('thi')); 

Nota: non esiste un supporto <= IE11 per String.prototype.includes() (Edge funziona, String.prototype.includes() ), ma stai bene con un polyfill, o semplicemente fai un salto indietro a indexOf() .

Cerca semplicemente la stringa in plain indexOf

 arr.forEach(function(a){if (a.indexOf('curl')>-1) console.log(a);}) 

ref: In javascript, come si cerca una matrice per una corrispondenza di sottostringa

La soluzione fornita qui è generica a differenza della soluzione 4556343 # 4556343 , che richiede una analisi precedente per identificare una stringa con cui join() , che non è un componente di nessuna delle stringhe di array.
Inoltre, in quel codice /!id-[^!]*/ È più correttamente, /![^!]*id-[^!]*/ Per soddisfare i parametri della domanda:

  1. “cerca un array …” (di stringhe o numeri e non funzioni, matrici, oggetti, ecc.)
  2. “solo per parte della stringa da abbinare” (la corrispondenza può essere ovunque)
  3. “restituisci l’elemento … abbinato …” (singolare, non TUTTO, come in “… gli … elementi”)
  4. “con la stringa completa” (includere le virgolette)

… soluzioni NetScape / FireFox (vedi sotto per una soluzione JSON ):

 javascript: /* "one-liner" statement solution */ alert( ["x'!x'\"id-2",'\' "id-1 "', "item","thing","id-3-text","class" ] . toSource() . match( new RegExp( '[^\\\\]("([^"]|\\\\")*' + 'id-' + '([^"]|\\\\")*[^\\\\]")' ) ) [1] ); 

o

 javascript: ID = 'id-' ; QS = '([^"]|\\\\")*' ; /* only strings with escaped double quotes */ RE = '[^\\\\]("' +QS+ ID +QS+ '[^\\\\]")' ;/* escaper of escaper of escaper */ RE = new RegExp( RE ) ; RA = ["x'!x'\"id-2",'\' "id-1 "', "item","thing","id-3-text","class" ] ; alert(RA.toSource().match(RE)[1]) ; 

visualizza "x'!x'\"id-2" .
Magari facendo irruzione nell’array per trovare TUTTE le partite è ‘più pulito’.

 /* literally (? backslash star escape quotes it!) not true, it has this one v */ javascript: /* purely functional - it has no ... =! */ RA = ["x'!x'\"id-2",'\' "id-1 "', "item","thing","id-3-text","class" ] ; function findInRA(ra,id){ ra.unshift(void 0) ; /* cheat the [" */ return ra . toSource() . match( new RegExp( '[^\\\\]"' + '([^"]|\\\\")*' + id + '([^"]|\\\\")*' + '[^\\\\]"' , 'g' ) ) ; } alert( findInRA( RA, 'id-' ) . join('\n\n') ) ; 

display:

      "X '! X' \" id-2"

      "'\" id-1 \ ""

      "Id-3-text"

Utilizzando, JSON.stringify() :

 javascript: /* needs prefix cleaning */ RA = ["x'!x'\"id-2",'\' "id-1 "', "item","thing","id-3-text","class" ] ; function findInRA(ra,id){ return JSON.stringify( ra ) . match( new RegExp( '[^\\\\]"([^"]|\\\\")*' + id + '([^"]|\\\\")*[^\\\\]"' , 'g' ) ) ; } alert( findInRA( RA, 'id-' ) . join('\n\n') ) ; 

display:

     [ "X '! X' \" id-2"

     , "'\" id-1 \ ""

     , "Id-3-text"

le rughe:

  • Il RegExp globale “non sottoposto a escape” è /[^\]"([^"]|\")*id-([^"]|\")*[^\]"/g con \ essere trovato alla lettera. Per fare in modo che ([^"]|\")* corrisponda alle stringhe con " tutti i caratteri di escape” come \" , è necessario che il carattere di se stesso sia salvato come ([^"]|\\")* . Quando questo è referenziato come una stringa da concatenare con id- , ogni \ deve essere nuovamente scappato, quindi ([^"]|\\\\")* !
  • Un ID ricerca con un \ , * , " , …, deve anche essere sfuggito tramite .toSource() o JSON o ….
  • i risultati di ricerca null devono restituire '' (o "" come in una stringa EMPTY che contiene NO " !) o [] (per tutte le ricerche).
  • Se i risultati della ricerca devono essere incorporati nel codice del programma per un’ulteriore elaborazione, allora eval() è necessario, come eval('['+findInRA(RA,ID).join(',')+']') .

————————————————– ——————————

Digressione:
Incursioni e fughe? Questo codice è in conflitto?
La semiotica, la syntax e la semantica di /* it has no ... =! */ /* it has no ... =! */ enfaticamente enfatizza la fuga dal conflitto letterale quotato.

“No =” significa:

  • “no ‘=’ sign” come in javascript:alert('\x3D') (Not! Esegui e vedi che c’è!),
  • “nessuna istruzione javascript con l’operatore di assegnazione”,
  • “non uguale” come in “nulla di identico in nessun altro codice” (le precedenti soluzioni di codice dimostrano che esistono equivalenti funzionali),

Citando su un altro livello si può fare anche con l’URI del protocollo javascript della modalità immediata di seguito. (// i commenti terminano con una nuova riga (aka nl, ctrl-J, LineFeed, ASCII decimale 10, ottale 12, esadecimale A) che richiede quoting dall’inserimento di un nl, premendo il tasto Return, richiama l’URI.)

 javascript:/* a comment */ alert('visible') ; javascript:// a comment ; alert( 'not' ) this is all comment %0A; javascript:// a comment %0A alert('visible but %\0A is wrong ') // X %0A javascript:// a comment %0A alert('visible but %'+'0A is a pain to type') ; 

Nota: taglia e incolla qualsiasi delle javascript: linee come URI della modalità immediata (almeno, al massimo ?, in FireFox) per utilizzare il primo javascript: come schema o protocollo URI e il resto come etichette JS.

Per un esame affascinante di alcune delle alternative e della loro efficienza, vedi i post recenti di John Resig:

  • JavaScript Trie Performance Analysis
  • Ricerca del dizionario JavaScript rivista

(Il problema discusso qui è leggermente diverso, con gli elementi del pagliaio che sono prefissi dell’ago e non il contrario, ma la maggior parte delle soluzioni è facile da adattare.)

Il più semplice codice javascript di vanilla per raggiungere questo objective è

 var windowArray = ["item", "thing", "id-3-text", "class", "3-id-text"]; var textToFind = "id-"; //if you only want to match id- as prefix var matches = windowArray.filter(function(windowValue){ if(windowValue) { return (windowValue.substring(0, textToFind.length) === textToFind); } }); //["id-3-text"] //if you want to match id- string exists at any position var matches = windowArray.filter(function(windowValue){ if(windowValue) { return windowValue.indexOf(textToFind) >= 0; } }); //["id-3-text", "3-id-text"] 

Un’altra possibilità è

 var res = /!id-[^!]*/.exec("!"+windowArray.join("!")); return res && res[0].substr(1); 

che l’IMO può avere senso se si può avere un delimitatore di caratteri speciali (qui ho usato “!”), la matrice è costante o prevalentemente costante (quindi il join può essere calcolato una volta o raramente) e la stringa completa non è molto più lunga di il prefisso cercato.

Le persone qui stanno rendendo questo waaay troppo difficile. Basta fare quanto segue …

 myArray.findIndex(element => element.includes("substring")) 

findIndex () è un metodo di ordine superiore ES6 che itera attraverso gli elementi di una matrice e restituisce l’indice del primo elemento che corrisponde ad alcuni criteri (fornito come funzione). In questo caso ho usato la syntax ES6 per dichiarare la funzione di ordine superiore. element è il parametro della funzione (che potrebbe essere qualsiasi nome) e la fat fat dichiara quanto segue come una funzione anonima (che non ha bisogno di essere racchiusa tra parentesi graffe a meno che non occupi più di una riga).

All’interno di findIndex() ho usato il semplicissimo metodo includes() per verificare se l’elemento corrente include la sottostringa che si desidera.