JavaScript 正则表达式处理json，json对象的遍历和处理

//***** https://www.runoob.com/js/js-regexp.html //

```
 正则表达式.exec(  )
```

  new RegExp("\\{" + i + "\\}", "gm");               g是全局匹配   m表示匹配到的式子后面可以有n位字符

// 正则表达式实时测试是否正确 ***//

不同的环境下正则表达式的一些细节是不相同的，这里介绍两种可用的测试工具：
RegexBuddy http://www.regexbuddy.com/
Javascript正则表达式在线测试工具 https://c.runoob.com/front-end/854

测试

例如 ret.proto 协议文件
syntax = “proto3”;
option go_package = “app/protos/out/ret”;
package ret;
enum RET {
/*********************************/
//以下同cg.proto中RET一致禁止修改
ERROR = 0;
OK = 1;
SERVER_MAINTAIN = 2; //服务器维护中
USER_NOT_EXIST = 3; //玩家不存在
USER_NAME_REPEAT = 4; //创角时，角色名字重复
LOGIN_REPEAT = 5; //重复登录
//以上同cg.proto中RET一致禁止修改
/*********************************/

// service自身错误码从101开始
SERVER_BUSY = 101; //服务器繁忙
SERVER_ERROR = 102; //服务器异常
USER_ACCOUNT_EXISTS = 107; //账号已存在
NOT_ENOUGH_RESOURCES = 108; //资源不够
}

被generate.js的正则表达式处理
let regProto = /(\w+)\s*=\s*(\d+)\s*;\s*(//.+)?/g
let retsProtoDict = {}
while ((match = regProto.exec(retProtoContent)) != null) {
// alert(match[0]+’-’+match[1]);
// console.log(match[1], match[2], match[3])
retsProtoDict[match[1]] = { id: match[2], name: match[1], comment: match[3], lang: “” }
}
match = regProto.exec(retProtoContent 的match就是表达式执行之后的每一行的对象
SERVER_BUSY = 101; //服务器繁忙
SERVER_ERROR = 102; //服务器异常
match[1] 就是每一行对象的第一个属性，在此表示 SERVER_BUSY ，SERVER_BUSY等等
match[2] 就是每一行对象的第二个属性，在此表示 101 ，102 等等
match[2] 就是每一行对象的第三个属性，在此表示 //服务器繁忙，//服务器异常

// 实例讲解验证 ***//

其中 let regProto = /(\w+)\s*=\s*(\d+)\s*;\s*(//.+)?/g 表示
\w+ = \d+ ； // 注释的语句 ?表示可有可无 g表示全局匹配
字符 = 数字； // 注释的语句
对照上面的就是 SERVER_MAINTAIN = 2 ; //服务器维护中
对照上面的就是 USER_NOT_EXIST = 3 ; //玩家不存在
对照上面的就是 SERVER_BUSY = 101 ; //服务器繁忙

\s 表示（） = () ; // 中有 /s 的位置的地方都允许有空格

表示任意字符

语法
/正则表达式主体/修饰符(可选)
其中修饰符是可选的。

实例：
var patt = /runoob/i
实例解析：
/runoob/i 是一个正则表达式。
runoob 是一个正则表达式主体 (用于检索)。
i 是一个修饰符 (搜索不区分大小写)。

//*** js 正则表达式转驼峰*//

使用字符串方法
在 JavaScript 中，正则表达式通常用于两个字符串方法 : search() 和 replace()。
search() 方法用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串，并返回子串的起始位置。
replace() 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。

let regProto = /(\w+)\s*=\s*(\d+)\s*;\s*(//.+)?/g

let retsProtoDict = {}
while ((match = regProto.exec(retProtoContent)) != null) {// alert(match[0]+'-'+match[1]);// console.log(match[1], match[2], match[3])retsProtoDict[match[1]] = { id: match[2], name: match[1], comment: match[3], lang: "" }
}

红框内是表达式主题，
g 是修饰符 g在js正则表达式中是全局匹配

使用 test()
test() 方法是一个正则表达式方法。
test() 方法用于检测一个字符串是否匹配某个模式，如果字符串中含有匹配的文本，则返回 true，否则返回 false。
以下实例用于搜索字符串中的字符 “e”：
实例
var patt = /e/;
patt.test(“The best things in life are free!”);

使用 exec()
exec() 方法是一个正则表达式方法。
exec() 方法用于检索字符串中的正则表达式的匹配。
该函数返回一个数组，其中存放匹配的结果。如果未找到匹配，则返回值为 null。
以下实例用于搜索字符串中的字母 “e”:
实例 1
/e/.exec(“The best things in life are free!”);
字符串中含有 “e”，所以该实例输出为:
e

//正则表达式模式***********//

//******************************* 方括号用于查找某个范围内的字符： ******************************************//
表达式描述
[abc] 查找方括号之间的任何字符。
[0-9] 查找任何从 0 至 9 的数字。
(x|y) 查找任何以 | 分隔的选项。
{m} 表示 \d 或 [0-9] 后面的数字有m位
{m,n} 表示 \d 或 [0-9] 后面的数字有 m 到 n 位
（）子表达式

//******************************* 元字符是拥有特殊含义的字符：* ******************************************//
元字符描述
\d 查找数字。\digitization \数字化
\s 查找空白字符。 \space \字符串
\b 匹配单词边界。\boundary \边界
\uxxxx 查找以十六进制数 xxxx 规定的 Unicode 字符。

//******************************* 元字符* *************************************//
现在你已经知道几个很有用的元字符了，
如\b,.,，还有\d.正则表达式里还有更多的元字符，比如\s匹配任意的空白符，包括空格，制表符(Tab)，换行符，中文全角空格等。\w匹配字母或数字或下划线或汉字等。
注：对中文/汉字的特殊处理是由.Net提供的正则表达式引擎支持的，其它环境下的具体情况请查看相关文档。
下面来看看更多的例子：
\ba\w\b 匹配以字母a开头的单词——先是某个单词开始处(\b)，然后是字母a,然后是任意数量的字母或数字(\w)，最后是单词结束处(\b)。
\d+ 匹配1个或更多连续的数字。这里的+是和类似的元字符，不同的是匹配重复任意次(可能是0次)，而+则匹配重复1次或更多次。
\b\w{6}\b 匹配刚好6个字符的单词。
表1.常用的元字符
代码说明

. 匹配除换行符以外的任意字符
\w 匹配字母或数字或下划线或汉字
\s 匹配任意的空白符 \string \字符串
\d 匹配数字 \digitization \数字化
\b 匹配单词的开始或结束 \boundary \边界
^ 匹配字符串的开始(自会返回^后面得字符串类型，其他得类型都会被自动移除)
$ 匹配字符串的结束
$0 正则表达式捕获到的第0个字符
$1 正则表达式捕获到的第1个字符
$2 正则表达式捕获到的第2个字符
\1 表示前面的()执行的次数为1
\2 表示前面的()执行的次数为2

 var RegExp1 = /^(123)(456)\2$/;这个正则表达式匹配到的字符串是123456456     可以看出456执行了2次

name.replace(/([A-Z])/g, “-$1”) 假如捕获到的第一个大写字母是 A 就把 A 替换为 _A
即正则表达式捕获到什么 $1 就是什么
…
//******************************* 通配符 ***************************************//

```
 解释成任意的字符串
```

? 匹配任何包含零个或一个字符串。

匹配                 1个  或  更多   连续的字符

```
 匹配  横杠字符
```

；匹配；号字符

//******************************* 量词:* *****************************************//
n+ 匹配任何包含至少一个 n 的字符串。
n 匹配任何包含零个或多个 n 的字符串。
n? 匹配任何包含零个或一个 n 的字符串。

//******************************* 重复* ****************************************//
你已经看过了前面的,+,{2},{5,12}这几个匹配重复的方式了。下面是正则表达式中所有的限定符(指定数量的代码，例如,{5,12}等)：
表2.常用的限定符
代码/语法说明

重复零次或更多次

重复一次或更多次
? 重复零次或一次
{n} 重复n次
{n,} 重复n次或更多次
{n,m} 重复n到m次

//正则表达式30分钟入门教程***********//

//************** https://www.runoob.com/w3cnote/regular-expression-30-minutes-tutorial.html //
//******************* 分枝条件* ***************************************//
不幸的是，刚才那个表达式也能匹配010)12345678或(022-87654321这样的"不正确"的格式。要解决这个问题，我们需要用到分枝条件。正则表达式里的分枝条件指的是有几种规则，如果满足其中任意一种规则都应该当成匹配，具体方法是用|把不同的规则分隔开。听不明白？没关系，看例子：

0\d{2}-\d{8}|0\d{3}-\d{7} 表示 0\d{2}-\d{8} | 0\d{3}-\d{7} 即 0\d{2}-\d{8} 或 0\d{3}-\d{7} 两种格式
这个表达式能匹配两种以连字号分隔的电话号码：
一种是3位区号， 8位本地号(如010-12345678)，
一种是4位区号， 7位本地号(0376-2233445)。

(?0\d{2})?[- ]?\d{8}|0\d{2}[- ]?\d{8} 表示 (?0\d{2})?[- ]?\d{8} | 0\d{2}[- ]?\d{8}
这个表达式匹配3位区号的电话号码，其中区号可以用小括号括起来，也可以不用，区号与本地号间可以用连字号或空格间隔，也可以没有间隔。你可以试试用分枝条件把这个表达式扩展成也支持4位区号的。

\d{5}-\d{4}|\d{5}这个表达式用于匹配美国的邮政编码。美国邮编的规则是5位数字，或者用连字号间隔的9位数字。之所以要给出这个例子是因为它能说明一个问题：使用分枝条件时，要注意各个条件的顺序。如果你把它改成\d{5}|\d{5}-\d{4}的话，那么就只会匹配5位的邮编(以及9位邮编的前5位)。原因是匹配分枝条件时，将会从左到右地测试每个条件，如果满足了某个分枝的话，就不会去再管其它的条件了。

//******************************* 分组 ******************************************//
我们已经提到了怎么重复单个字符（直接在字符后面加上限定符就行了）；
但如果想要重复多个字符又该怎么办？
你可以用小括号来指定子表达式(也叫做分组)，然后你就可以指定这个子表达式的重复次数了，
你也可以对子表达式进行其它一些操作(后面会有介绍)。

(\d{1,3}.){3}\d{1,3}是一个简单的IP地址匹配表达式。要理解这个表达式，请按下列顺序分析它：\d{1,3}匹配1到3位的数字，(\d{1,3}.){3}匹配三位数字加上一个英文句号(这个整体也就是这个分组)重复3次，最后再加上一个一到三位的数字(\d{1,3})。

注：IP地址中每个数字都不能大于255. 经常有人问我, 01.02.03.04 这样前面带有0的数字, 是不是正确的IP地址呢? 答案是: 是的, IP 地址里的数字可以包含有前导 0 (leading zeroes).
不幸的是，它也将匹配256.300.888.999这种不可能存在的IP地址。如果能使用算术比较的话，或许能简单地解决这个问题，但是正则表达式中并不提供关于数学的任何功能，所以只能使用冗长的分组，选择，字符类来描述一个正确的IP地址：((2[0-4]\d|25[0-5]|[01]?\d\d?).){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)。

理解这个表达式的关键是理解2[0-4]\d|25[0-5]|[01]?\d\d?，这里我就不细说了，你自己应该能分析得出来它的意义。

//******************************* 反义 ******************************************//
有时需要查找不属于某个能简单定义的字符类的字符。比如想查找除了数字以外，其它任意字符都行的情况，这时需要用到反义：

表3.常用的反义代码
代码/语法说明
\W 匹配任意不是字母，数字，下划线，汉字的字符
\S 匹配任意不是空白符的字符
\D 匹配任意非数字的字符
\B 匹配不是单词开头或结束的位置
[^x] 匹配除了x以外的任意字符
[^aeiou] 匹配除了aeiou这几个字母以外的任意字符
例子：\S+匹配不包含空白符的字符串。

<a[^>]+>匹配用尖括号括起来的以a开头的字符串。

*.doc。在这里，*会被解释成任意的字符串
例如：
0\d\d-\d\d\d\d\d\d\d\d匹配这样的字符串：以0开头，然后是两个数字，然后是一个连字号"-"，最后是8个数字(也就是中国的电话号码。当然，这个例子只能匹配区号为3位的情形)。
这里的\d是个新的元字符，匹配一位数字(0，或1，或2，或……)。-不是元字符，只匹配它本身——连字符(或者减号，或者中横线，或者随你怎么称呼它)。
为了避免那么多烦人的重复，我们也可以这样写这个
表达式：0\d{2}-\d{8}。这里\d后面的{2}({8})的意思是前面\d必须连续重复匹配2次(8次)。
测试正则表达式
如果你不觉得正则表达式很难读写的话，要么你是一个天才，要么，你不是地球人。正则表达式的语法很令人头疼，即使对经常使用它的人来说也是如此。由于难于读写，容易出错，所以找一种工具对正则表达式进行测试是很有必要的。
不同的环境下正则表达式的一些细节是不相同的，这里介绍两种可用的测试工具：
RegexBuddy http://www.regexbuddy.com/
Javascript正则表达式在线测试工具 https://c.runoob.com/front-end/854

//* json对象的遍历和处理 **********//

function merge_dict(a, b) {
let c = {}
for (let item in a) { //a是json文件，是json文件 , c是一个对象接受a和b中的json对象
c[item] = a[item]
}
for (let item in b) {
c[item] = b[item]
}
return c
}

function generate_proto_ts() {
//ret enums
let rets = []
let valuesRet = retData.nested.ret.nested.RET.values
for (let val in valuesRet) {
rets.push({ name: val, value: valuesRet[val] })
}
//msg id enums
let ids = []
let valuesID = merge_dict(clData.nested.cl.nested.ID.values, cgData.nested.cg.nested.ID.values)
let smartDict = {}
let idMsgDict = {}
for (let val in valuesID) { //val 是遍历json 的每一个对象的对象名 valuesID[val]是每一行对象的对象值
let valId = valuesID[val]
// content += " " + val + " = " + valId + “,” + “\n”;
ids.push({ name: val, value: valId })
let realMsgName = val.substr(4); //在每一行得对象name中从索引为4的位置，开始抽取数组，抽取到末尾，
//返回给数组realMsgName
if (realMsgName.indexOf("_") != -1 && realMsgName.indexOf(“2”) != -1) { //-1表示索引的位置不存在！= -1表示索引位置存在
//过滤掉不带下划线的和不带2的,比如: MSG_NONE
idMsgDict[valId] = realMsgName
}

    let returnVal = ""let shortName = val.substr(8);if (val.indexOf("MSG_C2L_") == 0) {returnVal = "MSG_L2C_" + shortName;} else if (val.indexOf("MSG_C2G_") == 0) {returnVal = "MSG_G2C_" + shortName;}if (returnVal != "" && valuesID[returnVal] != null) {smartDict[valId] = valuesID[returnVal]}
}//smart id
let waits = []
for (let val in smartDict) {   waits.push({ id: val, wait: smartDict[val] })
}
//id msg dict
let id_map = []
for (let val in idMsgDict) {id_map.push({ id: val, name: idMsgDict[val] })
}
//all enums
let enums = []
for (let enumName in commonData.nested.common.nested) {let enum_one = { name: enumName, list: [] }let values = commonData.nested.common.nested[enumName].valuesfor (let val in values) {if (!val.endsWith("_S")) {enum_one.list.push({ name: val, value: values[val] })} else {// delete values[val]// 文件游戏不需要了，这里也不用去删除了}}enums.push(enum_one)
}
let data = {rets: rets,ids: ids,waits: waits,id_map: id_map,enums: enums
}
render_and_save(data, "proto.ts", PROTO_DIR + "/proto.ts")// fs.writeFileSync(RESOURCE_DIR + "/proto/common.json",  JSON.stringify(commonData,null,2))

}

元字符
描述

将下一个字符标记符、或一个向后引用、或一个八进制转义符。例如，“\n”匹配\n。“\n”匹配换行符。序列“\”匹配“\”而“(”则匹配“(”。即相当于多种编程语言中都有的“转义字符”的概念。
^
匹配输入字行首。如果设置了RegExp对象的Multiline属性，^也匹配“\n”或“\r”之后的位置。
$
匹配输入行尾。如果设置了RegExp对象的Multiline属性，$也匹配“\n”或“\r”之前的位置。
*
匹配前面的子表达式任意次。例如，zo能匹配“z”，也能匹配“zo”以及“zoo”。等价于{0,}。
+
匹配前面的子表达式一次或多次(大于等于1次）。例如，“zo+”能匹配“zo”以及“zoo”，但不能匹配“z”。+等价于{1,}。
?
匹配前面的子表达式零次或一次。例如，“do(es)?”可以匹配“do”或“does”。?等价于{0,1}。
{n}
n是一个非负整数。匹配确定的n次。例如，“o{2}”不能匹配“Bob”中的“o”，但是能匹配“food”中的两个o。
{n,}
n是一个非负整数。至少匹配n次。例如，“o{2,}”不能匹配“Bob”中的“o”，但能匹配“foooood”中的所有o。“o{1,}”等价于“o+”。“o{0,}”则等价于“o”。
{n,m}
m和n均为非负整数，其中n<=m。最少匹配n次且最多匹配m次。例如，“o{1,3}”将匹配“fooooood”中的前三个o为一组，后三个o为一组。“o{0,1}”等价于“o?”。请注意在逗号和两个数之间不能有空格。
?
当该字符紧跟在任何一个其他限制符（,+,?，{n}，{n,}，{n,m}）后面时，匹配模式是非贪婪的。非贪婪模式尽可能少地匹配所搜索的字符串，而默认的贪婪模式则尽可能多地匹配所搜索的字符串。例如，对于字符串“oooo”，“o+”将尽可能多地匹配“o”，得到结果[“oooo”]，而“o+?”将尽可能少地匹配“o”，得到结果 [‘o’, ‘o’, ‘o’, ‘o’]
.点
匹配除“\n”和"\r"之外的任何单个字符。要匹配包括“\n”和"\r"在内的任何字符，请使用像“[\s\S]”的模式。
(pattern)
匹配pattern并获取这一匹配。所获取的匹配可以从产生的Matches集合得到，在VBScript中使用SubMatches集合，在JScript中则使用$0…$9属性。要匹配圆括号字符，请使用“(”或“)”。
(?:pattern)
非获取匹配，匹配pattern但不获取匹配结果，不进行存储供以后使用。这在使用或字符“(|)”来组合一个模式的各个部分时很有用。例如“industr(?:y|ies)”就是一个比“industry|industries”更简略的表达式。
(?=pattern)
非获取匹配，正向肯定预查，在任何匹配pattern的字符串开始处匹配查找字符串，该匹配不需要获取供以后使用。例如，“Windows(?=95|98|NT|2000)”能匹配“Windows2000”中的“Windows”，但不能匹配“Windows3.1”中的“Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)
非获取匹配，正向否定预查，在任何不匹配pattern的字符串开始处匹配查找字符串，该匹配不需要获取供以后使用。例如“Windows(?!95|98|NT|2000)”能匹配“Windows3.1”中的“Windows”，但不能匹配“Windows2000”中的“Windows”。
(?<=pattern)
非获取匹配，反向肯定预查，与正向肯定预查类似，只是方向相反。例如，“(?<=95|98|NT|2000)Windows”能匹配“2000Windows”中的“Windows”，但不能匹配“3.1Windows”中的“Windows”。
*python的正则表达式没有完全按照正则表达式规范实现，所以一些高级特性建议使用其他语言如java、scala等
(?<!pattern)
非获取匹配，反向否定预查，与正向否定预查类似，只是方向相反。例如“(?<!95|98|NT|2000)Windows”能匹配“3.1Windows”中的“Windows”，但不能匹配“2000Windows”中的“Windows”。
*python的正则表达式没有完全按照正则表达式规范实现，所以一些高级特性建议使用其他语言如java、scala等
x|y
匹配x或y。例如，“z|food”能匹配“z”或“food”(此处请谨慎)。“[z|f]ood”则匹配“zood”或“food”。
[xyz]
字符集合。匹配所包含的任意一个字符。例如，“[abc]”可以匹配“plain”中的“a”。
[^xyz]
负值字符集合。匹配未包含的任意字符。例如，“[^abc]”可以匹配“plain”中的“plin”任一字符。
[a-z]
字符范围。匹配指定范围内的任意字符。例如，“[a-z]”可以匹配“a”到“z”范围内的任意小写字母字符。
注意:只有连字符在字符组内部时,并且出现在两个字符之间时,才能表示字符的范围; 如果出字符组的开头,则只能表示连字符本身.
[^a-z]
负值字符范围。匹配任何不在指定范围内的任意字符。例如，“[^a-z]”可以匹配任何不在“a”到“z”范围内的任意字符。
\b
匹配一个单词的边界，也就是指单词和空格间的位置（即正则表达式的“匹配”有两种概念，一种是匹配字符，一种是匹配位置，这里的\b就是匹配位置的）。例如，“er\b”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”；“\b1_”可以匹配“1_23”中的“1_”，但不能匹配“21_3”中的“1_”。
\B
匹配非单词边界。“er\B”能匹配“verb”中的“er”，但不能匹配“never”中的“er”。
\cx
匹配由x指明的控制字符。例如，\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则，将c视为一个原义的“c”字符。
\d
匹配一个数字字符。等价于[0-9]。grep 要加上-P，perl正则支持
\D
匹配一个非数字字符。等价于[^0-9]。grep要加上-P，perl正则支持
\f
匹配一个换页符。等价于\x0c和\cL。
\n
匹配一个换行符。等价于\x0a和\cJ。
\r
匹配一个回车符。等价于\x0d和\cM。
\s
匹配任何不可见字符，包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。
\S
匹配任何可见字符。等价于[^ \f\n\r\t\v]。
\t
匹配一个制表符。等价于\x09和\cI。
\v
匹配一个垂直制表符。等价于\x0b和\cK。
\w
匹配包括下划线的任何单词字符。类似但不等价于“[A-Za-z0-9_]”，这里的"单词"字符使用Unicode字符集。
\W
匹配任何非单词字符。等价于“[^A-Za-z0-9_]”。
\xn
匹配n，其中n为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，“\x41”匹配“A”。“\x041”则等价于“\x04&1”。正则表达式中可以使用ASCII编码。
\num
匹配num，其中num是一个正整数。对所获取的匹配的引用。例如，“(.)\1”匹配两个连续的相同字符。
\n
标识一个八进制转义值或一个向后引用。如果\n之前至少n个获取的子表达式，则n为向后引用。否则，如果n为八进制数字（0-7），则n为一个八进制转义值。
\nm
标识一个八进制转义值或一个向后引用。如果\nm之前至少有nm个获得子表达式，则nm为向后引用。如果\nm之前至少有n个获取，则n为一个后跟文字m的向后引用。如果前面的条件都不满足，若n和m均为八进制数字（0-7），则\nm将匹配八进制转义值nm。
\nml
如果n为八进制数字（0-7），且m和l均为八进制数字（0-7），则匹配八进制转义值nml。
\un
匹配n，其中n是一个用四个十六进制数字表示的Unicode字符。例如，\u00A9匹配版权符号（©）。
\p{P}
小写 p 是 property 的意思，表示 Unicode 属性，用于 Unicode 正表达式的前缀。中括号内的“P”表示Unicode 字符集七个字符属性之一：标点字符。
其他六个属性：
L：字母；
M：标记符号（一般不会单独出现）；
Z：分隔符（比如空格、换行等）；
S：符号（比如数学符号、货币符号等）；
N：数字（比如阿拉伯数字、罗马数字等）；
C：其他字符。
*注：此语法部分语言不支持，例：javascript。
<
>
匹配词（word）的开始（<）和结束（>）。例如正则表达式<the>能够匹配字符串"for the wise"中的"the"，但是不能匹配字符串"otherwise"中的"the"。注意：这个元字符不是所有的软件都支持的。
( )
将( 和 ) 之间的表达式定义为“组”（group），并且将匹配这个表达式的字符保存到一个临时区域（一个正则表达式中最多可以保存9个），它们可以用 \1 到\9 的符号来引用。
|
将两个匹配条件进行逻辑“或”（or）运算。例如正则表达式(him|her) 匹配"it belongs to him"和"it belongs to her"，但是不能匹配"it belongs to them."。注意：这个元字符不是所有的软件都支持的。

二、校验字符的表达式

汉字：¹{0,}$
英文和数字：²+$ 或 ³{4,40}$
长度为3-20的所有字符：^.{3,20}$
由26个英文字母组成的字符串：⁴+$
由26个大写英文字母组成的字符串：⁵+$
由26个小写英文字母组成的字符串：⁶+$
由数字和26个英文字母组成的字符串：⁷+$
由数字、26个英文字母或者下划线组成的字符串：^\w+$ 或 ^\w{3,20}$
中文、英文、数字包括下划线：⁸+$
中文、英文、数字但不包括下划线等符号：⁹+$ 或 ¹⁰{2,20}$
可以输入含有^%&’,;=?KaTeX parse error: Can't use function '\"' in math mode at position 1: \̲"̲等字符：[^%&',;=?\x22]+12 禁止输入含有_{的字符：[^}\x22]+
2E80～33FFh：中日韩符号区。收容康熙字典部首、中日韩辅助部首、注音符号、日本假名、韩文音符，中日韩的符号、标点、带圈或带括符文数字、月份，以及日本的假名组合、单位、年号、月份、日期、时间等。

3400～4DFFh：中日韩认同表意文字扩充A区，总计收容6,582个中日韩汉字。
4E00～9FFFh：中日韩认同表意文字区，总计收容20,902个中日韩汉字。
A000～A4FFh：彝族文字区，收容中国南方彝族文字和字根。
AC00～D7FFh：韩文拼音组合字区，收容以韩文音符拼成的文字。
F900～FAFFh：中日韩兼容表意文字区，总计收容302个中日韩汉字。
FB00～FFFDh：文字表现形式区，收容组合拉丁文字、希伯来文、阿拉伯文、中日韩直式标点、小符号、半角符号、全角符号等。
比如需要匹配所有中日韩非符号字符,那么正则表达式应该是¹¹+$
理论上没错, 可是我到msn.co.ko随便复制了个韩文下来, 发现根本不对, 诡异
再到msn.co.jp复制了个’お’, 也不得行…
然后把范围扩大到¹²+ , 这样倒是都通过了 , 这个应该就是匹配中日韩文字的正则表达式了 , 包括我們臺灣省還在盲目使用的繁體中文而关于中文的正则表达式 , 应该是 [ / u 4 E 00 − / u 9 F F F ] + , 这样倒是都通过了, 这个应该就是匹配中日韩文字的正则表达式了, 包括我們臺灣省還在盲目使用的繁體中文而关于中文的正则表达式, 应该是^[/u4E00-/u9FFF]+ ,这样倒是都通过了,这个应该就是匹配中日韩文字的正则表达式了,包括我們臺灣省還在盲目使用的繁體中文而关于中文的正则表达式,应该是[/u4E00−/u9FFF]+, 和论坛里常被人提起的¹³+ 很接近需要注意的是论坛里说的 [ / u 4 E 00 − / u 9 F A 5 ] + 很接近需要注意的是论坛里说的^[/u4E00-/u9FA5]+ 很接近需要注意的是论坛里说的[/u4E00−/u9FA5]+这是专门用于匹配简体中文的正则表达式, 实际上繁体字也在里面, 我用测试器测试了下’中華人民共和國’, 也通过了, 当然, ¹⁴+$也是一样的结果

\u4e00-\u9fa5 ↩︎
A-Za-z0-9 ↩︎
A-Za-z0-9 ↩︎
A-Za-z ↩︎
A-Z ↩︎
a-z ↩︎
A-Za-z0-9 ↩︎
\u4E00-\u9FA5A-Za-z0-9_ ↩︎
\u4E00-\u9FA5A-Za-z0-9 ↩︎
\u4E00-\u9FA5A-Za-z0-9 ↩︎
/u3400-/u9FFF ↩︎
/u2E80-/u9FFF ↩︎
/u4E00-/u9FA5 ↩︎
/u4E00-/u9FFF ↩︎