Co To jest Liczba?

Mam proste pytanie do twojego "prostego" pytania: co dokładnie rozumiesz przez "liczbę"?

• Czy −0 jest liczbą?
• co myślisz o √−1?
• to ⅝ czy ⅔ liczba?
• czy 186,282.42±0.02 miles/second one number-czy może jest ich dwa lub trzy?
• czy 6.02e23 jest liczbą?
• Czy 3.141_592_653_589 jest liczbą? A może π, albo ℯ? I −2π⁻³ ͥ?
• ile liczb w 0.083̄?
• ile liczb w 128.0.0.1?
• jaki numer trzyma ⚄? A może ⚂⚃?
• czy 10,5 mm ma jeden numer - czy ma dwa?
• to ∛8³ Liczba - czy to trzy z nich?
• jaki numer ↀↀⅮⅭⅭⅬⅫ AUC oznacza, 2762 lub 2009?
• to ४५६७ i ৭৮৯৮ liczby?
• a co z 0377, 0xDEADBEEF, i 0b111101101?
• czy Inf jest liczbą? Czy NaN?
• czy ④② jest liczbą? A co z ⓰?
• co myślisz o ㊅?
• Co ℵ₀ i ℵ₁ mają wspólnego z liczbami? Lub ℝ, ℚ, i ℂ?

Sugerowane Wzory

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]+))|))/

Podejrzewam, że niektóre z tych wzorów powyżej mogą zaspokajaj swoje potrzeby. Ale nie mogę ci powiedzieć, który lub jeden - lub, jeśli nie, podać ci inny-ponieważ nie powiedziałeś, co masz na myśli przez "numer".

Jak widzisz, istnieje ogromna liczba możliwości liczbowych: całkiem prawdopodobnie warto z nich, w rzeczywistości. ☺

Klucz do sugerowanych wzorów

Każde ponumerowane Wyjaśnienie wymienione poniżej opisuje wzór odpowiedniego ponumerowanego wzoru wymienionego powyżej.

1. Dopasuj, jeśli są jakieś niecyfrowe w dowolnym miejscu łańcucha, włącznie z białymi spacjami, takimi jak podziały linii.
2. Dopasuj tylko wtedy, gdy łańcuch zawiera tylko cyfry, z możliwym wyjątkiem końcowego podziału linii. Zauważ, że cyfra jest zdefiniowana jako posiadająca właściwość General Category Decimal Number, która jest dostępna jako \p{Nd}, \p{Decimal_Number}, lub \p{General_Category=Decimal_Number}. To jest turn jest w rzeczywistości tylko odbiciem tych punktów kodu, których numeryczna Kategoria typu jest dziesiętna, która jest dostępna jako \p{Numeric_Type=Decimal}.
3. to jest to samo co 2 w większości języków regex. Java jest tutaj wyjątkiem, ponieważ nie mapuje prostych znaków znaków, takich jak \w i\W, \d oraz \D, \s i \S, i \b lub \B do odpowiedniej właściwości Unicode. Oznacza to, że w Javie nie wolno używać żadnego z tych ośmiu jednoznakowych znaków specjalnych dla żadnych danych Unicode, ponieważ działają one tylko na ASCII, mimo że Java zawsze używa znaków Unicode wewnętrznie.
4. to nieco różni się od 3 tym, że nie jest ograniczone do liczb dziesiętnych, ale może być dowolną liczbą, czyli, każda postać z \pN, \p{Number}, lub \p{General_Category=Number} nieruchomości. Należą do nich \p{Nl} lub {[75] } dla rzeczy, takich jak cyfry rzymskie i \p{No} lub {[77] } dla zapisanych i zapisanych liczb, ułamków i zakreślonych liczb - między innymi, jak pręty liczące.
5. to pasuje Tylko do tych ciągów złożonych w całości z liczb, których wartość dziesiętna wynosi 10, więc rzeczy takie jak Ⅹ rzymska cyfra dziesięć i ⑩, ⑽, ⒑, ⓾, ❿, ➉, i ➓.
6. tylko te łańcuchy znaków, które zawierają znaki bez wartości numerycznej NaN; innymi słowy, wszystkie znaki muszą mieć jakąś wartość numeryczną.
7. pasuje Tylko do liczb dziesiętnych, opcjonalnie z myślnikiem minusem.
8. to samo co 7, ale teraz działa również, jeśli znak jest plus zamiast minus.
9. Szuka cyfr dziesiętnych, z opcjonalnym myślnikiem MINUS i opcjonalnym kropką plus zero lub więcej cyfr dziesiętnych.
10. tak samo jak 9 ale nie wymaga cyfr przed kropką, jeśli ma trochę później.
11. Standardowa notacja zmiennoprzecinkowa na C i wiele innych języków, pozwalająca na notację naukową.
12. Znajduje liczby składające się tylko z dwóch lub więcej miejsc po przecinku dowolnego skryptu w porządku malejącym, jak 987 lub 54321. Ten rekurencyjny regex zawiera wywołanie do kodu Perla, które sprawdza, czy dana cyfra ma wartość punktu kodu, który jest następcą bieżącej cyfry; to znaczy, jej wartość porządkowa wynosi jeden większe. Można to zrobić w PCRE używając funkcji C jako wywołania.
13. to szuka poprawnego adresu IPv4 z czterema cyframi dziesiętnymi w poprawnym zakresie, jak 128.0.0.1 lub 255.255.255.240, ale nie 999.999.999.999.999.
14. to wygląda na poprawny adres MAC, więc sześć oddzielonych dwukropkami par dwóch cyfr szesnastkowych ASCII.
15. to wyszukuje liczby całkowite w zakresie ASCII z opcjonalnym znakiem wiodącym. Jest to normalny wzorzec dopasowywania liczb całkowitych ASCII.
16. to jest jak 15, poza tym, że wymaga przecinka do oddzielenia grup po trzy.
17. to jest jak 15, tyle że przecinek do oddzielania grup jest teraz opcjonalny.
18. jest to normalny wzorzec dopasowywania liczb zmiennoprzecinkowych w stylu C w ASCII.
19. to jest jak 18, ale wymaga przecinka do oddzielenia grup 3 i w bazie-2 zamiast w bazie-10.
20. to jest jak 19, ale w hex. Zauważ, że wykładnik opcjonalny jest teraz oznaczany przez G zamiast E, ponieważ E jest prawidłowym hexem digit.
21. sprawdza, czy łańcuch zawiera liczbę zmiennoprzecinkową w stylu C, ale z opcjonalnym separatorem grupującym co trzy cyfry przecinka lub podkreślenia (LOW LINE) między nimi. Zapisuje również ten ciąg do grupy przechwytywania \1, udostępnianej jako $1 po pomyślnym dopasowaniu.

Źródła i konserwacja

Wzory numer 1,2,7–11 pochodzą z poprzedniego wcielenia Perla Lista Najczęściej Zadawanych Pytań w pytaniu " Jak mogę zweryfikować dane wejściowe?". Sekcja ta została zastąpiona sugestią użycia modułu Regexp::Common, napisanego przez Abigail i Damiana Conwaya. Oryginalne wzory można jeszcze znaleźć w przepisie 2.1 z Perl Cookbook, "sprawdzanie, czy ciąg znaków jest poprawną liczbą", rozwiązania, które można znaleźć dla zawrotnej liczby różnych języków, w tym ada, common lisp, groovy, guile, haskell, java, merd, ocaml, php, pike, python, rexx, ruby i tcl w projekcie the PLEAC .

Wzór 12 może być czytelniej przepisany

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

Używa rekurencji regex , która znajduje się w wielu silnikach wzorców, w tym Perlu i wszystkich językach pochodnych PCRE. Ale używa również wbudowanego wywołania kodu jako testu swojego drugiego warunkowego wzorca; z mojej wiedzy, wywołania kodu są dostępne tylko w Perlu i PCRE.

Wzory 13-21 pochodzą z wspomniany moduł Regexp:: Common. Zauważ, że dla zwięzłości, wszystkie są napisane bez spacji i komentarzy, które na pewno chcesz w kodzie produkcyjnym. Oto jak to może wyglądać w trybie /x:

$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

Z punktu widzenia inżynierii oprogramowania, istnieje jeszcze kilka problemów ze stylem używanym w wersji trybu /x bezpośrednio powyżej. Po pierwsze, jest wiele powtórzeń kodu, gdzie widzisz to samo [0123456789]; co się stanie, jeśli jedna z tych sekwencji przypadkowo zostawia cyfrę? Po drugie, polegasz na parametrach pozycyjnych, które musisz policzyć. Oznacza to, że możesz napisać coś w stylu:

(
  $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/);

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;

Teraz abstrakcje są nazwane, co pomaga. Możesz wyciągnąć grupy po nazwie, A potrzebujesz tylko tych, na których Ci zależy. Na przykład:

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

Jest jeszcze jedna rzecz, aby ten wzór był jeszcze bardziej możliwy do utrzymania. Problem w tym, że wciąż jest zbyt wiele powtórzeń, co oznacza, że jest zbyt łatwo zmienić w jednym miejscu, ale nie w innym. Gdybyś robił analizę McCabe ' a, powiedziałbyś jego metryka złożoności jest zbyt wysoka. Większość z nas powie, że jest zbyt wcięta. To utrudnia śledzenie. Aby naprawić te wszystkie rzeczy, potrzebujemy "wzorca gramatycznego", takiego z blokiem definicji do tworzenia nazwanych abstrakcji, które następnie traktujemy nieco jak wywołanie podprogramu później w meczu.

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;

Widzisz jak [188]} szalenie lepszy wzór gramatyczny jest od oryginalnego wzorca wierszowego? O wiele łatwiej jest też poprawić składnię: wpisałem, że w bez nawet jednego błędu składni regex, który wymagał korekty. (OK w porządku, wpisałem wszystkie inne bez błędów składniowych, ale robię to od jakiegoś czasu. :)

Wzory gramatyczne wyglądają bardziej jak BNF niż brzydkie stare wyrażenia regularne, których ludzie nienawidzą. Są o wiele łatwiejsze do odczytu, zapisu i utrzymania. Więc skończmy z brzydkimi wzorami, OK?

Spróbuj tego:

^-?\d{1,3}(,\d{3})*(\.\d\d)?$|^\.\d\d$

Pozwala na:

1
12
.99
12.34 
-18.34
12,345.67
999,999,999,999,999.99

Ponieważ to pytanie zostało PONOWNIE OTWARTE cztery lata później, chciałbym zaproponować inne podejście. Ponieważ ktoś spędza dużo czasu na pracy z regexem, moim zdaniem jest to:

A. Jeśli to możliwe, nie używaj Regex do walidacji liczb

Jeśli to możliwe, używaj swojego języka. Mogą istnieć funkcje, które pomogą Ci określić, czy wartość zawarta w łańcuchu jest poprawną liczbą. To powiedziawszy, jeśli akceptujesz różne formaty (przecinki itp.) może nie mieć wybór.

B. Nie zapisuj Regex ręcznie, aby zweryfikować zakres liczb

• pisanie wyrażenia regularnego w celu dopasowania liczby w danym zakresie jest trudne. Można popełnić błąd nawet pisząc regex do dopasować liczbę z zakresu od 1 do 10.
• gdy masz regex dla zakresu liczb, trudno jest debugować. Po pierwsze, to okropne patrzeć na to. Po drugie, jak możesz być pewien, że pasuje do wszystkich wartości, które chcesz, bez dopasowania żadnej z wartości, których nie chcesz? Szczerze mówiąc, jeśli jesteś sam, bez oglądania się przez ramię, nie możesz. najlepszą techniką debugowania jest generowanie całego zakresu liczb programowo i sprawdzanie ich przed wyrażeniem regularnym.
• na szczęście istnieją narzędzia do automatycznego generowania wyrażeń regularnych dla zakresu liczb.

C. mądrze wykorzystuj energię Regex: używaj narzędzi

• dopasowanie liczb w danym zakresie jest problemem, który został rozwiązany. Nie musisz próbować. odkryj koło na nowo. Jest to problem, który może być rozwiązany mechanicznie, przez program, w sposób gwarantujący, że będzie wolny od błędów. Skorzystaj z darmowej przejażdżki.
• rozwiązywanie regex zakresu liczb może być interesujące dla celów uczenia się kilka razy. Poza tym, jeśli masz energię, aby zainwestować w rozwijanie swoich umiejętności regex, wydaj ją na coś przydatnego, na przykład pogłębienie zrozumienia regex , czytanie na Unicode regex , granie z zerową szerokością dopasowanie lub rekurencja, czytanie so regex FAQ i odkrywanie ciekawych sztuczek, takich jak jak wykluczenie pewnych wzorców z dopasowania regex... lub czytanie klasyków, takich jak Matering Regular Expressions, 3rd Ed lub The Regular Expressions Cookbook, 2nd Ed .

Do narzędzi można użyć:

• Online: Regex_for_range
• Offline: jedynym, którego jestem świadomy jest RegexMagic (nie Wolny) przez Guru regex Jana Goyvaertsa. On jego początkujący produkt regex, a z tego co pamiętam ma duży zakres opcji generowania liczb w danym zakresie, między innymi funkcje.
• jeśli warunki są zbyt złożone, automatycznie Wygeneruj dwa zakresy... następnie połącz je z operatorem alternacji |

D. ćwiczenie: budowanie Regex dla specyfikacji w pytaniu

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

Jak pierwsze dwie wartości odnoszą się? W pierwszym przecinek pasuje do grup potęg trzech. W drugim, prawdopodobnie odpowiada punktowi dziesiętnemu w formacie liczbowym w stylu kontynentalno-Europejskim. Nie oznacza to, że powinniśmy wszędzie dopuszczać cyfry, jak w 1,2,3,44. Z tego samego powodu, nie powinniśmy ograniczać się. Na przykład wyrażenie regularne w zaakceptowanej odpowiedzi nie będzie odpowiadać jednemu z wymagań, 123,456,789 (Zobacz demo ).

Jak zbudować nasz regex, aby pasował do specyfikacje?

• zakotwiczmy wyrażenie pomiędzy ^ i $, aby uniknąć podmatchów
• pozwólmy na opcjonalny minus: -?
• dopasujmy dwa typy liczb po obu stronach przemiennika (?:this|that):
• po lewej cyfra W Stylu Europejskim z opcjonalnym przecinkiem dla części dziesiętnej: [1-9][0-9]*(?:,[0-9]+)?
• po prawej stronie Liczba z separatorami tysięcy: [1-9][0-9]{1,2}(?:,[0-9]{3})+

Kompletny regex:

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

Zobacz demo .

To regex nie pozwala na liczby W Stylu Europejskim zaczynające się od 0, takie jak 0,12. To funkcja, nie błąd. Aby dopasować te, jak również, mały tweak zrobi:

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

Zobacz demo .

Spróbuj tego:

^-?[\d\,]+$

Pozwoli na opcjonalne - jako pierwszy znak, a następnie dowolną kombinację przecinków i cyfr.

^-?    # 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

^[-+]?(\d{1,3})(,?(?1))*$

Debuggex Demo

Więc co to robi?!

• ^ oznacza początek łańcucha
• [-+]? pozwala na minus lub plus tuż po początku łańcucha
• (\d{1,3}) dopasowuje co najmniej jedną i maksymalnie trzy ({1,3}) cyfry (\d - powszechnie [0-9]) w rzędzie i grupuje je (nawiasy (...) budują grupę) jako pierwszą grupę
• Ok... rozwalmy to. down
  • (...) buduje kolejną grupę (niezbyt ważną )
  • ,? dopasowuje przecinek (jeśli istnieje) zaraz po pierwszej sekwencji cyfr
  • (?1) ponownie pasuje do wzorca pierwszej grupy (remember (\d{1,3})); W słowach: w tym momencie wyrażenie pasuje do znaku (plus / minus / none), po którym następuje sekwencja cyfr, ewentualnie przecinek, a następnie kolejny ciąg cyfr ponownie.
  • (,?(?1))*, * powtarza drugą część (przecinek & Sekwencja) tak często, jak to możliwe
• $ wreszcie dopasowuje koniec łańcucha

Zaletą takich wyrażeń jest unikanie definiowania tego samego wzorca w wyrażeniu raz po raz... cóż, wadą jest czasami złożoność : - /

W Javie można używać {[1] } z jej metodą useLocale

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

isADouble = myScanner.hasNextDouble()

Dla przykładów:

    ^(-)?([,0-9])+$

Spróbuj tego:

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

Ten RegEx będzie pasował tylko do cyfr, kropek i przecinków.