test - ¿Cómo recupero todas las coincidencias para una expresión regular en JavaScript?

probar expresiones regulares

Question

Soy nuevo en expresiones regulares. Estoy tratando de analizar el siguiente tipo de cadena:

[key:"val" key2:"val2"]

donde hay una clave arbitraria: pares "val" dentro. Quiero tomar el nombre de la clave y el valor. Para los curiosos, estoy tratando de analizar el formato de la base de datos de task warrior. Aquí está mi cadena de prueba:

[description:"aoeu" uuid:"123sth"] que pretende resaltar que cualquier cosa puede estar en una clave o valor aparte del espacio, no hay espacios alrededor de los dos puntos, y los valores están siempre entre comillas dobles. En nodo, este es mi resultado:

[deuteronomy][gatlin][~]$ node
> var re = /^/[(?:(.+?):"(.+?)"/s*)+/]$/g
> re.exec(''[description:"aoeu" uuid:"123sth"]'');
[ ''[description:"aoeu" uuid:"123sth"]'',
  ''uuid'',
  ''123sth'',
  index: 0,
  input: ''[description:"aoeu" uuid:"123sth"]'' ]

Pero description:"aoeu" también coincide con este patrón. ¿Cómo puedo recuperar todas las coincidencias?

Answer 1

Aquí está mi función para obtener las coincidencias:

function getAllMatches(regex, text) {
    if (regex.constructor !== RegExp) {
        throw new Error(''not RegExp'');
    }

    var res = [];
    var match = null;

    if (regex.global) {
        while (match = regex.exec(text)) {
            res.push(match);
        }
    }
    else {
        if (match = regex.exec(text)) {
            res.push(match);
        }
    }

    return res;
}

var regex = /abc|def|ghi/g;
var res = getAllMatches(regex, ''abcdefghi'');

res.forEach(function (item) {
    console.log(item[0]);
});

Answer 2

Aquí está mi respuesta:

var str = ''[me nombre es] : My name is. [Yo puedo] is the right word''; 

var reg = //[(.*?)/]/g;

var a = str.match(reg);

a = a.toString().replace(/[/[/]]/g, "").split('',''));

Answer 3

Basado en la función de Agus, pero prefiero devolver solo los valores de coincidencia:

var bob = "> bob <";
function matchAll(str, regex) {
    var res = [];
    var m;
    if (regex.global) {
        while (m = regex.exec(str)) {
            res.push(m[1]);
        }
    } else {
        if (m = regex.exec(str)) {
            res.push(m[1]);
        }
    }
    return res;
}
var Amatch = matchAll(bob, /(&.*?;)/g);
console.log(Amatch);  // yeilds: [>, <]

Answer 4

Continúe llamando a re.exec(s) en un bucle para obtener todas las coincidencias:

var re = //s*([^[:]+):/"([^"]+)"/g;
var s = ''[description:"aoeu" uuid:"123sth"]'';
var m;

do {
    m = re.exec(s);
    if (m) {
        console.log(m[1], m[2]);
    }
} while (m);

Pruébalo con este jsfiddle: http://jsfiddle.net/7yS2V/

Answer 5

Definitivamente recomendaría usar la función String.match () y crear un RegEx relevante para ella. Mi ejemplo es con una lista de cadenas, que a menudo es necesaria al escanear las entradas de los usuarios para palabras clave y frases.

    // 1) Define keywords
    var keywords = [''apple'', ''orange'', ''banana''];

    // 2) Create regex, pass "i" for case-insensitive and "g" for global search
    regex = new RegExp("(" + keywords.join(''|'') + ")", "ig");
    => /(apple|orange|banana)/gi

    // 3) Match it against any string to get all matches 
    "Test string for ORANGE''s or apples were mentioned".match(regex);
    => ["ORANGE", "apple"]

¡Espero que esto ayude!

Answer 6

Esta es una solución

var s = ''[description:"aoeu" uuid:"123sth"]'';

var re = //s*([^[:]+):/"([^"]+)"/g;
var m;
while (m = re.exec(s)) {
  console.log(m[1], m[2]);
}

Esto se basa en la respuesta de lawnsea, pero más corto.

Observe que el indicador `g ''debe establecerse para mover el puntero interno hacia adelante a través de las invocaciones.

Answer 7

Iterables son más agradables:

const matches = (text, pattern) => ({
  [Symbol.iterator]: function * () {
    const clone = new RegExp(pattern.source, pattern.flags);
    let match = null;
    do {
      match = clone.exec(text);
      if (m) {
        yield match;
      }
    } while (match);
  }
});

Uso en un bucle:

for (const match of matches(''abcdefabcdef'', /ab/g)) {
  console.log(match);
}

O si quieres una matriz:

[ ...matches(''abcdefabcdef'', /ab/g) ]

Answer 8

OMG No entiendo que desde 2011 nadie haya enviado la buena respuesta.

Supongamos que su cadena es como [tecla: "val" clave2: "val2"] como se solicitó anteriormente por y desea recuperar todas las coincidencias con una expresión regular: puede disfrutar del segundo parámetro de la función de reemplazo que puede ser un función de devolución de llamada ... y luego obtener todos los argumentos que ha encontrado su expresión regular. A continuación, un ejemplo que puedes jugar en tu consola:

var str = ''[foo:"bar" thud:"grunt" bazola:"ztesch"]'';
var regex = new RegExp(''(//w+):"(//w+)"'', ''ig'');
var table = [];
str.replace(regex, function() {
    var matches = arguments;
    table.push(matches);
});
console.log(table);
//=> ["foo:"bar"", "foo", "bar", 1, .....

Answer 9

Para mí, una función final es esencial, así que preparé la respuesta de lawnsea en una función para copiar y pegar fácilmente.

function findall(regex_pattern, string_)
    {
        var output_list = [];
        while (true) 
            {
                var a_match = regex_pattern.exec(string_);
                if (a_match) 
                    {
                        // get rid of the string copy
                        delete a_match.input;
                        // store the match data
                        output_list.push(a_match);
                    }
                else
                    {
                        break;
                    }
            } 
        return output_list;
    }

uso de ejemplo:

console.log(   findall(/blah/g,''blah1 blah2'')   ) 

productos:

[ [ ''blah'', index: 0 ], [ ''blah'', index: 6 ] ]

Answer 10

Para recorrer todas las coincidencias, puede usar la función de replace :

var re = //s*([^[:]+):/"([^"]+)"/g;
var s = ''[description:"aoeu" uuid:"123sth"]'';

s.replace(re, function(match, g1, g2) { console.log(g1, g2); });

Answer 11

Utilizar esta...

var all_matches = your_string.match(re);
console.log(all_matches)

Devolverá una matriz de todas las coincidencias ... Eso funcionaría bien ... Pero recuerde que no tomará en cuenta a los grupos ... Devolverá las coincidencias completas ...

Answer 12

str.match(pattern) devolverá todas las coincidencias como una matriz. Supongo que esta es la forma más fácil.

Por ejemplo -

"All of us except @Emran, @Raju and @Noman was there".match(/@/w*/g)
// Will return ["@Emran", "@Raju", "@Noman"]