Matching numbers mit regulären Ausdrücken — nur Ziffern und Kommas

Was ist eine Zahl?

Ich habe eine einfache Frage für Ihre "einfache" Frage: Was genau meinst du mit "eine Zahl"?

• Ist −0 einer Reihe?
• Wie fühlen Sie sich über √−1?
• Ist ⅝ oder ⅔ einer Reihe?
• Ist 186,282.42±0.02 km/Sekunde eine Zahl — oder ist es zwei oder drei von Ihnen?
• Ist 6.02e23 einer Reihe?
• Ist 3.141_592_653_589 einer Reihe? Wie wäre π oder ℯ? Und −2π⁻³ ͥ?
• Wie viele zahlen in 0.083̄?
• Wie viele zahlen in 128.0.0.1?
• Welche Nummer hat ⚄ halten? Wie wäre ⚂⚃?
• Hat 10,5 mm haben eine Zahl in es — oder hat er zwei?
• Ist ∛8³ eine Zahl — oder ist es drei?
• Welche Nummer hat ↀↀⅮⅭⅭⅬⅫ AUC darstellen, 2762 oder 2009?
• Sind ४५६७ und ৭৮৯৮ zahlen?
• Was 03770xDEADBEEFund 0b111101101?
• Ist Inf einer Reihe? Ist NaN?
• Ist ④② einer Reihe? Was ⓰?
• Wie fühlen Sie sich über ㊅?
• Was tun ℵ₀ und ℵ₁ haben mit zahlen zu tun? Oder ℝℚund ℂ?

Vorgeschlagen Muster

Außerdem sind Sie vertraut mit diesen mustern? Können Sie erläutern die vor-und Nachteile der einzelnen?

1. /\D/
2. /^\d+$/
3. /^\p{Nd}+$/
4. /^\pN+$/
5. /^\p{Numeric_Value:10}$/
6. /^\P{Numeric_Value:NaN}+$/
7. /^-?\d+$/
8. /^[+-]?\d+$/
9. /^-?\d+\.?\d*$/
10. /^-?(?:\d+(?:\.\d*)?|\.\d+)$/
11. /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/
12. /^((\d)(?(?=(\d))|$)(?(?{ord$3==1+ord$2})(?1)|$))$/
13. /^(?:(?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})[.](?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})[.](?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})[.](?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2}))$/
14. /^(?:(?:[0-9a-fA-F]{1,2}):(?:[0-9a-fA-F]{1,2}):(?:[0-9a-fA-F]{1,2}):(?:[0-9a-fA-F]{1,2}):(?:[0-9a-fA-F]{1,2}):(?:[0-9a-fA-F]{1,2}))$/
15. /^(?:(?:[+-]?)(?:[0123456789]+))$/
16. /(([+-]?)([0123456789]{1,3}(?:,?[0123456789]{3})*))/
17. /^(?:(?:[+-]?)(?:[0123456789]{1,3}(?:,?[0123456789]{3})*))$/
18. /^(?:(?i)(?:[+-]?)(?:(?=[0123456789]|[.])(?:[0123456789]*)(?:(?:[.])(?:[0123456789]{0,}))?)(?:(?:[E])(?:(?:[+-]?)(?:[0123456789]+))|))$/
19. /^(?:(?i)(?:[+-]?)(?:(?=[01]|[.])(?:[01]{1,3}(?:(?:[,])[01]{3})*)(?:(?:[.])(?:[01]{0,}))?)(?:(?:[E])(?:(?:[+-]?)(?:[01]+))|))$/
20. /^(?:(?i)(?:[+-]?)(?:(?=[0123456789ABCDEF]|[.])(?:[0123456789ABCDEF]{1,3}(?:(?:[,])[0123456789ABCDEF]{3})*)(?:(?:[.])(?:[0123456789ABCDEF]{0,}))?)(?:(?:[G])(?:(?:[+-]?)(?:[0123456789ABCDEF]+))|))$/
21. /((?i)([+-]?)((?=[0123456789]|[.])([0123456789]{1,3}(?:(?:[_,]?)[0123456789]{3})*)(?:([.])([0123456789]{0,}))?)(?:([E])(([+-]?)([0123456789]+))|))/

Ich vermute, dass einige dieser Muster oben kann Ihren Bedürfnissen gerecht zu werden. Aber ich kann Ihnen nicht sagen, die oder die, oder, falls nicht vorhanden, liefern Sie ein weiteres—, weil Sie nicht sagte, was meinen Sie mit "Anzahl".

Wie Sie sehen, gibt es eine große Anzahl der Anzahl Möglichkeiten: die wohl ℵ₁ Wert, in der Tat. ☺

Schlüssel zur Vorgeschlagenen Muster

Jedes nummerierte Erläuterung nachfolgend beschrieben, das Muster der entsprechenden nummerierten Muster oben aufgeführt.

1. Entsprechen, wenn es irgendwelche nicht-Ziffern überall in der Zeichenfolge, einschließlich Leerzeichen, wie Zeilenumbrüche.
2. Stimmen nur überein, wenn der string enthält nichts außer Ziffern, mit der möglichen Ausnahme von einem abschließenden Zeilenumbruch. Beachten Sie, dass eine Ziffer ist so definiert, dass die Eigenschaft der Allgemeinen Kategorie Dezimalzahl, die als \p{Nd}\p{Decimal_Number} oder \p{General_Category=Decimal_Number}. Dies wiederum ist eigentlich nur ein Spiegelbild jener code, der Punkte, deren Numerische Kategorie " Typ " ist Dezimal, die als \p{Numeric_Type=Decimal}.
3. Das ist das gleiche wie 2 in den meisten regex-Sprachen. Java bildet hier eine Ausnahme, weil es nicht die Karte einfach charclass entweicht wie \w und \W\d und \D\s und \Sund \b oder \B in das entsprechende Unicode-Eigenschaft. Das bedeutet, Sie müssen nicht verwenden, jede von denen acht ein-Zeichen-escapes für alle Unicode-Daten in Java -, denn Sie arbeiten nur auf ASCII-obwohl Java verwendet immer Unicode-Zeichen intern.
4. Dies unterscheidet sich etwas von den 3, es ist nicht begrenzt auf Dezimalzahlen, sondern kann eine beliebige Zahl; das ist,
   jeder Charakter mit der \pN, \p{Number} oder \p{General_Category=Number} Eigenschaft. Dazu gehören \p{Nl} oder \p{Letter_Number} für Dinge wie die römischen Ziffern und die \p{No} oder \p{Other_Number} für adscriptum und tiefgestellte Ziffern, Brüche und eingekreisten zahlen — unter anderem, wie das zählen von Stangen.
5. Dies entspricht nur die strings aus vollständig zahlen, deren dezimal-Wert ist 10, so Dinge wie Ⅹ die römische Ziffer zehn, und ⑩⑽⒑⓾❿➉und ➓.
6. Nur die strings, die Zeichen enthalten, fehlen den Numerischen Wert NaN; in anderen Worten, alle chars müssen einige numerische Wert.
7. Spiele nur Dezimale Zahlen, Optional mit einem führenden BINDESTRICH-MINUS.
8. Gleiche wie 7, aber funktioniert jetzt auch, wenn das Vorzeichen ist plus statt minus.
9. Sieht für dezimale zahlen, mit optionalen BINDESTRICH, MINUS-und optionale FULL STOP plus null oder mehr Dezimalzahlen folgenden.
10. Gleiche wie 9, aber nicht erforderlich Ziffern vor dem Punkt, wenn es einige danach.
11. Standard floating-point notation pro C und vielen anderen Sprachen, so dass für die wissenschaftliche notation.
12. Findet zahlen setzt sich nur aus zwei oder mehr Dezimalstellen von jedem Skript, in absteigender Reihenfolge, wie 987 oder 54321. Diese rekursive regex enthält eine Legende, Perl-code, der prüft, ob der look-ahead-Ziffer hat einen code-point-Wert, dass ist der Nachfolger von der aktuellen Stelle; das heißt, der ordinale Wert um eins größer ist. Könnte man dies in PCRE die Verwendung einer C-Funktion als die Legende.
13. Das sieht für eine gültige IPv4-Adresse durch vier Dezimalzahlen, die in den gültigen Bereich, wie 128.0.0.1 oder 255.255.255.240, aber nicht 999.999.999.999.
14. Das sieht für eine gültige MAC-Adresse, also sechs durch Doppelpunkte getrennte Paaren von zwei ASCII-hex-Zeichen.
15. Das sieht für ganze zahlen in der ASCII-Bereich mit einem optionalen Vorzeichen. Dies ist das normale Muster für ASCII-Integer-zahlen.
16. Das ist wie 15, mit Ausnahme, dass es erfordert eine durch Komma zu trennen Gruppen von drei.
17. Das ist wie 15, außer dass das Komma für die Trennung der Gruppen ist nun optional.
18. Dies ist das normale Muster für C-style floating-point-zahlen in ASCII.
19. Das ist wie 18, aber erfordern ein Komma zu trennen Gruppen von 3 und in der base-2 anstelle der in der Basis-10.
20. Das ist wie 19, jedoch in hex. Beachten Sie, dass der optionale exponent ist nun gekennzeichnet durch ein G statt ein E, denn E ist eine gültige hex-Ziffer.
21. Dieser prüft, ob der string enthält einen C-Stil-floating-point-Zahl, aber mit einem optionalen Gruppierungstrennzeichen alle drei Ziffern ein Komma oder ein Unterstrich (LOW LINE) zwischen Ihnen. Außerdem speichert die Zeichenfolge in die \1 capture group, verfügbar machen, als $1 nach dem match gelingt.

Quellen und Wartbarkeit

Muster Anzahl 1,2,7–11 stammen aus einer früheren Inkarnation des Perl - Häufig Gestellte Fragen Liste in der Frage, "Wie bestätige ich die Eingabe?". Diesem Abschnitt wurde ersetzt durch einen Vorschlag, der Regexp::Common Modul, geschrieben von Abigail und Damian Conway. Die original-Muster noch im Rezept 2.1 der Perl-Kochbuch"die Prüfung, Ob ein String eine Gültige Zahl", Lösungen, die gefunden werden können, für eine schwindelerregende Reihe von verschiedenen Sprachen, darunter ada, common lisp, groovy, guile, haskell, java, merd, ocaml, php, pike, python, rexx, ruby, und tcl auf der die PLEAC-Projekt.

Muster 12 könnte mehr lesbar umgeschrieben

m{
    ^
    (
        ( \d )
        (?(?= ( \d ) ) | $ )
        (?(?{ ord $3 == 1 + ord $2 }) (?1) | $ )
    )
    $
}x

Es nutzt regex Rekursiondie sich in vielen Muster-Motoren, einschließlich Perl-und alle die PCRE-abgeleiteten Sprachen. Aber es nutzt ein embedded-code Legende, wie der test des zweiten bedingten Muster, meines Wissens, code Legenden sind nur in Perl und PCRE.

Muster 13-21 wurden abgeleitet von den oben genannten Regexp::Common-Modul. Beachten Sie, dass der Kürze wegen, diese sind alle geschrieben, ohne Leerzeichen und Kommentare, die Sie würde definitiv in der Produktion code. Hier ist, wie das Aussehen könnte in /x - Modus:

$real_rx = qr{ (   # start $1 to hold entire pattern
    ( [+-]? )                  # optional leading sign, captured into $2
    (                          # start $3
        (?=                    # look ahead for what next char *will* be
            [0123456789]       #    EITHER:  an ASCII digit
          | [.]                #    OR ELSE: a dot
        )                      # end look ahead
        (                      # start $4
           [0123456789]{1,3}       # 1-3 ASCII digits to start the number
           (?:                     # then optionally followed by
               (?: [_,]? )         # an optional grouping separator of comma or underscore
               [0123456789]{3}     # followed by exactly three ASCII digits
           ) *                     # repeated any number of times
        )                          # end $4
        (?:                        # begin optional cluster
             ( [.] )               # required literal dot in $5
             ( [0123456789]{0,} )  # then optional ASCII digits in $6
        ) ?                        # end optional cluster
     )                         # end $3
    (?:                        # begin cluster group
        ( [E] )                #   base-10 exponent into $7
        (                      #   exponent number into $8
            ( [+-] ? )         #     optional sign for exponent into $9
            ( [0123456789] + ) #     one or more ASCII digits into $10
        )                      #   end $8
      |                        #   or else nothing at all
    )                          # end cluster group
) }xi;          # end $1 and whole pattern, enabling /x and /i modes

Aus Sicht des software engineering, es gibt noch einige Probleme mit dem Stil in der /x - mode-version sofort oben. Erstens, es ist viel code Wiederholung, wo sehen Sie die gleichen [0123456789]; was geschieht, wenn einer dieser Sequenzen versehentlich lässt eine Ziffer aus? Zweitens, Sie befinden sich auf positionale Parameter, mit denen Sie rechnen muss. Das bedeutet, dass Sie vielleicht etwas schreiben wie:

(
  $real_number,          # $1
  $real_number_sign,     # $2
  $pre_exponent_part,    # $3
  $pre_decimal_point,    # $4
  $decimal_point,        # $5
  $post_decimal_point,   # $6
  $exponent_indicator,   # $7
  $exponent_number,      # $8
  $exponent_sign,        # $9
  $exponent_digits,      # $10
) = ($string =~ /$real_rx/);

ist ehrlich gesagt abscheulich! Es ist einfach, die Nummerierung falsch, schwer zu erinnern, was symbolischen Namen gehen Sie, wo und langweilig zu schreiben, vor allem, wenn Sie brauchen nicht alle Stücke. Umschreiben, benutzt, um benannte Gruppen, anstatt nur nummeriert lieben. Nochmals, ich verwende die Perl-syntax für die Variablen, aber der Inhalt des Musters sollten überall arbeiten, dass die genannten Gruppen werden unterstützt.

use 5.010;              # Perl got named patterns in 5.10
$real_rx = qr{
  (?<real_number>
    # optional leading sign
    (?<real_number_sign> [+-]? )
    (?<pre_exponent_part>
        (?=                         # look ahead for what next char *will* be
            [0123456789]            #    EITHER:  an ASCII digit
          | [.]                     #    OR ELSE: a dot
        )                           # end look ahead
        (?<pre_decimal_point>
            [0123456789]{1,3}       # 1-3 ASCII digits to start the number
            (?:                     # then optionally followed by
                (?: [_,]? )         # an optional grouping separator of comma or underscore
                [0123456789]{3}     # followed by exactly three ASCII digits
            ) *                     # repeated any number of times
         )                          # end <pre_decimal_part>
         (?:                        # begin optional anon cluster
            (?<decimal_point> [.] ) # required literal dot
            (?<post_decimal_point>
                [0123456789]{0,}  )
         ) ?                        # end optional anon cluster
   )                                # end <pre_exponent_part>
   # begin anon cluster group:
   (?:
       (?<exponent_indicator> [E] ) #   base-10 exponent
       (?<exponent_number>          #   exponent number
           (?<exponent_sign>   [+-] ?         )
           (?<exponent_digits> [0123456789] + )
       )                      #   end <exponent_number>
     |                        #   or else nothing at all
   )                          # end anon cluster group
 )                            # end <real_number>
}xi;

Nun die Abstraktionen, die benannt werden, die hilft. Sie können ziehen Sie die Gruppen aus, indem Sie name, und Sie müssen sich nur diejenigen, die Sie interessieren. Zum Beispiel:

if ($string =~ /$real_rx/) {
    ($pre_exponent, $exponent_number) =
        @+{ qw< pre_exponent exponent_number > };
}

Es gibt eine weitere Sache zu tun, dieses Muster, um es noch besser zu warten. Das problem ist, dass es immer noch zu viel Wiederholung, was bedeutet, es ist zu leicht geändert werden, in einem Ort, in einem anderen aber nicht. Wenn Sie Taten, eine McCabe-Analyse, Sie würde sagen, seine Komplexität Metrik ist zu hoch. Die meisten von uns würden nur sagen, es ist auch eingerückt. Dies macht es schwer zu Folgen. Zu lösen alle diese Dinge, was wir brauchen, ist eine "grammatische Muster", ein mit einer definition block zu erstellen benannte Abstraktionen, die wir dann behandeln Sie ein wenig wie ein Unterprogramm Aufruf, der später in die Partie.

use 5.010;              # Perl first got regex subs in v5.10
$real__rx = qr{ 

    ^                   # anchor to front
    (?&real_number)     # call &real_number regex sub
    $                   # either at end or before final newline

  ##################################################
  # the rest is definition only; think of         ##
  # each named buffer as declaring a subroutine   ##
  # by that name                                  ##
  ##################################################
  (?(DEFINE)
      (?<real_number>
          (?&mantissa)
          (?&abscissa) ?

      )
      (?<abscissa>
          (?&exponent_indicator)
          (?&exponent)
      )
      (?<exponent>
          (&?sign)    ?
          (?&a_digit) +
      )
      (?<mantissa>
         # expecting either of these....
         (?= (?&a_digit)
           | (?&point)
         )
         (?&a_digit) {1,3}
         (?: (?&digit_separator) ?
             (?&a_digit) {3}
         ) *
         (?: (?&point)
             (?&a_digit) *
         ) ?
      )
      (?<point>               [.]     )
      (?<sign>                [+-]    )
      (?<digit_separator>     [_,]    )
      (?<exponent_indicator>  [Ee]    )
      (?<a_digit>             [0-9]   )
   ) # end DEFINE block
}x;

Sehen, wie wahnsinnig besser die grammatischen Muster ist als das original-line-laut Muster? Es ist auch weit leichter zu bekommen, die syntax stimmt: ich eingegeben, ohne selbst eine regex-syntax-Fehler, Bedarf der Korrektur. (OK gut, ich tippte alle anderen ohne irgendwelche syntax-Fehler, aber ich habe das getan, für eine Weile. 🙂

Grammatische Muster Aussehen viel mehr wie eine BNF als die hässlichen alten regulären Ausdrücke, dass die Menschen kommen, um Sie zu hassen. Sie sind viel leichter zu Lesen, zu schreiben und zu verwalten. Lassen Sie uns also nicht mehr hässlich Muster, OK?

InformationsquelleAutor der Antwort tchrist

Da diese Frage wurde wieder eröffnet, vier Jahre später, würde ich gerne einen anderen nehmen. Als jemand, der viel Zeit damit verbringt, arbeitet mit regex, meine Ansicht ist diese:

A. Wenn Möglich, nicht mit Regex Zu Validieren Zahlen

Wenn möglich, verwenden Ihre Sprache. Möglicherweise gibt es Funktionen, um Ihnen helfen, festzustellen, ob der Wert enthalten ist ein string eine gültige Zahl ein. That being said, wenn Sie akzeptieren eine Vielzahl von Formaten (Kommata, etc.) Sie dürfen keine Wahl haben.

B. nicht mit dem Schreiben der Regex Manuell zu Überprüfen Nummernkreis

• Schreiben Sie einen regulären Ausdruck für eine Zahl in einem bestimmten Bereich ist hart. Sie können einen Fehler machen, auch schriftlich, eine regex zu match eine Zahl zwischen 1 und 10.
• Sobald Sie einen regex für einen Nummernkreis, es ist schwer zu Debuggen. Erstens, es ist schrecklich, zu betrachten. Zweitens, wie kann Sie sicher sein, dass es passt alle Werte, die Sie wollen, ohne passende Werte, die Sie nicht wollen? Ehrlich gesagt, wenn Sie von sich selbst, ohne den Kollegen über die Schulter schaut, kann man nicht. Die besten debugging-Technik ist die Ausgabe einer ganzen Reihe von zahlen, die programmgesteuert und überprüfen Sie Sie gegen die regex.
• Glücklicherweise gibt es tools zum generieren eines regex für einen Nummernkreis automatisch.

C. Verbringen Sie Ihre Regex Energie mit Bedacht: Verwenden Sie Tools,

• Passenden zahlen in einem bestimmten Bereich ist ein problem, das gelöst wurde. Es gibt keine Notwendigkeit für Sie, um zu versuchen, das Rad neu zu erfinden. Es ist ein problem, das gelöst werden kann, mechanisch, durch ein Programm, in einer Weise, die garantiert fehlerfrei ist. Nutzen Sie diese freie Fahrt.
• Die Lösung als Zahl in einer Reihe regex kann interessant sein, zu Lernzwecken ein paar mal. Darüber hinaus, wenn Sie haben, Energie zu investieren in die Förderung Ihrer regex-Fähigkeiten, verbringen Sie auf etwas nützliches, wie z.B. die Vertiefung Ihrer Verständnis der regex GierLesen,Unicode regexspielen mit null-Breite entspricht oder Rekursion, Lesen die ALSO regex-FAQ und entdecken, nette tricks, wie Sie ausschließen bestimmter Muster von ein regex-match... oder Lesen von Klassikern wie Matering Reguläre Ausdrücke, 3. Ed oder Die Regular Expressions Cookbook, 2nd Ed .

Für tools, die Sie verwenden können:

• Online: Regex_for_range
• Offline: die einzige, die ich bewusst bin, ist RegexMagic (nicht kostenlos) von regex-guru Jan Goyvaerts. Es ist seine regex-Anfänger-Produkt, und soweit ich mich erinnere hat es eine große Palette von Optionen für die Generierung von zahlen in einem bestimmten Bereich, unter anderem features.
• Wenn die Bedingungen zu Komplex sind, automatisch zu generieren, ist in zwei Bereiche... dann kommen Sie mit einem Wechsel operator |

D. Übung: erstellen eines Regex für die Angaben in der Frage

Diese Spezifikationen sind ziemlich breit... aber nicht notwendigerweise vage. Schauen wir uns die sample-Werte wieder:

123,456,789
-12,34
1234
-8

Wie die ersten beiden Werte beziehen? In der ersten, das Komma entspricht Gruppen von Kräfte der drei. In der zweiten, ist es wahrscheinlich entspricht dem Dezimaltrennzeichen in einer continental-European-style-Nummer format. Das bedeutet nicht, wir sollten Ziffern, die überall in 1,2,3,44. Durch den gleichen token, wir sollten nicht zu restriktiv. Die regex in der akzeptierten Antwort, zum Beispiel, wird nicht mit einer den Anforderungen 123,456,789 (siehe demo).

Wie bauen wir unsere regulären Ausdruck für die specs?

• Let ' s Anker der Ausdruck zwischen ^ und $ zu vermeiden submatches
• Lassen wir ein optionales minus: -?
• Lassen Sie uns mit zwei Arten von Nummern, die auf beiden Seiten von einem Wechsel (?:this|that):
• Auf der linken Seite, einem europäischen Stil-stellig mit optionalen Komma für die Dezimalstellen: [1-9][0-9]*(?:,[0-9]+)?
• Auf der rechten Seite, eine Zahl mit Tausendertrennzeichen: [1-9][0-9]{1,2}(?:,[0-9]{3})+

Die komplette regex:

^-?(?:[1-9][0-9]*(?:,[0-9]+)?|[1-9][0-9]{1,2}(?:,[0-9]{3})+)$

Sehen demo.

Diese regex nicht erlauben, im europäischen Stil Ziffern, beginnend mit 0 wie 0,12. Es ist ein feature, kein bug. Übereinstimmen, wie auch, ein kleiner tweak:

^-?(?:(?:0|[1-9][0-9]*)(?:,[0-9]+)?|[1-9][0-9]{1,2}(?:,[0-9]{3})+)$

Sehen demo.

InformationsquelleAutor der Antwort zx81

^-?    # start of line, optional -
(\d+   # any number of digits
|(\d{1,3}(,\d{3})*))  # or digits followed by , and three digits
((,|\.)\d+)? # optional comma or period decimal point and more digits
$  # end of line

InformationsquelleAutor der Antwort Andrew

In java, können Sie java.util.Scanner mit seinen useLocale Methode

Scanner myScanner =  new Scanner(input).useLocale( myLocale)

isADouble = myScanner.hasNextDouble()

InformationsquelleAutor der Antwort Jorge DeFlon Developer

Versuchen Sie dies:

    boxValue = boxValue.replace(/[^0-9\.\,]/g, "");

Dieser RegEx entsprechen nur Ziffern, Punkte und Kommas.

InformationsquelleAutor der Antwort Narasimha