javascript - ¿Es preferible usar métodos en objetos RegExp o en objetos String?

Hay métodos de coincidencia de expresiones regulares tanto en los objetos RegExp como en los objetos String en Javascript.

Los objetos RegExp tienen los métodos

• ejecutar
• prueba

Los objetos String tienen los métodos

• partido
• buscar

Los métodos exec y match son muy similares:

/word/.exec("words");
//Result: ["word"]
"words".match(/word/);
//Result: ["word"]

/word/.exec("No match");
//Result: null
"No match".match(/word/);
//Result: null

/word/g.exec("word word");
//Result: ["word"]
"word word".match(/word/g);
//Result: ["word", "word"]

y el test y el search también son muy similares:

/word/.test("words");
//Result: true
"words".search(/word/);
//Result: 0
//Which can converted to a boolean:
"word".search(/word/) > -1;
//Result: true

/word/.test("No match");
//Result: false
"No match".search(/word/) > -1;
//Result: false

¿Hay una preferencia por usar los métodos en objetos RegExp o en objetos String?

Respuesta #1

Mayormente preferencia personal

Esto es principalmente una cuestión de preferencia personal, aunque hay una ligera diferencia en las capacidades (ver el último párrafo para esa diferencia). A menos que quieras comenzar a medir el rendimiento y convertir la pregunta en una de rendimiento, es principalmente cuestión de preferencia personal.

Prefiero hacer:

string.match(/word/)

porque creo que eso hace que el código se lea como mi cerebro piensa en la operación. Estoy tomando el objeto cadena y buscando una expresión regular en particular en él. Tiene sentido para mí que buscar algo en una cadena sea un método del objeto cadena. Esto me lee como:

object.action(tool)

que es como debería funcionar el código orientado a objetos en mi opinión.

Si tienes:

/word/.match(string)

entonces para mí se siente como:

tool.action(object)

lo cual encuentro mucho menos lógico y menos orientado a objetos. Sí, /word/ es técnicamente un objeto también, pero no es el objeto sobre el que estoy tratando de operar, lo pienso más como una herramienta o un parámetro que estoy usando con mi objeto.

Obviamente ambos funcionan. Puedes decidir por ti mismo cuál te gusta.

Una diferencia importante

Hay algunas cosas que creo que solo se pueden hacer con un objeto de expresión regular. Por ejemplo, si quieres coincidir con todas las ocurrencias de una expresión regular, tienes que crear el objeto de expresión regular, pasarle la opción "g" y luego llamar a re.exec() varias veces para obtener cada coincidencia hasta que exec devuelva null, lo que indica que no hay más coincidencias. No creo que se pueda hacer eso con string.match().

Respuesta #2

Hay algunas diferencias entre match y exec al usar la bandera global g. No puedes recorrer las ocurrencias globales con match, mientras que usando exec puedes:

var string="xabx xnnx";
var regexp=new RegExp('x([^x]*)x','g');

// match returns the list of matching parts:
string.match(regexp) // ["xabx", "xnnx"]

// with exec you could build a loop:
var match=regexp.exec(string);
while (match) {
    console.log(match);
    match=regexp.exec(string);
}
// This loops through matches and returns subpatterns too:
// ["xabx", "ab"]
// ["xnnx", "nn"]

Y index no funciona en absoluto al usar match con un objeto RegExp globalizado:

var r=/b/g;
r.exec("0123b56b").index // 4
r.exec("0123b56b").index // 7
"0123b56b".match(r).index // undefined
"0123b56b".match(/b/).index // 4