Regex-Ausdruck, der Excel-ähnliche Referenzzellen entspricht

Question

Ich versuche eine Regex zu erstellen, die nur auf die Buchstaben zwischen dem Bereich von A-Z (inklusive) gefolgt von einer Zahl zwischen 0-100 (einschließlich) passt. Wenn vor meiner Regex irgendwelche Zahlen stehen, möchte ich nicht, dass sie übereinstimmen. Beispiel: 5A1 sollte nicht übereinstimmen, da die Zahl 5 davor liegt, obwohl A1 in der Zeichenfolge enthalten ist. Ebenso möchte ich nicht, dass es übereinstimmt, wenn nach diesem Bereich Zahlenwerte wie A10000 vorhanden sind (sollte nicht übereinstimmen, weil 1000 außerhalb von 100 liegt).

unten zeigt, was ich versuche zu passen:

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 

ich diese Regex Ausdrücke versucht haben, aber ich bin nicht sicher, wie vor keine Zahlen auszuschließen oder nach diesem Bereich:

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

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

Answer 1

verwenden regex:

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

oder einfacher Äquivalent:

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

oder die kürzere Ziffer metacharacter äquivalent:

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

Mit dem \b metacharacter am Anfang und Ende der Regex, eliminierst du unerwünschte vorangehende oder nachfolgende Zeichen. Die Zeichenklasse enthält nur einen Großbuchstaben, um die Zellenreferenz zu starten. Der numerische Teil wird durch einen Wechsel von entweder 0-99 oder 100 gehandhabt, wobei der 0-99 Teil von ein- bis zweistelligen Zeichenklassen gehandhabt wird. Anstelle der expliziten [0-9] Zeichenklassen würde das \ d Metazeichen genau so gut funktionieren, wenn Sie das bevorzugen.

Hier ist ein Beispiel Ruby-Programm (ähnlich regex Geschmack Javascript), es zu zeigen arbeiten:

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 

Im data Array jedes Paares das zweite Element eine Boolesche ist, das anzeigt, ob die Testzellenreferenz bestimmt sollte passen oder nicht.

Der Ausgang dieses Programm laufen zeigt alle Tests bestanden:

> 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)' 

Answer 2

Hier gehen Sie:

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

$1 wird Ihr Spiel halten.

Beispiel Nutzung:

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

Erklärung

Es muss entweder der Beginn einer Linie sein, oder keine Ziffer:

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

Dann haben Sie ein oder zwei Buchstaben, gefolgt entweder durch 100 oder eine ein- oder zweistellige Nummer:

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

Dann muss es entweder das Ende der Linie für Sie oder etwas sein, das kein Buchstabe/Zahl ist:

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

Answer 3

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"; 

Spiele A1, A2, Z100 Aber nicht A101 oder A1000

([A-Z](\d{1,2}(?!\d)|100)) 

• Hinweis: ohne (?!\d) "A1000" wird recogn ized als "A100"

beginnen mit SUM (und enden mit)

SUM(.*) 

eine beliebige Anzahl Sätze haben kann ":" oder "" folgen durch optionale Leerzeichen und optional Anzahl Spiele SUM (A1: A2, 5A1, A3)

(:|,)\s?\d{0,} 

Answer 4

Das ist nicht komplizierter als

sein sollte

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

Answer 5

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 

, die häufig geschrieben:

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"]