Javascript 是否将正则表达式更改为仅接受指定字符？_Javascript_Regex

Javascript 是否将正则表达式更改为仅接受指定字符？

javascript regex

Javascript 是否将正则表达式更改为仅接受指定字符？,javascript,regex,Javascript,Regex,我目前将正则表达式保存在javascript文件中，如下所示： function (value) { regex = new RegExp("[\<|\>|\"|\'|\%|\;|$|$|\&|\_|\.]", "i"); return !regex.test(value); } 函数（值）{ regex=newregexp（“[\\\”\\'\\%\\\\\\\\\（\\\）\\&\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

我目前将正则表达式保存在javascript文件中，如下所示：

function (value) {
    regex = new RegExp("[\<|\>|\"|\'|\%|\;|\(|\)|\&|\_|\.]", "i");
    return !regex.test(value);
}

函数（值）{
regex=newregexp（“[\\\”\\'\\%\\\\\\\\\（\\\）\\&\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\.]”，即“i”）；
return！regex.test（值）；
}

与其指定哪些字符是不允许的，我如何声明哪些字符是允许的？我需要的字符是a-z a-z 0-9（以及实际字符“-”，但不在开始或结束处，仅在中间）。感谢高级版。

限制在开头或结尾不使用破折号会使正则表达式稍微复杂一些。下面的正则表达式首先匹配单个字符，然后可选地匹配零个或多个字符（包括破折号），然后再以非破折号字符结尾

/^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/

限制在开始或结束处不使用破折号使正则表达式稍微复杂一些。下面的正则表达式首先匹配单个字符，然后可选地匹配零个或多个字符（包括破折号），然后再以非破折号字符结尾

/^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/

regex=newregexp（“^[a-zA-Z0-9]+（？：-[a-zA-Z0-9]+）*$”；

还是经典的“正常*（特殊正常*）*”模式；）

功能体变为：

function (value) {
    regex = new RegExp("^[a-zA-Z0-9]+(?:-[a-zA-Z0-9]+)*$");
    return regex.test(value) && value.length >= 6;
}

编辑：由于此处未执行任何捕获，因此将分组设置为非捕获。

regex=new RegExp（“^[a-zA-Z0-9]+（？：-[a-zA-Z0-9]+）*$”；

还是经典的“正常*（特殊正常*）*”模式；）

功能体变为：

function (value) {
    regex = new RegExp("^[a-zA-Z0-9]+(?:-[a-zA-Z0-9]+)*$");
    return regex.test(value) && value.length >= 6;
}

编辑：由于此处未进行任何捕获，因此将分组设置为非捕获

regex = new RegExp("^(?!-)[a-z0-9-]*[a-z0-9]$", "i");

锚定到字符串的开头

（？！-）

一个负向前瞻，确保字符串不以破折号开头

[a-z0-9-]*

类中的0个或多个字符

[a-z0-9]$

以类中的一个字符结尾

看到这个了吗

更新

这是一个使用两个lookahead的变体，它还接受空字符串

^(?!-)(?!.*-$)[a-z0-9-]*$

更新2：至少6个字符

^(?!-)[a-z0-9-]{5,}[a-z0-9]$

反驳

它实际上是一个太复杂的正则表达式——而且肯定比我的正则表达式
我做了一个小的基准测试（在Perl中，应该不是什么大问题）
结果
带有前瞻和测试字符串“Foo-Bar”的代码耗时：16个时钟秒（14.94 usr+0.00 sys=14.94 CPU）
没有前瞻和测试字符串“Foo-Bar”的代码耗时：18个时钟秒（17.50 usr+0.02 sys=17.52 CPU）
带有前瞻和测试字符串“-Foo-Bar”的代码耗时：13个时钟秒（12.03 usr+0.00 sys=12.03 CPU）
不带前瞻和测试字符串“-Foo-Bar”的代码耗时：14个时钟秒（13.44 usr+0.00 sys=13.44 CPU）
带有前瞻和测试字符串“Foo-Bar-”的代码占用了：17个时钟秒（15.28 usr+0.00 sys=15.28 CPU）
没有前瞻和测试字符串“Foo-Bar-”的代码占用了：23个时钟秒（21.61 usr+0.02 sys=21.63 CPU）
带有前瞻和测试字符串“Foo”的代码耗时：14个时钟秒（13.70 usr+0.00 sys=13.70 CPU）
不带前瞻和测试字符串“Foo”的代码耗时：19个时钟秒（17.09 usr+0.02 sys=17.11 CPU）
因此，总体而言，我的带有负前瞻的正则表达式比简单的正则表达式与外部长度检查的组合要快一些。但是我需要调用每个代码10000000次才能得到显著的结果，所以我认为使用哪一个不是性能决定。
试试这个

regex = new RegExp("^(?!-)[a-z0-9-]*[a-z0-9]$", "i");

^
锚定到字符串的开头

（？！-）
一个负向前瞻，确保字符串不以破折号开头

[a-z0-9-]*
类中的0个或多个字符

[a-z0-9]$
以类中的一个字符结尾
看到这个了吗
更新
这是一个使用两个lookahead的变体，它还接受空字符串

^(?!-)(?!.*-$)[a-z0-9-]*$

更新2：至少6个字符

^(?!-)[a-z0-9-]{5,}[a-z0-9]$

反驳

它实际上是一个太复杂的正则表达式——而且肯定比我的正则表达式
我做了一个小的基准测试（在Perl中，应该不是什么大问题）
结果
带有前瞻和测试字符串“Foo-Bar”的代码耗时：16个时钟秒（14.94 usr+0.00 sys=14.94 CPU）
没有前瞻和测试字符串“Foo-Bar”的代码耗时：18个时钟秒（17.50 usr+0.02 sys=17.52 CPU）
带有前瞻和测试字符串“-Foo-Bar”的代码耗时：13个时钟秒（12.03 usr+0.00 sys=12.03 CPU）
不带前瞻和测试字符串“-Foo-Bar”的代码耗时：14个时钟秒（13.44 usr+0.00 sys=13.44 CPU）
带有前瞻和测试字符串“Foo-Bar-”的代码占用了：17个时钟秒（15.28 usr+0.00 sys=15.28 CPU）
没有前瞻和测试字符串“Foo-Bar-”的代码占用了：23个时钟秒（21.61 usr+0.02 sys=21.63 CPU）
带有前瞻和测试字符串“Foo”的代码耗时：14个时钟秒（13.70 usr+0.00 sys=13.70 CPU）
不带前瞻和测试字符串“Foo”的代码耗时：19个时钟秒（17.09 usr+0.02 sys=17.11 CPU）

因此，总体而言，我的带有负前瞻的正则表达式比简单的正则表达式与外部长度检查的组合要快一点。但我需要调用每个代码10000000次才能得到显著的结果，所以我认为使用哪一个不是性能决定。
不，一点也不：请看我的答案+1，尽管它不会改变接受空字符串。不确定OP是否需要它，只需记下它：）不，一点也不：看我的答案+1，尽管它不会接受空字符串。不确定OP是否需要它，只需记下它：）很好地使用了否定的前瞻。嗨，那么最后的代码将是：
regex=newregexp（^（？！-）[a-z0-9-]{5，}[a-z0-9]$，“i”）
？它实际上是一个太复杂的正则表达式——而且肯定比我的正则表达式慢。嗨，谢谢你在那个网站上给出的例子。它是一个展示代码的好工具