mm_matchs 1.1.8 → 1.1.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/index.js CHANGED
@@ -1,5 +1,5 @@
1
1
  /**
2
- * @fileOverview mm_matchs 字符串匹配原型函数
2
+ * mm_matchs 字符串匹配原型函数
3
3
  * @author <a href="http://qww.elins.cn">邱文武</a>
4
4
  * @version 1.0
5
5
  */
@@ -11,60 +11,60 @@ var dict_regex = require('./regex.js');
11
11
  * @class
12
12
  */
13
13
  var dict = {
14
- "{日期时间}": "datetime",
15
- "{日期}": "date",
16
- "{时间}": "time",
17
- // "{年}": "year",
18
- // "{月}": "month",
19
- // "{日}": "day",
20
- "{年月日}": "year_month_day",
21
- "{月日}": "month_day",
22
- "{时分秒}": "hour_minute_second",
23
- "{时分}": "hour_minute",
24
- "{时态}": "tense",
25
- "{星期}": "week",
26
- "{周期}": "cycle",
14
+ '{日期时间}': 'datetime',
15
+ '{日期}': 'date',
16
+ '{时间}': 'time',
17
+ // "{年}": "year",
18
+ // "{月}": "month",
19
+ // "{日}": "day",
20
+ '{年月日}': 'year_month_day',
21
+ '{月日}': 'month_day',
22
+ '{时分秒}': 'hour_minute_second',
23
+ '{时分}': 'hour_minute',
24
+ '{时态}': 'tense',
25
+ '{星期}': 'week',
26
+ '{周期}': 'cycle',
27
27
 
28
- "{国家}": "country",
29
- "{省份}": "province",
30
- "{城市}": "city",
31
- "{管辖区}": "district",
32
- "{方位}": "bearing",
33
- "{性别}": "gender",
34
- "{年龄}": "age",
35
- "{不对}": "wrong",
36
- "{职位}": "job",
28
+ '{国家}': 'country',
29
+ '{省份}': 'province',
30
+ '{城市}': 'city',
31
+ '{管辖区}': 'district',
32
+ '{方位}': 'bearing',
33
+ '{性别}': 'gender',
34
+ '{年龄}': 'age',
35
+ '{不对}': 'wrong',
36
+ '{职位}': 'job',
37
37
 
38
- "{网址}": "url",
39
- "{域名}": "web",
40
- "{邮箱}": "email",
41
- "{账号}": "account",
42
- "{强账号}": "strong_account",
43
- "{密码}": "password",
44
- "{强密码}": "strong_password",
38
+ '{网址}': 'url',
39
+ '{域名}': 'web',
40
+ '{邮箱}': 'email',
41
+ '{账号}': 'account',
42
+ '{强账号}': 'strong_account',
43
+ '{密码}': 'password',
44
+ '{强密码}': 'strong_password',
45
45
 
46
- "{身份证号}": "idcard",
47
- "{车牌号}": "car_number",
48
- "{邮政编码}": "post_code",
49
- "{疑问}": "question",
50
- "{颜色}": "color",
51
- "{中文}": "chinese",
52
- "{英文}": "english",
53
- "{中英文}": "chinese_english",
54
- "{中文或英文}": "chinese_or_english",
55
- "{手机号码}": "phone",
56
- "{电话号码}": "telephone",
57
- "{数字}": "digits",
58
- "{数值}": "number",
59
- "{浮点数}": "float",
46
+ '{身份证号}': 'idcard',
47
+ '{车牌号}': 'car_number',
48
+ '{邮政编码}': 'post_code',
49
+ '{疑问}': 'question',
50
+ '{颜色}': 'color',
51
+ '{中文}': 'chinese',
52
+ '{英文}': 'english',
53
+ '{中英文}': 'chinese_english',
54
+ '{中文或英文}': 'chinese_or_english',
55
+ '{手机号码}': 'phone',
56
+ '{电话号码}': 'telephone',
57
+ '{数字}': 'digits',
58
+ '{数值}': 'number',
59
+ '{浮点数}': 'float',
60
60
 
61
- "{IP}": "ip",
62
- "{QQ}": "qq",
63
- "{a标签}": "a_tag",
64
- "{img标签}": "img_tag",
65
- "{html标签}": "html_tag",
66
- "{标签之间}": "html_between",
67
- "{链接}": "href",
61
+ '{IP}': 'ip',
62
+ '{QQ}': 'qq',
63
+ '{a标签}': 'a_tag',
64
+ '{img标签}': 'img_tag',
65
+ '{html标签}': 'html_tag',
66
+ '{标签之间}': 'htmlBetween',
67
+ '{链接}': 'href',
68
68
  };
69
69
 
70
70
  /**
@@ -72,331 +72,360 @@ var dict = {
72
72
  * @class
73
73
  */
74
74
  class Matchs {
75
- /**
76
- * 匹配拓展
77
- */
78
- constructor(config) {
79
- this.dict = dict;
80
- this.dict_regex = dict_regex;
81
- }
75
+ /**
76
+ * 匹配拓展
77
+ */
78
+ constructor(config) {
79
+ this.dict = dict;
80
+ this.dict_regex = dict_regex;
81
+ }
82
82
  }
83
83
 
84
84
  /**
85
85
  * 改变格式
86
- * @param {String} str 匹配的字符串
87
- * @param {String} format 匹配格式
88
- * @param {Regex} rx 正则表达式
89
- * @param {String} key 替换名
90
- * @return {String} 返回新的格式
86
+ * @param {string} str 匹配的字符串
87
+ * @param {string} format 匹配格式
88
+ * @param {object} rx 正则表达式
89
+ * @param {string} key 替换名
90
+ * @returns {string} 返回新的格式
91
91
  */
92
92
  function change(str, format, rx, key) {
93
- var t = str;
94
- var f = format;
95
- var mh = str.match(rx);
96
- if (mh) {
97
- var len = mh.length;
98
- for (var i = 0; i < len; i++) {
99
- var k = mh[i];
100
- if (t.indexOf(k) !== -1) {
101
- t = t.replace(k, '');
102
- f = f.replace(key, k);
103
- }
104
- }
105
- }
106
- return f;
93
+ var t = str;
94
+ var f = format;
95
+ var mh = str.match(rx);
96
+ if (mh) {
97
+ var len = mh.length;
98
+ for (var i = 0; i < len; i++) {
99
+ var k = mh[i];
100
+ if (t.indexOf(k) !== -1) {
101
+ t = t.replace(k, '');
102
+ f = f.replace(key, k);
103
+ }
104
+ }
105
+ }
106
+ return f;
107
107
  };
108
108
  Matchs.prototype.change = change;
109
109
 
110
110
  /**
111
111
  * 改变格式(可变形)
112
- * @param {String} str 匹配的字符串
113
- * @param {String} format 匹配格式
114
- * @param {Regex} rx 正则表达式
115
- * @param {String} key 替换名
116
- * @param {Function} func 回调函数(用于匹配项变形)
117
- * @return {String} 返回新的格式
112
+ * @param {string} str 匹配的字符串
113
+ * @param {string} format 匹配格式
114
+ * @param {object} rx 正则表达式
115
+ * @param {string} key 替换名
116
+ * @param {function} func 回调函数(用于匹配项变形)
117
+ * @returns {string} 返回新的格式
118
118
  */
119
- function change_func(str, format, rx, key, func) {
120
- var t = str;
121
- var f = format;
122
- var mh = str.match(rx);
123
- if (mh) {
124
- var len = mh.length;
125
- for (var i = 0; i < len; i++) {
126
- var k = mh[i];
127
- if (t.indexOf(k) !== -1) {
128
- t = t.replace(k, '');
129
- if (func) {
130
- f = f.replace(key, func(k));
131
- } else {
132
- f = f.replace(key, k);
133
- }
134
- }
135
- }
136
- }
137
- return f;
119
+ function changeFunc(str, format, rx, key, func) {
120
+ var t = str;
121
+ var f = format;
122
+ var mh = str.match(rx);
123
+ if (mh) {
124
+ var len = mh.length;
125
+ for (var i = 0; i < len; i++) {
126
+ var k = mh[i];
127
+ if (t.indexOf(k) !== -1) {
128
+ t = t.replace(k, '');
129
+ if (func) {
130
+ f = f.replace(key, func(k));
131
+ } else {
132
+ f = f.replace(key, k);
133
+ }
134
+ }
135
+ }
136
+ }
137
+ return f;
138
138
  };
139
- Matchs.prototype.change_func = change_func;
139
+
140
+ Matchs.prototype.changeFunc = changeFunc;
140
141
 
141
142
  /**
142
143
  * 改变格式(通过数组)
143
- * @param {String} str 匹配的字符串
144
- * @param {String} format 匹配格式
144
+ * @param {string} str 匹配的字符串
145
+ * @param {string} format 匹配格式
145
146
  * @param {Array} arr 数组
146
- * @param {String} key 替换名
147
- * @return {String} 返回新的格式
147
+ * @param {string} key 替换名
148
+ * @returns {string} 返回新的格式
148
149
  */
149
- function change_arr(str, format, arr, key) {
150
- var t = str;
151
- var f = format;
152
- for (var i = 0; i < arr.length; i++) {
153
- var k = arr[i];
154
- if (t.indexOf(k) !== -1) {
155
- t = t.replace(k, '');
156
- f = f.replace(key, k);
157
- }
158
- }
159
- return f;
150
+ function changeArr(str, format, arr, key) {
151
+ var t = str;
152
+ var f = format;
153
+ for (var i = 0; i < arr.length; i++) {
154
+ var k = arr[i];
155
+ if (t.indexOf(k) !== -1) {
156
+ t = t.replace(k, '');
157
+ f = f.replace(key, k);
158
+ }
159
+ }
160
+ return f;
160
161
  };
161
- Matchs.prototype.change_arr = change_arr;
162
+ Matchs.prototype.changeArr = changeArr;
162
163
 
163
164
  /**
164
165
  * 匹配{国家}
165
- * @param {String} str 匹配的字符串
166
- * @param {String} format 匹配格式
167
- * @return {String} 返回新的格式
166
+ * @param {string} str 匹配的字符串
167
+ * @param {string} format 匹配格式
168
+ * @returns {string} 返回新的格式
168
169
  */
169
- Matchs.prototype.country = function(str, format) {
170
- var arr = ["中国", "蒙古", "朝鲜", "韩国", "日本", "菲律宾", "越南", "老挝", "柬埔寨", "缅甸", "泰国", "马来西亚", "文莱", "新加坡", "印度尼西亚",
171
- " 东帝汶",
172
- "尼泊尔", "不丹", "孟加拉国", "印度", "巴基斯坦", "斯里兰卡", "马尔代夫", "哈萨克斯坦", "吉尔吉斯斯坦", "塔吉克斯坦", "乌兹别克斯坦", "土库曼斯坦", "阿富汗",
173
- "伊拉克",
174
- "伊朗", "叙利亚", "约旦", "黎巴嫩", "以色列", "巴勒斯坦", "沙特阿拉伯", "巴林", "卡塔尔", "科威特", "阿拉伯联合酋长国", "阿联酋", "阿曼", "也门",
175
- "格鲁吉亚", "亚美尼亚",
176
- "阿塞拜疆", "土耳其", "塞浦路斯", "芬兰", "瑞典", "挪威", "冰岛", "丹麦 法罗群岛", "爱沙尼亚", "拉脱维亚", "立陶宛", "白俄罗斯", "俄罗斯", "乌克兰",
177
- "摩尔多瓦", "波兰",
178
- "捷克", "斯洛伐克", "匈牙利", "德国", "奥地利", "瑞士", "列支敦士登", "英国", "爱尔兰", "荷兰", "比利时", "卢森堡", "法国", "摩纳哥", "罗马尼亚",
179
- "保加利亚",
180
- "塞尔维亚", "黑山", "马其顿", "阿尔巴尼亚", "希腊", "斯洛文尼亚", "克罗地亚", "波斯尼亚", "墨塞哥维那", "意大利", "梵蒂冈", "圣马力诺", "马耳他",
181
- "西班牙", "葡萄牙",
182
- "安道尔", "埃及", "利比亚", "苏丹", "突尼斯", "阿尔及利亚", "摩洛哥", "亚速尔群岛", "马德拉群岛", "埃塞俄比亚", "厄立特里亚", "索马里", "吉布提",
183
- "肯尼亚", "坦桑尼亚",
184
- "乌干达", "卢旺达", "布隆迪", "塞舌尔", "乍得", "中非", "喀麦隆", "赤道几内亚", "加蓬", "刚果共和国", "刚果", "刚果民主共和国", "圣多美及普林西比",
185
- "毛里塔尼亚", "西撒哈拉",
186
- "塞内加尔", "冈比亚", "马里", "布基纳法索", "几内亚", "几内亚比绍", "佛得角", "塞拉利昂", "利比里亚", "科特迪瓦", "加纳", "多哥", "贝宁", "尼日尔",
187
- "加那利群岛",
188
- "赞比亚", "安哥拉", "津巴布韦", "马拉维", "莫桑比克", "博茨瓦纳", "纳米比亚", "南非", "斯威士兰", "莱索托", "马达加斯加", "科摩罗", "毛里求斯", "留尼旺",
189
- "圣赫勒拿",
190
- "澳大利亚", "新西兰", "巴布亚新几内亚", "所罗门群岛", "瓦努阿图", "密克罗尼西亚", "马绍尔群岛", "帕劳", "瑙鲁", "基里巴斯", "图瓦卢", "萨摩亚", "斐济群岛",
191
- "汤加",
192
- "库克群岛", "关岛", "新喀里多尼亚", "法属波利尼西亚", "皮特凯恩岛", "瓦利斯与富图纳", "纽埃", "托克劳", "美属萨摩亚", "北马里亚纳", "加拿大", "美国",
193
- "墨西哥", "格陵兰",
194
- "危地马拉", "伯利兹", "萨尔瓦多", "洪都拉斯", "尼加拉瓜", "哥斯达黎加", "巴拿马", "巴哈马", "古巴", "牙买加", "海地", "多米尼加共和国", "安提瓜和巴布达",
195
- "圣基茨和尼维斯",
196
- "多米尼克", "圣卢西亚", "圣文森特和格林纳丁斯", "格林纳达", "巴巴多斯", "特立尼达和多巴哥", "波多黎各", "英属维尔京群岛", "美属维尔京群岛", "安圭拉", "蒙特塞拉特",
197
- "瓜德罗普",
198
- "马提尼克", "荷属安的列斯", "阿鲁巴", "特克斯和凯科斯群岛", "开曼群岛", "百慕大", "哥伦比亚", "委内瑞拉", "圭亚那", "法属圭亚那", "苏里南", "厄瓜多尔",
199
- "秘鲁", "玻利维亚",
200
- "智利", "阿根廷", "乌拉圭", "巴拉圭"
201
- ]
202
- return change_arr(str, format, arr, '{国家}');
203
- }
170
+ Matchs.prototype.country = function (str, format) {
171
+ var arr = ['中国', '蒙古', '朝鲜', '韩国', '日本', '菲律宾', '越南', '老挝', '柬埔寨', '缅甸', '泰国', '马来西亚', '文莱', '新加坡', '印度尼西亚',
172
+ ' 东帝汶',
173
+ '尼泊尔', '不丹', '孟加拉国', '印度', '巴基斯坦', '斯里兰卡', '马尔代夫', '哈萨克斯坦', '吉尔吉斯斯坦', '塔吉克斯坦', '乌兹别克斯坦', '土库曼斯坦', '阿富汗',
174
+ '伊拉克',
175
+ '伊朗', '叙利亚', '约旦', '黎巴嫩', '以色列', '巴勒斯坦', '沙特阿拉伯', '巴林', '卡塔尔', '科威特', '阿拉伯联合酋长国', '阿联酋', '阿曼', '也门',
176
+ '格鲁吉亚', '亚美尼亚',
177
+ '阿塞拜疆', '土耳其', '塞浦路斯', '芬兰', '瑞典', '挪威', '冰岛', '丹麦 法罗群岛', '爱沙尼亚', '拉脱维亚', '立陶宛', '白俄罗斯', '俄罗斯', '乌克兰',
178
+ '摩尔多瓦', '波兰',
179
+ '捷克', '斯洛伐克', '匈牙利', '德国', '奥地利', '瑞士', '列支敦士登', '英国', '爱尔兰', '荷兰', '比利时', '卢森堡', '法国', '摩纳哥', '罗马尼亚',
180
+ '保加利亚',
181
+ '塞尔维亚', '黑山', '马其顿', '阿尔巴尼亚', '希腊', '斯洛文尼亚', '克罗地亚', '波斯尼亚', '墨塞哥维那', '意大利', '梵蒂冈', '圣马力诺', '马耳他',
182
+ '西班牙', '葡萄牙',
183
+ '安道尔', '埃及', '利比亚', '苏丹', '突尼斯', '阿尔及利亚', '摩洛哥', '亚速尔群岛', '马德拉群岛', '埃塞俄比亚', '厄立特里亚', '索马里', '吉布提',
184
+ '肯尼亚', '坦桑尼亚',
185
+ '乌干达', '卢旺达', '布隆迪', '塞舌尔', '乍得', '中非', '喀麦隆', '赤道几内亚', '加蓬', '刚果共和国', '刚果', '刚果民主共和国', '圣多美及普林西比',
186
+ '毛里塔尼亚', '西撒哈拉',
187
+ '塞内加尔', '冈比亚', '马里', '布基纳法索', '几内亚', '几内亚比绍', '佛得角', '塞拉利昂', '利比里亚', '科特迪瓦', '加纳', '多哥', '贝宁', '尼日尔',
188
+ '加那利群岛',
189
+ '赞比亚', '安哥拉', '津巴布韦', '马拉维', '莫桑比克', '博茨瓦纳', '纳米比亚', '南非', '斯威士兰', '莱索托', '马达加斯加', '科摩罗', '毛里求斯', '留尼旺',
190
+ '圣赫勒拿',
191
+ '澳大利亚', '新西兰', '巴布亚新几内亚', '所罗门群岛', '瓦努阿图', '密克罗尼西亚', '马绍尔群岛', '帕劳', '瑙鲁', '基里巴斯', '图瓦卢', '萨摩亚', '斐济群岛',
192
+ '汤加',
193
+ '库克群岛', '关岛', '新喀里多尼亚', '法属波利尼西亚', '皮特凯恩岛', '瓦利斯与富图纳', '纽埃', '托克劳', '美属萨摩亚', '北马里亚纳', '加拿大', '美国',
194
+ '墨西哥', '格陵兰',
195
+ '危地马拉', '伯利兹', '萨尔瓦多', '洪都拉斯', '尼加拉瓜', '哥斯达黎加', '巴拿马', '巴哈马', '古巴', '牙买加', '海地', '多米尼加共和国', '安提瓜和巴布达',
196
+ '圣基茨和尼维斯',
197
+ '多米尼克', '圣卢西亚', '圣文森特和格林纳丁斯', '格林纳达', '巴巴多斯', '特立尼达和多巴哥', '波多黎各', '英属维尔京群岛', '美属维尔京群岛', '安圭拉', '蒙特塞拉特',
198
+ '瓜德罗普',
199
+ '马提尼克', '荷属安的列斯', '阿鲁巴', '特克斯和凯科斯群岛', '开曼群岛', '百慕大', '哥伦比亚', '委内瑞拉', '圭亚那', '法属圭亚那', '苏里南', '厄瓜多尔',
200
+ '秘鲁', '玻利维亚',
201
+ '智利', '阿根廷', '乌拉圭', '巴拉圭'
202
+ ];
203
+ return changeArr(str, format, arr, '{国家}');
204
+ };
204
205
 
205
206
  /**
206
207
  * 匹配{域名}
207
- * @param {String} str 匹配的字符串
208
- * @param {String} format 匹配格式
209
- * @return {String} 返回新的格式
208
+ * @param {string} str 匹配的字符串
209
+ * @param {string} format 匹配格式
210
+ * @returns {string} 返回新的格式
210
211
  */
211
- Matchs.prototype.web = function(str, format) {
212
- var rx = this.dict_regex.domain;
213
- return change(str, format, rx, '{域名}').replace(/((https|http|ftp|rtsp|mms)?:\/\/)?/, "");
212
+ Matchs.prototype.web = function (str, format) {
213
+ var rx = this.dict_regex.domain;
214
+ return change(str, format, rx, '{域名}').replace(/((https|http|ftp|rtsp|mms)?:\/\/)?/, '');
214
215
  };
215
216
 
216
217
 
217
218
  /**
218
219
  * 匹配{链接}
219
- * @param {String} str 匹配的字符串
220
- * @param {String} format 匹配格式
221
- * @return {String} 返回新的格式
220
+ * @param {string} str 匹配的字符串
221
+ * @param {string} format 匹配格式
222
+ * @returns {string} 返回新的格式
222
223
  */
223
- Matchs.prototype.href = function(str, format) {
224
- var rx = this.dict_regex.href_attr;
225
- var f = change_func(str, format, rx, '{链接}', function(o) {
226
- return o.between('"', '"');
227
- });
228
- return f;
224
+ Matchs.prototype.href = function (str, format) {
225
+ var rx = this.dict_regex.href_attr;
226
+ var f = changeFunc(str, format, rx, '{链接}', (o) => {
227
+ return o.between('"', '"');
228
+ });
229
+ return f;
229
230
  };
230
231
 
231
232
  /**
232
233
  * 匹配{手机号码}
233
- * @param {String} str 匹配的字符串
234
- * @param {String} format 匹配格式
235
- * @return {String} 返回新的格式
234
+ * @param {string} str 匹配的字符串
235
+ * @param {string} format 匹配格式
236
+ * @returns {string} 返回新的格式
236
237
  */
237
- Matchs.prototype.phone = function(str, format) {
238
- var rx = this.dict_regex.mobile;
239
- var f = change_func(str, format, rx, '{手机号码}', function(o) {
240
- return o.replace(/[ -]/g, '');
241
- });
242
- return f;
238
+ Matchs.prototype.phone = function (str, format) {
239
+ var rx = this.dict_regex.mobile;
240
+ var f = changeFunc(str, format, rx, '{手机号码}', (o) => {
241
+ return o.replace(/[ -]/g, '');
242
+ });
243
+ return f;
243
244
  };
244
245
 
245
246
  /**
246
247
  * 匹配{标签之间}
247
- * @param {String} str 匹配的字符串
248
- * @param {String} format 匹配格式
249
- * @return {String} 返回新的格式
248
+ * @param {string} str 匹配的字符串
249
+ * @param {string} format 匹配格式
250
+ * @returns {string} 返回新的格式
250
251
  */
251
- Matchs.prototype.html_between = function(str, format) {
252
- var rx = this.dict_regex.html_tag;
253
- var f = change_func(str, format, rx, '{标签之间}', function(o) {
254
- var mh = o.match(
255
- '^<[a-zA-Z!][a-zA-Z\-_]*([ ]+[a-zA-Z][a-zA-Z0-9]+="[ ]*[a-zA-Z0-9/.%&#:?]+[ ]*"[ ]*)(\/>|>)'
256
- );
257
- if (mh) {
258
- var left = mh[0];
259
- // console.log('标签?', left)
260
- var mh = o.match("</[a-zA-Z!][a-zA-Z\-_]*>$");
261
- if (mh) {
262
- var right = mh[0];
263
- // console.log('标签?', right)
264
- var str = o.substring(0, o.length - right.length).replace(left, '');
265
- // console.log('标签?', str);
266
- return str
267
- }
268
- }
269
- return "";
270
- });
271
- return f;
252
+ Matchs.prototype.htmlBetween = function (str, format) {
253
+ var rx = this.dict_regex.html_tag;
254
+ var f = changeFunc(str, format, rx, '{标签之间}', (o) => {
255
+ var mh = o.match(
256
+ '^<[a-zA-Z!][a-zA-Z\-_]*([ ]+[a-zA-Z][a-zA-Z0-9]+="[ ]*[a-zA-Z0-9/.%&#:?]+[ ]*"[ ]*)(\/>|>)'
257
+ );
258
+ if (mh) {
259
+ var left = mh[0];
260
+ // $.log.debug('标签?', left)
261
+ var mh = o.match('</[a-zA-Z!][a-zA-Z\-_]*>$');
262
+ if (mh) {
263
+ var right = mh[0];
264
+ // $.log.debug('标签?', right)
265
+ var str = o.substring(0, o.length - right.length).replace(left, '');
266
+ // $.log.debug('标签?', str);
267
+ return str;
268
+ }
269
+ }
270
+ return '';
271
+ });
272
+ return f;
272
273
  };
273
274
 
274
275
  /**
275
276
  * 获取匹配的内容
276
- * @param {String} str 要匹配的字符串
277
- * @param {String} format 用作匹配的字符串格式
278
- * @param {Array} arr 匹配的字符串格式片段(可以为空)
279
- * @return {String} 返回匹配的结果
277
+ * @param {string} str 要匹配的字符串
278
+ * @param {string} format 用作匹配的字符串格式
279
+ * @returns {string} 返回匹配的结果
280
280
  */
281
- Matchs.prototype.get = function(str, format) {
282
- var rxs = [];
283
- var arr = [];
284
- var ft = format.replace(/\{/g, '`{').replace(/\}/g, '}`');
285
- ft.split('`').map((o) => {
286
- if (o.indexOf('{') !== -1) {
287
- if (!/\{[0-9]+,?[0-9]+\}/.test(o)) {
288
- var rx = this.to_regex(o);
289
- if (rx) {
290
- rxs.push({
291
- word: o,
292
- rx: rx.toString().trim("/")
293
- });
294
- } else {
295
- arr.push(o);
296
- }
297
- }
298
- }
299
- });
281
+ Matchs.prototype.get = function (str, format) {
282
+ var parsed = this._parseFormat(format);
283
+ var fmt = this._processRegexReplace(format, parsed.rxs);
284
+ fmt = this._processDictReplace(str, fmt, parsed.arr);
285
+ return this._executeRegexMatch(str, fmt);
286
+ };
300
287
 
301
- format = format.replace(/\r/g, '\\r').replace(/\n/g, '\\n').replace(/\*/g, '.*').replace(/\//g, '\\/');
288
+ /**
289
+ * 解析格式字符串
290
+ * @param {string} format 格式字符串
291
+ * @returns {object} 返回解析结果对象
292
+ */
293
+ Matchs.prototype._parseFormat = function (format) {
294
+ var rxs = [];
295
+ var arr = [];
296
+ var ft = format.replace(/\{/g, '`{').replace(/\}/g, '}`');
297
+
298
+ ft.split('`').map((o) => {
299
+ if (o.indexOf('{') !== -1) {
300
+ if (!/\{[0-9]+,?[0-9]+\}/.test(o)) {
301
+ var rx = this.toRegex(o);
302
+ if (rx) {
303
+ rxs.push({
304
+ word: o,
305
+ rx: rx.toString().trim('/')
306
+ });
307
+ } else {
308
+ arr.push(o);
309
+ }
310
+ }
311
+ }
312
+ });
313
+
314
+ return {
315
+ rxs: rxs,
316
+ arr: arr
317
+ };
318
+ };
319
+
320
+ /**
321
+ * 处理正则表达式替换
322
+ * @param {string} fmt 格式字符串
323
+ * @param {Array} rxs 正则表达式数组
324
+ * @returns {string} 返回处理后的格式字符串
325
+ */
326
+ Matchs.prototype._processRegexReplace = function (fmt, rxs) {
327
+ var proc_fmt = fmt.replace(/\r/g, '\\r').replace(/\n/g, '\\n').replace(/\*/g, '.*').replace(/\//g, '\\/');
328
+
329
+ try {
330
+ rxs.map((o) => {
331
+ proc_fmt = proc_fmt.replace(o.word, o.rx);
332
+ });
333
+ } catch (e) {
334
+ $.log.error('错误!', e);
335
+ }
336
+
337
+ return proc_fmt;
338
+ };
302
339
 
303
- // console.log("这啥1?", format);
304
- // var fmt = format.replace(/\{[a-zA-Z\u4e00-\u9fa5_]+\}/g, '[\\s\\S]*');
305
- try {
306
- rxs.map((o) => {
307
- format = format.replace(o.word, o.rx);
308
- });
309
- // fmt = fmt.replace(/\{[a-zA-Z\u4e00-\u9fa5_]+\}/g, '[\\s\\S]*');
310
- } catch (e) {
311
- console.error("错误!", e);
312
- //TODO handle the exception
313
- }
340
+ /**
341
+ * 处理字典方法替换
342
+ * @param {string} str 要匹配的字符串
343
+ * @param {string} fmt 格式字符串
344
+ * @param {Array} arr 字典方法数组
345
+ * @returns {string} 返回处理后的格式字符串
346
+ */
347
+ Matchs.prototype._processDictReplace = function (str, fmt, arr) {
348
+ var proc_fmt = fmt;
349
+
350
+ for (var i = 0; i < arr.length; i++) {
351
+ var key = arr[i];
352
+ var method = this.dict[key];
353
+ if (method) {
354
+ if (this[method]) {
355
+ var f = this[method](str, key);
356
+ proc_fmt = proc_fmt.replace(key, f.replace(/\\/g, '\\\\').replace(/\//g, '\\/').replace(/\./g, '\\.')
357
+ .replace(/\r/g, '\\r').replace(/\n/g, '\\n'));
358
+ }
359
+ }
360
+ }
361
+
362
+ return proc_fmt;
363
+ };
314
364
 
315
- // console.log("这啥2?", format);
316
- // console.log("测试", arr);
317
- for (var i = 0; i < arr.length; i++) {
318
- var key = arr[i];
319
- var func_name = this.dict[key];
320
- if (func_name) {
321
- if (this[func_name]) {
322
- // console.log("进入了?", func_name)
323
- var f = this[func_name](str, key);
324
- format = format.replace(key, f.replace(/\\/g, '\\').replace(/\//g, '\\/').replace(/\./g, '\\.')
325
- .replace(/\r/g, '\\r').replace(/\n/g, '\\n'));
326
- }
327
- }
328
- }
329
- // console.log("这啥3?", format);
330
- // console.log("正则", format);
331
- var txt = "";
332
- if (format) {
333
- try {
334
- format = format.replace(/\]\+\{/g, "]{");
335
- // console.log("这啥4?", format);
336
- rx = eval('/' + format + '/');
337
- var mh = str.match(rx);
338
- if (mh) {
339
- txt = mh[0];
340
- }
341
- } catch (e) {
342
- console.error("错误!", e);
343
- }
344
- }
345
- // console.log("转换规则", format);
346
- return txt;
365
+ /**
366
+ * 执行正则匹配
367
+ * @param {string} str 要匹配的字符串
368
+ * @param {string} fmt 格式字符串
369
+ * @returns {string} 返回匹配结果
370
+ */
371
+ Matchs.prototype._executeRegexMatch = function (str, fmt) {
372
+ var txt = '';
373
+ if (fmt) {
374
+ try {
375
+ var proc_fmt = fmt.replace(/\]\+\{/g, ']{');
376
+ var rx = eval('/' + proc_fmt + '/');
377
+ var mh = str.match(rx);
378
+ if (mh) {
379
+ txt = mh[0];
380
+ }
381
+ } catch (e) {
382
+ $.log.error('错误!', e);
383
+ }
384
+ }
385
+ return txt;
347
386
  };
348
387
 
349
388
  /**
350
389
  * 转正则表达式
351
- * @param {String} format 格式
390
+ * @param {string} format 格式
352
391
  * @returns 返回正则表达式
353
392
  * @example
354
393
  * var matchs = new Matchs();
355
- * var rx = matchs.to_regex("{数字}");
394
+ * var rx = matchs.toRegex("{数字}");
356
395
  */
357
- Matchs.prototype.to_regex = function(format) {
358
- var key = this.dict[format];
359
- if (!key) {
360
- return "";
361
- }
362
- return this.dict_regex[key];
363
- }
396
+ Matchs.prototype.toRegex = function (format) {
397
+ var key = this.dict[format];
398
+ if (!key) {
399
+ return '';
400
+ }
401
+ return this.dict_regex[key];
402
+ };
364
403
 
365
404
 
366
405
  /**
367
406
  * 匹配字符串
368
- * @param {String} format 用作匹配的字符串格式
369
- * @return {String} 匹配成功返回匹配的字符串,否则返回空
370
- */
371
- String.prototype.matchs = function(format) {
372
- var rx;
373
- var ret = "";
374
- var str = this + "";
375
- if (format.startWith('/') && (format.endWith('/') || format.endWith('/g') || format.endWith('/gi'))) {
376
- try {
377
- rx = eval(format);
378
- var mh = str.match(rx);
379
- if (mh) {
380
- ret = mh[0];
381
- }
382
- } catch (e) {
383
- // TODO handle the exception
384
- }
385
- } else {
386
- var matchs = new Matchs();
387
- ret = matchs.get(str, format);
388
- }
389
- return ret;
390
- };
391
-
392
- /**
393
- * 替换匹配的字符串
394
- * @param {String} format 用作匹配的字符串格式
395
- * @return {String} 匹配成功返回匹配的字符串,否则返回空
407
+ * @param {string} format 用作匹配的字符串格式
408
+ * @returns {string} 匹配成功返回匹配的字符串,否则返回空
396
409
  */
397
- String.prototype.replaces = function(format, word = "") {
398
- var str = this;
410
+ String.prototype.matchs = function (format) {
411
+ var rx;
412
+ var ret = '';
413
+ var str = this + '';
414
+ if (format.startsWith('/') && (format.endsWith('/') || format.endsWith('/g') || format.endsWith('/gi'))) {
415
+ try {
416
+ rx = eval(format);
417
+ var mh = str.match(rx);
418
+ if (mh) {
419
+ ret = mh[0];
420
+ }
421
+ } catch {
399
422
 
423
+ }
424
+ } else {
425
+ var matchs = new Matchs();
426
+ ret = matchs.get(str, format);
427
+ }
428
+ return ret;
400
429
  };
401
430
 
402
431
  module.exports = Matchs;