regulares - regexp javascript

¿Cuál es la diferencia entre la función exec() de RegExp y la función match() de String?

Question

Si ejecuto esto:

/([^//]+)+/g.exec(''/a/b/c/d'');

Entiendo esto:

["a", "a"]

Pero si ejecuto esto:

''/a/b/c/d''.match(/([^//]+)+/g);

Entonces obtengo el resultado esperado de esto:

["a", "b", "c", "d"]

¿Cual es la diferencia?

Answer 1

Si su expresión regular es global, y está capturando, entonces debe usar exec. Match no devolverá todas tus capturas.

La coincidencia funciona muy bien cuando solo hace juego (no captura). Lo ejecuta una vez y le da una matriz de todas las coincidencias. (aunque si la expresión regular no es global, entonces la coincidencia mostrará la coincidencia seguida de capturas)

Exec es lo que usa cuando está capturando, y cada vez que se ejecuta da la coincidencia, seguido de las capturas. (match se comportará de manera de dar la coincidencia completa seguida de capturas, solo cuando la expresión regular no sea global).

Otro uso con Exec es obtener el índice o la posición de un partido. Cuando tiene una variable para su expresión regular, puede usar .lastIndex y obtener la posición de la correspondencia. Un objeto regex tiene .lastIndex, y el objeto regex es lo que usted hace .exec on. La coincidencia de puntos se realiza en una cadena y no podrás hacer regex object dot lastIndex

Una cadena, tiene la función de coincidencia, que se pasa una expresión regular. Y una expresión regular, tiene la función ejecutiva, y se le pasa una cadena

ejecutivo que ejecuta varias veces. partido que ejecutas una vez

Es bueno usar coincidencias cuando no se captura y al capturar se puede usar exec, que es más potente ya que es bueno para obtener capturas, pero si usó coincidencias al capturar, vea que muestra capturas cuando la expresión regular no es global, pero no lo hace No muestra capturas cuando la expresión regular es global.

> "azb".match(/a(z)b/);
[ "azb", "z" ]
> "azb".match(/a(z)b/g);
[ "azb" ]
>

Otra cosa es que si usa Exec, tenga en cuenta que se llama en la expresión regular, entonces, si usó una variable para la expresión regular, tiene más poder

No obtiene las coincidencias cuando no usa la variable para la expresión regular, por lo tanto, use la variable para la expresión regular cuando use el comando ejecutivo

> /./g.exec("abc")
[ "a" ]
> /./g.exec("abc")
[ "a" ]
> /./g.exec("abc")
[ "a" ]
>
> /[a-c]/g.exec("abc")
[ "a" ]
> /[a-c]/g.exec("abc")
[ "a" ]
>
> var r=/[a-c]/g
> r.exec("abc")
[ "a" ]
> r.exec("abc")
[ "b" ]
> r.exec("abc")
[ "c" ]
> r.exec("abc")
null
>

Y con el ejecutivo, puede obtener el "índice" del partido

> var r=/T/g
> r.exec("qTqqqTqqTq");
[ "T" ]
> r.lastIndex
2
> r.exec("qTqqqTqqTq");
[ "T" ]
> r.lastIndex
6
> r.exec("qTqqqTqqTq");
[ "T" ]
> r.lastIndex
9
> r.exec("qTqqqTqqTq");
null
> r.lastIndex
0
>

Entonces, si quieres índices o capturas, usa Exec (ten en cuenta que, como puedes ver, con el "índice", el "índice" que da es realmente una enésima ocurrencia, está contando desde 1. Entonces puedes derivar el correcto index restando 1. Y como puede ver da 0 - lastIndex of 0 - for not found).

Y si desea estirar la coincidencia, puede usarla cuando está capturando, pero no cuando la expresión regular es global, y cuando lo hace para eso, entonces el contenido de la matriz no son todas las coincidencias, sino que están completas. partido seguido por las capturas.

Answer 2

Una imagen es mejor, ya sabes ...

re_once = /([a-z])([A-Z])/
re_glob = /([a-z])([A-Z])/g
st = "aAbBcC"
console.log("match once="+ st.match(re_once)+ " match glob="+ st.match(re_glob))
console.log("exec once="+ re_once.exec(st) + " exec glob="+ re_glob.exec(st))
console.log("exec once="+ re_once.exec(st) + " exec glob="+ re_glob.exec(st))
console.log("exec once="+ re_once.exec(st) + " exec glob="+ re_glob.exec(st))

¿Ver la diferencia?

Nota: Para resaltar, observe que los grupos capturados (p. Ej .: a, A) se devuelven después del patrón coincidente (p. Ej .: aA), no es solo el patrón coincidente.

Answer 3

/regex/.exec() devuelve solo la primera coincidencia encontrada, mientras que "string".match() devuelve todos si usa la bandera g en la expresión regular.

Ver aquí: exec , match .

Answer 4

exec con una expresión regular global está destinado a ser utilizado en un bucle, ya que aún recuperará todas las subexpresiones coincidentes. Asi que:

var re = /[^//]+/g;
var match;
while (match = re.exec(''/a/b/c/d'')) {
// match is now the next match, in array form.
}
// No more matches.

String.match hace esto por ti y descarta los grupos capturados.