如何在 JavaScript 中使用支持 Unicode 的正则表达式？
应该有类似于 \w 的东西，可以匹配字母或标记类别中的任何代码点（不仅仅是 ASCII 代码点），并希望有像 [[P*]] 这样的过滤器用于标点符号等。
There should be something akin to \w that can match any code-point in Letters or Marks category (not just the ASCII ones), and hopefully have filters like [[P*]] for punctuation, etc.
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（11）
ES 6 的情况
ECMAScript 语言规范第 6 版（通常也称为 ES2015）包含支持 Unicode 的正则表达式。 必须使用正则表达式上的
u修饰符启用支持。 请参阅 ES6 中支持 Unicode 的正则表达式 了解更多信息详细介绍该功能和一些注意事项。ES6 在浏览器和独立的 Javascript 运行时（例如 Node.js）中被广泛采用，因此在大多数情况下使用此功能不需要额外的努力。 完整兼容性列表：https://kangax.github.io/compat-table/es6/
ES 5 及以下版本（旧版浏览器）的情况
有 一个名为 regexpu 的转译器它将 ES6 Unicode 正则表达式转换为等效的 ES5。 它可以用作构建过程的一部分。 在线试用。。
尽管 JavaScript 对 Unicode 字符串进行操作，但它不实现支持 Unicode 的字符类，并且没有 POSIX 字符类或 Unicode 块/子范围的概念。
JavaScript 正则表达式中的 Unicode 问题
在此处检查您的期望：Javascript RegExp Unicode 字符类测试器（编辑：原始页面已关闭，互联网档案馆仍有副本。）< /p>
Flagrant Badassery 有一篇关于 JavaScript 的文章，正则表达式和 Unicode 为这个问题提供了一些线索。
另请阅读正则表达式和 Unicode 此处。 也许您必须构建自己的“标点字符类”。
查看正则表达式：匹配 Unicode 块范围构建器 (存档副本），它可以让您构建一个JavaScript 正则表达式，匹配任意数量的指定 Unicode 块中的字符。
我只是针对“常规标点符号”和“补充标点符号”子范围进行了此操作，结果正如我所期望的那样简单直接：
<前><代码> [\u2000-\u206F\u2E00-\u2E7F]
还有 XRegExp，一个为 JavaScript 带来 Unicode 支持的项目 通过提供具有扩展功能的替代正则表达式引擎。
当然，必读：mathiasbynens.be - JavaScript 有 Unicode 问题：< /p>
Situation for ES 6
The ECMAScript language specification, edition 6 (also commonly known as ES2015), includes Unicode-aware regular expressions. Support must be enabled with the
umodifier on the regex. See Unicode-aware regular expressions in ES6 for a break-down of the feature and some caveats.ES6 is widely adopted in both browsers and stand-alone Javascript runtimes such as Node.js, so using this feature won't require extra effort in most cases. Full compatibility list: https://kangax.github.io/compat-table/es6/
Situation for ES 5 and below (legacy browsers)
There is a transpiler named regexpu that translates ES6 Unicode regular expressions into equivalent ES5. It can be used as part of your build process. Try it out online..
Even though JavaScript operates on Unicode strings, it does not implement Unicode-aware character classes and has no concept of POSIX character classes or Unicode blocks/sub-ranges.
Issues with Unicode in JavaScript regular expressions
Check your expectations here: Javascript RegExp Unicode Character Class tester (Edit: the original page is down, the Internet Archive still has a copy.)
Flagrant Badassery has an article on JavaScript, Regex, and Unicode that sheds some light on the matter.
Also read Regex and Unicode here on SO. Probably you have to build your own "punctuation character class".
Check out the Regular Expression: Match Unicode Block Range builder (archived copy), which lets you build a JavaScript regular expression that matches characters that fall in any number of specified Unicode blocks.
I just did it for the "General Punctuation" and "Supplemental Punctuation" sub-ranges, and the result is as simple and straight-forward as I would have expected it:
There also is XRegExp, a project that brings Unicode support to JavaScript by offering an alternative regex engine with extended capabilities.
And of course, required reading: mathiasbynens.be - JavaScript has a Unicode problem:
就我个人而言，我宁愿不安装另一个库只是为了获得此功能。 我的答案不需要任何外部库，并且除了 JavaScript 之外，它也可以在对正则表达式风格进行少量修改的情况下工作。
Unicode 的网站提供了一种将Unicode 类别转换为一组代码点的方法。 由于它是 Unicode 的网站，因此其中的信息应该是准确的。
请注意，您需要排除高端字符，因为 JavaScript 只能处理小于
FFFF（十六进制）的字符。 我建议选中“缩写整理”和“转义”复选框，它们在避免无法打印的字符和最小化正则表达式的大小之间取得平衡。以下是不同 Unicode 属性的一些常见扩展：
\p{L}（字母）：\p{Nd}（数字十进制数字）：\p{ P}（标点符号）：该页面还识别许多晦涩的字符类，例如
\p{Hira}，这只是（日语）平假名字符：最后，这是可能的插入具有多个 Unicode 属性的 char 类，以获得比仅组合它们所获得的更短的正则表达式（只要检查了某些设置）。
Personally, I would rather not install another library just to get this functionality. My answer does not require any external libraries, and it may also work with little modification for regex flavors besides JavaScript.
Unicode's website provides a way to translate Unicode categories into a set of code points. Since it's Unicode's website, the information from it should be accurate.
Note that you will need to exclude the high-end characters, as JavaScript can only handle characters less than
FFFF(hex). I suggest checking the Abbreviate Collate, and Escape check boxes, which strike a balance between avoiding unprintable characters and minimizing the size of the regex.Here are some common expansions of different Unicode properties:
\p{L}(Letters):\p{Nd}(Number decimal digits):\p{P}(Punctuation):The page also recognizes a number of obscure character classes, such as
\p{Hira}, which is just the (Japanese) Hiragana characters:Lastly, it's possible to plug a char class with more than one Unicode property to get a shorter regex than you would get by just combining them (as long as certain settings are checked).
由于也没有找到好的解决方案，我很久以前通过下载数据编写了一个小 脚本来自 unicode 规范 (v.5.0.0) 并为每个 unicode 类别和子类别生成间隔在 BMP 中（最近被一个小型 Java 程序 取代，该程序使用自己的本机 Unicode 支持）。
基本上它将
\p{...}转换为一系列值，非常类似于 工具，但间隔最终可能会很大（因为它不是处理块，而是处理分散在许多不同地方的字符）。例如，像这样编写的正则表达式：
将转换为这样的内容：
在实践中没有经常使用它，但从我的测试来看它似乎工作得很好，所以我在这里发布以防有人发现它有用。 尽管生成的正则表达式的长度很长（上面的示例展开时有 3591 个字符），但性能似乎是可以接受的（请参阅 在 jsFiddle 进行测试；感谢 @modiX 和 @Lwangaman 的改进）。
这是源（原始，27.5KB；缩小，24.9KB，好不了多少...）。 通过取消转义 unicode 字符，可能会变得更小，但 OTOH 会面临编码问题的风险，所以我保持原样。 希望 ES6 不再需要这种事情了。
更新：这看起来与 XRegExp Unicode 插件 Tim Down 提到过，只不过本例中使用的是常规 JavaScript 正则表达式。
Having also not found a good solution, I wrote a small script a long time ago, by downloading data from the unicode specification (v.5.0.0) and generating intervals for each unicode category and subcategory in the BMP (lately replaced by a small Java program that uses its own native Unicode support).
Basically it converts
\p{...}to a range of values, much like the output of the tool mentioned by Tomalak, but the intervals can end up quite large (since it's not dealing with blocks, but with characters scattered through many different places).For instance, a Regex written like this:
Will be converted to something like this:
Haven't used it a lot in practice, but it seems to work fine from my tests, so I'm posting here in case someone find it useful. Despite the length of the resulting regexes (the example above has 3591 characters when expanded), the performance seems to be acceptable (see the tests at jsFiddle; thanks to @modiX and @Lwangaman for the improvements).
Here's the source (raw, 27.5KB; minified, 24.9KB, not much better...). It might be made smaller by unescaping the unicode characters, but OTOH will run the risk of encoding issues, so I'm leaving as it is. Hopefully with ES6 this kind of thing won't be necessary anymore.
Update: this looks like the same strategy adopted in the XRegExp Unicode plug-in mentioned by Tim Down, except that in this case regular JavaScript regexes are being used.
2018 年 9 月（2019 年 2 月更新）
似乎 regexp
/\p{L}/u用于匹配字母（如 unicode 类别)这是一个 工作示例
我在此处报告了此错误。
更新
2 年后根据：1500035 > 1361876 > 1634135 最终此错误已修复，并将在 Firefox v.78+ 中提供
September 2018 (updated February 2019)
It seems that regexp
/\p{L}/ufor match letters (as unicode categories)Here is a working example
I report this bug here.
Update
After over 2 years according to: 1500035 > 1361876 > 1634135 finally this bug is fixed and will be available in Firefox v.78+
[^\u0000-\u007F]+用于不包含 ASCII 字符的任何字符。例如：
以下是一些完美的参考：
Unicode 范围正则表达式生成器
Unicode 正则表达式
Unicode 10.0字符代码图表
匹配 Unicode 块范围
[^\u0000-\u007F]+for any characters which is not included ASCII characters.For example:
Here are some perfect references:
Unicode range RegExp generator
Unicode Regular Expressions
Unicode 10.0 Character Code Charts
Match Unicode Block Range
正如其他答案中提到的，JavaScript 正则表达式不支持 Unicode 字符类。 然而，有一个库确实提供了这一点：Steven Levithan 出色的 XRegExp 及其 Unicode 插件。
As mentioned in other answers, JavaScript regexes have no support for Unicode character classes. However, there is a library that does provide this: Steven Levithan's excellent XRegExp and its Unicode plug-in.
在 JavaScript 中，\w 和 \d 是 ASCII，而 \s 是 Unicode。 别问我为什么。 JavaScript 确实支持带有 Unicode 类别的 \p，您可以使用它来模拟支持 Unicode 的 \w 和 \d。
对于 \d 使用 \p{N} （数字）
对于 \w 使用 [\p{L}\p{N}\p{Pc}\p{M}] （字母、数字、下划线、标记）
更新：不幸的是，我错了。 JavaScript 也不正式支持 \p，尽管某些实现可能仍然支持它。 JavaScript 正则表达式中唯一的 Unicode 支持是将特定代码点与 \uFFFF 进行匹配。 您可以在字符类的范围内使用它们。
In JavaScript, \w and \d are ASCII, while \s is Unicode. Don't ask me why. JavaScript does support \p with Unicode categories, which you can use to emulate a Unicode-aware \w and \d.
For \d use \p{N} (numbers)
For \w use [\p{L}\p{N}\p{Pc}\p{M}] (letters, numbers, underscores, marks)
Update: Unfortunately, I was wrong about this. JavaScript does does not officially support \p either, though some implementations may still support this. The only Unicode support in JavaScript regexes is matching specific code points with \uFFFF. You can use those in ranges in character classes.
这样就可以了：
它显式地选择一系列 unicode 字符。
它适用于拉丁字符，但其他奇怪的字符可能超出此范围。
This will do it:
It explicitly selects a range of unicode characters.
It will work for latin characters, but other strange characters may be out of this range.
如果您使用 Babel 则 Unicode 支持 已经可用。
我还发布了一个插件，可以转换源代码，以便您可以编写正则表达式，例如
/^\p{L}+$/。 然后这些将被转换成浏览器可以理解的东西。这是插件的项目页面：
babel-plugin-utf- 8-正则表达式
If you are using Babel then Unicode support is already available.
I also released a plugin which transforms your source code such that you can write regular expressions like
/^\p{L}+$/. These will then be transformed into something that browsers understand.Here is the project page of the plugin:
babel-plugin-utf-8-regex
我来回答这个问题
相当于什么js 的 regExp 中的 \p{Lu} 或 \p{Ll} ？
因为它被标记为当前旧问题的精确重复。
查询 Unicode 12 的 UCD 数据库，\p{Lu} 生成 1,788 个代码点。
转换为 UTF-16 会产生等效的类构造。
它只是一个 4k 字符串，并且可以在任何正则表达式引擎中轻松实现。
查询 Unicode 12 的 UCD 数据库，\p{Ll} 生成 2,151 个代码点。
转换为 UTF-16 会产生等效的类构造。
请注意，\p{Lu} 或 \p{Pl} 的正则表达式实现实际上调用了
用于测试值的非标准函数。
此处显示的字符类的处理方式不同，并且是线性的、标准的
当挤进一个班级时，速度相当慢。
关于正则表达式引擎（通常）如何实现 Unicode 属性类的一些见解：
检查属性之间的这些性能特征
和班级块（如上）
哇，有什么不同！
让我们看看如何实现属性
指针数组 [ 10FFFF ]，其中每个索引都是一个代码点
数组中的每个指针都指向一个分类结构。
分类结构包含固定字段元素。
有些是 NULL 并且不相关。
有些包含类别分类。
示例：一般类别
这是一个位图元素，使用 64 位中的 17 位。
无论此代码点支持什么，都将位设置为掩码。
-Close_标点符号
-连接器_标点符号
-控制
-货币_符号
-Dash_标点符号
-Decimal_Number
-Enclosure_Mark
-Final_标点符号
-格式
-初始标点符号
-字母_编号
-Line_Separator
-小写_字母
-数学符号
-Modifier_Letter
-Modifier_Symbol
-Nonspacing_Mark
-Open_标点符号
-其他_信件
-其他_号码
-其他_标点符号
-其他_符号
-段落_分隔符
-私人_使用
-空格_分隔符
-Spacing_Mark
-代理人
-Titlecase_Letter
-未分配
-Uppercase_Letter
当使用类似 \p{Lu} 的内容解析正则表达式时
直接转换为
另一个示例，当使用标点符号属性 \p{P} 解析正则表达式时
被转换为
检查该元素中是否有任何这些项目位，这些位被连接到掩码中：
-Close_标点符号
-连接器_标点符号
-Dash_标点符号
-Final_标点符号
-初始标点符号
-Open_标点符号
-Other_Punctuation
偏移量和位或位（掩码）存储为该属性的正则表达式步骤。
使用此数组为所有 Unicode 代码点创建一次查找表。
当检查一个字符时，就像使用 CP 作为索引一样简单
该数组并检查该位（掩码）的分类结构的特定元素。
该结构是可扩展的和间接的，以提供更复杂的查找。 这只是一个简单的例子。
将直接查找与字符类搜索进行比较：
所有类都是从左到右搜索的项目的线性列表。
在此比较中，假设我们的目标字符串仅包含完整的
仅大写 Unicode 字母，平均定律将预测
类中一半的项目必须进行范围检查
找到匹配的。
这在性能上是一个巨大的劣势。
但是，如果查找表不存在或不是最新的
使用最新的 Unicode 版本（截至目前有 12 个）
那么这将是唯一的方法。
事实上，这基本上是获得完整表情符号的唯一方法
字符，因为它们的分配没有特定的属性（或推理）。
I'm answering this question
What would be the equivalent for \p{Lu} or \p{Ll} in regExp for js?
since it was marked as an exact duplicate of the current old question.
Querying the UCD Database of Unicode 12, \p{Lu} generates 1,788 code points.
Converting to UTF-16 yields the class construct equivalency.
It's only a 4k character string and is easily doable in any regex engines.
Querying the UCD database of Unicode 12, \p{Ll} generates 2,151 code points.
Converting to UTF-16 yields the class construct equivalency.
Note that a regex implementation of \p{Lu} or \p{Pl} actually calls a
non standard function to test the value.
The character classes shown here are done differently and are linear, standard
and pretty slow, when jammed into mostly a single class.
Some insight on how a Regex engine (in general) implements Unicode Property Classes:
Examine these performance characteristics between the property
and the class block (like above)
Wow what a difference !!
Lets see how Properties might be implemented
Array of Pointers [ 10FFFF ] where each index is is a Code Point
Each pointer in the Array is to a structure of classification.
A Classification structure contains fixed field elemets.
Some are NULL and do not pertain.
Some contain category classifications.
Example : General Category
This is a bitmapped element that uses 17 out of 64 bits.
Whatever this Code Point supports has bit(s) set as a mask.
-Close_Punctuation
-Connector_Punctuation
-Control
-Currency_Symbol
-Dash_Punctuation
-Decimal_Number
-Enclosing_Mark
-Final_Punctuation
-Format
-Initial_Punctuation
-Letter_Number
-Line_Separator
-Lowercase_Letter
-Math_Symbol
-Modifier_Letter
-Modifier_Symbol
-Nonspacing_Mark
-Open_Punctuation
-Other_Letter
-Other_Number
-Other_Punctuation
-Other_Symbol
-Paragraph_Separator
-Private_Use
-Space_Separator
-Spacing_Mark
-Surrogate
-Titlecase_Letter
-Unassigned
-Uppercase_Letter
When a regex is parsed with something like this \p{Lu} it
is translated directly into
Another example, when a regex is parsed with punctuation property \p{P} it
is translated into
A check of that element for any of these items bits, which are joined into a mask :
-Close_Punctuation
-Connector_Punctuation
-Dash_Punctuation
-Final_Punctuation
-Initial_Punctuation
-Open_Punctuation
-Other_Punctuation
The offset and bit or bit(mask) are stored as a regex step for that property.
The lookup table is created once for all Unicode Code Points using this array.
When a character is checked, it is as simple as using the CP as an index into
this array and checking the Classification Structure's specific element for that bit(mask).
This structure is expandable and indirect to provide much more complex look ups. This is just a simple example.
Compare that direct lookup with a character class search :
All classes are a linear list of items searched from left to right.
In this comparison, given our target string contains only the complete
Upper Case Unicode Letters only, the law of averages would predict that
half of the items in the class would have to be ranged checked
to find a match.
This is a huge disadvantage in performance.
However, if the lookup tables are not there or are not up to date
with the latest Unicode release (12 as of this date)
then this would be the only way.
In fact, it is mostly the only way to get the complete Emoji
characters as there is no specific property (or reasoning) to their assignment.
您还可以使用：
You can also use: