PageSourceSearch

https://www.isheji.com/new/javascript/public/tools.js?version=3.36

js isheji.com collected 2026-10-08 20:25:10 UTC 74,359 bytes, 2,406 lines download raw bytes

1/**
2 * @authors SX
3 * @date    2014-08-07 13:31:41
4 * @explain 前端工具集合 PS;维护人员;注意保证每个方法的独立性与通用性
5 */
6
7// ------------------------自定义的工具类------------------------
8(function ($) {
9  function ToolsClass() {
10    this.queryString = {
11      /* 获取
12       * key:需要获取的对象,默认返回地址栏所有对象
13       * */
14      get: function (key) {
15        var search = window.location.search;
16        if (search.length < 1) {
17          return;
18        }
19        if (key && search.indexOf(key) < 0) {
20          return;
21        }
22        search = search.substring(1);
23        search = decodeURI(search);
24        var searchArr = search.split('&');
25        var searchJSON = {};
26        $.each(searchArr, function (index, item) {
27          var item = item.split('=');
28          searchJSON[item[0]] = item[1];
29        });
30        if (key) {
31          return searchJSON[key];
32        } else {
33          return searchJSON;
34        }
35      },
36      /* 设置
37       * data:数值对象,url:跳转的路径(默认为当前路径),isOpen:是否新建窗口打开(默认为否)
38       * 如果传递的为空对象,即删除所有参数
39       * */
40      set: function (data, url, isOpen) {
41        if (!data || $.type(data) != 'object') {
42          return;
43        }
44        var pathname = url || window.location.pathname;
45        var str = '?',
46          index = 0;
47        if ($.isEmptyObject(data)) {
48          str = '';
49        } else {
50          $.each(data, function (key, val) {
51            str += (index > 0 ? '&' : '') + key + '=' + val;
52            index++;
53          });
54        }
55        if (isOpen) {
56          window.open(pathname + str);
57        } else {
58          window.location.href = pathname + str;
59        }
60      },
61      /* 添加
62       * data:数值对象,url:跳转的路径(默认为当前路径),isOpen:是否新建窗口打开(默认为否)
63       * 如果当前某项值已经存在地址栏中,将更新该值,不存在则添加值
64       * */
65      add: function (data, url, isOpen) {
66        if (!data || $.type(data) != 'object') {
67          return;
68        }
69        var query = this.get();
70        if (query) {
71          $.each(query, function (key, val) {
72            if (!data.hasOwnProperty(key)) {
73              data[key] = val;
74            }
75          });
76        }
77        this.set(data, url, isOpen);
78      },
79      /* 更新
80       * data:数值对象,url:跳转的路径(默认为当前路径),isOpen:是否新建窗口打开(默认为否)
81       * 仅更新当前地址栏已经存在的对象值
82       * */
83      update: function (data, url, isOpen) {
84        if (!data || $.type(data) != 'object') {
85          return;
86        }
87        var query = this.get();
88        if (query) {
89          $.each(data, function (key, val) {
90            if (query.hasOwnProperty(key)) {
91              query[key] = val;
92            }
93          });
94        }
95        this.set(query, url, isOpen);
96      },
97      /* 删除
98       * data:数值数组,url:跳转的路径(默认为当前路径),isOpen:是否新建窗口打开(默认为否)
99       * 如果传递的为空数组,即删除所有参数
100       * */
101      delete: function (data, url, isOpen) {
102        if (!data || $.type(data) != 'array') {
103          return;
104        }
105        var query = this.get();
106        if (data.length == 0) {
107          query = {};
108        } else {
109          $.each(data, function (index, item) {
110            if (query.hasOwnProperty(item)) {
111              delete query[item];
112            }
113          });
114        }
115        this.set(query, url, isOpen);
116      },
117    };
118
119    this.storage = {
120      setLocal: function (key, value) {
121        window.localStorage.setItem(key, JSON.stringify(value));
122      },
123      getLocal: function (key) {
124        let value = window.localStorage.getItem(key);
125        return JSON.parse(value);
126      },
127      setSession: function (key, value) {
128        window.sessionStorage.setItem(key, JSON.stringify(value));
129      },
130      getSession: function (key) {
131        let value = window.sessionStorage.getItem(key);
132        return JSON.parse(value);
133      },
134      clearOneLocal: function (key) {
135        window.localStorage.removeItem(key);
136      },
137      clearOneSession: function (key) {
138        window.sessionStorage.removeItem(key);
139      },
140      clearAllLocal: function () {
141        // debugger;
142        window.localStorage.clear();
143      },
144      clearAllSession: function () {
145        window.sessionStorage.clear();
146      },
147    };
148
149    this.widget = {
150      getmodalshow: function (modal) {
151        var body = $('body');
152        body.find('.modal_mask').remove();
153        body.append("<div class='modal_mask'></div>");
154        modal.show();
155        modal.find('.prompt').text('');
156        modal.find('.close').click(function () {
157          modal.hide();
158          body.find('.modal_mask').remove();
159          modal.find('input').val('');
160          modal.find('.prompt').text('');
161        });
162        modal.find('.close_button').click(function () {
163          modal.hide();
164          body.find('.modal_mask').remove();
165          modal.find('input').val('');
166          modal.find('.prompt').text('');
167        });
168      },
169      getmodalhide: function (modal) {
170        var body = $('body');
171        body.find('.modal_mask').remove();
172        modal.hide();
173
174        modal.find('input').val('');
175        modal.find('.prompt').text('');
176      },
177    };
178  }
179
180  ToolsClass.prototype = {
181    // 动态加载JS文 件
182    requireScript: function (options) {
183      var head = document.getElementsByTagName('head')[0];
184      var oldScript = document.getElementById(options.scriptId);
185      if (oldScript) {
186        head.removeChild(oldScript);
187      }
188      var newScript = document.createElement('script');
189      options.scriptId ? (newScript.id = options.scriptId) : '';
190      options.async ? (newScript.async = true) : '';
191      newScript.src = options.scriptSrc;
192
193      var scriptLoaded = 0;
194      // IE和opera支持onreadystatechange
195      // safari、chrome、opera支持onload
196      newScript.onload = newScript.onreadystatechange = function () {
197        // 避免opera下的多次调用
198        if (scriptLoaded) {
199          return;
200        }
201
202        var readyState = newScript.readyState;
203        if ('undefined' == typeof readyState || readyState == 'loaded' || readyState == 'complete') {
204          scriptLoaded = 1;
205          try {
206            if (options.initFun) {
207              options.initFun();
208            }
209          } finally {
210            newScript.onload = newScript.onreadystatechange = null;
211          }
212        }
213      };
214      head.appendChild(newScript);
215    },
216
217    loadScript: function (options) {
218      var head = document.getElementsByTagName('head')[0];
219      var oldScript = document.getElementById(options.scriptId);
220      if (oldScript) {
221        head.removeChild(oldScript);
222      }
223      var newScript = document.createElement('script');
224      options.scriptId ? (newScript.id = options.scriptId) : '';
225      options.async ? (newScript.async = true) : '';
226      newScript.src = options.scriptSrc;
227      head.appendChild(newScript);
228    },
229
230    // 获取页面滚动条数据
231    GetPageScroll: function (win) {
232      var x, y;
233      if (win.pageYOffset) {
234        // all except IE
235        y = win.pageYOffset;
236        x = win.pageXOffset;
237      } else if (win.document.documentElement && win.document.documentElement.scrollTop) {
238        // IE 6 Strict
239        y = win.document.documentElement.scrollTop;
240        x = win.document.documentElement.scrollLeft;
241      } else if (document.body) {
242        // all other IE
243        y = win.document.body.scrollTop;
244        x = win.document.body.scrollLeft;
245      }
246      return {
247        X: x,
248        Y: y,
249      };
250    },
251
252    // 获取页面大小
253    GetPageSize: function (win) {
254      var scrW, scrH;
255      if (win.innerHeight && win.scrollMaxY) {
256        // Mozilla
257        scrW = win.innerWidth + win.scrollMaxX;
258        scrH = win.innerHeight + win.scrollMaxY;
259      } else if (win.document.body.scrollHeight > win.document.body.offsetHeight) {
260        // all but IE Mac
261        scrW = win.document.body.scrollWidth;
262        scrH = win.document.body.scrollHeight;
263      } else if (win.document.body) {
264        // IE Mac
265        scrW = win.document.body.offsetWidth;
266        scrH = win.document.body.offsetHeight;
267      }
268
269      var winW, winH;
270      if (win.innerHeight) {
271        // all except IE
272        winW = win.innerWidth;
273        winH = win.innerHeight;
274      } else if (win.document.documentElement && win.document.documentElement.clientHeight) {
275        // IE 6 Strict Mode
276        winW = win.document.documentElement.clientWidth;
277        winH = win.document.documentElement.clientHeight;
278      } else if (win.document.body) {
279        // other
280        winW = win.document.body.clientWidth;
281        winH = win.document.body.clientHeight;
282      }
283
284      // for small pages with total size less then the viewport
285      var pageW = scrW < winW ? winW : scrW;
286      var pageH = scrH < winH ? winH : scrH;
287
288      return {
289        PageW: pageW,
290        PageH: pageH,
291        WinW: winW,
292        WinH: winH,
293      };
294    },
295
296    // 取得数组中最大值
297    _array_getMaxVal: function (array) {
298      return Math.max.apply({}, array);
299    },
300
301    // 取得数组中最小值
302    _array_getMinVal: function (array) {
303      return Math.min.apply({}, array);
304    },
305
306    // 向数组中加入项(有查重功能)
307    _array_addItem: function (array, item) {
308      if (array.length <= 0) {
309        array.push(item);
310        return false;
311      }
312      for (var i = 0, len = array.length; i < len; i++) {
313        if (array[i] === item) {
314          return false;
315        } else {
316          array.push(item);
317          break;
318        }
319      }
320    },
321
322    // 删除数组中指定的项
323    _array_removeItem: function (array, item) {
324      for (var i = 0, len = array.length; i < len; i++) {
325        if (array[i] === item) {
326          array.splice(i, 1);
327        }
328      }
329    },
330    //  交换数组元素
331    _array_swapItem: function (arr, index1, index2) {
332      arr[index1] = arr.splice(index2, 1, arr[index1])[0];
333      return arr;
334    },
335
336    // 删除字符串中的前后空格
337    _string_trim: function (str) {
338      return str.replace(/(^\s*)|(\s*$)/g, '');
339    },
340
341    // 删除字符串中的所有空格
342    _string_trimAll: function (str) {
343      return str.replace(/\s/g, '');
344    },
345
346    // 删除字符串中的左侧空格
347    _string_ltrim: function (str) {
348      return str.replace(/(^\s*)/g, '');
349    },
350
351    // 删除字符串中的右侧空格
352    _string_rtrim: function (str) {
353      return str.replace(/(\s*$)/g, '');
354    },
355
356    // ------------------------字符串验证通用方法------------------------
357    /*
358     ** 用途:检查输入字符串是否为空或者全部都是空格
359     ** 输入:str
360     ** 返回:如果全是空返回true,否则返回false
361     */
362    isNull: function (str) {
363      if (str == '') {
364        return true;
365      } else if (str == 'null' || str === null) {
366        return true;
367      }
368      var regu = '^[ ]+$';
369      var re = new RegExp(regu);
370      return re.test(str);
371    },
372
373    /*
374     ** 用途:检查输入的Email信箱格式是否正确
375     ** 输入:strEmail:字符串
376     ** 返回:如果通过验证返回true,否则返回false
377     */
378    checkEmail: function (strEmail) {
379      var emailReg = /^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/;
380      if (emailReg.test(strEmail)) {
381        return true;
382      } else {
383        return false;
384      }
385    },
386    /*
387     ** 用途:检查输入的链接格式是否正确
388     ** 输入:setUrl:字符串
389     ** 返回:如果通过验证返回true,否则返回false
390     */
391    checkUrl: function (setUrl) {
392      var urlReg = /^http(s)?:\/\/([\w-]+\.)+[\w-]+(\/[\w- ./?%&=]*)?$/;
393      if (urlReg.test(setUrl)) {
394        return true;
395      } else {
396        return false;
397      }
398    },
399
400    /*
401     ** 用途:检查输入的qqEmail信箱格式是否正确
402     ** 输入:strqqEmail:字符串
403     ** 返回:如果通过验证返回true,否则返回false
404     */
405    checkqqEmail: function (strEmail) {
406      var regu = /^[a-zA-Z][A-Za-z0-9\.|-|_]+[A-Za-z0-9]+@[qQ][qQ]\.com$/;
407      if (regu.test(strEmail)) {
408        return true;
409      } else {
410        return false;
411      }
412    },
413
414    /*
415     ** 用途:检查输入字符串是否含有特殊符号
416     ** 输入:strqqEmail:字符串
417     ** 返回:如果通过验证返回true,否则返回false
418     */
419    isHasSpecificSymbol: function (str) {
420      var regu = "[`~%!@#^=''?~!@#¥……&——‘”“'?*()(),,。.、]";
421      var re = new RegExp(regu);
422      if (re.test(str)) {
423        return true;
424      } else {
425        return false;
426      }
427    },
428
429    /*
430     ** 用途:检查输入手机号码是否正确
431     ** 输入:strMobile:字符串
432     ** 返回:如果通过验证返回true,否则返回false
433     */
434    checkMobile: function (strMobile) {
435      var regu = /^[1][1-9][0-9]{9}$/;
436      var re = new RegExp(regu);
437      if (re.test(strMobile)) {
438        return true;
439      } else {
440        return false;
441      }
442    },
443
444    /*
445     ** 用途:检查输入字符串是否只由英文字母和数字和下划线组成
446     ** 输入:str:字符串
447     ** 返回:如果通过验证返回true,否则返回false
448     */
449    isNumberOr_Letter: function (str) {
450      var regu = '^[0-9a-zA-Z_]+$';
451      var re = new RegExp(regu);
452      if (re.test(str)) {
453        return true;
454      } else {
455        return false;
456      }
457    },
458
459    /*
460     ** 用途:检查输入字符串是否纯数字
461     ** 输入:str:字符串
462     ** 返回:如果通过验证返回true,否则返回false
463     */
464    isNumber: function (str) {
465      var regu = '^[0-9]+$';
466      var re = new RegExp(regu);
467      if (re.test(str)) {
468        return true;
469      } else {
470        return false;
471      }
472    },
473
474    /*
475     ** 用途:检查输入字符串是否是负数
476     ** 输入:str:字符串
477     ** 返回:如果通过验证返回true,否则返回false
478     */
479    isNegativeNumber: function (str) {
480      var regu = '^[-0-9]+$';
481      var re = new RegExp(regu);
482      if (re.test(str)) {
483        return true;
484      } else {
485        return false;
486      }
487    },
488
489    /*
490     ** 用途:检查输入字符串是否flaot型数字
491     ** 输入:str:字符串
492     ** 返回:如果通过验证返回true,否则返回false
493     */
494    isFloat: function (str) {
495      var regu = '^[0-9.]+$';
496      var re = new RegExp(regu);
497      if (re.test(str)) {
498        return true;
499      } else {
500        return false;
501      }
502    },
503
504    /*
505     ** 用途:检查输入字符串是否数字和字母组成
506     ** 输入:str:字符串
507     ** 返回:如果通过验证返回true,否则返回false
508     */
509    isNumberOrLetter: function (str) {
510      var regu = '^[0-9a-zA-Z]+$';
511      var re = new RegExp(regu);
512      if (re.test(str)) {
513        return true;
514      } else {
515        return false;
516      }
517    },
518
519    /*
520     ** 用途:检查输入字符串是否含有中文
521     ** 输入:str:字符串
522     ** 返回:如果通过验证返回true,否则返回false
523     */
524    isHasChinese: function (str) {
525      var regu = '[\u4e00-\u9fa5]';
526      var re = new RegExp(regu);
527      if (re.test(str)) {
528        return true;
529      } else {
530        return false;
531      }
532    },
533
534    /*
535     ** 用途:检查输入字符串是否只有中文
536     ** 输入:str:字符串
537     ** 返回:如果通过验证返回true,否则返回false
538     */
539    isOnlyChinese: function (str) {
540      var regu = '^[\u4e00-\u9fa5]+$';
541      var re = new RegExp(regu);
542      if (re.test(str)) {
543        return true;
544      } else {
545        return false;
546      }
547    },
548
549    /*
550     ** 用途:检查输入字符串是否为有效的身份证号
551     ** 输入:str:字符串
552     ** 返回:如果通过验证返回true,否则返回false
553     */
554    isCardNo: function (card) {
555      // 身份证号码为15位或者18位,15位时全为数字,18位前17位为数字,最后一位是校验位,可能为数字或字符X
556      var reg = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/;
557      if (reg.test(card)) {
558        return true;
559      } else {
560        return false;
561      }
562    },
563
564    /*
565     ** 用途:检查输入字符串是否以字母开头
566     ** 输入:str:字符串
567     ** 返回:如果通过验证返回true,否则返回false
568     */
569    isLetterStart: function (str) {
570      var regu = '^[a-zA-Z]';
571      var re = new RegExp(regu);
572      if (re.test(str)) {
573        return true;
574      } else {
575        return false;
576      }
577    },
578
579    /*
580     ** 用途:检查输入的字符串的长度是否符合标准
581     ** 输入:str:字符串 minNum:最小长度 maxNum:最大长度
582     ** 返回:如果通过验证返回true,否则返回false
583     */
584    checkLength: function (str, minNum, maxNum) {
585      if (str.length >= minNum && str.length <= maxNum) {
586        return true;
587      } else {
588        return false;
589      }
590    },
591
592    /*
593     ** 用途:剔除字符串中的敏感字符,防止script代码注入
594     ** 输入:str:字符串
595     ** 返回:如果通过验证返回true,否则返回false
596     */
597    stripScript: function (str) {
598      var pattern = new RegExp('[&*<>;]');
599      var rs = '';
600      for (var i = 0; i < str.length; i++) {
601        rs = rs + str.substr(i, 1).replace(pattern, '');
602      }
603      return rs;
604    },
605    /*
606     ** 用途:将已经经过转义的字符,正常显示
607     ** 输入:str:字符串
608     ** 返回:转义后的字符串
609     */
610    html_decode: function (str) {
611      var s = '';
612      if (str == null || str.length == 0) return '';
613      s = str.replace(/&gt;/g, '>');
614      s = s.replace(/&lt;/g, '<');
615      s = s.replace(/&gt/g, '>');
616      s = s.replace(/&lt/g, '<');
617      s = s.replace(/&nbsp;/g, ' ');
618      s = s.replace(/&amp;nbsp;/g, ' ');
619      s = s.replace(/&amp;/g, '&');
620      s = s.replace(/&#39;/g, "'");
621      s = s.replace(/&amp;quot;/g, '"');
622      s = s.replace(/&gt;quot;/g, '"');
623      s = s.replace(/>quot;/g, "'");
624      s = s.replace(/&quot;/g, '"');
625      s = s.replace(/<br>/g, '\n');
626      return s;
627    },
628    /*
629     ** 用途:输入框中输入的特殊字符进行转义
630     ** 输入:str:字符串
631     ** 返回:转义后的字符串
632     */
633    html_encode: function (str) {
634      var s = '';
635      if (str.length == 0) return '';
636      s = str.replace(/&/g, '&gt;');
637      s = s.replace(/</g, '&lt;');
638      s = s.replace(/>/g, '&gt;');
639      s = s.replace(/ /g, '&nbsp;');
640      s = s.replace(/\'/g, '&#39;');
641      s = s.replace(/\"/g, '&quot;');
642      s = s.replace(/\n/g, '<br>');
643      return s;
644    },
645
646    /*
647     ** 用途:查看字符串的字节数
648     ** 输入:str:字符串
649     ** 返回:字节数
650     */
651    getBytesLength: function (str) {
652      // 在GBK编码里,除了ASCII字符,其它都占两个字符宽
653      return str.replace(/[^\x00-\xff]/g, 'xx').length;
654    },
655
656    // ------------------------cookie操作------------------------
657    /*
658     ** 用途:向浏览器添加cookie
659     ** 输入:objName : 存入的cookie名称  |  objValue : 对应的cookie值  |  objHours : cookie保存时间
660     ** 返回:无返回值
661     */
662    addCookie: function (objName, objValue, objHours) {
663      var str = objName + '=' + escape(objValue);
664      if (objHours > 0) {
665        //为0时不设定过期时间,浏览器关闭时cookie自动消失
666        var date = new Date();
667        var ms = objHours * 3600 * 1000;
668        date.setTime(date.getTime() + ms);
669        str += '; expires=' + date.toGMTString();
670      }
671      document.cookie = str;
672    },
673    setCookie: function (name, value) {
674      var Days = 1;
675      var exp = new Date();
676      exp.setTime(exp.getTime() + Days * 24 * 60 * 60 * 1000);
677      var hostname = location.hostname.substring(location.hostname.indexOf('.') + 1); // 设置为一级域名
678      document.cookie = name + '=' + escape(value) + ';expires=' + exp.toGMTString() + ';domain=' + hostname + ';path=/';
679    },
680    setCookieToday: function (name, value) {
681      var exp = new Date();
682      exp.setDate(exp.getDate());
683      exp.setHours(23);
684      exp.setMinutes(59);
685      exp.setSeconds(59);
686      exp.setTime(exp.getTime());
687      var hostname = location.hostname.substring(location.hostname.indexOf('.') + 1); // 设置为一级域名
688      document.cookie = name + '=' + escape(value) + ';expires=' + exp.toGMTString() + ';path=/';
689    },
690
691    /*
692     ** 用途:根据cookie名称取得cookie值
693     ** 输入:objName : cookie名称
694     ** 返回:与cookie名称对应的cookie值(如果存在的话)
695     */
696    getCookie: function (objName) {
697      var arrStr = document.cookie.split('; ');
698      for (var i = 0; i < arrStr.length; i++) {
699        var temp = arrStr[i].split('=');
700        if (temp[0] == objName) {
701          return unescape(temp[1]);
702        }
703      }
704      return null;
705    },
706
707    /*
708     ** 用途:根据cookie名称删除cookie
709     ** 输入:objName : cookie名称
710     ** 返回:无返回值
711     */
712    delCookie: function (objName) {
713      var date = new Date();
714      date.setTime(date.getTime() - 10000);
715      document.cookie = objName + '=a; expires=' + date.toGMTString();
716    },
717
718    /*
719     ** 用途:取得浏览器中的所有cookie
720     ** 输入:无
721     ** 返回:所有cookie的字符串
722     */
723    allCookie: function () {
724      return document.cookie;
725    },
726    clearAllCookie: function () {
727      var cookies = document.cookie.split(';');
728      for (var i = 0; i < cookies.length; i++) {
729        var cookie = cookies[i];
730        var eqPos = cookie.indexOf('=');
731        var name = eqPos > -1 ? cookie.substr(0, eqPos) : cookie;
732        document.cookie = name + '=;expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/';
733      }
734      if (cookies.length > 0) {
735        for (var i = 0; i < cookies.length; i++) {
736          var cookie = cookies[i];
737          var eqPos = cookie.indexOf('=');
738          var name = eqPos > -1 ? cookie.substr(0, eqPos) : cookie;
739          var domain = location.host.substr(location.host.indexOf('.'));
740          document.cookie = name + '=;expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/; domain=' + domain;
741        }
742      }
743    },
744
745    /*
746     ** 用途:传入范围,在范围内生成随机数
747     ** 输入:Min:最小数	Max:最大数
748     ** 返回:随机数
749     */
750    GetRandomNum: function (Min, Max) {
751      var Range = Max - Min;
752      var Rand = Math.random();
753      return Min + Math.round(Rand * Range);
754    },
755
756    /*
757     ** 用途:获取指定区间范围随机数
758     ** 输入:lowerValue:最小数	upperValue:最大数
759     ** 返回:随机数
760     */
761    //
762    randomFrom: function (lowerValue, upperValue) {
763      return Math.floor(Math.random() * (upperValue - lowerValue + 1) + lowerValue);
764    },
765
766    /*
767     ** 用途:取得地址中的参数
768     ** 输入:name: key值
769     ** 返回:key值对应的值
770     */
771    GetQueryString: function (name) {
772      var result = '';
773      var searchStr = window.location.search.substr(1);
774      if (!searchStr || searchStr === '') {
775        return null;
776      }
777
778      searchs = searchStr.split('&');
779      var querys = {};
780      for (var i = searchs.length - 1; i >= 0; i--) {
781        querys[searchs[i].split('=')[0]] = searchs[i].split('=')[1];
782      }
783
784      if (querys[name] && querys[name] !== '' && querys[name] !== 'null') {
785        result = querys[name];
786      }
787
788      return result;
789    },
790
791    AddQueryString: function (uri, key, value) {
792      if (!value) {
793        return uri;
794      }
795      var re = new RegExp('([?&])' + key + '=.*?(&|$)', 'i');
796      var separator = uri.indexOf('?') !== -1 ? '&' : '?';
797      if (uri.match(re)) {
798        return uri.replace(re, '$1' + key + '=' + value + '$2');
799      } else {
800        return uri + separator + key + '=' + value;
801      }
802    },
803
804    // 获取随即字符串
805    getRandomString: function () {
806      var str = '',
807        range = 30,
808        arr = [
809          '0',
810          '1',
811          '2',
812          '3',
813          '4',
814          '5',
815          '6',
816          '7',
817          '8',
818          '9',
819          'a',
820          'b',
821          'c',
822          'd',
823          'e',
824          'f',
825          'g',
826          'h',
827          'i',
828          'j',
829          'k',
830          'l',
831          'm',
832          'n',
833          'o',
834          'p',
835          'q',
836          'r',
837          's',
838          't',
839          'u',
840          'v',
841          'w',
842          'x',
843          'y',
844          'z',
845          'A',
846          'B',
847          'C',
848          'D',
849          'E',
850          'F',
851          'G',
852          'H',
853          'I',
854          'J',
855          'K',
856          'L',
857          'M',
858          'N',
859          'O',
860          'P',
861          'Q',
862          'R',
863          'S',
864          'T',
865          'U',
866          'V',
867          'W',
868          'X',
869          'Y',
870          'Z',
871        ];
872
873      // 随机产生
874      for (var i = 0; i < range; i++) {
875        str += arr[Math.round(Math.random() * (arr.length - 1))];
876      }
877      return str;
878    },
879
880    // 输入框效果
881    loadInputComponentEvent: function () {
882      var inputs = $('.input-component').find('input');
883      inputs.each(function () {
884        $(this).focus(function () {
885          $(this).parent().addClass('input-component-onfocus');
886          $(this).siblings('label').addClass('active active-font');
887          if ($(this).parent().hasClass('input-error')) {
888            $(this).siblings('label').addClass('error-font-color');
889          } else {
890            $(this).siblings('label').removeClass('error-font-color');
891          }
892        });
893        $(this).focusout(function () {
894          $(this).parent().removeClass('input-component-onfocus');
895          if (!$(this).val()) {
896            $(this).siblings('label').removeClass('active active-font');
897            if ($(this).parent().hasClass('input-error')) {
898              $(this).siblings('label').addClass('error-font-color');
899            } else {
900              $(this).siblings('label').removeClass('error-font-color');
901            }
902          } else {
903            $(this).siblings('label').removeClass('active-font');
904            if ($(this).parent().hasClass('input-error')) {
905              $(this).siblings('label').addClass('error-font-color');
906            } else {
907              $(this).siblings('label').removeClass('error-font-color');
908            }
909          }
910        });
911      });
912    },
913
914    // 数组去重复
915    array_unique: function (array) {
916      var n = {},
917        r = []; //n为hash表,r为临时数组
918      for (var i = 0; i < array.length; i++) {
919        //遍历当前数组
920        if (!n[array[i]]) {
921          //如果hash表中没有当前项
922          n[array[i]] = true; //存入hash表
923          r.push(array[i]); //把当前数组的当前项push到临时数组里面
924        }
925      }
926      return r;
927    },
928
929    // 取得鼠标进入对象的方位
930    // mouseEvent: 鼠标对象  enterObj: 进入对象
931    getMousePosition: function (mouseEvent, enterObj) {
932      enterObj = $(enterObj);
933      var w = $(enterObj).width();
934      var h = $(enterObj).height();
935      var x = (mouseEvent.pageX - enterObj.offset().left - w / 2) * (w > h ? h / w : 1);
936      var y = (mouseEvent.pageY - enterObj.offset().top - h / 2) * (h > w ? w / h : 1);
937      var direction = Math.round((Math.atan2(y, x) * (180 / Math.PI) + 180) / 90 + 3) % 4;
938      var eventType = mouseEvent.type;
939      var dirName = new Array('top', 'right', 'bottom', 'left');
940      if (eventType == 'mouseenter') {
941        return dirName[direction];
942      } else {
943        return dirName[direction];
944      }
945    },
946    // 获取鼠标是否在某个元素内
947    checkMouseIsInDom: function (_layer) {
948      if (!window.event) {
949        return false;
950      }
951      var x = Number(window.event.clientX) - Number($('.i-design-work-bench-content')[0].getBoundingClientRect().left); // 鼠标相对屏幕横坐标
952      var y = Number(window.event.clientY) - Number($('.i-design-work-bench-content')[0].getBoundingClientRect().top); // 鼠标相对屏幕纵坐标
953      _layer = _layer.rect_outer.point;
954      return this.isPointInPolygon({ x, y }, [_layer.left_top, _layer.right_top, _layer.right_bottom, _layer.left_bottom]);
955    },
956    // 判断点是否在另一平面图中
957    // 点: { x: xxx, y: xxx }
958    // 线: [{ x: xxx, y: xxx }, { x: xxx, y: xxx }]
959    // 面: [{ x: xxx, y: xxx }, { x: xxx, y: xxx }, { x: xxx, y: xxx }...]
960    isPointInPolygon: function (point, polygon) {
961      //基本思想是利用射线法,计算射线与多边形各边的交点,如果是偶数,则点在多边形外,否则
962      //在多边形内。还会考虑一些特殊情况,如点在多边形顶点上,点在多边形边上等特殊情况。
963
964      var N = polygon.length;
965      var boundOrVertex = true; //如果点位于多边形的顶点或边上,也算做点在多边形内,直接返回true
966      var intersectCount = 0; //cross points count of x
967      var precision = 2e-10; //浮点类型计算时候与0比较时候的容差
968      var p1, p2; //neighbour bound vertices
969      var p = point; //测试点
970
971      p1 = polygon[0]; //left vertex
972      for (var i = 1; i <= N; ++i) {
973        //check all rays
974        if (p.x == p1.x && p.y == p1.y) {
975          return boundOrVertex; //p is an vertex
976        }
977
978        p2 = polygon[i % N]; //right vertex
979        if (p.y < Math.min(p1.y, p2.y) || p.y > Math.max(p1.y, p2.y)) {
980          //ray is outside of our interests
981          p1 = p2;
982          continue; //next ray left point
983        }
984
985        if (p.y > Math.min(p1.y, p2.y) && p.y < Math.max(p1.y, p2.y)) {
986          //ray is crossing over by the algorithm (common part of)
987          if (p.x <= Math.max(p1.x, p2.x)) {
988            //x is before of ray
989            if (p1.y == p2.y && p.x >= Math.min(p1.x, p2.x)) {
990              //overlies on a horizontal ray
991              return boundOrVertex;
992            }
993
994            if (p1.x == p2.x) {
995              //ray is vertical
996              if (p1.x == p.x) {
997                //overlies on a vertical ray
998                return boundOrVertex;
999              } else {
1000                //before ray
1001                ++intersectCount;
1002              }
1003            } else {
1004              //cross point on the left side
1005              var xinters = ((p.y - p1.y) * (p2.x - p1.x)) / (p2.y - p1.y) + p1.x; //cross point of x
1006              if (Math.abs(p.x - xinters) < precision) {
1007                //overlies on a ray
1008                return boundOrVertex;
1009              }
1010
1011              if (p.x < xinters) {
1012                //before ray
1013                ++intersectCount;
1014              }
1015            }
1016          }
1017        } else {
1018          //special case when ray is crossing through the vertex
1019          if (p.y == p2.y && p.x <= p2.x) {
1020            //p crossing over p2
1021            var p3 = polygon[(i + 1) % N]; //next vertex
1022            if (p.y >= Math.min(p1.y, p3.y) && p.y <= Math.max(p1.y, p3.y)) {
1023              //p.y lies between p1.y & p3.y
1024              ++intersectCount;
1025            } else {
1026              intersectCount += 2;
1027            }
1028          }
1029        }
1030        p1 = p2; //next ray left point
1031      }
1032
1033      if (intersectCount % 2 == 0) {
1034        //偶数在多边形外
1035        return false;
1036      } else {
1037        //奇数在多边形内
1038        return true;
1039      }
1040    },
1041    // 判断鼠标选区与图层是否相交(图层有可能旋转)
1042    // 点: { x: xxx, y: xxx }
1043    // 线: [{ x: xxx, y: xxx }, { x: xxx, y: xxx }]
1044    // 面: [{ x: xxx, y: xxx }, { x: xxx, y: xxx }, { x: xxx, y: xxx }...]
1045    isPolygonsOverlap: function (selectionPoint, layerPoint) {
1046      let _this = this;
1047      plyA = [selectionPoint.left_top, selectionPoint.right_top, selectionPoint.right_bottom, selectionPoint.left_bottom];
1048      plyB = [layerPoint.left_top, layerPoint.right_top, layerPoint.right_bottom, layerPoint.left_bottom];
1049      return isPolygonsIntersectant(plyA, plyB) || isPointInPolygonBidirectional(plyA, plyB);
1050      //判断两多边形线段是否相交
1051      function isSegmentsIntersectant(segA, segB) {
1052        //线线
1053        const abc = (segA[0].x - segB[0].x) * (segA[1].y - segB[0].y) - (segA[0].y - segB[0].y) * (segA[1].x - segB[0].x);
1054        const abd = (segA[0].x - segB[1].x) * (segA[1].y - segB[1].y) - (segA[0].y - segB[1].y) * (segA[1].x - segB[1].x);
1055        if (abc * abd >= 0) {
1056          return false;
1057        }
1058        const cda = (segB[0].x - segA[0].x) * (segB[1].y - segA[0].y) - (segB[0].y - segA[0].y) * (segB[1].x - segA[0].x);
1059        const cdb = cda + abc - abd;
1060        return !(cda * cdb >= 0);
1061      }
1062
1063      //判断两多边形边界是否相交
1064      function isPolygonsIntersectant(plyA, plyB) {
1065        //面面
1066        for (let i = 0, il = plyA.length; i < il; i++) {
1067          for (let j = 0, jl = plyB.length; j < jl; j++) {
1068            const segA = [plyA[i], plyA[i === il - 1 ? 0 : i + 1]];
1069            const segB = [plyB[j], plyB[j === jl - 1 ? 0 : j + 1]];
1070            if (isSegmentsIntersectant(segA, segB)) {
1071              return true;
1072            }
1073          }
1074        }
1075        return false;
1076      }
1077      //判断两多变形是否存在点与区域的包含关系(A的点在B的区域内或B的点在A的区域内)
1078      function isPointInPolygonBidirectional(plyA, plyB) {
1079        //面面
1080        let [a, b] = [false, false];
1081        a = plyA.some(item => _this.isPointInPolygon(item, plyB));
1082        if (!a) {
1083          b = plyB.some(item => _this.isPointInPolygon(item, plyA));
1084        }
1085        return a || b;
1086      }
1087    },
1088
1089    // 根据条件显示对应字数的字符串, 如果多则剪切
1090    getStringByNum: function (str, num) {
1091      if (str) {
1092        if (str.length > num) {
1093          str = str.substr(0, num) + '...';
1094        }
1095        return str;
1096      }
1097      return str;
1098    },
1099
1100    //---------------------------------------------------
1101    // 日期格式化
1102    // 格式 YYYY/yyyy/YY/yy 表示年份
1103    // MM/M 月份
1104    // W/w 星期
1105    // dd/DD/d/D 日期
1106    // hh/HH/h/H 时间
1107    // mm/m 分钟
1108    // ss/SS/s/S 秒
1109    //---------------------------------------------------
1110    dateFormat: function (date, formatStr) {
1111      var str = formatStr;
1112      var Week = ['日', '一', '二', '三', '四', '五', '六'];
1113
1114      str = str.replace(/yyyy|YYYY/, date.getFullYear());
1115      str = str.replace(/yy|YY/, date.getYear() % 100 > 9 ? (date.getYear() % 100).toString() : '0' + (date.getYear() % 100));
1116
1117      str = str.replace(/MM/, date.getMonth() + 1 > 9 ? (date.getMonth() + 1).toString() : '0' + (date.getMonth() + 1));
1118      str = str.replace(/M/g, date.getMonth() + 1);
1119
1120      str = str.replace(/w|W/g, Week[date.getDay()]);
1121
1122      str = str.replace(/dd|DD/, date.getDate() > 9 ? date.getDate().toString() : '0' + date.getDate());
1123      str = str.replace(/d|D/g, date.getDate());
1124
1125      str = str.replace(/hh|HH/, date.getHours() > 9 ? date.getHours().toString() : '0' + date.getHours());
1126      str = str.replace(/h|H/g, date.getHours());
1127      str = str.replace(/mm/, date.getMinutes() > 9 ? date.getMinutes().toString() : '0' + date.getMinutes());
1128      str = str.replace(/m/g, date.getMinutes());
1129
1130      str = str.replace(/ss|SS/, date.getSeconds() > 9 ? date.getSeconds().toString() : '0' + date.getSeconds());
1131      str = str.replace(/s|S/g, date.getSeconds());
1132
1133      return str;
1134    },
1135
1136    //+---------------------------------------------------
1137    //| 关于日期操作的一些操作 - 取得当前日期
1138    //| 格式为 2015-11-03 15:34
1139    //+---------------------------------------------------
1140    getCurentTime: function () {
1141      var now = new Date();
1142      var year = now.getFullYear(); //å¹´
1143      var month = now.getMonth() + 1; //月
1144      var day = now.getDate(); //日
1145
1146      var hh = now.getHours(); //时
1147      var mm = now.getMinutes(); //分
1148      var ss = ':00'; //秒
1149
1150      var clock = year + '-';
1151
1152      if (month < 10) {
1153        clock += '0';
1154      }
1155
1156      clock += month + '-';
1157
1158      if (day < 10) {
1159        clock += '0';
1160      }
1161
1162      clock += day + ' ';
1163
1164      // if(hh < 10){
1165      // 	clock += "0";
1166      // }
1167
1168      // clock += hh + ":";
1169
1170      // if (mm < 10){
1171      // 	clock += '0';
1172      // }
1173
1174      // clock += mm + ss;
1175      return clock;
1176    },
1177
1178    //+---------------------------------------------------
1179    //| 关于日期操作的一些操作 - 取得当前日期(不带0)
1180    //| 格式为 2015-11-03 15:34
1181    //+---------------------------------------------------
1182    getCurentTimeParse: function () {
1183      var now = new Date();
1184      var year = now.getFullYear(); //å¹´
1185      var month = now.getMonth() + 1; //月
1186      var day = now.getDate(); //日
1187
1188      var hh = now.getHours(); //时
1189      var mm = now.getMinutes(); //分
1190      var ss = ':00'; //秒
1191
1192      var clock = year + '-';
1193
1194      // if (month < 10) {
1195      //     clock += "0";
1196      // }
1197
1198      clock += month + '-';
1199
1200      // if (day < 10) {
1201      //     clock += "0";
1202      // }
1203
1204      clock += day + ' ';
1205
1206      // if(hh < 10){
1207      // 	clock += "0";
1208      // }
1209
1210      // clock += hh + ":";
1211
1212      // if (mm < 10){
1213      // 	clock += '0';
1214      // }
1215
1216      // clock += mm + ss;
1217      return clock;
1218    },
1219
1220    //+---------------------------------------------------
1221    //| 关于日期操作的一些操作 - 取得当前时间的时分秒
1222    //+---------------------------------------------------
1223    getEventTime: function () {
1224      var curentTime = null;
1225      var now = new Date();
1226      var H = now.getHours();
1227      var M = now.getMinutes();
1228      var S = now.getSeconds();
1229      H = H < 10 ? '0' + H : H;
1230      M = M < 10 ? '0' + M : M;
1231      S = S < 10 ? '0' + S : S;
1232      curentTime = H + ':' + M + ':' + S;
1233      return curentTime;
1234    },
1235
1236    //+---------------------------------------------------
1237    //| 关于日期操作的一些操作 - 取得当前时间的日期
1238    //+---------------------------------------------------
1239    getEventDay: function () {
1240      var curentTime = null;
1241      var now = new Date();
1242      var year = now.getFullYear();
1243      var month = now.getMonth() + 1;
1244      var day = now.getDate();
1245      month = month < 10 ? '0' + month : month;
1246      day = day < 10 ? '0' + day : day;
1247      curentTime = year + '-' + month + '-' + day;
1248      return curentTime;
1249    },
1250
1251    //+---------------------------------------------------
1252    //| 比较当前时间是否在某个时间段
1253    //+---------------------------------------------------
1254    getTimeRange: function (beginTime, endTime) {
1255      var strb = beginTime.split(':');
1256      if (strb.length != 2) {
1257        return false;
1258      }
1259
1260      var stre = endTime.split(':');
1261      if (stre.length != 2) {
1262        return false;
1263      }
1264
1265      var b = new Date();
1266      var e = new Date();
1267      var n = new Date();
1268
1269      b.setHours(strb[0]);
1270      b.setMinutes(strb[1]);
1271      e.setHours(stre[0]);
1272      e.setMinutes(stre[1]);
1273
1274      if (n.getTime() - b.getTime() > 0 && n.getTime() - e.getTime() < 0) {
1275        return true;
1276      }
1277    },
1278
1279    //+---------------------------------------------------
1280    //| 日期计算 - 增加
1281    //+---------------------------------------------------
1282    dateAdd: function (date, strInterval, Number) {
1283      var dtTmp = date;
1284      switch (strInterval) {
1285        case 's':
1286          return new Date(Date.parse(dtTmp.replace(/-/g, '/')) + 1000 * Number); // 秒
1287        case 'n':
1288          return new Date(Date.parse(dtTmp.replace(/-/g, '/')) + 60000 * Number); // 分
1289        case 'h':
1290          return new Date(Date.parse(dtTmp.replace(/-/g, '/')) + 3600000 * Number); // 时
1291        case 'd':
1292          return new Date(Date.parse(dtTmp.replace(/-/g, '/')) + 86400000 * Number); // 天
1293        case 'w':
1294          return new Date(Date.parse(dtTmp.replace(/-/g, '/')) + 86400000 * 7 * Number); // 周
1295        case 'q':
1296          return new Date(dtTmp.getFullYear(), dtTmp.getMonth() + Number * 3, dtTmp.getDate(), dtTmp.getHours(), dtTmp.getMinutes(), dtTmp.get
1296Seconds()); // å­£
1297        case 'm':
1298          return new Date(dtTmp.getFullYear(), dtTmp.getMonth() + Number, dtTmp.getDate(), dtTmp.getHours(), dtTmp.getMinutes(), dtTmp.getSeconds()); // 月
1299        case 'y':
1300          return new Date(dtTmp.getFullYear() + Number, dtTmp.getMonth(), dtTmp.getDate(), dtTmp.getHours(), dtTmp.getMinutes(), dtTmp.getSeconds()); // å¹´
1301      }
1302    },
1303
1304    //+---------------------------------------------------
1305    //| 日期计算 - 减去
1306    //+---------------------------------------------------
1307    dateMinus: function (date, strInterval, Number) {
1308      var dtTmp = date;
1309      switch (strInterval) {
1310        case 's':
1311          return new Date(Date.parse(dtTmp.replace(/-/g, '/')) - 1000 * Number); // 秒
1312        case 'n':
1313          return new Date(Date.parse(dtTmp.replace(/-/g, '/')) - 60000 * Number); // 分
1314        case 'h':
1315          return new Date(Date.parse(dtTmp.replace(/-/g, '/')) - 3600000 * Number); // 时
1316        case 'd':
1317          return new Date(Date.parse(dtTmp.replace(/-/g, '/')) - 86400000 * Number); // 天
1318        case 'w':
1319          return new Date(Date.parse(dtTmp.replace(/-/g, '/')) - 86400000 * 7 * Number); // 周
1320        case 'q':
1321          return new Date(dtTmp.getFullYear(), dtTmp.getMonth() - Number * 3, dtTmp.getDate(), dtTmp.getHours(), dtTmp.getMinutes(), dtTmp.get
1321Seconds()); // å­£
1322        case 'm':
1323          return new Date(dtTmp.getFullYear(), dtTmp.getMonth() - Number, dtTmp.getDate(), dtTmp.getHours(), dtTmp.getMinutes(), dtTmp.getSeconds()); // 月
1324        case 'y':
1325          return new Date(dtTmp.getFullYear() - Number, dtTmp.getMonth(), dtTmp.getDate(), dtTmp.getHours(), dtTmp.getMinutes(), dtTmp.getSeconds()); // å¹´
1326      }
1327    },
1328
1329    //+---------------------------------------------------
1330    //| 比较日期差 dtEnd 格式为日期型或者有效日期格式字符串
1331    //+---------------------------------------------------
1332    dateDiff: function (date, strInterval, dtEnd) {
1333      var dtStart = date;
1334      switch (strInterval) {
1335        case 's':
1336          return parseInt((dtEnd - dtStart) / 1000); // 秒
1337        case 'n':
1338          return parseInt((dtEnd - dtStart) / 60000); // 分
1339        case 'h':
1340          return parseInt((dtEnd - dtStart) / 3600000); // 时
1341        case 'd':
1342          return parseInt((dtEnd - dtStart) / 86400000); // 天
1343        case 'w':
1344          return parseInt((dtEnd - dtStart) / (86400000 * 7)); // 周
1345        case 'm':
1346          return dtEnd.getMonth() + 1 + (dtEnd.getFullYear() - dtStart.getFullYear()) * 12 - (dtStart.getMonth() + 1); // 月
1347        case 'y':
1348          return dtEnd.getFullYear() - dtStart.getFullYear(); // å¹´
1349      }
1350    },
1351
1352    getMonthDays: function (selectedDate) {
1353      var year = selectedDate.substring(0, 4);
1354      var month = selectedDate.substring(5, 7);
1355      var d = new Date(year, month, 0);
1356      var daysCount = d.getDate();
1357      return daysCount;
1358    },
1359
1360    DatetoArray: function (date) {
1361      var myDate = date;
1362      var myArray = Array();
1363      myArray[0] = myDate.getFullYear();
1364      myArray[1] = myDate.getMonth();
1365      myArray[2] = myDate.getDate();
1366      myArray[3] = myDate.getHours();
1367      myArray[4] = myDate.getMinutes();
1368      myArray[5] = myDate.getSeconds();
1369      return myArray;
1370    },
1371
1372    //+---------------------------------------------------
1373    //| 字符串转日期类型
1374    //+---------------------------------------------------
1375    StringToDate: function (DateStr) {
1376      if (!DateStr) {
1377        return false;
1378      }
1379      var _date = DateStr.split(' ')[0];
1380      var _time = DateStr.split(' ')[1];
1381      var arys = _date.split('-');
1382      var arys_time = _time.split(':');
1383      myDate = new Date(arys[0], --arys[1], arys[2], arys_time[0], arys_time[1], '');
1384      return myDate;
1385    },
1386
1387    //+---------------------------------------------------
1388    //| 日期时间检查
1389    //| 格式为:YYYY-MM-DD HH:MM:SS
1390    //+---------------------------------------------------
1391    CheckDateTime: function (str) {
1392      var reg = /^(\d{1,4})(-|\/)(\d{1,2})\2(\d{1,2}) (\d{1,2}):(\d{1,2}):(\d{1,2})$/;
1393      var r = str.match(reg);
1394      if (r == null) return false;
1395      return true;
1396    },
1397
1398    //+---------------------------------------------------
1399    //| 取得日期数据信息
1400    //| 参数 interval 表示数据类型
1401    //| y 年 m月 d日 w星期 ww周 h时 n分 s秒
1402    //+---------------------------------------------------
1403
1404    DatePart: function (data, interval) {
1405      var myDate = data;
1406      var partStr = '';
1407      var Week = ['日', '一', '二', '三', '四', '五', '六'];
1408      switch (interval) {
1409        case 'y':
1410          partStr = myDate.getFullYear();
1411          break;
1412        case 'm':
1413          partStr = myDate.getMonth() + 1;
1414          break;
1415        case 'd':
1416          partStr = myDate.getDate();
1417          break;
1418        case 'w':
1419          partStr = Week[myDate.getDay()];
1420          break;
1421        case 'ww':
1422          partStr = myDate.WeekNumOfYear();
1423          break;
1424        case 'h':
1425          partStr = myDate.getHours();
1426          break;
1427        case 'n':
1428          partStr = myDate.getMinutes();
1429          break;
1430        case 's':
1431          partStr = myDate.getSeconds();
1432          break;
1433      }
1434      return partStr;
1435    },
1436
1437    bLength: function (str) {
1438      if (!str) {
1439        return 0;
1440      }
1441      var aMatch = str.match(/[^\x00-\xff]/g);
1442      return str.length + (!aMatch ? 0 : aMatch.length);
1443    },
1444
1445    // 取得字符串的长度
1446    getStringLength: function (str) {
1447      if (!str) {
1448        return false;
1449      }
1450      str = str.replace(/\r\n/g, '\n');
1451      var min = 41,
1452        max = 140,
1453        surl = 20,
1454        tmp = str;
1455      var urls = str.match(/http:\/\/[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)+([-A-Z0-9a-z_\$\.\+\!\*\(\)\/,:;@&=\?\~\#\%]*)*/gi) || [];
1456      var urlCount = 0;
1457      for (var i = 0, len = urls.length; i < len; i++) {
1458        var count = this.bLength(urls[i]);
1459        if (/^(http:\/\/t.cn)/.test(urls[i])) {
1460          continue;
1461        } else {
1462          if (/^(http:\/\/)+(t.sina.com.cn|t.sina.cn)/.test(urls[i]) || /^(http:\/\/)+(weibo.com|weibo.cn)/.test(urls[i])) {
1463            urlCount += count <= min ? count : count <= max ? surl : count - max + surl;
1464          } else {
1465            urlCount += count <= max ? surl : count - max + surl;
1466          }
1467        }
1468        tmp = tmp.replace(urls[i], '');
1469      }
1470      var result = Math.ceil((urlCount + this.bLength(tmp)) / 2);
1471      //$.log('rs = '+result);
1472      return result;
1473    },
1474
1475    // 检测内容中URL地址的长度
1476    checkUrlength: function (content, type) {
1477      var len = (max = std = 0);
1478      var urls = [];
1479      if (type == 'sina') {
1480        (max = 140), (std = 20);
1481        urls = content.match(/https?:\/\/[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)+([-A-Z0-9a-z_\$\.\+\!\*\(\)\/,:;@&=\?\~\#\%]*)*/gi) || [];
1482      } else {
1483        (max = 257), (std = 22);
1484        var urlReg = RegExp(
1485          '((news|telnet|nttp|file|http|ftp|https)://){1}(([-A-Za-z0-9]+(\\.[-A-Za-z0-9]+)*(\\.[-A-Za-z]{2,5}))|([0-9]{1,3}(\\.[0-9]{1,3}){3}))(:[0-9]*)?(/[-A-Za-z0-9_\\$\\.\\+\\!\\*\\(\\),;:@&=\\?/~\\#\\%]*)*',
1486          'gi'
1487        );
1488        var result, arr;
1489        while ((result = urlReg.exec(content)) != null) {
1490          arr = result.toString().split(',');
1491          urls.push(arr[0]);
1492        }
1493      }
1494
1495      if (urls.length == 0) {
1496        return 0;
1497      }
1498
1499      var de = max - std;
1500      for (var i = 0, url; (url = urls[i]); i++) {
1501        if (url.length >= max) {
1502          len += de;
1503        } else {
1504          len += url.length - std;
1505        }
1506      }
1507      return len;
1508    },
1509
1510    length: function (a) {
1511      var b = 0;
1512      for (var i = 0; i < a.length; i++) {
1513        if (a.charCodeAt(i) < 0 || a.charCodeAt(i) > 255) {
1514          b = b + 2;
1515        } else {
1516          b = b + 1;
1517        }
1518      }
1519      return b;
1520    },
1521    //MD5方法
1522    MD5: function (string) {
1523      function RotateLeft(lValue, iShiftBits) {
1524        return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits));
1525      }
1526
1527      function AddUnsigned(lX, lY) {
1528        var lX4, lY4, lX8, lY8, lResult;
1529
1530        lX8 = lX & 0x80000000;
1531
1532        lY8 = lY & 0x80000000;
1533
1534        lX4 = lX & 0x40000000;
1535
1536        lY4 = lY & 0x40000000;
1537
1538        lResult = (lX & 0x3fffffff) + (lY & 0x3fffffff);
1539
1540        if (lX4 & lY4) {
1541          return lResult ^ 0x80000000 ^ lX8 ^ lY8;
1542        }
1543
1544        if (lX4 | lY4) {
1545          if (lResult & 0x40000000) {
1546            return lResult ^ 0xc0000000 ^ lX8 ^ lY8;
1547          } else {
1548            return lResult ^ 0x40000000 ^ lX8 ^ lY8;
1549          }
1550        } else {
1551          return lResult ^ lX8 ^ lY8;
1552        }
1553      }
1554
1555      function F(x, y, z) {
1556        return (x & y) | (~x & z);
1557      }
1558
1559      function G(x, y, z) {
1560        return (x & z) | (y & ~z);
1561      }
1562
1563      function H(x, y, z) {
1564        return x ^ y ^ z;
1565      }
1566
1567      function I(x, y, z) {
1568        return y ^ (x | ~z);
1569      }
1570
1571      function FF(a, b, c, d, x, s, ac) {
1572        a = AddUnsigned(a, AddUnsigned(AddUnsigned(F(b, c, d), x), ac));
1573
1574        return AddUnsigned(RotateLeft(a, s), b);
1575      }
1576
1577      function GG(a, b, c, d, x, s, ac) {
1578        a = AddUnsigned(a, AddUnsigned(AddUnsigned(G(b, c, d), x), ac));
1579
1580        return AddUnsigned(RotateLeft(a, s), b);
1581      }
1582
1583      function HH(a, b, c, d, x, s, ac) {
1584        a = AddUnsigned(a, AddUnsigned(AddUnsigned(H(b, c, d), x), ac));
1585
1586        return AddUnsigned(RotateLeft(a, s), b);
1587      }
1588
1589      function II(a, b, c, d, x, s, ac) {
1590        a = AddUnsigned(a, AddUnsigned(AddUnsigned(I(b, c, d), x), ac));
1591
1592        return AddUnsigned(RotateLeft(a, s), b);
1593      }
1594
1595      function ConvertToWordArray(string) {
1596        var lWordCount;
1597
1598        var lMessageLength = string.length;
1599
1600        var lNumberOfWords_temp1 = lMessageLength + 8;
1601
1602        var lNumberOfWords_temp2 = (lNumberOfWords_temp1 - (lNumberOfWords_temp1 % 64)) / 64;
1603
1604        var lNumberOfWords = (lNumberOfWords_temp2 + 1) * 16;
1605
1606        var lWordArray = Array(lNumberOfWords - 1);
1607
1608        var lBytePosition = 0;
1609
1610        var lByteCount = 0;
1611
1612        while (lByteCount < lMessageLength) {
1613          lWordCount = (lByteCount - (lByteCount % 4)) / 4;
1614
1615          lBytePosition = (lByteCount % 4) * 8;
1616
1617          lWordArray[lWordCount] = lWordArray[lWordCount] | (string.charCodeAt(lByteCount) << lBytePosition);
1618
1619          lByteCount++;
1620        }
1621
1622        lWordCount = (lByteCount - (lByteCount % 4)) / 4;
1623
1624        lBytePosition = (lByteCount % 4) * 8;
1625
1626        lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80 << lBytePosition);
1627
1628        lWordArray[lNumberOfWords - 2] = lMessageLength << 3;
1629
1630        lWordArray[lNumberOfWords - 1] = lMessageLength >>> 29;
1631
1632        return lWordArray;
1633      }
1634
1635      function WordToHex(lValue) {
1636        var WordToHexValue = '',
1637          WordToHexValue_temp = '',
1638          lByte,
1639          lCount;
1640
1641        for (lCount = 0; lCount <= 3; lCount++) {
1642          lByte = (lValue >>> (lCount * 8)) & 255;
1643
1644          WordToHexValue_temp = '0' + lByte.toString(16);
1645
1646          WordToHexValue = WordToHexValue + WordToHexValue_temp.substr(WordToHexValue_temp.length - 2, 2);
1647        }
1648
1649        return WordToHexValue;
1650      }
1651
1652      function Utf8Encode(string) {
1653        string = string.replace(/\r\n/g, '\n');
1654
1655        var utftext = '';
1656
1657        for (var n = 0; n < string.length; n++) {
1658          var c = string.charCodeAt(n);
1659
1660          if (c < 128) {
1661            utftext += String.fromCharCode(c);
1662          } else if (c > 127 && c < 2048) {
1663            utftext += String.fromCharCode((c >> 6) | 192);
1664
1665            utftext += String.fromCharCode((c & 63) | 128);
1666          } else {
1667            utftext += String.fromCharCode((c >> 12) | 224);
1668
1669            utftext += String.fromCharCode(((c >> 6) & 63) | 128);
1670
1671            utftext += String.fromCharCode((c & 63) | 128);
1672          }
1673        }
1674
1675        return utftext;
1676      }
1677
1678      var x = Array();
1679
1680      var k, AA, BB, CC, DD, a, b, c, d;
1681
1682      var S11 = 7,
1683        S12 = 12,
1684        S13 = 17,
1685        S14 = 22;
1686
1687      var S21 = 5,
1688        S22 = 9,
1689        S23 = 14,
1690        S24 = 20;
1691
1692      var S31 = 4,
1693        S32 = 11,
1694        S33 = 16,
1695        S34 = 23;
1696
1697      var S41 = 6,
1698        S42 = 10,
1699        S43 = 15,
1700        S44 = 21;
1701
1702      string = Utf8Encode(string);
1703
1704      x = ConvertToWordArray(string);
1705
1706      a = 0x67452301;
1707      b = 0xefcdab89;
1708      c = 0x98badcfe;
1709      d = 0x10325476;
1710
1711      for (k = 0; k < x.length; k += 16) {
1712        AA = a;
1713        BB = b;
1714        CC = c;
1715        DD = d;
1716
1717        a = FF(a, b, c, d, x[k + 0], S11, 0xd76aa478);
1718
1719        d = FF(d, a, b, c, x[k + 1], S12, 0xe8c7b756);
1720
1721        c = FF(c, d, a, b, x[k + 2], S13, 0x242070db);
1722
1723        b = FF(b, c, d, a, x[k + 3], S14, 0xc1bdceee);
1724
1725        a = FF(a, b, c, d, x[k + 4], S11, 0xf57c0faf);
1726
1727        d = FF(d, a, b, c, x[k + 5], S12, 0x4787c62a);
1728
1729        c = FF(c, d, a, b, x[k + 6], S13, 0xa8304613);
1730
1731        b = FF(b, c, d, a, x[k + 7], S14, 0xfd469501);
1732
1733        a = FF(a, b, c, d, x[k + 8], S11, 0x698098d8);
1734
1735        d = FF(d, a, b, c, x[k + 9], S12, 0x8b44f7af);
1736
1737        c = FF(c, d, a, b, x[k + 10], S13, 0xffff5bb1);
1738
1739        b = FF(b, c, d, a, x[k + 11], S14, 0x895cd7be);
1740
1741        a = FF(a, b, c, d, x[k + 12], S11, 0x6b901122);
1742
1743        d = FF(d, a, b, c, x[k + 13], S12, 0xfd987193);
1744
1745        c = FF(c, d, a, b, x[k + 14], S13, 0xa679438e);
1746
1747        b = FF(b, c, d, a, x[k + 15], S14, 0x49b40821);
1748
1749        a = GG(a, b, c, d, x[k + 1], S21, 0xf61e2562);
1750
1751        d = GG(d, a, b, c, x[k + 6], S22, 0xc040b340);
1752
1753        c = GG(c, d, a, b, x[k + 11], S23, 0x265e5a51);
1754
1755        b = GG(b, c, d, a, x[k + 0], S24, 0xe9b6c7aa);
1756
1757        a = GG(a, b, c, d, x[k + 5], S21, 0xd62f105d);
1758
1759        d = GG(d, a, b, c, x[k + 10], S22, 0x2441453);
1760
1761        c = GG(c, d, a, b, x[k + 15], S23, 0xd8a1e681);
1762
1763        b = GG(b, c, d, a, x[k + 4], S24, 0xe7d3fbc8);
1764
1765        a = GG(a, b, c, d, x[k + 9], S21, 0x21e1cde6);
1766
1767        d = GG(d, a, b, c, x[k + 14], S22, 0xc33707d6);
1768
1769        c = GG(c, d, a, b, x[k + 3], S23, 0xf4d50d87);
1770
1771        b = GG(b, c, d, a, x[k + 8], S24, 0x455a14ed);
1772
1773        a = GG(a, b, c, d, x[k + 13], S21, 0xa9e3e905);
1774
1775        d = GG(d, a, b, c, x[k + 2], S22, 0xfcefa3f8);
1776
1777        c = GG(c, d, a, b, x[k + 7], S23, 0x676f02d9);
1778
1779        b = GG(b, c, d, a, x[k + 12], S24, 0x8d2a4c8a);
1780
1781        a = HH(a, b, c, d, x[k + 5], S31, 0xfffa3942);
1782
1783        d = HH(d, a, b, c, x[k + 8], S32, 0x8771f681);
1784
1785        c = HH(c, d, a, b, x[k + 11], S33, 0x6d9d6122);
1786
1787        b = HH(b, c, d, a, x[k + 14], S34, 0xfde5380c);
1788
1789        a = HH(a, b, c, d, x[k + 1], S31, 0xa4beea44);
1790
1791        d = HH(d, a, b, c, x[k + 4], S32, 0x4bdecfa9);
1792
1793        c = HH(c, d, a, b, x[k + 7], S33, 0xf6bb4b60);
1794
1795        b = HH(b, c, d, a, x[k + 10], S34, 0xbebfbc70);
1796
1797        a = HH(a, b, c, d, x[k + 13], S31, 0x289b7ec6);
1798
1799        d = HH(d, a, b, c, x[k + 0], S32, 0xeaa127fa);
1800
1801        c = HH(c, d, a, b, x[k + 3], S33, 0xd4ef3085);
1802
1803        b = HH(b, c, d, a, x[k + 6], S34, 0x4881d05);
1804
1805        a = HH(a, b, c, d, x[k + 9], S31, 0xd9d4d039);
1806
1807        d = HH(d, a, b, c, x[k + 12], S32, 0xe6db99e5);
1808
1809        c = HH(c, d, a, b, x[k + 15], S33, 0x1fa27cf8);
1810
1811        b = HH(b, c, d, a, x[k + 2], S34, 0xc4ac5665);
1812
1813        a = II(a, b, c, d, x[k + 0], S41, 0xf4292244);
1814
1815        d = II(d, a, b, c, x[k + 7], S42, 0x432aff97);
1816
1817        c = II(c, d, a, b, x[k + 14], S43, 0xab9423a7);
1818
1819        b = II(b, c, d, a, x[k + 5], S44, 0xfc93a039);
1820
1821        a = II(a, b, c, d, x[k + 12], S41, 0x655b59c3);
1822
1823        d = II(d, a, b, c, x[k + 3], S42, 0x8f0ccc92);
1824
1825        c = II(c, d, a, b, x[k + 10], S43, 0xffeff47d);
1826
1827        b = II(b, c, d, a, x[k + 1], S44, 0x85845dd1);
1828
1829        a = II(a, b, c, d, x[k + 8], S41, 0x6fa87e4f);
1830
1831        d = II(d, a, b, c, x[k + 15], S42, 0xfe2ce6e0);
1832
1833        c = II(c, d, a, b, x[k + 6], S43, 0xa3014314);
1834
1835        b = II(b, c, d, a, x[k + 13], S44, 0x4e0811a1);
1836
1837        a = II(a, b, c, d, x[k + 4], S41, 0xf7537e82);
1838
1839        d = II(d, a, b, c, x[k + 11], S42, 0xbd3af235);
1840
1841        c = II(c, d, a, b, x[k + 2], S43, 0x2ad7d2bb);
1842
1843        b = II(b, c, d, a, x[k + 9], S44, 0xeb86d391);
1844
1845        a = AddUnsigned(a, AA);
1846
1847        b = AddUnsigned(b, BB);
1848
1849        c = AddUnsigned(c, CC);
1850
1851        d = AddUnsigned(d, DD);
1852      }
1853
1854      var temp = WordToHex(a) + WordToHex(b) + WordToHex(c) + WordToHex(d);
1855
1856      return temp.toLowerCase();
1857    },
1858
1859    // 获取十位时间戳
1860    getTimestamp: function () {
1861      var timestamp = new Date().getTime().toString();
1862      timestamp = timestamp.slice(0, 10);
1863      return parseInt(timestamp);
1864    },
1865
1866    // Base64编码,支持中文
1867    Base64: {
1868      // 转码表
1869      table: [
1870        'A',
1871        'B',
1872        'C',
1873        'D',
1874        'E',
1875        'F',
1876        'G',
1877        'H',
1878        'I',
1879        'J',
1880        'K',
1881        'L',
1882        'M',
1883        'N',
1884        'O',
1885        'P',
1886        'Q',
1887        'R',
1888        'S',
1889        'T',
1890        'U',
1891        'V',
1892        'W',
1893        'X',
1894        'Y',
1895        'Z',
1896        'a',
1897        'b',
1898        'c',
1899        'd',
1900        'e',
1901        'f',
1902        'g',
1903        'h',
1904        'i',
1905        'j',
1906        'k',
1907        'l',
1908        'm',
1909        'n',
1910        'o',
1911        'p',
1912        'q',
1913        'r',
1914        's',
1915        't',
1916        'u',
1917        'v',
1918        'w',
1919        'x',
1920        'y',
1921        'z',
1922        '0',
1923        '1',
1924        '2',
1925        '3',
1926        '4',
1927        '5',
1928        '6',
1929        '7',
1930        '8',
1931        '9',
1932        '+',
1933        '/',
1934      ],
1935      UTF16ToUTF8: function (str) {
1936        var res = [],
1937          len = str.length;
1938        for (var i = 0; i < len; i++) {
1939          var code = str.charCodeAt(i);
1940          if (code > 0x0000 && code <= 0x007f) {
1941            // 单字节,这里并不考虑0x0000,因为它是空字节
1942            // U+00000000 – U+0000007F 	0xxxxxxx
1943            res.push(str.charAt(i));
1944          } else if (code >= 0x0080 && code <= 0x07ff) {
1945            // 双字节
1946            // U+00000080 – U+000007FF 	110xxxxx 10xxxxxx
1947            // 110xxxxx
1948            var byte1 = 0xc0 | ((code >> 6) & 0x1f);
1949            // 10xxxxxx
1950            var byte2 = 0x80 | (code & 0x3f);
1951            res.push(String.fromCharCode(byte1), String.fromCharCode(byte2));
1952          } else if (code >= 0x0800 && code <= 0xffff) {
1953            // 三字节
1954            // U+00000800 – U+0000FFFF 	1110xxxx 10xxxxxx 10xxxxxx
1955            // 1110xxxx
1956            var byte1 = 0xe0 | ((code >> 12) & 0x0f);
1957            // 10xxxxxx
1958            var byte2 = 0x80 | ((code >> 6) & 0x3f);
1959            // 10xxxxxx
1960            var byte3 = 0x80 | (code & 0x3f);
1961            res.push(String.fromCharCode(byte1), String.fromCharCode(byte2), String.fromCharCode(byte3));
1962          } else if (code >= 0x00010000 && code <= 0x001fffff) {
1963            // 四字节
1964            // U+00010000 – U+001FFFFF 	11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
1965          } else if (code >= 0x00200000 && code <= 0x03ffffff) {
1966            // 五字节
1967            // U+00200000 – U+03FFFFFF 	111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
1968          } /** if (code >= 0x04000000 && code <= 0x7FFFFFFF)*/ else {
1969            // 六字节
1970            // U+04000000 – U+7FFFFFFF 	1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
1971          }
1972        }
1973
1974        return res.join('');
1975      },
1976      encode: function (str) {
1977        if (!str) {
1978          return '';
1979        }
1980        var utf8 = this.UTF16ToUTF8(str); // 转成UTF8
1981        var i = 0; // 遍历索引
1982        var len = utf8.length;
1983        var res = [];
1984        while (i < len) {
1985          var c1 = utf8.charCodeAt(i++) & 0xff;
1986          res.push(this.table[c1 >> 2]);
1987          // 需要补2个=
1988          if (i == len) {
1989            res.push(this.table[(c1 & 0x3) << 4]);
1990            res.push('==');
1991            break;
1992          }
1993          var c2 = utf8.charCodeAt(i++);
1994          // 需要补1个=
1995          if (i == len) {
1996            res.push(this.table[((c1 & 0x3) << 4) | ((c2 >> 4) & 0x0f)]);
1997            res.push(this.table[(c2 & 0x0f) << 2]);
1998            res.push('=');
1999            break;
2000          }
2001          var c3 = utf8.charCodeAt(i++);
2002          res.push(this.table[((c1 & 0x3) << 4) | ((c2 >> 4) & 0x0f)]);
2003          res.push(this.table[((c2 & 0x0f) << 2) | ((c3 & 0xc0) >> 6)]);
2004          res.push(this.table[c3 & 0x3f]);
2005        }
2006
2007        return res.join('');
2008      },
2009    },
2010
2011    // 获取浏览器相关信息
2012    getBrowserInfo: function () {
2013      var info = {};
2014
2015      info.appName = navigator.appName; //浏览器的正式名称
2016      info.appVersion = navigator.appVersion; //浏览器的版本号
2017      info.cookieEnabled = navigator.cookieEnabled; // 返回用户浏览器是否启用了cookie
2018      info.cpuClass = navigator.cpuClass; //返回用户计算机的cpu的型号,通常intel芯片返回"x86"(火狐没有)
2019
2020      info.mimeType = navigator.mimeTypes; // 浏览器支持的所有MIME类型的数组
2021      info.platform = navigator.platform;
2021 // 浏览器正在运行的操作系统平台,包括Win16(windows3.x)
2022      //   Win32(windows98,Me,NT,2000,xp),Mac68K(Macintosh 680x0)
2023      //     和MacPPC(Macintosh PowerPC)
2024      info.plugins = navigator.plugins; //  安装在浏览器上的所有插件的数组
2025      info.userLanguage = navigator.userLanguage; // 用户在自己的操作系统上设置的语言(火狐没有)
2026      info.userAgent = navigator.userAgent; //包含以下属性中所有或一部分的字符串:appCodeName,appName,appVersion,language,platform
2027      info.systemLanguage = navigator.systemLanguage; // 用户操作系统支持的默认语言(火狐没有)
2028
2029      info.appCodeName = navigator.appCodeName; //与浏览器相关的内部代码名
2030      info.appMinorVersion = navigator.appMinorVersion; //辅版本号(通常应用于浏览器的补丁或服务包)
2031      info.language = navigator.language; //浏览器支持的语言 (IE没有)
2032      info.onLine = navigator.onLine; //返回浏览器是否处于在线模式(IE4以上版本)
2033      info.opsProfile = navigator.opsProfile; // 未定义   (IE、火狐没有)
2034      info.oscpu = navigator.oscpu; //浏览器正在运行的操作系统,其中可能有CPU的信息(IE没有)
2035      info.product = navigator.product; // 浏览器的产品名(IE没有)
2036      info.productSub = navigator.productSub; //关于浏览器更多信息(IE没有)
2037      info.securityPolicy = navigator.securityPolicy; // 浏览器支持的加密类型(IE没有)
2038      info.userProfile = navigator.userProfile; //  返回一个UserProfile对象,它存储用户的个人信息(火狐没有)
2039      info.vender = navigator.vender; // 浏览器厂商名称(IE、火狐没有)
2040      info.vendorSub = navigator.vendorSub; // 关于浏览器厂商更多的信息
2041
2042      //获取插件所有的名称
2043      info.getPluginName = function () {
2044        var info = '';
2045        var plugins = navigator.plugins;
2046        if (plugins.length > 0) {
2047          for (i = 0; i < navigator.plugins.length; i++) {
2048            info += navigator.plugins[i].name + ';';
2049          }
2050        }
2051        return info;
2052      };
2053
2054      //检查是否安装了某插件,如果安装了返回版本号
2055      info.checkePlugs = function (pluginname) {
2056        var f = '-';
2057        var plugins = navigator.plugins;
2058        if (plugins.length > 0) {
2059          for (i = 0; i < navigator.plugins.length; i++) {
2060            if (navigator.plugins[i].name.indexOf(pluginname) >= 0) {
2061              f = navigator.plugins[i].description.split(pluginname)[1];
2062              return f;
2063            }
2064          }
2065        }
2066        return false;
2067      };
2068
2069      //判断是否IE
2070      info.isIe = function () {
2071        var i = navigator.userAgent.toLowerCase().indexOf('msie');
2072        return i >= 0;
2073      };
2074
2075      //判断是否firefox
2076      info.isFireFox = function () {
2077        var i = navigator.userAgent.toLowerCase().indexOf('firefox');
2078        return i >= 0;
2079      };
2080
2081      info.isWeixin = function () {
2082        var ua = navigator.userAgent.toLowerCase();
2083        if (ua.match(/MicroMessenger/i) == 'micromessenger') {
2084          return true;
2085        } else {
2086          return false;
2087        }
2088      };
2089
2090      info.isMobile = function () {
2091        var sUserAgent = navigator.userAgent;
2092        return (
2093          sUserAgent.indexOf('Android') > -1 ||
2094          sUserAgent.indexOf('iPhone') > -1 ||
2095          sUserAgent.indexOf('iPad') > -1 ||
2096          sUserAgent.indexOf('iPod') > -1 ||
2097          sUserAgent.indexOf('Symbian') > -1
2098        );
2099      };
2100      return info;
2101    },
2102
2103    timeCountDown: function (time, interval) {
2104      let endTime = time;
2105      setInterval(function () {
2106        let currentTime = new Date();
2107        let timeCounting = endTime - currentTime;
2108        if (timeCounting < 0) {
2109          return false;
2110        }
2111        let hour = parseInt((timeCounting / 1000 / 60 / 60) % 24);
2112        let minute = parseInt((timeCounting / 1000 / 60) % 60);
2113        let second = parseInt((timeCounting / 1000) % 60);
2114        let millisecond = Math.floor((timeCounting - 60 * 60 * 1000 * hour - 60 * 1000 * minute - second * 1000) / 1);
2115        if (hour < 10) {
2116          hour = '0' + hour;
2117        }
2118        if (minute < 10) {
2119          minute = '0' + minute;
2120        }
2121        if (second < 10) {
2122          second = '0' + second;
2123        }
2124        if (millisecond < 10) {
2125          millisecond = '0' + millisecond;
2126        }
2127
2128        return {
2129          hours: hour,
2130          minutes: minute,
2131          seconds: second,
2132          milliseconds: millisecond,
2133        };
2134      }, interval);
2135    },
2136    checkWebp: function () {
2137      try {
2138        return document.createElement('canvas').toDataURL('image/webp').indexOf('data:image/webp') == 0;
2139      } catch (err) {
2140        return false;
2141      }
2142    },
2143    isOnDesktop: function () {
2144      var UserAgent = navigator.userAgent;
2145      var isMacPlatfrom = UserAgent.indexOf('dmg') > -1;
2146
2147      var isExePlatfrom = UserAgent.indexOf('exe') > -1;
2148      if (isMacPlatfrom || isExePlatfrom) {
2149        return true;
2150      } else {
2151        return false;
2152      }
2153    },
2154    getDeskPlatform(key) {
2155      var UserAgent = navigator.userAgent;
2156      if (UserAgent.indexOf('exe') > -1 || UserAgent.indexOf('dmg') > -1) {
2157        const deskInfoStringStart = UserAgent.indexOf('platform');
2158        if (deskInfoStringStart > -1) {
2159          deskInfoString = UserAgent.substring(deskInfoStringStart);
2160          deskInfoString = decodeURI(deskInfoString);
2161          const deskInfoArr = deskInfoString.split(' ');
2162          const deskInfoJSON = {};
2163          $.each(deskInfoArr, function (index, item) {
2164            var item = item.split('=');
2165            deskInfoJSON[item[0]] = item[1];
2166          });
2167          console.log(deskInfoJSON);
2168          if (key) {
2169            return deskInfoJSON[key];
2170          } else {
2171            return deskInfoJSON;
2172          }
2173        }
2174      } else {
2175        return {
2176          platform: '',
2177          utm_source: '',
2178          utm_medium: '',
2179          utm_campaign: '',
2180        };
2181      }
2182    },
2183    stringnormalize: function (data) {
2184      if (!data || $.type(data) != 'object') {
2185        return;
2186      }
2187
2188      var str = '?',
2189        index = 0;
2190      if ($.isEmptyObject(data)) {
2191        str = '';
2192      } else {
2193        $.each(data, function (key, val) {
2194          str += (index > 0 ? '&' : '') + key + '=' + val;
2195          index++;
2196        });
2197      }
2198      return str;
2199    },
2200    geturlObject: function (search, key) {
2201      if (search.length < 1) {
2202        return;
2203      }
2204      if (key && search.indexOf(key) < 0) {
2205        return;
2206      }
2207      search = search.substring(1);
2208      search = decodeURI(search);
2209      var searchArr = search.split('&');
2210      var searchJSON = {};
2211      $.each(searchArr, function (index, item) {
2212        var item = item.split('=');
2213        searchJSON[item[0]] = item[1];
2214      });
2215      if (key) {
2216        return searchJSON[key];
2217      } else {
2218        return searchJSON;
2219      }
2220    },
2221    isLogin: function () {
2222      if (localStorage.authorization) {
2223        var authorization = JSON.parse(localStorage.authorization);
2224        var access_token = authorization.access_token;
2225        return access_token ? true : false;
2226      } else {
2227        return false;
2228      }
2229    },
2230    /**
2231     * 校验身份证
2232     * @param idNo
2233     * @returns {boolean}
2234     */
2235    checkIdCard: function (idNo) {
2236      var regu = /^(\d{6})(\d{4})(\d{2})(\d{2})(\d{3})([0-9]|X)$/gi;
2237      var re = new RegExp(regu);
2238      return re.test(idNo);
2239    },
2240  };
2241  $.mytools = new ToolsClass();
2242
2243  //定义分页类
2244  function Paging(element, options) {
2245    this.element = element;
2246    //传入形参
2247    this.options = {
2248      pageNo: options.pageNo || 1,
2249      totalPage: options.totalPage,
2250      totalSize: options.totalSize,
2251      callback: options.callback,
2252    };
2253    //根据形参初始化分页html和css代码
2254    this.init();
2255  }
2256
2257  //对Paging的实例对象添加公共的属性和方法
2258  Paging.prototype = {
2259    constructor: Paging,
2260    init: function init() {
2261      this.creatHtml();
2262      this.bindEvent();
2263    },
2264    creatHtml: function creatHtml() {
2265      var me = this;
2266      var content = '';
2267      var current = me.options.pageNo;
2268      var total = me.options.totalPage;
2269      var totalNum = me.options.totalSize;
2270
2271      //页面前面的上一页
2272      if (total > 1) {
2273        content += '<span class="active" id="prePage">\n<img src="/new/image/designcenter/prevpage.png">\n</span>';
2274      }
2275      //总页数大于5时候
2276      if (total > 5) {
2277        //当前页数小于4时显示省略号并显示最后一页
2278        if (current < 4) {
2279          for (var i = 1; i < 5; i++) {
2280            if (current == i) {
2281              content += '<span class="current">' + i + '</span>';
2282            } else {
2283              content += '<span>' + i + '</span>';
2284            }
2285          }
2286          content += '<a>...</a>';
2287          content += '<span>' + total + '</span>';
2288        } else {
2289          //判断页码在末尾的时候  4 <= current <total - 3;
2290          if (current < total - 3) {
2291            for (var i = current - 1; i < current + 3; i++) {
2292              if (current == i) {
2293                content += "<span class='current'>" + i + '</span>';
2294              } else {
2295                content += '<span>' + i + '</span>';
2296              }
2297            }
2298            content += '<a>...</a>';
2299            content += '<span>' + total + '</span>';
2300            //页码在中间部分时候    current = 7;
2301          } else {
2302            content += '<span>1</span>';
2303            content += '<a>...</a>';
2304            for (var i = total - 3; i < total + 1; i++) {
2305              if (current == i) {
2306                content += "<span class='current'>" + current + '</span>';
2307              } else {
2308                content += '<span>' + i + '</span>';
2309              }
2310            }
2311          }
2312        }
2313        //页面总数小于5的时候
2314      } else {
2315        for (var i = 1; i < total + 1; i++) {
2316          if (current == i) {
2317            content += "<span class='current'>" + i + '</span>';
2318          } else {
2319            content += '<span>' + i + '</span>';
2320          }
2321        }
2322      }
2323      if (total > 1) {
2324        content += '<span class="active" id="nextPage">\n<img src="/new/image/designcenter/nextpage.png">\n</span>';
2325      }
2326      me.element.html(content);
2327    },
2328    //添加页面操作事件
2329    bindEvent: function bindEvent() {
2330      var me = this;
2331      me.element.off('click', 'span');
2332      me.element.on('click', 'span', function () {
2333        var num = $(this).html();
2334        var id = $(this).attr('id');
2335        if (id == 'prePage') {
2336          if (me.options.pageNo == 1) {
2337            me.options.pageNo = 1;
2338          } else {
2339            me.options.pageNo = +me.options.pageNo - 1;
2340          }
2341        } else if (id == 'nextPage') {
2342          if (me.options.pageNo == me.options.totalPage) {
2343            me.options.pageNo = me.options.totalPage;
2344          } else {
2345            me.options.pageNo = +me.options.pageNo + 1;
2346          }
2347        } else if (id == 'firstPage') {
2348          me.options.pageNo = 1;
2349        } else if (id == 'lastPage') {
2350          me.options.pageNo = me.options.totalPage;
2351        } else {
2352          me.options.pageNo = +num;
2353        }
2354        me.creatHtml();
2355        if (me.options.callback) {
2356          me.options.callback(me.options.pageNo);
2357        }
2358      });
2359    },
2360  };
2361
2362  //通过jQuery对象初始化分页对象
2363  $.fn.paging = function (options) {
2364    return new Paging($(this), options);
2365  };
2366  // ++++++++++++++++++++++++ 自定义组件 ++++++++++++++++++++++++
2367
2368  $.extend($.fn, {
2369    // 文字输入 字数控制
2370    fontSizeMonitoring: function (fontSize, isHalfAngle) {
2371      var _input_obj = $(this); // 输入框对象
2372      if (!_input_obj) {
2373        return false;
2374      }
2375
2376      var _input_obj_id = _input_obj.attr('id');
2377
2378      var _fontSizeInput = _input_obj.siblings('[data-fontSizeBind=' + _input_obj_id + ']'); // 与输入框绑定的字数输出对象
2379      _fontSizeInput.find('em').text(fontSize);
2380
2381      _input_obj.bind('input propertychange', function () {
2382        runEvent($(this));
2383      });
2384
2385      runEvent(_input_obj);
2386
2387      function runEvent(obj) {
2388        var currentFontSize = isHalfAngle ? $(obj).val().length : $.mytools.getStringLength($(obj).val());
2389        _fontSizeInput.find('em').text(fontSize - currentFontSize);
2390        if (fontSize - currentFontSize < 0) {
2391          _fontSizeInput.html('已经超出<em style="color: #E74C3C;">' + (fontSize - currentFontSize) * -1 + '</em>个字');
2392        } else {
2393          _fontSizeInput.html('还可以输入<em>' + (fontSize - currentFontSize) + '</em>个字');
2394        }
2395      }
2396    },
2397  });
2398
2399  if (location.href.indexOf('/h5/poster') == -1) {
2400    // 动态加载track.js
2401    $.mytools.requireScript({
2402      scriptSrc: '/new/javascript/track/track.js',
2403      // async: true,
2404    });
2405  }
2406})(jQuery);

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.