regulares regular probar online minimo expresiones expresion espacio ejemplos caracteres blanco alfanumerico c# java .net regex

probar - ¿Son compatibles las expresiones regulares Java y C#?



regex ejemplos (6)

Java usa expresiones regulares de tipo Perl y expresiones regulares POSIX. Si observamos la documentación de C # sobre expresiones regulares, parece que Java tiene toda la sintaxis regex de C #, pero no al revés.

Compárelos usted mismo: Java : C #:

EDITAR: Actualmente, ningún otro sabor regex admite la versión de Microsoft de la captura con nombre.

Ambos lenguajes afirman usar expresiones regulares de estilo Perl. Si tengo una prueba de idioma, una expresión regular para validez, ¿funcionará en la otra? ¿Dónde difieren las sintaxis de expresiones regulares?

El caso de uso aquí es una interfaz de usuario de C # (.NET) que habla con una implementación posterior de Java que usará la expresión regular para hacer coincidir los datos.

Tenga en cuenta que solo tengo que preocuparme por la coincidencia, no por extraer partes de los datos coincidentes.

c # regex tiene su propia convención para grupos con nombre (?<name>) . No sé de ninguna otra diferencia.

.NET Regex admite el recuento, por lo que puede hacer coincidir paréntesis anidados, que es algo que normalmente no se puede hacer con una expresión regular. De acuerdo con Mastering Regular Expressions esa es una de las pocas implementaciones para hacer eso, así que eso podría ser una diferencia.

Hay bastantes (muchas) diferencias.

Clase de personaje

  1. [abc-[cde]] clases de caracteres [abc-[cde]]
    • .NET SÍ (2.0)
    • Java: Emulado a través de la intersección y negación de la clase de caracteres: [abc&&[^cde]] )
  2. Intersección de clases de caracteres [abc&&[cde]]
    • .NET: Emulado mediante la resta y la negación de la clase de caracteres: [abc-[^cde]] )
    • Java SÍ
  3. /p{Alpha} clase de caracteres POSIX
    • .NET NO
    • Java SÍ (US-ASCII)
  4. En el modo (?x) IgnorePatternWhitespace / IgnorePatternWhitespace , el espacio (U + 0020) en la clase de caracteres es significativo .
    • .NET SÍ
    • Java NO
  5. Categoría Unicode (L, M, N, P, S, Z, C)
    • .NET SÍ : /p{L} solo formulario
    • Java SÍ :
      • De Java 5: /pL , /p{L} , /p{IsL}
      • De Java 7: /p{general_category=L} , /p{gc=L}
  6. Categoría Unicode (Lu, Ll, Lt, ...)
    • .NET SÍ : solo formulario /p{Lu}
    • Java SÍ :
      • De Java 5: /p{Lu} , /p{IsLu}
      • De Java 7: /p{general_category=Lu} , /p{gc=Lu}
  7. Bloque Unicode
    • .NET SÍ : /p{IsBasicLatin} solamente. ( Bloques con nombre admitidos )
    • Java SÍ : (el nombre del bloque es de envoltura libre)
      • De Java 5: /p{InBasicLatin}
      • De Java 7: /p{block=BasicLatin} , /p{blk=BasicLatin}
  8. Espacios y guiones bajos permitidos en todos los nombres de bloques largos (p BasicLatin Ej., BasicLatin puede escribirse como Basic_Latin o Basic Latin )
    • .NET NO
    • Java SÍ (Java 5)

Cuantificador

  1. ?+ , *+ , ++ y {m,n}+ (cuantificadores posesivos)
    • .NET NO
    • Java SÍ

Cotización

  1. /Q.../E escapa de una cadena de metacaracteres
    • .NET NO
    • Java SÍ
  2. /Q.../E escapa de una cadena de metacaracteres de clase de caracteres (en conjuntos de caracteres)
    • .NET NO
    • Java SÍ

Construcción a juego

  1. Condicional coincidencia (?(?=regex)then|else) , (?(regex)then|else) , (?(1)then|else) o (?(group)then|else)
    • .NET SÍ
    • Java NO
  2. Grupo de captura con nombre y retro-referencia nombrada
    • .NET SÍ :
      • Grupo de captura: (?<name>regex) (?''name''regex) (?<name>regex) o (?''name''regex)
      • Referencia: /k<name> o /k''name''
    • Java SÍ ( Java 7 ):
      • Grupo de captura: (?<name>regex)
      • Referencia posterior: /k<name>
  3. Múltiples grupos de captura pueden tener el mismo nombre
    • .NET SÍ
    • Java NO (Java 7)
  4. Definición del grupo de equilibrio (?<name1-name2>regex) o (?''name1-name2''subexpression)
    • .NET SÍ
    • Java NO

Afirmaciones

  1. (?<=text) (mirada positiva detrás)
    • .NET ancho variable
    • Ancho obvio de Java
  2. (?<!text) (mirada negativa detrás)
    • .NET ancho variable
    • Ancho obvio de Java

Opciones de modo / Banderas

  1. Opción ExplicitCapture (?n)
    • .NET SÍ
    • Java NO

Diverso

  1. (?#comment) comentarios en línea
    • .NET SÍ
    • Java NO

Referencias

De acuerdo con mi experiencia:

Expresiones regulares de Java 7 en comparación con expresiones regulares de .NET 2.0:

  • El símbolo de subrayado en los nombres de grupo no es compatible

  • Los grupos con el mismo nombre (en la misma expresión regular) no son compatibles (¡aunque puede ser realmente útil en expresiones que usan "o"!)

  • Los grupos que han capturado nada tienen valor de null y no de cadena vacía

  • El grupo con índice 0 también contiene la coincidencia completa (igual que en .NET) PERO no está incluido en groupCount()

  • La referencia grupal en reemplazo de expresiones también se denota con signo de dólar (ej. $ 1), pero si la misma expresión contiene un signo de dólar como marcador de fin de línea, entonces el dólar de referencia debe escaparse (/ $); de lo contrario, en Java obtenemos el error de "referencia de grupo ilegal"

  • El símbolo de fin de línea ($) se comporta como un codicioso. Considere, por ejemplo, la siguiente expresión (se da Java-string): "bla (bla (?: $ | / R / n)) +)? $". ¡Aquí la última línea de texto NO será capturada! Para capturarlo, debemos sustituir "$" por "/ z".

  • No hay modo de "Captura explícita".

  • La cadena vacía no satisface el patrón ^. {0} $.

  • El símbolo "-" debe escaparse cuando se utiliza entre corchetes. Es decir, el patrón "[a-z + -] +" no coincide con la cadena "f + gh" en Java, pero sí en .NET. Para que coincida con Java, el patrón debe verse como (se da Java-string): "[a-z + / -] +".

NOTA: "(se da Java-string)" - solo para explicar el doble escape en la expresión.