说明

　　个人感觉总结得很好忍不住要分享，转载自github地址，作者博客原文发现打不开，于是复制粘贴到此处，如有侵权，请联系本人删除。

Type

  1. class TypeFn {
  2.     isString (o) { //是否字符串
  3.         return Object.prototype.toString.call(o).slice(, -) === 'String'
  4.     }
  5.  
  6.     isNumber (o) { //是否数字
  7.         return Object.prototype.toString.call(o).slice(, -) === 'Number'
  8.     }
  9.  
  10.     isBoolean (o) { //是否boolean
  11.         return Object.prototype.toString.call(o).slice(, -) === 'Boolean'
  12.     }
  13.  
  14.     isFunction (o) { //是否函数
  15.         return Object.prototype.toString.call(o).slice(, -) === 'Function'
  16.     }
  17.  
  18.     isNull (o) { //是否为null
  19.         return Object.prototype.toString.call(o).slice(, -) === 'Null'
  20.     }
  21.  
  22.     isUndefined (o) { //是否undefined
  23.         return Object.prototype.toString.call(o).slice(, -) === 'Undefined'
  24.     }
  25.  
  26.     isObj (o) { //是否对象
  27.         return Object.prototype.toString.call(o).slice(, -) === 'Object'
  28.     }
  29.  
  30.     isArray (o) { //是否数组
  31.         return Object.prototype.toString.call(o).slice(, -) === 'Array'
  32.     }
  33.  
  34.     isDate (o) { //是否时间
  35.         return Object.prototype.toString.call(o).slice(, -) === 'Date'
  36.     }
  37.  
  38.     isRegExp (o) { //是否正则
  39.         return Object.prototype.toString.call(o).slice(, -) === 'RegExp'
  40.     }
  41.  
  42.     isError (o) { //是否错误对象
  43.         return Object.prototype.toString.call(o).slice(, -) === 'Error'
  44.     }
  45.  
  46.     isSymbol (o) { //是否Symbol函数
  47.         return Object.prototype.toString.call(o).slice(, -) === 'Symbol'
  48.     }
  49.  
  50.     isPromise (o) { //是否Promise对象
  51.         return Object.prototype.toString.call(o).slice(, -) === 'Promise'
  52.     }
  53.  
  54.     isSet (o) { //是否Set对象
  55.         return Object.prototype.toString.call(o).slice(, -) === 'Set'
  56.     }
  57.  
  58.     isFalse (o) {
  59.         if (o == '' || o == undefined || o == null || o == 'null' || o == 'undefined' || o ==  || o == false || o == NaN) return true
  60.         return false
  61.     }
  62.  
  63.     isTrue (o) {
  64.         return !this.isFalse(o)
  65.     }
  66.  
  67.     isIos () {
  68.         var u = navigator.userAgent;
  69.         if (u.indexOf('Android') > - || u.indexOf('Linux') > -) {//安卓手机
  70.             // return "Android";
  71.             return false
  72.         } else if (u.indexOf('iPhone') > -) {//苹果手机
  73.             // return "iPhone";
  74.             return true
  75.         } else if (u.indexOf('iPad') > -) {//iPad
  76.             // return "iPad";
  77.             return false
  78.         } else if (u.indexOf('Windows Phone') > -) {//winphone手机
  79.             // return "Windows Phone";
  80.             return false
  81.         }else{
  82.             return false
  83.         }
  84.     }
  85.  
  86.     isPC () { //是否为PC端
  87.         var userAgentInfo = navigator.userAgent;
  88.         var Agents = ["Android", "iPhone",
  89.                     "SymbianOS", "Windows Phone",
  90.                     "iPad", "iPod"];
  91.         var flag = true;
  92.         for (var v = ; v < Agents.length; v++) {
  93.             if (userAgentInfo.indexOf(Agents[v]) > ) {
  94.                 flag = false;
  95.                 break;
  96.             }
  97.         }
  98.         return flag;
  99.     }
  100.  
  101.     browserType(){
  102.         var userAgent = navigator.userAgent; //取得浏览器的userAgent字符串
  103.         var isOpera = userAgent.indexOf("Opera") > -; //判断是否Opera浏览器
  104.         var isIE = userAgent.indexOf("compatible") > - && userAgent.indexOf("MSIE") > - && !isOpera; //判断是否IE浏览器
  105.         var isIE11 = userAgent.indexOf('Trident') > - && userAgent.indexOf("rv:11.0") > -;
  106.         var isEdge = userAgent.indexOf("Edge") > - && !isIE; //判断是否IE的Edge浏览器
  107.         var isFF = userAgent.indexOf("Firefox") > -; //判断是否Firefox浏览器
  108.         var isSafari = userAgent.indexOf("Safari") > - && userAgent.indexOf("Chrome") == -; //判断是否Safari浏览器
  109.         var isChrome = userAgent.indexOf("Chrome") > - && userAgent.indexOf("Safari") > -; //判断Chrome浏览器
  110.  
  111.         if (isIE) {
  112.             var reIE = new RegExp("MSIE (\\d+\\.\\d+);");
  113.             reIE.test(userAgent);
  114.             var fIEVersion = parseFloat(RegExp["$1"]);
  115.             if(fIEVersion == ) return "IE7"
  116.             else if(fIEVersion == ) return "IE8";
  117.             else if(fIEVersion == ) return "IE9";
  118.             else if(fIEVersion == ) return "IE10";
  119.             else return "IE7以下"//IE版本过低
  120.         }
  121.         if (isIE11) return 'IE11';
  122.         if (isEdge) return "Edge";
  123.         if (isFF) return "FF";
  124.         if (isOpera) return "Opera";
  125.         if (isSafari) return "Safari";
  126.         if (isChrome) return "Chrome";
  127.     }
  128.  
  129.     checkStr (str, type) {
  130.         switch (type) {
  131.             case 'phone':   //手机号码
  132.                 return /^[|||||][-]{}$/.test(str);
  133.             case 'tel':     //座机
  134.                 return /^(\d{,}-\d{,})(-\d{,})?$/.test(str);
  135.             case 'card':    //身份证
  136.                 return /(^\d{}$)|(^\d{}$)|(^\d{}(\d|X|x)$)/.test(str);
  137.             case 'pwd':     //密码以字母开头，长度在6~18之间，只能包含字母、数字和下划线
  138.                 return /^[a-zA-Z]\w{,}$/.test(str)
  139.             case 'postal':  //邮政编码
  140.                 return /[-]\d{}(?!\d)/.test(str);
  141.             case 'QQ':      //QQ号
  142.                 return /^[-][-]{,}$/.test(str);
  143.             case 'email':   //邮箱
  144.                 return /^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/.test(str);
  145.             case 'money':   //金额(小数点2位)
  146.                 return /^\d*(?:\.\d{,})?$/.test(str);
  147.             case 'URL':     //网址
  148.                 return /(http|ftp|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&:/~\+#]*[\w\-\@?^=%&/~\+#])?/.test(str)
  149.             case 'IP':      //IP
  150.                 return /((?:(?:[-]|[-]\\d|[]?\\d?\\d)\\.){}(?:[-]|[-]\\d|[]?\\d?\\d))/.test(str);
  151.             case 'date':    //日期时间
  152.                 return /^(\d{})\-(\d{})\-(\d{}) (\d{})(?:\:\d{}|:(\d{}):(\d{}))$/.test(str) || /^(\d{})\-(\d{})\-(\d{})$/.test(str)
  153.             case 'number':  //数字
  154.                 return /^[-]$/.test(str);
  155.             case 'english': //英文
  156.                 return /^[a-zA-Z]+$/.test(str);
  157.             case 'chinese': //中文
  158.                 return /^[\u4E00-\u9FA5]+$/.test(str);
  159.             case 'lower':   //小写
  160.                 return /^[a-z]+$/.test(str);
  161.             case 'upper':   //大写
  162.                 return /^[A-Z]+$/.test(str);
  163.             case 'HTML':    //HTML标记
  164.                 return /<("[^"]*"|'[^']*'|[^'">])*>/.test(str);
  165.             default:
  166.                 return true;
  167.         }
  168.     }
  169.  
  170.     // 严格的身份证校验
  171.     isCardID(sId) {
  172.         if (!/(^\d{}$)|(^\d{}(\d|X|x)$)/.test(sId)) {
  173.             alert('你输入的身份证长度或格式错误')
  174.             return false
  175.         }
  176.         //身份证城市
  177.         var aCity={:"北京",:"天津",:"河北",:"山西",:"内蒙古",:"辽宁",:"吉林",:"黑龙江",:"上海",:"江苏",:"浙江",:"安徽",:"福建",:"江西",:"山东",:"河南",:"湖北",:"湖南",:"广东",:"广西",:"海南",:"重庆",:"四川",:"贵州",:"云南",:"西藏",:"陕西",:"甘肃",:"青海",:"宁夏",:"新疆",:"台湾",:"香港",:"澳门",:"国外"};
  178.         if(!aCity[parseInt(sId.substr(,))]) {
  179.             alert('你的身份证地区非法')
  180.             return false
  181.         }
  182.  
  183.         // 出生日期验证
  184.         var sBirthday=(sId.substr(,)+"-"+Number(sId.substr(,))+"-"+Number(sId.substr(,))).replace(/-/g,"/"),
  185.             d = new Date(sBirthday)
  186.         if(sBirthday != (d.getFullYear()+"/"+ (d.getMonth()+) + "/" + d.getDate())) {
  187.             alert('身份证上的出生日期非法')
  188.             return false
  189.         }
  190.  
  191.         // 身份证号码校验
  192.         var sum = ,
  193.             weights =  [, , , , , , , , , , , , , , , , ],
  194.             codes = "10X98765432"
  195.         for (var i = ; i < sId.length - ; i++) {
  196.             sum += sId[i] * weights[i];
  197.         }
  198.         var last = codes[sum % ]; //计算出来的最后一位身份证号码
  199.         if (sId[sId.length-] != last) {
  200.             alert('你输入的身份证号非法')
  201.             return false
  202.         }
  203.  
  204.         return true
  205.     }
  206. }

Array

  1. class ArrayFn {
  2.     /*判断一个元素是否在数组中*/
  3.     contains (arr, val) {
  4.         return arr.indexOf(val) != - ? true : false;
  5.     }
  6.  
  7.     /**
  8.      * @param  {arr} 数组
  9.      * @param  {fn} 回调函数
  10.      * @return {undefined}
  11.      */
  12.     each (arr, fn) {
  13.         fn = fn || Function;
  14.         var a = [];
  15.         var args = Array.prototype.slice.call(arguments, );
  16.         for(var i = ; i < arr.length; i++) {
  17.             var res = fn.apply(arr, [arr[i], i].concat(args));
  18.             if(res != null) a.push(res);
  19.         }
  20.     }
  21.  
  22.     /**
  23.      * @param  {arr} 数组
  24.      * @param  {fn} 回调函数
  25.      * @param  {thisObj} this指向
  26.      * @return {Array}
  27.      */
  28.     map (arr, fn, thisObj) {
  29.         var scope = thisObj || window;
  30.         var a = [];
  31.         for(var i = , j = arr.length; i < j; ++i) {
  32.             var res = fn.call(scope, arr[i], i, this);
  33.             if(res != null) a.push(res);
  34.         }
  35.         return a;
  36.     }
  37.  
  38.     /**
  39.      * @param  {arr} 数组
  40.      * @param  {type} 1：从小到大   2：从大到小   3：随机
  41.      * @return {Array}
  42.      */
  43.     sort (arr, type = ) {
  44.         return arr.sort( (a, b) => {
  45.             switch(type) {
  46.                 case :
  47.                     return a - b;
  48.                 case :
  49.                     return b - a;
  50.                 case :
  51.                     return Math.random() - 0.5;
  52.                 default:
  53.                     return arr;
  54.             }
  55.         })
  56.     }
  57.  
  58.     /*去重*/
  59.     unique (arr) {
  60.         if ( Array.hasOwnProperty('from') ) {
  61.             return Array.from(new Set(arr));
  62.         }else{
  63.             var n = {},r=[];
  64.             for(var i = ; i < arr.length; i++){
  65.                 if (!n[arr[i]]){
  66.                     n[arr[i]] = true;
  67.                     r.push(arr[i]);
  68.                 }
  69.             }
  70.             return r;
  71.         }
  72.         // 注：上面 else 里面的排重并不能区分 2 和 '2'，但能减少用indexOf带来的性能
  73.         /* 正确排重
  74.         if ( Array.hasOwnProperty('from') ) {
  75.             return Array.from(new Set(arr))
  76.         }else{
  77.             var r = [], NaNBol = true
  78.             for(var i=0; i < arr.length; i++) {
  79.                 if (arr[i] !== arr[i]) {
  80.                     if (NaNBol && r.indexOf(arr[i]) === -1) {
  81.                         r.push(arr[i])
  82.                         NaNBol = false
  83.                     }
  84.                 }else{
  85.                     if(r.indexOf(arr[i]) === -1) r.push(arr[i])
  86.                 }
  87.             }
  88.             return r
  89.         }
  90.  
  91.          */
  92.     }
  93.  
  94.     /*求两个集合的并集*/
  95.     union (a, b) {
  96.         var newArr = a.concat(b);
  97.         return this.unique(newArr);
  98.     }
  99.  
  100.     /*求两个集合的交集*/
  101.     intersect (a, b) {
  102.         var _this = this;
  103.         a = this.unique(a);
  104.         return this.map(a, function(o) {
  105.             return _this.contains(b, o) ? o : null;
  106.         });
  107.     }
  108.  
  109.     /*删除其中一个元素*/
  110.     remove (arr, ele) {
  111.         var index = arr.indexOf(ele);
  112.         if(index > -) {
  113.             arr.splice(index, );
  114.         }
  115.         return arr;
  116.     }
  117.  
  118.     /*将类数组转换为数组的方法*/
  119.     formArray (ary) {
  120.         var arr = [];
  121.         if(Array.isArray(ary)) {
  122.             arr = ary;
  123.         } else {
  124.             arr = Array.prototype.slice.call(ary);
  125.         };
  126.         return arr;
  127.     }
  128.  
  129.     /*最大值*/
  130.     max (arr) {
  131.         return Math.max.apply(null, arr);
  132.     }
  133.  
  134.     /*最小值*/
  135.     min (arr) {
  136.         return Math.min.apply(null, arr);
  137.     }
  138.  
  139.     /*求和*/
  140.     sum (arr) {
  141.         return arr.reduce( (pre, cur) => {
  142.             return pre + cur
  143.         })
  144.     }
  145.  
  146.     /*平均值*/
  147.     average (arr) {
  148.         return this.sum(arr)/arr.length
  149.     }
  150. }

Dom

  1. class DomFn {
  2.  
  3.     $ (selector){
  4.         var type = selector.substring(, );
  5.         if (type === '#') {
  6.             if (document.querySelecotor) return document.querySelector(selector)
  7.                 return document.getElementById(selector.substring())
  8.  
  9.         }else if (type === '.') {
  10.             if (document.querySelecotorAll) return document.querySelectorAll(selector)
  11.                 return document.getElementsByClassName(selector.substring())
  12.         }else{
  13.             return document['querySelectorAll' ? 'querySelectorAll':'getElementsByTagName'](selector)
  14.         }
  15.     } 
  16.  
  17.     /*检测类名*/
  18.     hasClass (ele, name) {
  19.         return ele.className.match(new RegExp('(\\s|^)' + name + '(\\s|$)'));
  20.     }
  21.  
  22.     /*添加类名*/
  23.     addClass (ele, name) {
  24.         if (!this.hasClass(ele, name)) ele.className += " " + name;
  25.     }
  26.  
  27.     /*删除类名*/
  28.     removeClass (ele, name) {
  29.         if (this.hasClass(ele, name)) {
  30.             var reg = new RegExp('(\\s|^)' + name + '(\\s|$)');
  31.             ele.className = ele.className.replace(reg, '');
  32.         }
  33.     }
  34.  
  35.     /*替换类名*/
  36.     replaceClass (ele, newName, oldName) {
  37.         this.removeClass(ele, oldName);
  38.         this.addClass(ele, newName);
  39.     }
  40.  
  41.     /*获取兄弟节点*/
  42.     siblings (ele) {
  43.         console.log(ele.parentNode)
  44.         var chid = ele.parentNode.children,eleMatch = [];
  45.         for(var i = , len = chid.length; i < len; i ++){
  46.             if(chid[i] != ele){
  47.                 eleMatch.push(chid[i]);
  48.             }
  49.         }
  50.         return eleMatch;
  51.     }
  52.  
  53.     /*获取行间样式属性*/
  54.     getByStyle (obj,name){
  55.         if(obj.currentStyle){
  56.             return  obj.currentStyle[name];
  57.         }else{
  58.             return  getComputedStyle(obj,false)[name];
  59.         }
  60.     }
  61. }

Http

  1. /*
  2.     let url = 'http://demo.com/api'
  3.     例:
  4.         ajax({
  5.             url: url,
  6.             success: function(data) {
  7.  
  8.             }
  9.         })
  10. */
  11. function ajax(setting){
  12.     //设置参数的初始值
  13.     var opts={
  14.         method: (setting.method || "GET").toUpperCase(), //请求方式
  15.         url: setting.url || "", // 请求地址
  16.         async: setting.async || true, // 是否异步
  17.         dataType: setting.dataType || "json", // 解析方式
  18.         data: setting.data || "", // 参数
  19.         success: setting.success || function(){}, // 请求成功回调
  20.         error: setting.error || function(){} // 请求失败回调
  21.     }
  22.  
  23.     // 参数格式化
  24.     function params_format (obj) {
  25.         var str = ''
  26.         for (var i in obj) {
  27.             str += i + '=' + obj[i] + '&'
  28.         }
  29.         return str.split('').slice(, -).join('')
  30.     }
  31.  
  32.     // 创建ajax对象
  33.     var xhr=new XMLHttpRequest();
  34.  
  35.     // 连接服务器open(方法GET/POST，请求地址， 异步传输)
  36.     if(opts.method == 'GET'){
  37.         xhr.open(opts.method, opts.url + "?" + params_format(opts.data), opts.async);
  38.         xhr.send();
  39.     }else{
  40.         xhr.open(opts.method, opts.url, opts.async);
  41.         xhr.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
  42.         xhr.send(opts.data);
  43.     }
  44.  
  45.     /*
  46.     ** 每当readyState改变时，就会触发onreadystatechange事件
  47.     ** readyState属性存储有XMLHttpRequest的状态信息
  48.     ** 0 ：请求未初始化
  49.     ** 1 ：服务器连接已建立
  50.     ** 2 ：请求已接受
  51.     ** 3 : 请求处理中
  52.     ** 4 ：请求已完成，且相应就绪
  53.     */
  54.     xhr.onreadystatechange = function() {
  55.         if (xhr.readyState ===  && (xhr.status ===  || xhr.status === )) {
  56.             switch(opts.dataType){
  57.                 case "json":
  58.                     var json = JSON.parse(xhr.responseText);
  59.                     opts.success(json);
  60.                     break;
  61.                 case "xml":
  62.                     opts.success(xhr.responseXML);
  63.                     break;
  64.                 default:
  65.                     opts.success(xhr.responseText);
  66.                     break;
  67.             }
  68.         }
  69.     }
  70.  
  71.     xhr.onerror = function(err) {
  72.         opts.error(err);
  73.     }
  74. }
  75.  
  76. /*
  77.     let url = 'http://demo.com/api'
  78.     例:
  79.         fetchHttp(url).
  80.             then( res => {
  81.                 console.log(res)
  82.             }).catch( e => {
  83.                 console.log(e)
  84.             })
  85.         fetchHttp(url, {
  86.             method: 'POST',
  87.  
  88.         })
  89. */
  90. function fetchHttp(url, setting = {}) {
  91.     //设置参数的初始值
  92.     let opts={
  93.         method: (setting.method || 'GET').toUpperCase(), //请求方式
  94.         headers : setting.headers  || {}, // 请求头设置
  95.         credentials : setting.credentials  || true, // 设置cookie是否一起发送
  96.         body: setting.body || {},
  97.         mode : setting.mode  || 'cors', // 可以设置 cors, no-cors, same-origin
  98.         redirect : setting.redirect  || 'follow', // follow, error, manual
  99.         cache : setting.cache  || 'default' // 设置 cache 模式 (default, reload, no-cache)
  100.     }
  101.     let dataType = setting.dataType || "json", // 解析方式
  102.         data = setting.data || "" // 参数
  103.  
  104.     // 参数格式化
  105.     function params_format (obj) {
  106.         var str = ''
  107.         for (var i in obj) {
  108.             str += `${i}=${obj[i]}&`
  109.         }
  110.         return str.split('').slice(, -).join('')
  111.     }
  112.  
  113.     if (opts.method === 'GET') {
  114.         url = url + (data?`?${params_format(data)}`:'')
  115.     }else{
  116.         setting.body = data || {}
  117.     }
  118.     return new Promise( (resolve, reject) => {
  119.         fetch(url, opts).then( async res => {
  120.             let data = dataType === 'text' ? await res.text() :
  121.                 dataType === 'blob' ? await res.blob() : await res.json()
  122.             resolve(data)
  123.         }).catch( e => {
  124.             reject(e)
  125.         })
  126.     })
  127. }

Number

  1. class NumberFn {
  2.  
  3.     /*随机数范围*/
  4.     random (min, max) {
  5.         if (arguments.length === ) {
  6.             return Math.floor(min + Math.random() * ( (max+) - min ))
  7.         }else{
  8.             return null;
  9.         }
  10.  
  11.     }
  12.  
  13.     /*将阿拉伯数字翻译成中文的大写数字*/
  14.     numberToChinese (num) {
  15.         var AA = new Array("零", "一", "二", "三", "四", "五", "六", "七", "八", "九", "十");
  16.         var BB = new Array("", "十", "百", "仟", "萬", "億", "点", "");
  17.         var a = ("" + num).replace(/(^*)/g, "").split("."),
  18.             k = ,
  19.             re = "";
  20.         for(var i = a[].length - ; i >= ; i--) {
  21.             switch(k) {
  22.                 case :
  23.                     re = BB[] + re;
  24.                     break;
  25.                 case :
  26.                     if(!new RegExp("0{4}//d{" + (a[].length - i - ) + "}$")
  27.                         .test(a[]))
  28.                         re = BB[] + re;
  29.                     break;
  30.                 case :
  31.                     re = BB[] + re;
  32.                     BB[] = BB[];
  33.                     k = ;
  34.                     break;
  35.             }
  36.             if(k %  ==  && a[].charAt(i + ) !=  && a[].charAt(i + ) == )
  37.                 re = AA[] + re;
  38.             if(a[].charAt(i) != )
  39.                 re = AA[a[].charAt(i)] + BB[k % ] + re;
  40.             k++;
  41.         }
  42.  
  43.         if(a.length > ) // 加上小数部分(如果有小数部分)
  44.         {
  45.             re += BB[];
  46.             for(var i = ; i < a[].length; i++)
  47.                 re += AA[a[].charAt(i)];
  48.         }
  49.         if(re == '一十')
  50.             re = "十";
  51.         if(re.match(/^一/) && re.length == )
  52.             re = re.replace("一", "");
  53.         return re;
  54.     }
  55.  
  56.     /*将数字转换为大写金额*/
  57.     changeToChinese (Num) {
  58.             //判断如果传递进来的不是字符的话转换为字符
  59.             if(typeof Num == "number") {
  60.                 Num = new String(Num);
  61.             };
  62.             Num = Num.replace(/,/g, "") //替换tomoney()中的“,”
  63.             Num = Num.replace(/ /g, "") //替换tomoney()中的空格
  64.             Num = Num.replace(/￥/g, "") //替换掉可能出现的￥字符
  65.             if(isNaN(Num)) { //验证输入的字符是否为数字
  66.                 //alert("请检查小写金额是否正确");
  67.                 return "";
  68.             };
  69.             //字符处理完毕后开始转换，采用前后两部分分别转换
  70.             var part = String(Num).split(".");
  71.             var newchar = "";
  72.             //小数点前进行转化
  73.             for(var i = part[].length - ; i >= ; i--) {
  74.                 if(part[].length > ) {
  75.                     return "";
  76.                     //若数量超过拾亿单位，提示
  77.                 }
  78.                 var tmpnewchar = ""
  79.                 var perchar = part[].charAt(i);
  80.                 switch(perchar) {
  81.                     case "":
  82.                         tmpnewchar = "零" + tmpnewchar;
  83.                         break;
  84.                     case "":
  85.                         tmpnewchar = "壹" + tmpnewchar;
  86.                         break;
  87.                     case "":
  88.                         tmpnewchar = "贰" + tmpnewchar;
  89.                         break;
  90.                     case "":
  91.                         tmpnewchar = "叁" + tmpnewchar;
  92.                         break;
  93.                     case "":
  94.                         tmpnewchar = "肆" + tmpnewchar;
  95.                         break;
  96.                     case "":
  97.                         tmpnewchar = "伍" + tmpnewchar;
  98.                         break;
  99.                     case "":
  100.                         tmpnewchar = "陆" + tmpnewchar;
  101.                         break;
  102.                     case "":
  103.                         tmpnewchar = "柒" + tmpnewchar;
  104.                         break;
  105.                     case "":
  106.                         tmpnewchar = "捌" + tmpnewchar;
  107.                         break;
  108.                     case "":
  109.                         tmpnewchar = "玖" + tmpnewchar;
  110.                         break;
  111.                 }
  112.                 switch(part[].length - i - ) {
  113.                     case :
  114.                         tmpnewchar = tmpnewchar + "元";
  115.                         break;
  116.                     case :
  117.                         if(perchar != ) tmpnewchar = tmpnewchar + "拾";
  118.                         break;
  119.                     case :
  120.                         if(perchar != ) tmpnewchar = tmpnewchar + "佰";
  121.                         break;
  122.                     case :
  123.                         if(perchar != ) tmpnewchar = tmpnewchar + "仟";
  124.                         break;
  125.                     case :
  126.                         tmpnewchar = tmpnewchar + "万";
  127.                         break;
  128.                     case :
  129.                         if(perchar != ) tmpnewchar = tmpnewchar + "拾";
  130.                         break;
  131.                     case :
  132.                         if(perchar != ) tmpnewchar = tmpnewchar + "佰";
  133.                         break;
  134.                     case :
  135.                         if(perchar != ) tmpnewchar = tmpnewchar + "仟";
  136.                         break;
  137.                     case :
  138.                         tmpnewchar = tmpnewchar + "亿";
  139.                         break;
  140.                     case :
  141.                         tmpnewchar = tmpnewchar + "拾";
  142.                         break;
  143.                 }
  144.                 var newchar = tmpnewchar + newchar;
  145.             }
  146.             //小数点之后进行转化
  147.             if(Num.indexOf(".") != -) {
  148.                 if(part[].length > ) {
  149.                     // alert("小数点之后只能保留两位,系统将自动截断");
  150.                     part[] = part[].substr(, )
  151.                 }
  152.                 for(i = ; i < part[].length; i++) {
  153.                     tmpnewchar = ""
  154.                     perchar = part[].charAt(i)
  155.                     switch(perchar) {
  156.                         case "":
  157.                             tmpnewchar = "零" + tmpnewchar;
  158.                             break;
  159.                         case "":
  160.                             tmpnewchar = "壹" + tmpnewchar;
  161.                             break;
  162.                         case "":
  163.                             tmpnewchar = "贰" + tmpnewchar;
  164.                             break;
  165.                         case "":
  166.                             tmpnewchar = "叁" + tmpnewchar;
  167.                             break;
  168.                         case "":
  169.                             tmpnewchar = "肆" + tmpnewchar;
  170.                             break;
  171.                         case "":
  172.                             tmpnewchar = "伍" + tmpnewchar;
  173.                             break;
  174.                         case "":
  175.                             tmpnewchar = "陆" + tmpnewchar;
  176.                             break;
  177.                         case "":
  178.                             tmpnewchar = "柒" + tmpnewchar;
  179.                             break;
  180.                         case "":
  181.                             tmpnewchar = "捌" + tmpnewchar;
  182.                             break;
  183.                         case "":
  184.                             tmpnewchar = "玖" + tmpnewchar;
  185.                             break;
  186.                     }
  187.                     if(i == ) tmpnewchar = tmpnewchar + "角";
  188.                     if(i == ) tmpnewchar = tmpnewchar + "分";
  189.                     newchar = newchar + tmpnewchar;
  190.                 }
  191.             }
  192.             //替换所有无用汉字
  193.             while(newchar.search("零零") != -)
  194.                 newchar = newchar.replace("零零", "零");
  195.             newchar = newchar.replace("零亿", "亿");
  196.             newchar = newchar.replace("亿万", "亿");
  197.             newchar = newchar.replace("零万", "万");
  198.             newchar = newchar.replace("零元", "元");
  199.             newchar = newchar.replace("零角", "");
  200.             newchar = newchar.replace("零分", "");
  201.             if(newchar.charAt(newchar.length - ) == "元") {
  202.                 newchar = newchar + "整"
  203.             }
  204.             return newchar;
  205.         }
  206.  
  207. }

String

  1. class StringFn {
  2.     /**
  3.      * 去除空格
  4.      * @param  {str}
  5.      * @param  {type}
  6.      *       type:  1-所有空格  2-前后空格  3-前空格 4-后空格
  7.      * @return {String}
  8.      */
  9.     trim (str, type) {
  10.         type = type ||
  11.         switch (type) {
  12.             case :
  13.                 return str.replace(/\s+/g, "");
  14.             case :
  15.                 return str.replace(/(^\s*)|(\s*$)/g, "");
  16.             case :
  17.                 return str.replace(/(^\s*)/g, "");
  18.             case :
  19.                 return str.replace(/(\s*$)/g, "");
  20.             default:
  21.                 return str;
  22.         }
  23.     }
  24.  
  25.     /**
  26.      * @param  {str}
  27.      * @param  {type}
  28.      *       type:  1:首字母大写  2：首页母小写  3：大小写转换  4：全部大写  5：全部小写
  29.      * @return {String}
  30.      */
  31.     changeCase (str, type) {
  32.         type = type ||
  33.         switch (type) {
  34.             case :
  35.                 return str.replace(/\b\w+\b/g, function (word) {
  36.                     return word.substring(, ).toUpperCase() + word.substring().toLowerCase();
  37.  
  38.                 });
  39.             case :
  40.                 return str.replace(/\b\w+\b/g, function (word) {
  41.                     return word.substring(, ).toLowerCase() + word.substring().toUpperCase();
  42.                 });
  43.             case :
  44.                 return str.split('').map( function(word){
  45.                     if (/[a-z]/.test(word)) {
  46.                         return word.toUpperCase();
  47.                     }else{
  48.                         return word.toLowerCase()
  49.                     }
  50.                 }).join('')
  51.             case :
  52.                 return str.toUpperCase();
  53.             case :
  54.                 return str.toLowerCase();
  55.             default:
  56.                 return str;
  57.         }
  58.     }
  59.  
  60.     /*
  61.         检测密码强度
  62.     */
  63.     checkPwd (str) {
  64.         var Lv = ;
  65.         if (str.length < ) {
  66.             return Lv
  67.         }
  68.         if (/[-]/.test(str)) {
  69.             Lv++
  70.         }
  71.         if (/[a-z]/.test(str)) {
  72.             Lv++
  73.         }
  74.         if (/[A-Z]/.test(str)) {
  75.             Lv++
  76.         }
  77.         if (/[\.|-|_]/.test(str)) {
  78.             Lv++
  79.         }
  80.         return Lv;
  81.     }
  82.  
  83.     /*过滤html代码(把<>转换)*/
  84.     filterTag (str) {
  85.         str = str.replace(/&/ig, "&amp;");
  86.         str = str.replace(/</ig, "&lt;");
  87.         str = str.replace(/>/ig, "&gt;");
  88.         str = str.replace(" ", "&nbsp;");
  89.         return str;
  90.     }
  91. }

Storage、cookie

  1. class StorageFn {
  2.     constructor () {
  3.         this.ls = window.localStorage;
  4.         this.ss = window.sessionStorage;
  5.     }
  6.  
  7.     /*-----------------cookie---------------------*/
  8.     /*设置cookie*/
  9.     setCookie (name, value, day) {
  10.         var setting = arguments[];
  11.         if (Object.prototype.toString.call(setting).slice(, -) === 'Object'){
  12.             for (var i in setting) {
  13.                 var oDate = new Date();
  14.                 oDate.setDate(oDate.getDate() + day);
  15.                 document.cookie = i + '=' + setting[i] + ';expires=' + oDate;
  16.             }
  17.         }else{
  18.             var oDate = new Date();
  19.             oDate.setDate(oDate.getDate() + day);
  20.             document.cookie = name + '=' + value + ';expires=' + oDate;
  21.         }
  22.  
  23.     }
  24.  
  25.     /*获取cookie*/
  26.     getCookie (name) {
  27.         var arr = document.cookie.split('; ');
  28.         for (var i = ; i < arr.length; i++) {
  29.             var arr2 = arr[i].split('=');
  30.             if (arr2[] == name) {
  31.                 return arr2[];
  32.             }
  33.         }
  34.         return '';
  35.     }
  36.  
  37.     /*删除cookie*/
  38.     removeCookie (name) {
  39.         this.setCookie(name, , -);
  40.     }
  41.  
  42.     /*-----------------localStorage---------------------*/
  43.     /*设置localStorage*/
  44.     setLocal(key, val) {
  45.         var setting = arguments[];
  46.         if (Object.prototype.toString.call(setting).slice(, -) === 'Object'){
  47.             for(var i in setting){
  48.                 this.ls.setItem(i, JSON.stringify(setting[i]))
  49.             }
  50.         }else{
  51.             this.ls.setItem(key, JSON.stringify(val))
  52.         }
  53.  
  54.     }
  55.  
  56.     /*获取localStorage*/
  57.     getLocal(key) {
  58.         if (key) return JSON.parse(this.ls.getItem(key))
  59.         return null;
  60.  
  61.     }
  62.  
  63.     /*移除localStorage*/
  64.     removeLocal(key) {
  65.         this.ls.removeItem(key)
  66.     }
  67.  
  68.     /*移除所有localStorage*/
  69.     clearLocal() {
  70.         this.ls.clear()
  71.     }
  72.  
  73.     /*-----------------sessionStorage---------------------*/
  74.     /*设置sessionStorage*/
  75.     setSession(key, val) {
  76.         var setting = arguments[];
  77.         if (Object.prototype.toString.call(setting).slice(, -) === 'Object'){
  78.             for(var i in setting){
  79.                 this.ss.setItem(i, JSON.stringify(setting[i]))
  80.             }
  81.         }else{
  82.             this.ss.setItem(key, JSON.stringify(val))
  83.         }
  84.  
  85.     }
  86.  
  87.     /*获取sessionStorage*/
  88.     getSession(key) {
  89.         if (key) return JSON.parse(this.ss.getItem(key))
  90.         return null;
  91.  
  92.     }
  93.  
  94.     /*移除sessionStorage*/
  95.     removeSession(key) {
  96.         this.ss.removeItem(key)
  97.     }
  98.  
  99.     /*移除所有sessionStorage*/
  100.     clearSession() {
  101.         this.ss.clear()
  102.     }
  103.  
  104. }

Others

  1. class OtherFn {
  2.  
  3.     /**
  4.      * [deepClone 深度克隆]
  5.      * @param  {[type]} obj [克隆对象]
  6.      * @return {[type]}     [返回深度克隆后的对象]
  7.      */
  8.     deepClone (obj) {
  9.         if (obj === null || typeof obj !== 'object') return obj
  10.         var isType = function(obj, type) {
  11.             var flag,
  12.                 typeString = Object.prototype.toString.call(obj)
  13.             switch(type) {
  14.                 case 'Array':
  15.                     flag = typeString === '[object Array]'
  16.                     break
  17.                 case 'Date':
  18.                     flag = typeString === '[object Date]'
  19.                     break
  20.                 case 'RegExp':
  21.                     flag = typeString === '[object RegExp]'
  22.                     break
  23.                 default:
  24.                     flag = false
  25.             }
  26.             return flag
  27.         }
  28.         var getRegExp = function(re) {
  29.             var flags = ''
  30.             if (re.global) flags += 'g'
  31.             if (re.ignoreCase) flags += 'i'
  32.             if (re.multiline) flags += 'm'
  33.             return flags
  34.         }
  35.  
  36.         var _clone = function(parent) {
  37.             var child, proto, parents = [], children = []
  38.             if (isType(parent, 'Array')) {// 对数组做特殊处理
  39.                 child = [];
  40.             } else if (isType(parent, 'RegExp')) {// 对正则做特殊处理
  41.                 child = new RegExp(parent.source, getRegExp(parent));
  42.                 if (parent.lastIndex) child.lastIndex = parent.lastIndex;
  43.             } else if (isType(parent, 'Date')) {// 对Date做特殊处理
  44.                 child = new Date(parent.getTime());
  45.             } else {
  46.                 // 处理对象原型
  47.                 proto = Object.getPrototypeOf(parent);
  48.                 // 利用Object.create切断原型链
  49.                 child = Object.create(proto);
  50.             }
  51.             // 处理循环引用
  52.             var index = parents.indexOf(parent);
  53.  
  54.             if (index != -) {
  55.                 // 如果父数组存在本对象,说明之前已经被引用过,直接返回此对象
  56.                 return children[index];
  57.             }
  58.             parents.push(parent);
  59.             children.push(child);
  60.  
  61.             for (var i in parent) {
  62.                 child[i] = _clone(parent[i]);
  63.             }
  64.  
  65.             return child;
  66.         }
  67.         return _clone(obj)
  68.     }
  69.  
  70.     /*获取网址参数*/
  71.     getUrlParams(name){
  72.         var reg = new RegExp("(^|&)"+ name +"=([^&]*)(&|$)");
  73.         var r = decodeURI(window.location.search).substr().match(reg);
  74.         if(r!=null) return  r[]; return null;
  75.     }
  76.  
  77.     /*获取全部url参数,并转换成json对象*/
  78.     getUrlAllParams (url) {
  79.         var url = url ? url : window.location.href;
  80.         var _pa = url.substring(url.indexOf('?') + ),
  81.             _arrS = _pa.split('&'),
  82.             _rs = {};
  83.         for (var i = , _len = _arrS.length; i < _len; i++) {
  84.             var pos = _arrS[i].indexOf('=');
  85.             if (pos == -) {
  86.                 continue;
  87.             }
  88.             var name = _arrS[i].substring(, pos),
  89.                 value = window.decodeURIComponent(_arrS[i].substring(pos + ));
  90.             _rs[name] = value;
  91.         }
  92.         return _rs;
  93.     }
  94.  
  95.     /*删除url指定参数，返回url*/
  96.     delParamsUrl(url, name){
  97.         var baseUrl = url.split('?')[] + '?';
  98.         var query = url.split('?')[];
  99.         if (query.indexOf(name)>-) {
  100.             var obj = {}
  101.             var arr = query.split("&");
  102.             for (var i = ; i < arr.length; i++) {
  103.                 arr[i] = arr[i].split("=");
  104.                 obj[arr[i][]] = arr[i][];
  105.             };
  106.             delete obj[name];
  107.             var url = baseUrl + JSON.stringify(obj).replace(/[\"\{\}]/g,"").replace(/\:/g,"=").replace(/\,/g,"&");
  108.             return url
  109.         }else{
  110.             return url;
  111.         }
  112.     }
  113.  
  114.     /*获取十六进制随机颜色*/
  115.     getRandomColor () {
  116.         return '#' + (function(h) {
  117.             return new Array( - h.length).join("") + h;
  118.         })((Math.random() * 0x1000000 << ).toString());
  119.     }
  120.  
  121.     /*图片加载*/
  122.     imgLoadAll(arr,callback){
  123.         var arrImg = [];
  124.         for (var i = ; i < arr.length; i++) {
  125.             var img = new Image();
  126.             img.src = arr[i];
  127.             img.onload = function(){
  128.                 arrImg.push(this);
  129.                 if (arrImg.length == arr.length) {
  130.                     callback && callback();
  131.                 }
  132.             }
  133.         }
  134.     }
  135.  
  136.     /*音频加载*/
  137.     loadAudio(src, callback) {
  138.         var audio = new Audio(src);
  139.         audio.onloadedmetadata = callback;
  140.         audio.src = src;
  141.     }
  142.  
  143.     /*DOM转字符串*/
  144.     domToStirng(htmlDOM){
  145.         var div= document.createElement("div");
  146.         div.appendChild(htmlDOM);
  147.         return div.innerHTML
  148.     }
  149.  
  150.     /*字符串转DOM*/
  151.     stringToDom(htmlString){
  152.         var div= document.createElement("div");
  153.         div.innerHTML=htmlString;
  154.         return div.children[];
  155.     }
  156.  
  157.     /**
  158.      * 光标所在位置插入字符，并设置光标位置
  159.      *
  160.      * @param {dom} 输入框
  161.      * @param {val} 插入的值
  162.      * @param {posLen} 光标位置处在 插入的值的哪个位置
  163.      */
  164.     setCursorPosition (dom,val,posLen) {
  165.         var cursorPosition = ;
  166.         if(dom.selectionStart){
  167.             cursorPosition = dom.selectionStart;
  168.         }
  169.         this.insertAtCursor(dom,val);
  170.         dom.focus();
  171.         console.log(posLen)
  172.         dom.setSelectionRange(dom.value.length,cursorPosition + (posLen || val.length));
  173.     }
  174.  
  175.     /*光标所在位置插入字符*/
  176.     insertAtCursor(dom, val) {
  177.         if (document.selection){
  178.             dom.focus();
  179.             sel = document.selection.createRange();
  180.             sel.text = val;
  181.             sel.select();
  182.         }else if (dom.selectionStart || dom.selectionStart == ''){
  183.             let startPos = dom.selectionStart;
  184.             let endPos = dom.selectionEnd;
  185.             let restoreTop = dom.scrollTop;
  186.             dom.value = dom.value.substring(, startPos) + val + dom.value.substring(endPos, dom.value.length);
  187.             if (restoreTop > ){
  188.                 dom.scrollTop = restoreTop;
  189.             }
  190.             dom.focus();
  191.             dom.selectionStart = startPos + val.length;
  192.             dom.selectionEnd = startPos + val.length;
  193.         } else {
  194.             dom.value += val;
  195.             dom.focus();
  196.         }
  197.     }
  198. }

Javascript总结（全）的更多相关文章

  1. 表单javascript checkbox全选 反选 全不选

    <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <meta http ...

  2. JavaScript 实现全选 / 反选功能

    JavaScript 实现全选 / 反选功能 版权声明:未经授权,内容严禁转载! 构建主体界面 编写 HTML 代码 和 CSS 代码,设计主题界面 <style> #user { wid ...

  3. JavaScript最全编码规范

    转载: JavaScript最全编码规范 类型 ●基本类型:访问基本类型时,应该直接操作类型值 ●string ●number ●boolean ●null ●undefined var foo = ...

  4. Javascript实现全选按钮

    Javascript实现全选按钮 效果:有全选选项框和单个选项框,选择全选框,所有的的选择都打上的钩,取消全选钩所有的都去掉了钩,如果取消其中某一个的钩,那么全选的钩也取消,反之全选所有的选项,那么全 ...

  5. JavaScript、全选反选-课堂笔记

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...

  6. 转发！HTML 复选框 checkbox 的 JavaScript 的全选和全反选

    checkbox 或者按钮实现 form 内的 checkbox 全选或者反选,代码很简单,全部代码如下: <html> <head> <meta http-equiv= ...

  7. jQuery/javascript实现全选全不选

    <html> <head> <meta charset="utf-8"> <title>Checkbox的练习</title& ...

  8. 用javascript实现全选/反选组件

    以下是本人制作的全选/反选 组件,供广大同行参考.指正: 效果如图: 在实现的过程中,全选和全部取消选中这两个功能较为简单,只需用for循环遍历所有复选框为true或false即可.反选也较为简单,也 ...

  9. javascript无缝全屏轮播

    虽然平时能利用插件来实现,但是总是觉得,如果连个无缝轮播都写不出来,还玩个毛线: 其实现在还真的是玩毛线,因为代码都是别人的,不过嘛,很快就变成是我的啦! 代码还没封装成插件,其实我也还没弄清楚. 下 ...

  10. JavaScript 实时 全角转半角

    //JavaScript全角字符转半角(参数str为input框输入的内容)var $fullChar2halfChar = function(str) { var result = ''; for ...

随机推荐

  1. ELK学习笔记之Kibana查询和使用说明

    0x00 概述 elasticsearch构建在Lucene之上,过滤器语法和Lucene相同 Kibana接口概述 Kibana接口分为四个主要部分: 发现 可视化 仪表板 设置 我们将按照列出的顺 ...

  2. Delphi中HInstance

    通过测试看出:HInstance.Application.Handle.Self.Handle不是一回事. Self.Handle是窗体句柄: Application.Handle也是个窗体的句柄,不 ...

  3. C# yield checked,unchecked lock语句（C#学习笔记04）

    特殊语句 yield语句 yield用于终止迭代 只能使用在返回类型必须为 IEnumerable.IEnumerable<T>.IEnumerator 或 IEnumerator< ...

  4. 测试欧气的小游戏-java

    Java 用我们学到的知识做处一个小的项目或者游戏等等应该都或多或少的有一点点的成就感吧,下列就是我用所学的基础知识做的猜字谜游戏,并且给他赋予了灵魂哈哈哈.有兴趣的可以尝试的用自己会的知识做一些小的 ...

  5. django子应用

    在Web应用中,通常有一些业务功能模块是在不同的项目中都可以复用的,故在开发中通常将工程项目拆分为不同的子功能模块,各功能模块间可以保持相对的独立,在其他工程项目中需要用到某个特定功能模块时,可以将该 ...

  6. 腕表wacche英语wacche手表

    watch As a noun, from Middle English wacche, Etymology As a noun, from Middle English wacche,See bel ...

  7. Shell 冒泡排序

    举例 #!/bin/bash echo "please input a number list:" read -a arrs for((i=0;i<${#arrs[@]};i ...

  8. linux基础命令学习

    一 su命令 1. [yunwei@elymedia ~]$ yunwei   表示当前用户名 @elymedia   表示主机名 - 表示当前路径,涉及到当前用户的主目录(家目录) $  表示普通用 ...

  9. U盘出现.exe问题的解决方案

    这代表U盘中了AutoRun病毒,原文件并未被删除,只是被设置为隐藏了. 所以切勿直接格式化U盘! 解决方案:分别创建文件1.reg和2.bat: 1.reg Windows Registry Edi ...

  10. 常用Windows命令、常用 Cmd命令（补充）

    常用的Windows 命令使用能够提升工作效率以及快捷处理事项. 下面为平时常用的Windows 命令/cmd 命令. 一.以下命令无需打开cmd 窗口即可操作(输入完毕 打个 回车,即可执行). 1 ...