一、主要的类型与对象之间的关系：

WPS JSA 宏代码：1.按命名的正则或字符集提取文本 - 图1

二、自定义的公式函数（应用）

  1. /*提取文本中连续匹配指定的字符集 N-M 次之间的第 x 个匹配到的连续字符串
  2. from : 文本或单元格，非文本会被自动转换成文本
  3. token : 提取第几个这种连续字符串，必须是正整数
  4. charSetRules : [NamedCharSet_Name1[, reverse1], 
  5.     NamedCharSet_Name2[,reverse2], ....]
  6. NamedCharSet_Name1/2/.../N : 第 N 个命名字符集的名称
  7. reverse1/2/.../N : 与上面字符集名称一一对应的字符集是否反转的描述，它们为
  8.     true 时，它对应的字符集将被反转后，再进行匹配；如果省略，一律设为 false，
  9.     即不反转字符集
  10. return : String，提取到的文本*/
  11. function GetMatchByNamedCharSet(from, token,
  12.     minTimes, maxTimes, ...charSetRules) {
  13.     {//0.检验并处理参数
  14.         //0.1.检验并处理 from 参数
  15.         if (typeof from != 'string') {
  16.             if (Object.prototype.toString.call(from)
  17.                 .slice(8, -1) === 'Range')
  18.                 from = from.Value().toString();
  19.             else
  20.                 from = from.toString();
  21.         }
  22.         if (from.length === 0) return '';
  24.         //0.2.检验并处理 token 参数
  25.         if (token === undefined) token = 1;
  26.         if (typeof token != 'number' || Math.trunc(token) <= 0) 
  27.             throw new Error('参数 token 必须是正整数');
  28.         else
  29.             token = Math.trunc(token);
  31.         //0.3.检验并处理 charSetRules 参数
  32.         //0.3.1.至少应该含有一个元素
  33.         let isArgCharSetRulesOkey = charSetRules.length > 0;
  34.         //0.3.2.只允许包含 String/Boolean 元素
  35.         isArgCharSetRulesOkey = isArgCharSetRulesOkey &&
  36.             charSetRules.every(x => 
  37.                 typeof x === 'boolean' ||
  38.                 typeof x === 'string');
  39.         //0.3.3.第一个元素不能是 Boolean 值
  40.         isArgCharSetRulesOkey = isArgCharSetRulesOkey &&
  41.             typeof charSetRules[0] !== 'boolean';
  42.         //0.3.4.不能连续有两个 Boolean 值
  43.         isArgCharSetRulesOkey = isArgCharSetRulesOkey &&
  44.             !charSetRules.some((x, idx) => 
  45.                 typeof x === 'boolean' &&
  46.                 typeof charSetRules[idx + 1] === 'boolean');
  47.         //0.3.5.每一个名称，都必须是已经存在的
  48.         var charSets = charSetRules.filter(x => typeof x === 'string')
  49.             .map((name, idx) => [name, idx, g.NamedCharSets.Get(name)]);
  50.         let badNames = charSets.filter(item => item[2] === undefined)
  51.             .map(item => item[0]);
  52.         let hasBadName = badNames.length !== 0;
  54.         if (!isArgCharSetRulesOkey) 
  55.             throw new Error('参数 charSetRules 必须形如：' +
  56.                 '[NamedCharSet_Name1[, reverse1], ' +
  57.                 'NamedCharSet_Name2[,reverse2], ....]');
  58.         if (hasBadName) {
  59.             let msg = badNames.join('”, “');
  60.             msg = `“${msg}” 这些名称不是已有的命名字符集的名称。\n` +
  61.                 `支持的命名字符集名称如下（每行是一个字符集）：\n` +
  62.                 g.NamedCharSets.AllNames + '\n请仅使用如上已有的名称';
  63.             throw new Error(msg);
  64.         }
  65.     }
  67.     //1.将 charSetRules 中的名称转换成对应的对象
  68.     charSets.forEach(item => charSetRules[item[1]] = item[2]);
  70.     //2.按规则取得总的正则表达式对象
  71.     let re = NamedCharSet.Combine(
  72.         minTimes, maxTimes, ...charSetRules);
  73.     re = new RegExp(re.source, 'g');
  75.     //3.取得需要的匹配
  76.     let matches = [...Array(token).keys()]
  77.         .map(i => re.exec(from));
  79.     //4.按情况返回提取到的目标文本
  80.     let match = matches[token - 1];
  81.     if (match === null) return '';
  82.     else return match[0];
  83. }
  85. /*按已命名的正则表达式提取从文本或单元格值中提取匹配的文本
  86. from : 文本或单元格，非文本会被自动转换成文本
  87. regExpName : 要使用的命名的正则表达式的名称
  88. return : String, 匹配到的文本*/
  89. function GetMatchByNamedRegExp(from, token, regExpName) {
  90.     {//0.检验并处理参数
  91.         //0.1.检验并处理 from 参数
  92.         if (typeof from != 'string') {
  93.             if (Object.prototype.toString.call(from)
  94.                 .slice(8, -1) === 'Range')
  95.                 from = from.Value().toString();
  96.             else
  97.                 from = from.toString();
  98.         }
  99.         if (from.length === 0) return '';
  101.         //0.2.检验并处理 regExpName 参数
  102.         if (typeof regExpName !== 'string')
  103.             throw new TypeError('参数 regExpName 必须是一个 String 对象');
  104.         var nre = g.NamedRegExps.Get(regExpName);
  105.         if (nre === undefined)
  106.             throw new Error(`名为[${regExpName}]的命名正则表达式不存在。\n` +
  107.                 `您可以使用的命名正则表达式名称如下：\n${g.NamedRegExps.AllNames}`);
  109.         //0.3.检验并处理 token 参数
  110.         if (token === undefined) token = 1;
  111.         if (typeof token != 'number' || Math.trunc(token) <= 0) 
  112.             throw new Error('参数 token 必须是正整数');
  113.         else
  114.             token = Math.trunc(token);
  115.     }
  117.     //1.按规则取得总的正则表达式对象
  118.     let re = new RegExp(nre.Expression, 'g');
  120.     //2.取得需要的匹配
  121.     let matches = [...Array(token).keys()]
  122.         .map(i => re.exec(from));
  124.     //3.按情况返回提取到的目标文本
  125.     let match = matches[token - 1];
  126.     if (match === null) return '';
  127.     else return match[0];
  128. }

应用示例：

样本 产生的值 使用的公式
he is 24, and 65kg weight. 65 ‘=GetMatchByNamedCharSet(A1,2,0,0,”数字”)
he said: “中国，你好” 你好 ‘=GetMatchByNamedCharSet(A2,2,0,0,”中文”)
he said: “中国666，中文666” 中文666 ‘=GetMatchByNamedCharSet(A3,2,0,0,”数字”,”中文”)
he has two email:”1234@qq.com” and “hero666@sina.com hero666@sina.com ‘=GetMatchByNamedRegExp(A4,2,”邮箱”)
The life of sun is about 10 billion years,his weight is 1.98892E30 kg. 1.98892E30 ‘=GetMatchByNamedRegExp(A5,2,”数字”)

三、依赖的类型

  1. class NamedObject {
  2.     constructor(...names) {
  3.         if (!(names.length >= 1 && names.every(n => typeof n === 'string')))
  4.             throw new TypeError('Parameter "names" must be a string ' +
  5.                 'array, and its length must great than 0.');
  6.         this.Names = names;        
  7.     }
  9.     /*判断当前对象是否拥有指定的名称
  10.     name : String, 必选，要决断是否存在的名称
  11.     return : Boolean，指示是否存在给定的名称，存在则为 true，否则为 false*/
  12.     HasName(name) {
  13.         name = name.toUpperCase();
  14.         return this.Names.some(n => n.toUpperCase() === name);
  15.     }
  17.     /*为对象添加指定的名称
  18.     names : String[]，必选，要添加的名称*/
  19.     AddName(...names) {
  20.         if (names.length === 0) return;
  21.         if (names.some(n => typeof n !== 'string'))
  22.             throw new TypeError('Parameter "names" must be ' +
  23.                 'a string array.');
  25.         names.forEach(name => {
  26.             let upper = name.toUpperCase();
  27.             let exist = this.Names.some(n =>
  28.                 n.toUpperCase() === upper);
  29.             if (!exist) this.Names.push(name);
  30.         });
  31.     }
  33.     /*为对象删除指定的名称
  34.     names : String[]，必选，要删除的名称*/
  35.     RemoveName(...names) {
  36.         if (names.length === 0) return;
  37.         if (names.some(n => typeof n !== 'string'))
  38.             throw new TypeError('Parameter "names" must be ' +
  39.                 'a string array.');    
  41.         let indices = names.map(name => {
  42.             let upper = name.toUpperCase();
  43.             let index = this.Names.findIndex(n => 
  44.                 n.toUpperCase() === upper);
  45.             if (index === -1)
  46.                 throw new Error(`名称【${name}】不存在，删除失败`);
  47.             return index;
  48.         });
  50.         indices.reverse()
  51.             .forEach(idx => this.Names.splice(idx, 1));
  52.     }
  54.     /*获取对象的名称数量*/
  55.     get NameCount() {
  56.         return this.Names.length;
  57.     }
  59.     toString() {
  60.         return this.Names.join(',');
  61.     }
  62. }
  64. class NamedObjectCollection {
  65.     Get(name) {
  66.         /*在当前集合中查找具有指定名称的命名对象
  67.         name : String, 必选，要查找的命名对象的名称
  68.         return : NamedCharSet/undefined，查找到的命名对象，如果
  69.                  未找到，则会返回 undefined*/
  70.         return Object.keys(this)
  71.             .map(key => this[key])
  72.             .filter(x => x.constructor !== Function.prototype.constructor)
  73.             .find(x => x.HasName(name));
  74.     }
  76.     get AllNames() {
  77.         /*取得支持的所有名称*/
  78.         return Object.keys(this)
  79.             .map(key => this[key])
  80.             .filter(x => x.constructor !== Function.prototype.constructor)
  81.             .map(obj => NamedObject.prototype.toString.call(obj))
  82.             .join('\n');            
  83.     }    
  84. }
  86. /*命名的字符集正则*/
  87. class NamedCharSet extends NamedObject {
  88.     constructor(expr, ...names) {
  89.         super(...names);
  90.         if (typeof expr != 'string')
  91.             throw new TypeError('Parameter "expr" must be a String object.');
  93.         this.Expression = expr;
  94.     }
  96.     /*以此字符集匹配规则为基础，获取匹配指定次数的正则表达式
  97.     minTimes : 最小匹配次数；undefined/number，必须不小于 0
  98.     maxTimes : 最大匹配次数；undefined/number，必须不小于 0
  99.     reverse : Boolean，可选，默认为 false，为 true 时会反转本字符集
  100.     return : RegExp，一个以此正则表达式为基础，指定了匹配次数范围的正则表达式对象；
  101.     */
  102.     ToContinuous(minTimes, maxTimes, reverse = false) {
  103.         let boundRule = NamedCharSet
  104.             .ProcessBounds(minTimes, maxTimes);
  106.         let reStr, re;
  107.         if (boundRule === '') {
  108.             if (reverse)
  109.                 return new RegExp(this.Reverse());
  110.             else 
  111.                 return this.valueOf();
  112.         } else {
  113.             if (reverse)
  114.                 reStr = this.Reverse();
  115.             else
  116.                 reStr = this.toString();
  117.             reStr += boundRule;
  119.             return new RegExp(reStr);
  120.         }
  121.     }
  123.     /*处理字符集匹配时的上下限
  124.     minTimes : Number, 可选，匹配最低次数
  125.     maxTimes : Number，可选，匹配最多次数
  126.     return : Number[]，形式是 [minTimes, maxTimes]*/
  127.     static ProcessBounds(minTimes, maxTimes) {
  128.         if (minTimes === undefined && maxTimes === undefined) return '';
  130.         if (minTimes === undefined)
  131.             minTimes = 0;
  132.         else if(typeof minTimes === 'number' && 
  133.             Math.trunc(minTimes) >= 0)
  134.             minTimes = Math.trunc(minTimes);
  135.         else
  136.             throw new Error('Parameter "minTimes" can be default, '+
  137.                 'otherwise must be a number, and great or equal then 0.');
  139.         let noMaxTimes = maxTimes === undefined;
  140.         if (noMaxTimes)
  141.             maxTimes = 0;
  142.         else if(typeof maxTimes === 'number' && 
  143.             Math.trunc(maxTimes) >= 0)
  144.             maxTimes = Math.trunc(maxTimes);
  145.         else
  146.             throw new Error('Parameter "maxTimes" can be default, '+
  147.                 'otherwise must be a number, and great or equal then 0.');
  149.         if (minTimes === 0 && maxTimes === 0) return '';
  151.         if (maxTimes === 0) maxTimes = '';
  152.         if (minTimes === 0) minTimes = '';
  154.         return `{${minTimes},${maxTimes}}`;        
  155.     }
  157.     /*将当前字符集匹配规则，与其它的字符集匹配规则拼接起来
  158.     minTimes : Number, 可选，匹配最低次数
  159.     maxTimes : Number，可选，匹配最多次数
  160.     other : [NamedCharSet1 [, reverse1], NamedCharSet2[, reverse2],...]
  161.             就是要追加的另一些 NamedCharSet 对象，及其是否反转的描述
  162.     reverse : Boolean，可选，默认为 false，为 true 时会反转本字符集
  163.     return : 合并后的正则表达式*/
  164.     CombineWith(minTimes, maxTimes, reverse = false, ...other) {
  165.         other.unshift(this, reverse);
  167.         return NamedCharSet.Combine(minTimes, maxTimes, ...other);
  168.     }
  170.     /*将当前字符集匹配规则，与其它的字符集匹配规则拼接起来
  171.     minTimes : Number, 可选，匹配最低次数
  172.     maxTimes : Number，可选，匹配最多次数
  173.     rules : [NamedCharSet1[, reverse1], NamedCharSet2[, reverse2], ...]
  174.             就是要合并的一些 NamedCharSet 对象，及其是否反转的设定
  175.     return : RegExp，合并后的正则表达式对象*/
  176.     static Combine(minTimes, maxTimes, ...rules) {    
  177.         {//0.检验参数 rules 的合法性
  178.             //0.1.必须最少有一个元素
  179.             let isArgRulesOkey = rules.length > 0;
  181.             //0.2.所有元素要么是 Boolean，要么是 NamedCharSet 对象
  182.             isArgRulesOkey = isArgRulesOkey && rules.every(x => 
  183.                 x.constructor === NamedCharSet.prototype
  184.                     .constructor || typeof x === 'boolean');
  186.             //0.3.第一个元素不能是 Boolean 值
  187.             isArgRulesOkey = isArgRulesOkey && 
  188.                 typeof rules[0] !== 'boolean';
  190.             //0.4.不能有连续的 Boolean 元素
  191.             isArgRulesOkey = isArgRulesOkey && !rules
  192.                 .some((x, idx) => typeof x == 'boolean' &&
  193.                     typeof rules[idx + 1] == 'boolean');
  195.             //0.5.如果参数不合法，报错并反馈信息    
  196.             if (!isArgRulesOkey)
  197.                 throw new TypeError('Parameter "rules" must be like ' +
  198.                     '[NamedCharSet1[, reverse1], NamedCharSet2[, reverse2], ...].');
  199.         }
  201.         //1.整理所有的字符集规则
  202.         rules = rules.reduce((items, cur) => {
  203.             let last = items[items.length - 1];
  204.             if (typeof cur != typeof last)
  205.                 items.push(cur);
  206.             else 
  207.                 items.push(false, cur);
  208.             return items;
  209.         }, []);
  211.         //2.按需要为最后一个规则增加是否反转的描述
  212.         if (typeof rules[rules.length - 1] != 'boolean')
  213.             rules.push(false);
  215.         //3.将所有的字符集规则，转换成成对的规则
  216.         rules = [...new Array(Math.trunc(rules.length / 2)).keys()]
  217.             .map(idx => [rules[idx * 2], rules[idx * 2 + 1]]);
  219.         //4.取得所有的字符集规则合并后的正则表达式的字符串
  220.         let rulesExpression;
  221.         if (rules.length === 1) {
  222.             let [ncs, reverse] = rules[0];    
  223.             if (reverse)
  224.                 rulesExpression = ncs.Reverse();
  225.             else
  226.                 rulesExpression = ncs.toString();
  227.         } else {
  228.             rulesExpression = rules.map(rule => {
  229.                     if (rule[1]) return rule[0].Reverse();
  230.                     else return rule[0].toString();
  231.                 }).join('|');
  232.             //最后的表达式形如：(charSet1|charSet2|...)
  233.             rulesExpression = `(${rulesExpression})`;
  234.         }
  236.         //5.取得限定匹配次数上下限的正则表达式字符串
  237.         let boundRule = NamedCharSet
  238.             .ProcessBounds(minTimes, maxTimes);
  240.         if (boundRule === '') boundRule = '+';
  241.         return new RegExp(rulesExpression + boundRule);
  242.     }
  244.     //反转字符集
  245.     Reverse() {
  246.         if (this.Expression.startsWith('^'))
  247.             return this.Expression.substr(1);
  248.         else
  249.             return `[^${this.Expression}]`;
  250.     }
  252.     toString() {
  253.         return `[${this.Expression}]`;
  254.     }
  256.     valueOf() {
  257.         return new RegExp(this.toString());
  258.     }
  259. }
  261. /*命名的功能正则表达式：面向各种固定格式字符串的正则规则*/
  262. class NamedRegExp extends NamedObject {
  263.     constructor(expr, ...names) {
  264.         super(...names);
  265.         if (typeof expr != 'string')
  266.             throw new TypeError('Parameter "expr" must be a String object.');
  268.         this.Expression = expr;
  269.     }
  271.     //转换成匹配首尾的正则表达式
  272.     ToWholeMode() {
  273.         return new RegExp(`^${this.Expression}$`);
  274.     }
  276.     //取得当前正则表达式的表达式字符串
  277.     toString() {
  278.         return this.Expression;
  279.     }
  281.     //取得当前正则表达式的正则对象
  282.     valueOf() {
  283.         return new RegExp(this.toString());
  284.     }    
  285. }

四、依赖的对象

  1. const g = {
  2.     NamedCharSets : {
  3.         Chinese : new NamedCharSet(
  4.             '\\u4e00-\\u9fbc', '汉语', '中文', '汉字', 
  5.             'zh-cn', '中国字', 'cn', 'zh'),
  6.         Number : new NamedCharSet(
  7.             '\\d', '数字', '整数', '数', '数符', '阿拉伯数字',
  8.             'Number', 'Integer', 'int', 'NumberChar'),
  9.         BigLetter : new NamedCharSet(
  10.             'A-Z', '大写字母', 'Capital', 'CapitalLetter',
  11.             'BigLetter', 'LargeLetter', 'UpperCase'),
  12.         SmallLetter : new NamedCharSet(
  13.             'a-z', '小写字母', 'SmallLetter', 'Minuscule',
  14.             'LowerCase'),
  15.         Letter : new NamedCharSet('a-zA-Z',
  16.             '字母', 'Letter', 'Alpha'),
  17.         NumberAndLetter : new NamedCharSet(
  18.             'a-zA-Z0-9', 'Number_Letter', 'numberandletter',
  19.             'number and letter'),
  20.         NumberAndLeterAndUnderline : new NamedCharSet(
  21.             'a-zA-Z0-9_', '字母数字下划线', '标识符', 'Number and Letter and underline',
  22.             'NumberAndLetterAndUnderline', 'Number_Letter_Underline'),
  23.         WhiteSpace : new NamedCharSet('\s', 
  24.             '空白字符', 'white space', 'WhiteSpace'),
  25.     },
  27.     NamedRegExps : {
  28.         //数字：支持正数、负数、科学计数
  29.         Number: new NamedRegExp('(\\+|-|)\\d+(\\.\\d+)?((e|E)(\\+|-|)\\d+)?',
  30.             '数字', 'Number'),
  32.         // Email地址：
  33.         Email: new NamedRegExp('\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*',
  34.             '邮箱', '邮箱地址', '电子邮件', '电子邮件地址', '电子邮箱',
  35.             '电子邮箱地址', 'Email', 'email address'),
  37.         // 护照：
  38.         Passport: new NamedRegExp('1[45][0-9]{7}|G[0-9]{8}|P[0-9]{7}|S[0-9]{7,8}|D[0-9]+',
  39.             '护照', '护照号码', 'Passport', 'Passport Number'),
  41.         // 手机号码：
  42.         Mobile: new NamedRegExp('1[345789]\\d{9}', '手机号', '手机号码', 'Mobile',
  43.             'Mobile Number'),
  45.         // 座机号码:
  46.         Telephone: new NamedRegExp('0\\d{2,3}-\\d{5,9}|0\\d{2,3}-\\d{5,9}',
  47.             '固定电话', '座机', '电话号码', '座机号', 'Telephone', 'Telephone Number'),
  49.         // 身份证号(15位、18位数字)：
  50.         IdCard: new NamedRegExp('([1-9]\\d{7}((0\\d)|(1[0-2]))(([0|1|2]\\d)|' +
  51.             '3[0-1])\\d{3})|([1-9]\\d{5}[1-9]\\d{3}((0\\d)|(1[0-2]))(([0|1|2' +
  52.             ']\\d)|3[0-1])((\\d{4})|\\d{3}[Xx]))', '身份证', '身份证号', 'IdCard', 
  53.             'Id', 'Id card', 'id card number'),
  54.         // 日期： 2017-1-1或2017/1/1
  55.         Date: new NamedRegExp('\\d{4}(-|\\/)\\d{1,2}(-|\\/)\\d{1,2}', '日期', 'Date'),
  57.         // 时间： 10:00:00
  58.         Time: new NamedRegExp('(0?\d|1\d|2[0-3]):(0?\d|[1-5]\d):(0?\d|[1-5]\d)',
  59.             '时间', 'Time'),
  61.         // 日期+时间： 2017-1-1 10:00:00
  62.         DateTime: new NamedRegExp('\d{4}(-|\/)\d{1,2}(-|\/)\d{1,2}\s([01]?\d|2[0-3]):[0-5]?\d:[0-5]?\d',
  63.             '日期时间', 'datetime', 'date and time', '日期和时间'), 
  65.         //腾讯QQ号：
  66.         QQ: new NamedRegExp('[1-9][0-9]{4,}', 'QQ', 'QQ号', 'QQ号码'),
  68.         //中国邮政编码：
  69.         Postcode: new NamedRegExp('[1-9]\\d{5}(?!\\d)',
  70.             '邮政编码', '邮编', '邮编号码', 'Postcode'),
  72.         //IP地址：
  73.         IPv4: new NamedRegExp('\\d+\\.\\d+\\.\\d+\\.\\d+', 'IPv4', 'IPv4地址'),
  75.         //域名：
  76.         URL: new NamedRegExp('(?=^.{3,255}$)(http(s)?:\/\/)?(www\.)?' +
  77.             '[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(\.[a-zA-Z0-9][-a-zA-Z0-9]' +
  78.             '{0,62})+(:\d+)*(\/\w+\.\w+)*([\?&]\w+=\w*)*', 'URL', '域名'),
  80.         // 车牌:
  81.         CarNumber: new NamedRegExp('[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣' +
  82.             '鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}[A-Z0-9' +
  83.             ']{4}[A-Z0-9挂学警港澳]{1}', '车牌', '车牌号', 'CarNumber',
  84.             'Car Number', 'license plate number', 'license plate'),
  86.         //银行卡：
  87.         BankCardNumber: new NamedRegExp('[1-9]{1}(\d{15}|\d{18})',
  88.             '银行卡号', 'Bank card number', 'BankCardNumber'),
  89.     },
  90. };
  91. //为一些属性对象重置原型，通过这种方式为其附加一些有用的方法和属性
  92. Object.setPrototypeOf(g.NamedCharSets, NamedObjectCollection.prototype);
  93. Object.setPrototypeOf(g.NamedRegExps, NamedObjectCollection.prototype);