Estoy tratando de hacer una expresión regular que solo coincida en las letras entre el rango de A-Z (inclusive) seguido de un número entre 0-100 (inclusive). Si hay algún número antes de mi expresión regular, no quiero que coincida. Por ejemplo: 5A1 no debería coincidir porque existe el número 5 antes, aunque A1 esté en la cadena. Del mismo modo, no quiero que coincida si hay valores numéricos después de ese rango, como A10000 (no debería coincidir porque 1000 está fuera de 100).

A continuación se muestra lo que estoy tratando de hacer coincidir:

A34A1                // no match
5A1                  // no match
2.344A1              // no match
A1001                // no match
A1                   // match A1
A10                  // match A10
A100                 // match A100
SUM(A1:A2)           // match A1 and A2
SUM(A1:A2, 5A1, A3)  // match A1,A2, A3

He estado probando estas expresiones de expresión regular pero no estoy seguro de cómo excluir cualquier número antes o después de ese rango:

/[A-Z]{1,2}[1-9]{0,3}/g

/([^0-9])[A-Z]{1,2}[0-9]{1,3}/g
1
AlphaWolf 10 may. 2016 a las 05:00

5 respuestas

La mejor respuesta

Usa esta expresión regular:

/\b[A-Z]([0-9]{1,2}|100)\b/

O equivalente más simple:

/\b[A-Z]([0-9][0-9]?|100)\b/

O el equivalente de metacaracteres de dígitos más cortos:

/\b[A-Z](\d\d?|100)\b/

Usando el metacarácter \b al comienzo y al final de la expresión regular, elimina cualquier carácter anterior o posterior no deseado. La clase de caracteres [A-Z] incluye solo una letra mayúscula para iniciar la referencia de celda. La porción numérica se maneja alternando cualquiera de 0-99 o 100, donde la porción 0-99 es manejada por clases de caracteres de uno a dos dígitos. En lugar de las clases de caracteres explícitas [0-9], el metacarácter \ d funcionaría igual de bien, si esa es su preferencia.

Aquí hay un programa Ruby de muestra (sabor regex similar a Javascript) para mostrar que funciona:

data = [
  [ "A34A1",   false ],
  [ "5A1",     false ],
  [ "2.344A1", false ],
  [ "A1001",   false ],
  [ "A1",      true ],
  [ "A10",     true ],
  [ "A100",    true ],
  [ "SUM(A1:A2)", true ],
  [ "SUM(A1:A2, 5A1, A3)", true ]
]

data.each do |pair|
  puts "#{pair[1] == !(pair[0] =~ /\b[A-Z]([0-9]{1,2}|100)\b/).nil? ? 'Pass' : 'Fail'}: '#{pair[0]}'"
end

En la matriz data, el segundo elemento de cada par es un valor booleano, que determina si la referencia de celda de prueba debe coincidir o no.

El resultado de ejecutar este programa muestra todas las pruebas pasadas:

> ruby regex_test.rb
Pass: 'A34A1'
Pass: '5A1'
Pass: '2.344A1'
Pass: 'A1001'
Pass: 'A1'
Pass: 'A10'
Pass: 'A100'
Pass: 'SUM(A1:A2)'
Pass: 'SUM(A1:A2, 5A1, A3)'
2
Michael Gaskill 22 may. 2016 a las 02:41

Esto no debería ser más complicado que

/^[A-Z](\d\d?|100)$/
1
user663031user663031 10 may. 2016 a las 08:00
r = /
    (?<!\d)   # match a digit in a negative lookbehind
    [A-Z]     # match a capital leter
    (?:       # start a non-capture group
      \d{1,2} # match one or two digits
      |       # or
      100     # match string
    )         # end non-capture group
    (?!\d)    # match a non-digit in a negative lookahead
    /x        # free-spacing regex definition mode

Que se escribe comúnmente:

r = /(?<!\d)[A-Z](?:\d{1,2}|100)(?!\d)/

test = ["A34A1", "5A1", "2.344A1", "A1001", "A1", "A10", "A100",
        "SUM(A1:A2, 5A1, A3)", "A100A", "_A1", "A1_"] 

test.each { |s| puts "#{s} -> #{s.scan(r)}" }
A34A1               -> ["A34"]
5A1                 -> []
2.344A1             -> []
A1001               -> []
A1                  -> ["A1"]
A10                 -> ["A10"]
A100                -> ["A100"]
SUM(A1:A2, 5A1, A3) -> ["A1", "A2", "A3"]
A100A               -> ["A100"]
_A1                 -> ["A1"]
A1_                 -> ["A1"]
1
Cary Swoveland 18 may. 2016 a las 07:30

Aquí tiene:

(?:^|[^0-9])([A-Z](?:100|[0-9][0-9]?))(?=$|[^0-9A-Z])

$1 mantendrá su partido.

Ejemplo de uso:

var re = /(?:^|[^0-9])([A-Z](?:100|[0-9][0-9]?))(?=$|[^0-9A-Z])/gim; 

Explicación

Debe ser el comienzo de una línea o no un dígito:

(?:^|[^0-9])

Luego, tiene una o dos letras seguidas de 100 o un número de uno o dos dígitos:

([A-Z](?:100|[0-9]?[0-9]))

Entonces debe ser el final de la línea para usted o algo que no sea una letra / número:

(?=$|[^0-9A-Z])
2
Laurel 10 may. 2016 a las 09:06
var regEx = "/([A-Z](\d{1,2}(?!\d)|100))|(SUM\([A-Z](\d{1,2}(?!\d)|100)((:|,)\s?\d{0,}[A-Z](\d{1,2}(?!\d)|100))*\))/g";

Partidos A1, A2, Z100 Pero no A101 o A1000

([A-Z](\d{1,2}(?!\d)|100))
  • Nota: sin (?!\d), "A1000" se reconocerá como "A100"

Comience con SUM (y termine con)

SUM(.*)

Puede tener cualquier conjunto de números de ":" o "," seguido de espacios en blanco opcionales y números opcionales Coincide con SUM (A1: A2, 5A1, A3)

(:|,)\s?\d{0,}
2
maryhadalittlelamb 10 may. 2016 a las 07:35