Regex Erlang正则表达式重新性能

尝试一些正则表达式性能测试（听到一些关于erlang速度慢的谣言）

>Fun=Fun F（X）->案例X>1000000的真值->确定；false->Y=X+1，重新：运行（，“^[a-zA-Z0-9\]+$”），F（Y）结束。
#乐趣
>计时器：tc（乐趣，[0]）。
{17233982，好的}
>计时器：tc（乐趣，[0]）。
{17155982，好的}

以及编译正则表达式后的一些测试

{ok, MP} = re:compile("^[a-zA-Z0-9_]+$").                                   
{ok,{re_pattern,0,0,0,                                                          
            <<69,82,67,80,107,0,0,0,16,0,0,0,1,0,0,0,255,255,255,
              255,255,255,...>>}}
> Fun = fun F(X) -> case X > 1000000 of true -> ok; false -> Y = X + 1, re:run(<<"1ab1jgjggghjgjgjhhhhhhhhhhhhhjgdfgfdgdfgdfgdfgdfgdfgdfgdfgdfgfgv">>, MP), F(Y) end end.               
#Fun<erl_eval.30.128620087>
> timer:tc(Fun, [0]).                                                         
{15796985,ok}                                                                   
>        
> timer:tc(Fun, [0]).
{15921984,ok}

{ok，MP}=re:compile（“^[a-zA-Z0-9\]+$”）。
{好，{re_模式，0,0,0，
}}
>Fun=Fun F（X）->案例X>1000000的真值->确定；false->Y=X+1，re:run（，MP），F（Y）end。
#乐趣
>计时器：tc（乐趣，[0]）。
{15796985，好的}
>        
>计时器：tc（乐趣，[0]）。
{15921984，好的}

:

除非另有说明，时间始终以毫秒为单位

:

如果要在程序生命周期内对多个主题使用相同的表达式进行匹配，则在匹配之前编译正则表达式非常有用。编译一次并执行多次要比每次编译都要高效得多

问题

为什么它向我返回微秒？（应该是毫秒？）

编译正则表达式没有多大区别，为什么

我应该费心编辑它吗

在模块中，函数tc/2返回微秒

因为函数

Fun

需要编译字符串

“^[a-zA-Z0-9\]+$”

在案例1中每一次递归（100万次）。相反，在案例2中，您首先进行编译。之后，将结果带入递归，这就是性能低于案例1的原因

运行（主题，重新）->{匹配，捕获}nomatch

Subject=iodata（）| unicode:charlist（）

RE=mp（）| iodata（）

正则表达式可以指定为iodata（），其中 如果自动编译（如编译/2）并执行，或 作为预编译的mp（），在这种情况下，它是针对主题执行的 直接的

是的，在使用递归之前，您应该首先注意编译

在模块中，函数tc/2返回微秒

因为函数

Fun

需要编译字符串

“^[a-zA-Z0-9\]+$”

在案例1中每一次递归（100万次）。相反，在案例2中，您首先进行编译。之后，将结果带入递归，这就是性能低于案例1的原因

运行（主题，重新）->{匹配，捕获}nomatch

Subject=iodata（）| unicode:charlist（）

RE=mp（）| iodata（）

正则表达式可以指定为iodata（），其中 如果自动编译（如编译/2）并执行，或 作为预编译的mp（），在这种情况下，它是针对主题执行的 直接的

是的，在使用递归之前，您应该首先注意编译

---

是的，您应该在尝试度量性能之前编译代码。在shell中键入代码时，代码将被解释，而不是编译成字节码。在将代码放入模块时，我看到了一个很大的改进：

7> timer:tc(Fun, [0]).
{6253194,ok}
8> timer:tc(fun foo:run/1, [0]).
{1768831,ok}

（这两个都使用编译的regexp。）

-模块（foo）。
-编译（全部导出）。
运行（X）->
{ok，MP}=re:compile（“^[a-zA-Z0-9_zon]+$”，
运行（X，MP）。
当X>1000000->
好啊
运行（X，MP）->
Y=X+1，
回复：运行（，MP），
跑（Y）。

是的，您应该在尝试测量性能之前编译代码。在shell中键入代码时，代码将被解释，而不是编译成字节码。在将代码放入模块时，我看到了一个很大的改进：

7> timer:tc(Fun, [0]).
{6253194,ok}
8> timer:tc(fun foo:run/1, [0]).
{1768831,ok}

（这两个都使用编译的regexp。）

-模块（foo）。
-编译（全部导出）。
运行（X）->
{ok，MP}=re:compile（“^[a-zA-Z0-9_zon]+$”，
运行（X，MP）。
当X>1000000->
好啊
运行（X，MP）->
Y=X+1，
回复：运行（，MP），
跑（Y）。

第一个测试没有事先编译正则表达式，第二个测试采用MP not regex（请重读问题），性能比情况1 not WORSERE高约2秒在microsecs中计算时间，idk我怎么错过了，感谢第一个测试没有事先编译正则表达式，第二个测试采用MP not regex（请重读问题）性能比第一种情况高出2秒。以微秒计算的平均时间，idk我怎么错过了，谢谢

7> timer:tc(Fun, [0]).
{6253194,ok}
8> timer:tc(fun foo:run/1, [0]).
{1768831,ok}

-module(foo).

-compile(export_all).

run(X) ->
    {ok, MP} = re:compile("^[a-zA-Z0-9_]+$"),
    run(X, MP).

run(X, _MP) when X > 1000000 ->
    ok;
run(X, MP) ->
    Y = X + 1,
    re:run(<<"1ab1jgjggghjgjgjhhhhhhhhhhhhhjgdfgfdgdfgdfgdfgdfgdfgdfgdfgdfgfgv">>, MP),
    run(Y).