数字是多少？

我有一个简单的问题你的“简单”问题：你所说的“数字”到底是什么意思？是

−0一个号码？

你觉得

√−1?

是

⅝或

⅔一个号码？

是

186,282.42±0.02英里/秒-或者是其中的两三英里？

是

6.02e23一个号码？

是

3.141_592_653_589一个号码？怎么样

π，或

ℯ？和

−2π⁻³ ͥ?

有多少个数字

0.083̄?

有多少个数字

128.0.0.1?

什么号码

⚄等一下？怎么样

⚂⚃?

是吗？

10,5 mm里面有一个号码-还是有两个？

是

∛8³一个数字-或者是其中的三个？

什么号码

ↀↀⅮⅭⅭⅬⅫ AUC代表，2762还是2009年？

是

४५६७和

৭৮৯৮数字?

关于

0377, 0xDEADBEEF，和

0b111101101?

是

Inf一个号码？是

NaN?

是

④②一个号码？关于

⓰?

你觉得

㊅?

做什么

ℵ₀和

ℵ₁跟数字有关吗？或

ℝ, ℚ，和

ℂ?

建议模式

另外，你熟悉这些模式吗？你能解释一下每一种方法的优缺点吗？/\D/

/^\d+$/

/^\p{Nd}+$/

/^\pN+$/

/^\p{Numeric_Value:10}$/

/^\P{Numeric_Value:NaN}+$/

/^-?\d+$/

/^[+-]?\d+$/

/^-?\d+\.?\d*$/

/^-?(?:\d+(?:\.\d*)?|\.\d+)$/

/^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/

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

/^(?:(?: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}))$/

/^(?:(?:[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}))$/

/^(?:(?:[+-]?)(?:[0123456789]+))$/

/(([+-]?)([0123456789]{1,3}(?:,?[0123456789]{3})*))/

/^(?:(?:[+-]?)(?:[0123456789]{1,3}(?:,?[0123456789]{3})*))$/

/^(?:(?i)(?:[+-]?)(?:(?=[0123456789]|[.])(?:[0123456789]*)(?:(?:[.])(?:[0123456789]{0,}))?)(?:(?:[E])(?:(?:[+-]?)(?:[0123456789]+))|))$/

/^(?:(?i)(?:[+-]?)(?:(?=[01]|[.])(?:[01]{1,3}(?:(?:[,])[01]{3})*)(?:(?:[.])(?:[01]{0,}))?)(?:(?:[E])(?:(?:[+-]?)(?:[01]+))|))$/

/^(?:(?i)(?:[+-]?)(?:(?=[0123456789ABCDEF]|[.])(?:[0123456789ABCDEF]{1,3}(?:(?:[,])[0123456789ABCDEF]{3})*)(?:(?:[.])(?:[0123456789ABCDEF]{0,}))?)(?:(?:[G])(?:(?:[+-]?)(?:[0123456789ABCDEF]+))|))$/

/((?i)([+-]?)((?=[0123456789]|[.])([0123456789]{1,3}(?:(?:[_,]?)[0123456789]{3})*)(?:([.])([0123456789]{0,}))?)(?:([E])(([+-]?)([0123456789]+))|))/

我怀疑上面的一些模式可以，可能满足你的需要。但我不能告诉你哪一个或哪一个-或者，如果没有，提供给你另一个-因为你没有说过你所说的“数字”是什么意思。

如你所见，有一个巨大的数字数量的可能性：很可能是ℵ₁值，事实上。☺

建议模式的关键

下面列出的每个编号说明都描述了上面列出的相应编号模式的模式。如果有匹配的话

非数字字符串中的任何位置，包括像换行符一样的空格。

只有在字符串只包含数字的情况下才匹配，但尾行中断可能除外。请注意，数字被定义为具有属性通用类别十进制数，该数字可作为

\p{Nd}, \p{Decimal_Number}，或

\p{General_Category=Decimal_Number}..这个转身实际上只是一个代码点的反映，这些代码点的数字类型类别为十进制，如

\p{Numeric_Type=Decimal}.

这与大多数regex语言中的2相同。这里的Java是一个例外，因为它不映射简单的charclass转义，例如

\w和

\W, \d和

\D, \s和

\S，和

\b或

\B进入适当的Unicode属性。这意味着您不能对Java中的任何Unicode数据使用这八个单字符转义，因为它们只在ASCII上工作，即使Java总是在内部使用Unicode字符。

这与3略有不同，因为它不仅限于十进制数，而且可以是任何数字；也就是说，任何带有

\pN, \p{Number}，或

\p{General_Category=Number}财产。这些包括

\p{Nl}或

\p{Letter_Number}比如罗马数字和

\p{No}或

\p{Other_Number}对于下标和下标的数字，分数和圈数-等等，就像计数棒。

这只匹配完全由十进制值为10的数字组成的字符串，所以如下所示

Ⅹ罗马数字十，和

⑩, ⑽, ⒑, ⓾, ❿, ➉，和

➓.

只有那些包含缺少数字值NaN的字符串；换句话说，所有字符都必须有一些数字值。

只匹配十进制数，可以选择使用前导连字符减号。

与7相同，但如果符号是加号而不是减号，现在也能工作。

查找十进制数，后面是可选连字符减号和可选句号加上零或多个十进制数。

与9相同，但如果后面有一些，则不需要在点之前使用数字。

C和许多其他语言的标准浮点表示法，允许科学记谱.

发现只有两个或更多的小数组成的数字按降序排列，如987或54321。这个递归正则表达式包括对Perl代码的标注，它检查前面的数字是否有一个代码点值，它是当前数字的后继值；也就是说，它的序号值更大。可以在PCRE中使用C函数作为标注。

它查找有效范围内有四个十进制数的有效IPv 4地址，比如128.0.0.1或255.255.240，但不是999.999.999.999。

这寻找一个有效的MAC地址，所以六个冒号-分开对两个ASCII十六进制数字.

这查找ASCII范围内带有可选引号的整数。这是匹配ASCII整数的正常模式。

这就像15，只不过它需要一个逗号来分隔三组。

这类似于15，只是分隔组的逗号现在是可选的。

这是在ASCII中匹配C型浮点数的正常模式.

这就像18，但需要一个逗号来分隔3和基-2的组，而不是基-10。

这是19岁，但用的是魔法。注意，可选指数现在由G而不是E表示，因为E是有效的十六进制数字。

这将检查字符串是否包含C样式的浮点数，但在它们之间使用可选的分组分隔符，每个逗号或下划线(低行)的三位数字。它还将该字符串存储到

\1捕获组，使其可作为

$1比赛成功后。

来源与可维护性

模式编号1，2，7-11来自perl的前一次化身。常见问题在问题中列出“如何验证输入”。该部分已被一项建议替换为使用Regexp：公共模块，由阿比盖尔和达米安·康韦..原始模式仍然可以在Perl烹饪本，“检查一个字符串是否是一个有效的数字”，它的解决方案可用于令人眼花缭乱的多种语言，包括ada、公共LISP、groovy、guile、haskell、java、merd、ocaml、php、pike、python、reexx、ruby和tcl。PLEAC项目.

模式12可以更清晰地重写。m{

^

(

( \d )

(?(?= ( \d ) ) | $ )

(?(?{ ord $3 == 1 + ord $2 }) (?1) | $ )

)

$}x

它用正则递归，它存在于许多模式引擎中，包括Perl和所有PCRE派生语言中。但它还使用嵌入式代码标注作为其第二种条件模式的测试；据我所知，代码标注仅在Perl和PCRE中可用。

模式13-21来自上述Regexp：公共模块。请注意，为了简洁起见，编写这些代码时都没有您在生产代码中绝对需要的空白和注释。这可能是怎么回事/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

从软件工程的角度来看，在/x上面的模式版本。首先，有大量的代码重复，您可以看到相同的代码。[0123456789]如果其中一个序列不小心遗漏了一个数字，会发生什么情况？其次，您所依赖的是位置参数，必须对其进行计数。这意味着您可能会编写如下内容：(

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

坦白地说，这是令人憎恶的！很容易弄错编号，很难记住什么符号名称会出现在哪里，写起来也很乏味，特别是在不需要所有这些内容的情况下。将其重写为使用命名组而不是仅编号组。同样，我将对变量使用Perl语法，但是模式的内容应该在任何支持命名组的地方工作。use 5.010;              # Perl got named patterns in 5.10$real_rx = qr{

(?

# optional leading sign

(? [+-]? )

(?

(?=                         # look ahead for what next char *will* be

[0123456789]            #    EITHER:  an ASCII digit

| [.]                     #    OR ELSE: a dot

)                           # end look ahead

(?

[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

(?:                        # begin optional anon cluster

(? [.] ) # required literal dot

(?

[0123456789]{0,}  )

) ?                        # end optional anon cluster

)                                # end

# begin anon cluster group:

(?:

(? [E] ) #   base-10 exponent

(?          #   exponent number

(?   [+-] ?         )

(? [0123456789] + )

)                      #   end

|                        #   or else nothing at all

)                          # end anon cluster group

)                            # end }xi;

现在命名了抽象，这很有帮助。你可以按名字把小组拉出来，你只需要那些你关心的人。例如：if ($string =~ /$real_rx/) {

($pre_exponent, $exponent_number) =

@+{ qw };}

还有一件事要做这个模式，以使它更易于维护。问题是，仍然有太多的重复，这意味着它太容易改变在一个地方，而不是在另一个地方。如果你在做McCabe分析，你会说它的复杂性度量太高了。我们大多数人都会说它太缩了。这就很难理解了。要解决所有这些问题，我们需要的是一个“语法模式”，一个带有定义块来创建命名抽象的模式，然后我们将其处理得有点像匹配中的子例程调用。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)

(?

(?&mantissa)

(?&abscissa) ?

)

(?

(?&exponent_indicator)

(?&exponent)

)

(?

(&?sign)    ?

(?&a_digit) +

)

(?

# expecting either of these....

(?= (?&a_digit)

| (?&point)

)

(?&a_digit) {1,3}

(?: (?&digit_separator) ?

(?&a_digit) {3}

) *

(?: (?&point)

(?&a_digit) *

) ?

)

(?               [.]     )

(?                [+-]    )

(?     [_,]    )

(?  [Ee]    )

(?             [0-9]   )

) # end DEFINE block}x;

看看如何疯狂的更好语法模式是否比原来的行噪模式更好？正确的语法也要容易得多：我输入时甚至没有一个需要纠正的regex语法错误。(好吧，我也输入了所有其他的语法错误，但我已经这样做了一段时间了。)*)

语法模式看上去更像一个BNF，而不是人们所讨厌的丑陋的旧正则表达式。它们更容易读、写和维护。所以我们不要再有丑陋的模式了，好吗？