Regex per estrarre la sottostringa, di ritorno 2 risultati per un qualche motivo

Ho bisogno di fare un sacco di regex cose in javascript, ma sto avendo alcuni problemi con la sintassi e non riesco a trovare una risorsa definitiva su questo.. per qualche motivo quando faccio:

var tesst = "afskfsd33j"
var test = tesst.match(/a(.*)j/);
alert (test)

mostra

"afskfsd33j, fskfsd33"

Non so perché, il suo dare questa uscita originale, e la stringa corrispondente, mi sto chiedendo come posso ottenere solo la partita (essenzialmente estrarre la parte che voglio dalla stringa originale)

Grazie per qualsiasi consiglio

  • Prestare attenzione a che non hai l’originale e la stringa riconosciuta come stato. Hai la stringa “afskfsd33j”. Poi la seconda voce “fskfsd33” proveniente dalla parentesi nell’espressione: (.*)
InformationsquelleAutor Rick | 2010-08-15

 

5 Replies
  1. 92

    match restituisce un array.

    Predefinito rappresentazione di stringa di un array in JavaScript gli elementi dell’array separati da virgole. In questo caso il risultato desiderato è il secondo elemento dell’array:

    var tesst = "afskfsd33j"
    var test = tesst.match(/a(.*)j/);
    alert (test[1]);
    • ohh ok, credo che ho perso.. grazie, ho confuso con javascript in quanto a volte ho usato per più ristretto di stampa array in php
    • Probabilmente suono muto, ma perché non corrisponde restituire la stringa originale? C’è qualche documentazione su questo?
    • Questo perché l’originale stringa corrisponde all’espressione regolare /a(.*)j/ e la seconda voce dell’array contiene il primo gruppo di matching (.*). Inoltre il gruppo(0) è sempre tutta la partita, mentre il gruppo(n) è l’n-esimo gruppo segnato da parentesi quadre. Spero che questa cosa è comprensibile se non si tenta documentazione per ulteriori informazioni.
  2. 5

    Credo che il tuo problema è che il match metodo restituisce un array. Il 0th elemento della matrice è la stringa originale, il 1 ° al ennesimo elementi corrispondono alla 1 ° attraverso ennesimo corrispondenza tra parentesi tonde elementi. Il “alert (“chiamata sta mostrando l’intero array.

    • Non posso dire se questo è corretto o semplicemente mal formulata. Il primo elemento dell’array (test[0]) non è tutta la stringa, è la porzione di stringa che è stato accompagnato da tutta la regex. In questo caso capita di essere lo stesso, ma se la regex era stato /f(.*)j/, il risultato sarebbe stato fskfsd33j, skfsd33 (iniziale a non è incluso nella partita).
  3. 4

    Ogni gruppo definito da parentesi () viene catturato durante la lavorazione, e ogni gruppo catturato il contenuto viene spinto nella matrice di risultato nello stesso ordine come i gruppi all’interno di pattern inizia. Vedere di più su http://www.regular-expressions.info/brackets.html e http://www.regular-expressions.info/refcapture.html (scegliere il linguaggio giusto per vedere le caratteristiche supportate)

    var source = "afskfsd33j"
    var result = source.match(/a(.*)j/);
    
    result: ["afskfsd33j", "fskfsd33"]

    Il motivo per cui hai ricevuto questo risultato esatto è il seguente:

    Primo valore dell’array è la prima stringa che conferma l’intero modello. Così si dovrebbe assolutamente iniziare con “a” seguita da un numero qualsiasi di caratteri e termina con il primo “j” char dopo l’avvio di “un”.

    Secondo valore nella matrice viene catturato gruppo definito da parentesi. Nel tuo caso il gruppo contenere tutta la corrispondenza senza contenuto definito al di fuori parentesi, in modo esattamente “fskfsd33”.

    Se si vuole sbarazzarsi di secondo valore nella matrice che si può definire il modello come questo:

    /a(?:.*)j/

    dove “?:” significa che il gruppo di caratteri che corrisponde al contenuto in parentesi non essere parte di array risultante.

    Altre opzioni potrebbero essere in questo caso semplice di scrivere modello senza gruppo, perché non è necessario l’uso di gruppo:

    /a.*j/

    Se si desidera controllare se il testo sorgente corrisponde al modello e non si cura che il testo trovato che si può provare:

    var result = /a.*j/.test(source);

    Il risultato dovrebbe tornare quindi solo i valori vero|falso. Per ulteriori informazioni vedere http://www.javascriptkit.com/javatutors/re3.shtml

  4. 3

    Ho appena avuto lo stesso problema.

    Di ottenere solo il testo due volte il risultato, se si include un match del gruppo (tra parentesi) e la ‘g’ (globale) modificatore.
    Il primo elemento è sempre il primo risultato, normalmente su OK quando si utilizza match(reg) su una breve stringa, tuttavia quando si utilizza un costrutto come:

    while ((result = reg.exec(string)) !== null){
        console.log(result);
    }

    i risultati sono un po ‘ diverse.

    Provare il seguente codice:

    var regEx = new RegExp('([0-9]+ (cat|fish))','g'), sampleString="1 cat and 2 fish";
    var result = sample_string.match(regEx);
    console.log(JSON.stringify(result));
    //["1 cat","2 fish"]
    
    var reg = new RegExp('[0-9]+ (cat|fish)','g'), sampleString="1 cat and 2 fish";
    while ((result = reg.exec(sampleString)) !== null) {
        console.dir(JSON.stringify(result))
    };
    //'["1 cat","cat"]'
    //'["2 fish","fish"]'
    
    var reg = new RegExp('([0-9]+ (cat|fish))','g'), sampleString="1 cat and 2 fish";
    while ((result = reg.exec(sampleString)) !== null){
        console.dir(JSON.stringify(result))
    };
    //'["1 cat","1 cat","cat"]'
    //'["2 fish","2 fish","fish"]'

    (testato su recenti V8 di Chrome, Node.js)

    La risposta migliore è attualmente un commento che non posso dare un voto positivo, quindi, il credito di @Mic.

  5. 2

    Semplicemente sbarazzarsi di parentesi e che vi darà un array con un solo elemento e:

    • Modificare questa riga

    var test = tesst.match(/a(.*)j/);

    • Per questo

    var test = tesst.match(/a.*j/);

    Se si aggiunge tra parentesi il match() funzione di due match per voi uno per tutta l’espressione e uno per l’espressione all’interno della parentesi

    • Anche secondo developer.mozilla.org docs :

    Se si desidera solo la prima corrispondenza trovata, si potrebbe desiderare di utilizzare
    RegExp.exec (), invece.

    È possibile utilizzare il seguente codice:

    RegExp(/a.*j/).exec(“afskfsd33j”)

Lascia un commento