¿Qué corresponde exactamente a una Regex creada con Regex.fromLiteral ()?

Creé un Regex.fromLiteral(".*") emparejamiento muy simple con Regex.fromLiteral(".*") .

De acuerdo con la documentation : "Devuelve una expresión regular literal para la cadena literal especificada".

Pero realmente no entiendo qué significa "para la cadena literal especificada".

Considera este ejemplo:

 fun main(args: Array<String>) { val regex1 = ".*".toRegex() val regex2 = Regex.fromLiteral(".*") println("regex1 matches abc: " + regex1.matches("abc")) println("regex2 matches abc: " + regex2.matches("abc")) println("regex2 matches .* : " + regex2.matches(".*")) } 

Salida:

 regex1 matches abc: true regex2 matches abc: false regex2 matches .* : true 

así que aparentemente (y contrario a mis expectativas), Regex.fromLiteral() y String.toRegex() comportan completamente diferente (he intentado docenas de arguments diferentes para regex2.matches() – el único que devolvió verdadero fue .* )

¿Esto significa que una Regex creada con Regex.fromLiteral() siempre coincide solo con la cadena exacta con la que se creó?

En caso afirmativo, ¿cuáles son los casos de uso posibles para dicha Regex? (No puedo pensar en ningún escenario donde eso sería útil)

Sí, de hecho crea una expresión regular que coincide con los caracteres literales de la String . Esto es útil cuando intenta hacer coincidir símbolos que se interpretarían en una expresión regular, no tiene que escaping de esta manera.

Por ejemplo, si busca cadenas que contengan .*[](1)?[2] , podría hacer lo siguiente:

 val regex = Regex.fromLiteral(".*[](1)?[2]") regex.containsMatchIn("foo") // false regex.containsMatchIn("abc.*[](1)?[2]abc") // true 

Por supuesto, puede hacer casi cualquier cosa que pueda hacer con un Regex con solo los methods de String habituales.

 val literal = ".*[](1)?[2]" literal == "foo" // equality checks literal in "abc.*[](1)?[2]abc" // containment checks "some string".replace(literal, "new") // replacements 

Pero a veces necesita una instancia Regex como parámetro, por lo que el método fromLiteral se puede usar en esos casos. El performance de estas diferentes operaciones para diferentes inputs también podría ser interesante para algunos casos de uso.

Regex.fromLiteral() una instancia de un object regex mientras se escapa de los metacaracteres de expresiones regulares especiales. El patrón que obtienes es en realidad \.\* , Y como usaste matches() que requiere una coincidencia de cadena completa, solo puedes hacer coincidir una cadena .* Con ella (con find() podrías hacer coincidir cualquier parte dentro de una cadena).

Ver el código fuente :

public fun fromLiteral(literal: String): Regex = Regex(escape(literal))

  • Fusionando varias tags <script> en una en Kotlin
  • Regex: un metacarácter para reconocer cualquier tipo de personaje
  • Regex no coincide en Kotlin
  • Regex para encontrar palabras completas