当前位置: 萬仟网 > IT编程>开发语言>Java > 编写自己的代码库

编写自己的代码库

2019年09月12日 Java 我要评论
大家在开发的时候应该知道,有很多常见的实例操作。比如数组去重,关键词高亮,打乱数组等。这些操作,代码一般不会很多,实现的逻辑也不会很难,下面的代码,我解释就不解释太多了,打上注释,相信大家就会懂了。但是,用的地方会比较,如果项目有哪个地方需要用,如果重复写的话,就是代码沉余,开发效率也不用,复用基本... ...

1.前言

大家在开发的时候应该知道,有很多常见的实例操作。比如数组去重,关键词高亮,打乱数组等。这些操作,代码一般不会很多,实现的逻辑也不会很难,下面的代码,我解释就不解释太多了,打上注释,相信大家就会懂了。但是,用的地方会比较,如果项目有哪个地方需要用,如果重复写的话,就是代码沉余,开发效率也不用,复用基本就是复制粘贴!这样是一个很不好的习惯,大家可以考虑一下把一些常见的操作封装成函数,调用的时候,直接调用就好!

2.字符串操作

2-1去除字符串空格

//去除空格  type 1-所有空格  2-前后空格  3-前空格 4-后空格
//util.trim('  1235asd',1)
//result:1235asd
//这个方法有原生的方案代替,但是考虑到有时候开发pc站需要兼容ie8,所以就还是继续保留
trim: function (str, type) {
    switch (type) {
        case 1:
            return str.replace(/\s+/g, "");
        case 2:
            return str.replace(/(^\s*)|(\s*$)/g, "");
        case 3:
            return str.replace(/(^\s*)/g, "");
        case 4:
            return str.replace(/(\s*$)/g, "");
        default:
            return str;
    }
}

2-2字母大小写切换

/*type
 1:首字母大写
 2:首页母小写
 3:大小写转换
 4:全部大写
 5:全部小写
 * */
//util.changecase('asdasd',1)
//result:asdasd
changecase: function (str, type) {
    function togglecase(str) {
        var itemtext = ""
        str.split("").foreach(
            function (item) {
                if (/^([a-z]+)/.test(item)) {
                    itemtext += item.touppercase();
                } else if (/^([a-z]+)/.test(item)) {
                    itemtext += item.tolowercase();
                } else {
                    itemtext += item;
                }
            });
        return itemtext;
    }
    switch (type) {
        case 1:
            return str.replace(/\b\w+\b/g, function (word) {
                return word.substring(0, 1).touppercase() + word.substring(1).tolowercase();
            });
        case 2:
            return str.replace(/\b\w+\b/g, function (word) {
                return word.substring(0, 1).tolowercase() + word.substring(1).touppercase();
            });
        case 3:
            return togglecase(str);
        case 4:
            return str.touppercase();
        case 5:
            return str.tolowercase();
        default:
            return str;
    }
}

2-3字符串循环复制

//repeatstr(str->字符串, count->次数)
//util.repeatstr('123',3)
//"result:123123123"
repeatstr: function (str, count) {
    var text = '';
    for (var i = 0; i < count; i++) {
        text += str;
    }
    return text;
}

2-4字符串替换

replaceall: function (str, afindtext, areptext) {
    raregexp = new regexp(afindtext, "g");
    return str.replace(raregexp, areptext);
}

2-5替换*

//字符替换*
//replacestr(字符串,字符格式, 替换方式,替换的字符(默认*))
//util.replacestr('18819322663',[3,5,3],0)
//result:188*****663
//util.replacestr('asdasdasdaa',[3,5,3],1)
//result:***asdas***
//util.replacestr('1asd88465asdwqe3',[5],0)
//result:*****8465asdwqe3
//util.replacestr('1asd88465asdwqe3',[5],1,'+')
//result:"1asd88465as+++++"
replacestr: function (str, regarr, type, areptext) {
    var regtext = '',
        reg = null,
        replacetext = areptext || '*';
    //repeatstr是在上面定义过的(字符串循环复制),大家注意哦
    if (regarr.length === 3 && type === 0) {
        regtext = '(\\w{' + regarr[0] + '})\\w{' + regarr[1] + '}(\\w{' + regarr[2] + '})'
        reg = new regexp(regtext);
        var replacecount = this.repeatstr(replacetext, regarr[1]);
        return str.replace(reg, '$1' + replacecount + '$2')
    }
    else if (regarr.length === 3 && type === 1) {
        regtext = '\\w{' + regarr[0] + '}(\\w{' + regarr[1] + '})\\w{' + regarr[2] + '}'
        reg = new regexp(regtext);
        var replacecount1 = this.repeatstr(replacetext, regarr[0]);
        var replacecount2 = this.repeatstr(replacetext, regarr[2]);
        return str.replace(reg, replacecount1 + '$1' + replacecount2)
    }
    else if (regarr.length === 1 && type === 0) {
        regtext = '(^\\w{' + regarr[0] + '})'
        reg = new regexp(regtext);
        var replacecount = this.repeatstr(replacetext, regarr[0]);
        return str.replace(reg, replacecount)
    }
    else if (regarr.length === 1 && type === 1) {
        regtext = '(\\w{' + regarr[0] + '}$)'
        reg = new regexp(regtext);
        var replacecount = this.repeatstr(replacetext, regarr[0]);
        return str.replace(reg, replacecount)
    }
}

2-6检测字符串

//检测字符串
//util.checktype('165226226326','phone')
//result:false
//大家可以根据需要扩展
checktype: function (str, type) {
    switch (type) {
        case 'email':
            return /^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/.test(str);
        case 'phone':
            return /^1[3|4|5|7|8][0-9]{9}$/.test(str);
        case 'tel':
            return /^(0\d{2,3}-\d{7,8})(-\d{1,4})?$/.test(str);
        case 'number':
            return /^[0-9]$/.test(str);
        case 'english':
            return /^[a-za-z]+$/.test(str);
        case 'text':
            return /^\w+$/.test(str);
        case 'chinese':
            return /^[\u4e00-\u9fa5]+$/.test(str);
        case 'lower':
            return /^[a-z]+$/.test(str);
        case 'upper':
            return /^[a-z]+$/.test(str);
        default:
            return true;
    }
}

2-7 检测密码强度

//util.checkpwd('12asdasad')
//result:3(强度等级为3)
checkpwd: function (str) {
    var nowlv = 0;
    if (str.length < 6) {
        return nowlv
    }
    if (/[0-9]/.test(str)) {
        nowlv++
    }
    if (/[a-z]/.test(str)) {
        nowlv++
    }
    if (/[a-z]/.test(str)) {
        nowlv++
    }
    if (/[\.|-|_]/.test(str)) {
        nowlv++
    }
    return nowlv;
}

2-8随机码(tostring详解)

//count取值范围0-36
//util.randomword(10)
//result:"2584316588472575"
//util.randomword(14)
//result:"9b405070dd00122640c192caab84537"
//util.randomword(36)
//result:"83vhdx10rmjkyb9"
randomword: function (count) {
    return math.random().tostring(count).substring(2);
}

2-9查找字符串

可能标题会有点误导,下面我就简单说明一个需求,在字符串'sad44654blog5a1sd67as9dablog4s5d16zxc4sdweasjkblogwqepaskdkblogahseiuadbhjcibloguyeajzxkcabloguyiwezxc967'中找出'blog'的出现次数。代码如下

//var strtest='sad44654blog5a1sd67as9dablog4s5d16zxc4sdweasjkblogwqepaskdkblogahseiuadbhjcibloguyeajzxkcabloguyiwezxc967'
//util.countstr(strtest,'blog')
//result:6
countstr: function (str, strsplit) {
    return str.split(strsplit).length - 1
}

2-10 过滤字符串

//过滤字符串(html标签,表情,特殊字符)
//字符串,替换内容(special-特殊字符,html-html标签,emjoy-emjoy表情,word-小写字母,word-大写字母,number-数字,chinese-中文),要替换成什么,默认'',保留哪些特殊字符
//如果需要过滤多种字符,type参数使用,分割,如下栗子
//过滤字符串的html标签,大写字母,中文,特殊字符,全部替换成*,但是特殊字符'%','?',除了这两个,其他特殊字符全部清除
//var str='asd    654a大蠢sasdasdasdqwexzc6d5#%^*^&*^%^&*$\\"\'#@!()*/-())_\'":"{}?<div></div><img src=""/>啊实打实大蠢猪自行车这些课程';
// util.filterstr(str,'html,word,chinese,special','*','%?')
//result:"asd    654a**sasdasd*********6d5#%^*^&*^%^&*$\"'#@!()*/-())_'":"{}?*****************"
filterstr: function (str, type, restr, spstr) {
    var typearr = type.split(','), _str = str;
    for (var i = 0, len = typearr.length; i < len; i++) {
        //是否是过滤特殊符号
        if (typearr[i] === 'special') {
            var pattern, regtext = '$()[]{}?\|^*+./\"\'+';
            //是否有哪些特殊符号需要保留
            if (spstr) {
                var _spstr = spstr.split(""), _regtext = "[^0-9a-za-z\\s";
                for (var j = 0, len1 = _spstr.length; j < len1; j++) {
                    if (regtext.indexof(_spstr[j]) === -1) {
                        _regtext += _spstr[j];
                    }
                    else {
                        _regtext += '\\' + _spstr[j];
                    }
                }
                _regtext += ']'
                pattern = new regexp(_regtext, 'g');
            }
            else {
                pattern = new regexp("[^0-9a-za-z\\s]", 'g')
            }
        }
        var _restr = restr || '';
        switch (typearr[i]) {
            case 'special':
                _str = _str.replace(pattern, _restr);
                break;
            case 'html':
                _str = _str.replace(/<\/?[^>]*>/g, _restr);
                break;
            case 'emjoy':
                _str = _str.replace(/[^\u4e00-\u9fa5|\u0000-\u00ff|\u3002|\uff1f|\uff01|\uff0c|\u3001|\uff1b|\uff1a|\u3008-\u300f|\u2018|\u2019|\u201c|\u201d|\uff08|\uff09|\u2014|\u2026|\u2013|\uff0e]/g, _restr);
                break;
            case 'word':
                _str = _str.replace(/[a-z]/g, _restr);
                break;
            case 'word':
                _str = _str.replace(/[a-z]/g, _restr);
                break;
            case 'number':
                _str = _str.replace(/[0-9]/g, _restr);
                break;
            case 'chinese':
                _str = _str.replace(/[\u4e00-\u9fa5]/g, _restr);
                break;
        }
    }
    return _str;
}

2-11格式化处理字符串

//util.formattext('1234asda567asd890')
//result:"12,34a,sda,567,asd,890"
//util.formattext('1234asda567asd890',4,' ')
//result:"1 234a sda5 67as d890"
//util.formattext('1234asda567asd890',4,'-')
//result:"1-234a-sda5-67as-d890"
formattext: function (str, size, delimiter) {
    var _size = size || 3, _delimiter = delimiter || ',';
    var regtext = '\\b(?=(\\w{' + _size + '})+(?!\\w))';
    var reg = new regexp(regtext, 'g');
    return str.replace(reg, _delimiter);
}

2-12找出最长单词

//util.longestword('find the longest word in a string')
//result:7
//util.longestword('find|the|longest|word|in|a|string','|')
//result:7
longestword: function (str, splittype) {
    var _splittype = splittype || /\s+/g,
        _max = 0,_item='';
    var strarr = str.split(_splittype);
    strarr.foreach(function (item) {
        if (_max < item.length) {
            _max = item.length
            _item=item;
        }
    })
    return {el:_item,max:_max};
}

2-13句中单词首字母大写

//这个我也一直在纠结,英文标题,即使是首字母大写,也未必每一个单词的首字母都是大写的,但是又不知道哪些应该大写,哪些不应该大写
//util.titlecaseup('this is a title')
//"this is a title"
titlecaseup: function (str, splittype) {
    var _splittype = splittype || /\s+/g;
    var strarr = str.split(_splittype),
        result = "", _this = this
    strarr.foreach(function (item) {
        result += _this.changecase(item, 1) + ' ';
    })
    return this.trim(result, 4)
}  

3.数组操作

3-1数组去重

removerepeatarray: function (arr) {
    return arr.filter(function (item, index, self) {
        return self.indexof(item) === index;
    });
}

3-2数组顺序打乱

upsetarr: function (arr) {
    return arr.sort(function () {
        return math.random() - 0.5
    });
},

3-3数组最大值最小值

//数组最大值
maxarr: function (arr) {
    return math.max.apply(null, arr);
},
//数组最小值
minarr: function (arr) {
    return math.min.apply(null, arr);
}

3-4数组求和,平均值

//这一块的封装,主要是针对数字类型的数组
//求和
sumarr: function (arr) {
    return arr.reduce(function (pre, cur) {
        return pre + cur
    })
}
//数组平均值,小数点可能会有很多位,这里不做处理,处理了使用就不灵活!
covarr: function (arr) {
    return this.sumarr(arr) / arr.length;
},

3-5从数组中随机获取元素

//util.randomone([1,2,3,6,8,5,4,2,6])
//2
//util.randomone([1,2,3,6,8,5,4,2,6])
//8
//util.randomone([1,2,3,6,8,5,4,2,6])
//8
//util.randomone([1,2,3,6,8,5,4,2,6])
//1
randomone: function (arr) {
    return arr[math.floor(math.random() * arr.length)];
}

3-6返回数组(字符串)一个元素出现的次数

//util.getelecount('asd56+asdasdwqe','a')
//result:3
//util.getelecount([1,2,3,4,5,66,77,22,55,22],22)
//result:2
getelecount: function (obj, ele) {
    var num = 0;
    for (var i = 0, len = obj.length; i < len; i++) {
        if (ele === obj[i]) {
            num++;
        }
    }
    return num;
}

3-7返回数组(字符串)出现最多的几次元素和出现次数

//arr, rank->长度,默认为数组长度,ranktype,排序方式,默认降序
//返回值:el->元素,count->次数
//util.getcount([1,2,3,1,2,5,2,4,1,2,6,2,1,3,2])
//默认情况,返回所有元素出现的次数
//result:[{"el":"2","count":6},{"el":"1","count":4},{"el":"3","count":2},{"el":"4","count":1},{"el":"5","count":1},{"el":"6","count":1}]
//util.getcount([1,2,3,1,2,5,2,4,1,2,6,2,1,3,2],3)
//传参(rank=3),只返回出现次数排序前三的
//result:[{"el":"2","count":6},{"el":"1","count":4},{"el":"3","count":2}]
//util.getcount([1,2,3,1,2,5,2,4,1,2,6,2,1,3,2],null,1)
//传参(ranktype=1,rank=null),升序返回所有元素出现次数
//result:[{"el":"6","count":1},{"el":"5","count":1},{"el":"4","count":1},{"el":"3","count":2},{"el":"1","count":4},{"el":"2","count":6}]
//util.getcount([1,2,3,1,2,5,2,4,1,2,6,2,1,3,2],3,1)
//传参(rank=3,ranktype=1),只返回出现次数排序(升序)前三的
//result:[{"el":"6","count":1},{"el":"5","count":1},{"el":"4","count":1}]
getcount: function (arr, rank, ranktype) {
    var obj = {},
        k, arr1 = []
    //记录每一元素出现的次数
    for (var i = 0, len = arr.length; i < len; i++) {
        k = arr[i];
        if (obj[k]) {
            obj[k]++;
        } else {
            obj[k] = 1;
        }
    }
    //保存结果{el-'元素',count-出现次数}
    for (var o in obj) {
        arr1.push({el: o, count: obj[o]});
    }
    //排序(降序)
    arr1.sort(function (n1, n2) {
        return n2.count - n1.count
    });
    //如果ranktype为1,则为升序,反转数组
    if (ranktype === 1) {
        arr1 = arr1.reverse();
    }
    var rank1 = rank || arr1.length;
    return arr1.slice(0, rank1);
}

3-8得到n1-n2下标的数组

//util.getarraynum([0,1,2,3,4,5,6,7,8,9],5,9)
//result:[5, 6, 7, 8, 9]
//getarraynum([0,1,2,3,4,5,6,7,8,9],2) //不传第二个参数,默认返回从n1到数组结束的元素
//result:[2, 3, 4, 5, 6, 7, 8, 9]
getarraynum: function (arr, n1, n2) {
    return arr.slice(n1, n2);
}

3-9筛选数组

//删除值为'val'的数组元素
//util.removearrayforvalue(['test','test1','test2','test','aaa'],'test',')
//result:["aaa"]   带有'test'的都删除
//util.removearrayforvalue(['test','test1','test2','test','aaa'],'test')
//result:["test1", "test2", "aaa"]  //数组元素的值全等于'test'才被删除
removearrayforvalue: function (arr, val, type) {
    return arr.filter(function (item) {
        return type ? item.indexof(val) === -1 : item !== val
    })
}

3-10 获取对象数组某些项

//var arr=[{a:1,b:2,c:9},{a:2,b:3,c:5},{a:5,b:9},{a:4,b:2,c:5},{a:4,b:5,c:7}]
//util.getoptionarray(arr,'a,c')
//result:[{a:1,c:9},{a:2,c:5},{a:5,c:underfind},{a:4,c:5},{a:4,c:7}]
//util.getoptionarray(arr,'b')
//result:[2, 3, 9, 2, 5]
getoptionarray: function (arr, keys) {
    var newarr = []
    if (!keys) {
        return arr
    }
    var _keys = keys.split(','), newarrone = {};
    //是否只是需要获取某一项的值
    if (_keys.length === 1) {
        for (var i = 0, len = arr.length; i < len; i++) {
            newarr.push(arr[i][keys])
        }
        return newarr;
    }
    for (var i = 0, len = arr.length; i < len; i++) {
        newarrone = {};
        for (var j = 0, len1 = _keys.length; j < len1; j++) {
            newarrone[_keys[j]] = arr[i][_keys[j]]
        }
        newarr.push(newarrone);
    }
    return newarr
}

3-11 排除对象数组某些项

//var arr=[{a:1,b:2,c:9},{a:2,b:3,c:5},{a:5,b:9},{a:4,b:2,c:5},{a:4,b:5,c:7}]
//util.filteroptionarray(arr,'a')
//result:[{b:2,c:9},{b:3,c:5},{b:9},{b:2,c:5},{b:5,c:7}]
//util.filteroptionarray(arr,'a,c')
//result:[{b:2},{b:3},{b:9},{b:2},{b:5}]
filteroptionarray: function (arr, keys) {
    var newarr = []
    var _keys = keys.split(','), newarrone = {};
    for (var i = 0, len = arr.length; i < len; i++) {
        newarrone = {};
        for (var key in arr[i]) {
            //如果key不存在排除keys里面,添加数据
            if (_keys.indexof(key) === -1) {
                newarrone[key] = arr[i][key];
            }
        }
        newarr.push(newarrone);
    }
    return newarr
}

3-12 对象数组排序

//var arr=[{a:1,b:2,c:9},{a:2,b:3,c:5},{a:5,b:9},{a:4,b:2,c:5},{a:4,b:5,c:7}]
//util.arraysort(arr,'a,b')a是第一排序条件,b是第二排序条件
//result:[{"a":1,"b":2,"c":9},{"a":2,"b":3,"c":5},{"a":4,"b":2,"c":5},{"a":4,"b":5,"c":7},{"a":5,"b":9}]
arraysort: function (arr, sorttext) {
    if (!sorttext) {
        return arr
    }
    var _sorttext = sorttext.split(',').reverse(), _arr = arr.slice(0);
    for (var i = 0, len = _sorttext.length; i < len; i++) {
        _arr.sort(function (n1, n2) {
            return n1[_sorttext[i]] - n2[_sorttext[i]]
        })
    }
    return _arr;
}

3-13 数组扁平化

//util.steamroller([1,2,[4,5,[1,23]]])
//[1, 2, 4, 5, 1, 23]
steamroller: function (arr) {
    var newarr = [],_this=this;
    for (var i = 0; i < arr.length; i++) {
        if (array.isarray(arr[i])) {
            // 如果是数组,调用(递归)steamroller 将其扁平化
            // 然后再 push 到 newarr 中
            newarr.push.apply(newarr, _this.steamroller(arr[i]));
        } else {
            // 不是数组直接 push 到 newarr 中
            newarr.push(arr[i]);
        }
    }
    return newarr;
}

4.基础dom操作

这个部分代码其实参考jquery的一些函数写法,唯一区别就是调用不用,参数一样.
比如下面的栗子

//设置对象内容
jquery:$('#xxx').html('hello world');
现在:util.html(document.getelementbyid('xxx'),'hello world')
//获取对象内容
jquery:$('#xxx').html();
现在:util.html(document.getelementbyid('xxx'))

4-1检测对象是否有哪个类名

//检测对象是否有哪个类名
hasclass: function (obj, classstr) {
    if (obj.classname && this.trim(obj.classname, 1) !== "") {
        var arr = obj.classname.split(/\s+/); //这个正则表达式是因为class可以有多个,判断是否包含
        return (arr.indexof(classstr) == -1) ? false : true;
    }
    else {
        return false;
    }
}

4-2 添加类名

addclass: function (obj, classstr) {
    if ((this.istype(obj, 'array') || this.istype(obj, 'elements')) && obj.length >= 1) {
        for (var i = 0, len = obj.length; i < len; i++) {
            if (!this.hasclass(obj[i], classstr)) {
                obj[i].classname += " " + classstr;
            }
        }
    }
    else {
        if (!this.hasclass(obj, classstr)) {
            obj.classname += " " + classstr;
        }
    }
}

4-3删除类名

removeclass: function (obj, classstr) {
    if ((this.istype(obj, 'array') || this.istype(obj, 'elements')) && obj.length > 1) {
        for (var i = 0, len = obj.length; i < len; i++) {
            if (this.hasclass(obj[i], classstr)) {
                var reg = new regexp('(\\s|^)' + classstr + '(\\s|$)');
                obj[i].classname = obj[i].classname.replace(reg, '');
            }
        }
    }
    else {
        if (this.hasclass(obj, classstr)) {
            var reg = new regexp('(\\s|^)' + classstr + '(\\s|$)');
            obj.classname = obj.classname.replace(reg, '');
        }
    }
}

4-4替换类名("被替换的类名","替换的类名")

replaceclass: function (obj, newname, oldname) {
    this.removeclass(obj, oldname);
    this.addclass(obj, newname);
}

4-5获取兄弟节点

//util.siblings(obj,'#id')
siblings: function (obj, opt) {
    var a = []; //定义一个数组,用来存o的兄弟元素
    var p = obj.previoussibling;
    while (p) { //先取o的哥哥们 判断有没有上一个哥哥元素,如果有则往下执行 p表示previoussibling
        if (p.nodetype === 1) {
            a.push(p);
        }
        p = p.previoussibling //最后把上一个节点赋给p
    }
    a.reverse() //把顺序反转一下 这样元素的顺序就是按先后的了
    var n = obj.nextsibling; //再取o的弟弟
    while (n) { //判断有没有下一个弟弟结点 n是nextsibling的意思
        if (n.nodetype === 1) {
            a.push(n);
        }
        n = n.nextsibling;
    }
    if (opt) {
        var _opt = opt.substr(1);
        var b = [];//定义一个数组,用于储存过滤a的数组
        if (opt[0] === '.') {
            b = a.filter(function (item) {
                return item.classname === _opt
            });
        }
        else if (opt[0] === '#') {
            b = a.filter(function (item) {
                return item.id === _opt
            });
        }
        else {
            b = a.filter(function (item) {
                return item.tagname.tolowercase() === opt
            });
        }
        return b;
    }
    return a;
}

4-6设置样式

css: function (obj, json) {
    for (var attr in json) {
        obj.style[attr] = json[attr];
    }
}

4-7设置文本内容

html: function (obj) {
    if (arguments.length === 1) {
        return obj.innerhtml;
    } else if (arguments.length === 2) {
        obj.innerhtml = arguments[1];
    }
}
text: function (obj) {
    if (arguments.length === 1) {
        return obj.innerhtml;
    } else if (arguments.length === 2) {
        obj.innerhtml = this.filterstr(arguments[1],'html');
    }
}

4-8显示隐藏

show: function (obj) {
    var blockarr=['div','li','ul','ol','dl','table','article','h1','h2','h3','h4','h5','h6','p','hr','header','footer','details','summary','section','aside','']
    if(blockarr.indexof(obj.tagname.tolocalelowercase())===-1){
        obj.style.display ='inline';
    }
    else{
        obj.style.display ='block';
    }
},
hide: function (obj) {
    obj.style.display = "none";
}

5.其他操作

//cookie
//设置cookie
setcookie: function (name, value, iday) {
    var odate = new date();
    odate.setdate(odate.getdate() + iday);
    document.cookie = name + '=' + value + ';expires=' + odate;
},
//获取cookie
getcookie: function (name) {
    var arr = document.cookie.split('; ');
    for (var i = 0; i < arr.length; i++) {
        var arr2 = arr[i].split('=');
        if (arr2[0] == name) {
            return arr2[1];
        }
    }
    return '';
},
//删除cookie
removecookie: function (name) {
    this.setcookie(name, 1, -1);
},

5-2清除对象中值为空的属性

//util.filterparams({a:"",b:null,c:"010",d:123})
//object {c: "010", d: 123}
filterparams: function (obj) {
    var _newpar = {};
    for (var key in obj) {
        if ((obj[key] === 0 ||obj[key] === false|| obj[key]) && obj[key].tostring().replace(/(^\s*)|(\s*$)/g, '') !== '') {
            _newpar[key] = obj[key];
        }
    }
    return _newpar;
}

5-3现金额大写转换函数

//util.updigit(168752632)
//result:"人民币壹亿陆仟捌佰柒拾伍万贰仟陆佰叁拾贰元整"
//util.updigit(1682)
//result:"人民币壹仟陆佰捌拾贰元整"
//util.updigit(-1693)
//result:"欠人民币壹仟陆佰玖拾叁元整"
updigit: function (n) {
    var fraction = ['角', '分', '厘'];
    var digit = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'];
    var unit = [
        ['元', '万', '亿'],
        ['', '拾', '佰', '仟']
    ];
    var head = n < 0 ? '欠人民币' : '人民币';
    n = math.abs(n);
    var s = '';
    for (var i = 0; i < fraction.length; i++) {
        s += (digit[math.floor(n * 10 * math.pow(10, i)) % 10] + fraction[i]).replace(/零./, '');
    }
    s = s || '整';
    n = math.floor(n);
    for (var i = 0; i < unit[0].length && n > 0; i++) {
        var p = '';
        for (var j = 0; j < unit[1].length && n > 0; j++) {
            p = digit[n % 10] + unit[1][j] + p;
            n = math.floor(n / 10);
        }
        s = p.replace(/(零.)*零$/, '').replace(/^$/, '零') + unit[0][i] + s;
        //s = p + unit[0][i] + s;
    }
    return head + s.replace(/(零.)*零元/, '元').replace(/(零.)+/g, '零').replace(/^整$/, '零元整');
} 

5-4获取,设置url参数

//设置url参数
//util.seturlprmt({'a':1,'b':2})
//result:a=1&b=2
seturlprmt: function (obj) {
    var _rs = [];
    for (var p in obj) {
        if (obj[p] != null && obj[p] != '') {
            _rs.push(p + '=' + obj[p])
        }
    }
    return _rs.join('&');
},
//获取url参数
//util.geturlprmt('test.com/write?draftid=122000011938')
//result:object{draftid: "122000011938"}
geturlprmt: function (url) {
    url = url ? url : window.location.href;
    var _pa = url.substring(url.indexof('?') + 1),
        _arrs = _pa.split('&'),
        _rs = {};
    for (var i = 0, _len = _arrs.length; i < _len; i++) {
        var pos = _arrs[i].indexof('=');
        if (pos == -1) {
            continue;
        }
        var name = _arrs[i].substring(0, pos),
            value = window.decodeuricomponent(_arrs[i].substring(pos + 1));
        _rs[name] = value;
    }
    return _rs;
}

5-5随机返回一个范围的数字

//util.randomnumber(5,10)
//返回5-10的随机整数,包括5,10
//util.randomnumber(10)
//返回0-10的随机整数,包括0,10
//util.randomnumber()
//返回0-255的随机整数,包括0,255
randomnumber: function (n1, n2) {
    if (arguments.length === 2) {
        return math.round(n1 + math.random() * (n2 - n1));
    }
    else if (arguments.length === 1) {
        return math.round(math.random() * n1)
    }
    else {
        return math.round(math.random() * 255)
    }
}

5-6随进产生颜色

randomcolor: function () {
    //randomnumber是下面定义的函数
    //写法1
    //return 'rgb(' + this.randomnumber(255) + ',' + this.randomnumber(255) + ',' + this.randomnumber(255) + ')';
    //写法2
    return '#' + math.random().tostring(16).substring(2).substr(0, 6);
    //写法3
    //var color='#',_index=this.randomnumber(15);
    //for(var i=0;i<6;i++){
    //color+='0123456789abcdef'[_index];
    //}
    //return color;
}
//这种写法,偶尔会有问题。大家得注意哦
//math.floor(math.random()*0xffffff).tostring(16);

5-7date日期时间部分

//到某一个时间的倒计时
//util.getendtime('2017/7/22 16:0:0')
//result:"剩余时间6天 2小时 28 分钟20 秒"
getendtime: function (endtime) {
    var startdate = new date(); //开始时间,当前时间
    var enddate = new date(endtime); //结束时间,需传入时间参数
    var t = enddate.gettime() - startdate.gettime(); //时间差的毫秒数
    var d = 0,
        h = 0,
        m = 0,
        s = 0;
    if (t >= 0) {
        d = math.floor(t / 1000 / 3600 / 24);
        h = math.floor(t / 1000 / 60 / 60 % 24);
        m = math.floor(t / 1000 / 60 % 60);
        s = math.floor(t / 1000 % 60);
    }
    return "剩余时间" + d + "天 " + h + "小时 " + m + " 分钟" + s + " 秒";
}

5-8适配rem

这个适配的方法很多,我就写我自己用的方法。大家也可以去我回答过得一个问题那里看更详细的说明!移动端适配问题

getfontsize: function (_client) {
    var doc = document,
        win = window;
    var docel = doc.documentelement,
        resizeevt = 'orientationchange' in window ? 'orientationchange' : 'resize',
        recalc = function () {
            var clientwidth = docel.clientwidth;
            if (!clientwidth) return;
            //如果屏幕大于750(750是根据我效果图设置的,具体数值参考效果图),就设置clientwidth=750,防止font-size会超过100px
            if (clientwidth > _client) {
                clientwidth = _client
            }
            //设置根元素font-size大小
            docel.style.fontsize = 100 * (clientwidth / _client) + 'px';
        };
    //屏幕大小改变,或者横竖屏切换时,触发函数
    win.addeventlistener(resizeevt, recalc, false);
    //文档加载完成时,触发函数
    doc.addeventlistener('domcontentloaded', recalc, false);
}
//util.getfontsize(750)
//使用方式很简单,比如效果图上,有张图片。宽高都是100px;
//750是设计图的宽度
//样式写法就是
img{
    width:1rem;
    height:1rem;
}
//这样的设置,比如在屏幕宽度大于等于750px设备上,1rem=100px;图片显示就是宽高都是100px
//比如在iphone6(屏幕宽度:375)上,375/750*100=50px;就是1rem=50px;图片显示就是宽高都是50px;

5-9ajax

/* 封装ajax函数
 * @param {string}obj.type http连接的方式,包括post和get两种方式
 * @param {string}obj.url 发送请求的url
 * @param {boolean}obj.async 是否为异步请求,true为异步的,false为同步的
 * @param {object}obj.data 发送的参数,格式为对象类型
 * @param {function}obj.success ajax发送并接收成功调用的回调函数
 * @param {function}obj.error ajax发送失败或者接收失败调用的回调函数
 */
//  util.ajax({
//      type:'get',
//      url:'xxx',
//      data:{
//          id:'111'
//      },
//      success:function(res){
//          console.log(res)
//      }
//  })
ajax: function (obj) {
    obj = obj || {};
    obj.type = obj.type.touppercase() || 'post';
    obj.url = obj.url || '';
    obj.async = obj.async || true;
    obj.data = obj.data || null;
    obj.success = obj.success || function () {
        };
    obj.error = obj.error || function () {
        };
    var xmlhttp = null;
    if (xmlhttprequest) {
        xmlhttp = new xmlhttprequest();
    } else {
        xmlhttp = new activexobject('microsoft.xmlhttp');
    }
    var params = [];
    for (var key in obj.data) {
        params.push(key + '=' + obj.data[key]);
    }
    var postdata = params.join('&');
    if (obj.type.touppercase() === 'post') {
        xmlhttp.open(obj.type, obj.url, obj.async);
        xmlhttp.setrequestheader('content-type', 'application/x-www-form-urlencoded;charset=utf-8');
        xmlhttp.send(postdata);
    } else if (obj.type.touppercase() === 'get') {
        xmlhttp.open(obj.type, obj.url + '?' + postdata, obj.async);
        xmlhttp.send(null);
    }
    xmlhttp.onreadystatechange = function () {
        if (xmlhttp.readystate == 4 && xmlhttp.status == 200) {
            obj.success(xmlhttp.responsetext);
        } else {
            obj.error(xmlhttp.responsetext);
        }
    };
}

5-10图片懒加载

//图片没加载出来时用一张图片代替
aftloadimg: function (obj, url, errorurl,cb) {
    var oimg = new image(), _this = this;
    oimg.src = url;
    oimg.onload = function () {
        obj.src = oimg.src;
        if (cb && _this.istype(cb, 'function')) {
            cb(obj);
        }
    }
    oimg.onerror=function () {
        obj.src=errorurl;
        if (cb && _this.istype(cb, 'function')) {
            cb(obj);
        }
    }
},
//图片滚动懒加载
//@classname {string} 要遍历图片的类名
//@num {number} 距离多少的时候开始加载 默认 0
//比如,一张图片距离文档顶部3000,num参数设置200,那么在页面滚动到2800的时候,图片加载。不传num参数就滚动,num默认是0,页面滚动到3000就加载
//html代码
//<p><img data-src="https://user-gold-cdn.xitu.io/2017/12/7/160319f12631736f" class="load-img" width='528' height='304' /></p>
//<p><img data-src="https://user-gold-cdn.xitu.io/2017/12/7/160319f12631736f" class="load-img" width='528' height='304' /></p>
//<p><img data-src="https://user-gold-cdn.xitu.io/2017/12/7/160319f12631736f" class="load-img" width='528' height='304' /></p>....
//data-src储存src的数据,到需要加载的时候把data-src的值赋值给src属性,图片就会加载。
//详细可以查看testloadimg.html
//window.onload = function() {
//    loadimg('load-img',100);
//    window.onscroll = function() {
//        util.loadimg('load-img',100);
//        }
//}
loadimg: function (classname, num, errorurl) {
    var _classname = classname || 'ec-load-img', _num = num || 0, _this = this,_errorurl=errorurl||null;
    var oimgload = document.getelementsbyclassname(_classname);
    for (var i = 0, len = oimgload.length; i < len; i++) {
        //如果图片已经滚动到指定的高度
        if (document.documentelement.clientheight + document.documentelement.scrolltop > oimgload[i].offsettop - _num && !oimgload[i].isload) {
            //记录图片是否已经加载
            oimgload[i].isload = true;
            //设置过渡,当图片下来的时候有一个图片透明度变化
            oimgload[i].style.csstext = "transition: ''; opacity: 0;"
            if (oimgload[i].dataset) {
                this.aftloadimg(oimgload[i], oimgload[i].dataset.src, _errorurl, function (o) {
                    //添加定时器,确保图片已经加载完了,再把图片指定的的class,清掉,避免重复编辑
                    settimeout(function () {
                        if (o.isload) {
                            _this.removeclass(o, _classname);
                            o.style.csstext = "";
                        }
                    }, 1000)
                });
            } else {
                this.aftloadimg(oimgload[i], oimgload[i].getattribute("data-src"), _errorurl, function (o) {
                    //添加定时器,确保图片已经加载完了,再把图片指定的的class,清掉,避免重复编辑
                    settimeout(function () {
                        if (o.isload) {
                            _this.removeclass(o, _classname);
                            o.style.csstext = "";
                        }
                    }, 1000)
                });
            }
            (function (i) {
                settimeout(function () {
                    oimgload[i].style.csstext = "transition:all 1s; opacity: 1;";
                }, 16)
            })(i);
        }
    }
}

5-11关键词加标签

//这两个函数多用于搜索的时候,关键词高亮
//创建正则字符
//util.createkeyexp([前端,过来])
//result:(前端|过来)/g
createkeyexp: function (strarr) {
    var str = "";
    for (var i = 0; i < strarr.length; i++) {
        if (i != strarr.length - 1) {
            str = str + strarr[i] + "|";
        } else {
            str = str + strarr[i];
        }
    }
    return "(" + str + ")";
},
//关键字加标签(多个关键词用空格隔开)
//util.findkey('守侯我oaks接到了来自下次你离开快乐吉祥留在开城侯','守侯 开','i')
//"<i>守侯</i>我oaks接到了来自下次你离<i>开</i>快乐吉祥留在<i>开</i>城侯"
findkey: function (str, key, el) {
    var arr = null,
        regstr = null,
        content = null,
        reg = null,
        _el = el || 'span';
    arr = key.split(/\s+/);
    //alert(regstr); //    如:(前端|过来)
    regstr = this.createkeyexp(arr);
    content = str;
    //alert(reg);//        /如:(前端|过来)/g
    reg = new regexp(regstr, "g");
    //过滤html标签 替换标签,往关键字前后加上标签
    content = content.replace(/<\/?[^>]*>/g, '')
    return content.replace(reg, "<" + _el + ">$1</" + _el + ">");
}

5-12数据类型判断

//util.istype([],'array')
//true
//util.istype([])
//'[object array]'
istype: function (o, type) {
    if (type) {
        var _type = type.tolowercase();
    }
    switch (_type) {
        case 'string':
            return object.prototype.tostring.call(o) === '[object string]';
        case 'number':
            return object.prototype.tostring.call(o) === '[object number]';
        case 'boolean':
            return object.prototype.tostring.call(o) === '[object boolean]';
        case 'undefined':
            return object.prototype.tostring.call(o) === '[object undefined]';
        case 'null':
            return object.prototype.tostring.call(o) === '[object null]';
        case 'function':
            return object.prototype.tostring.call(o) === '[object function]';
        case 'array':
            return object.prototype.tostring.call(o) === '[object array]';
        case 'object':
            return object.prototype.tostring.call(o) === '[object object]';
        case 'nan':
            return isnan(o);
        case 'elements':
            return object.prototype.tostring.call(o).indexof('html') !== -1
        default:
            return object.prototype.tostring.call(o)
    }
}

5-13手机类型判断

browserinfo: function (type) {
    switch (type) {
        case 'android':
            return navigator.useragent.tolowercase().indexof('android') !== -1
        case 'iphone':
            return navigator.useragent.tolowercase().indexof('iphone') !== -1
        case 'ipad':
            return navigator.useragent.tolowercase().indexof('ipad') !== -1
        case 'weixin':
            return navigator.useragent.tolowercase().indexof('micromessenger') !== -1
        default:
            return navigator.useragent.tolowercase()
    }
}

5-14函数节流

//多用于鼠标滚动,移动,窗口大小改变等高频率触发事件
// var count=0;
// function fn1(){
//     count++;
//     console.log(count)
// }
// //100ms内连续触发的调用,后一个调用会把前一个调用的等待处理掉,但每隔200ms至少执行一次
// document.onmousemove=util.delayfn(fn1,100,200)
delayfn: function (fn, delay, mustdelay) {
    var timer = null;
    var t_start;
    return function () {
        var context = this, args = arguments, t_cur = +new date();
        //先清理上一次的调用触发(上一次调用触发事件不执行)
        cleartimeout(timer);
        //如果不存触发时间,那么当前的时间就是触发时间
        if (!t_start) {
            t_start = t_cur;
        }
        //如果当前时间-触发时间大于最大的间隔时间(mustdelay),触发一次函数运行函数
        if (t_cur - t_start >= mustdelay) {
            fn.apply(context, args);
            t_start = t_cur;
        }
        //否则延迟执行
        else {
            timer = settimeout(function () {
                fn.apply(context, args);
            }, delay);
        }
    };
}

6.封装成形

可能有小伙伴会有疑问,这样封装,调用有点麻烦,为什么不直接在原型上面封装,调用方便。比如下面的栗子!

string.prototype.trim=function(type){
    switch (type){
        case 1:return this.replace(/\s+/g,"");
        case 2:return this.replace(/(^\s*)|(\s*$)/g, "");
        case 3:return this.replace(/(^\s*)/g, "");
        case 4:return this.replace(/(\s*$)/g, "");
        default:return this;
    }
}
//'  12345 6 8 96  '.trim(1)
//"123456896"
//比这样trim('  12345 6 8 96  ',1)调用方便。
//但是,这样是不推荐的做法,这样就污染了原生对象string,别人创建的string也会被污染,造成不必要的开销。
//更可怕的是,万一自己命名的跟原生的方法重名了,就被覆盖原来的方法了
//string.prototype.substr=function(){console.log('asdasd')}  
//'asdasdwe46546'.substr()
//asdasd 
//substr方法有什么作用,大家应该知道,不知道的可以去w3c看下

所以在原生对象原型的修改很不推荐!至少很多的公司禁止这样操作!

所以建议的封装姿势是

var util={
    trim:function(){..},
    changecase:function(){..}...
}

7.小结

我自己封装这个,并不是我有造轮子的习惯,而是:

1,都是一些常用,但是零散的小实例,网上基本没有插件。

2,因为零散的小实例,涉及到的有字符串,数组,对象等类型,就算找到插件,在项目引入的很有可能不止一个插件。

3,都是简单的代码,封装也不难。维护也简单。

(0)
打赏 微信扫一扫 微信扫一扫

相关文章:

  • Docker下使用disconf:细说demo开发

    Docker下使用disconf:细说demo开发

    Docker下的disconf实战全文链接 1. "《Docker搭建disconf环境,三部曲之一:极速搭建disconf》" ; 2. "《Do... [阅读全文]
  • Netty源码分析 (七)----- read过程 源码分析

    Netty源码分析 (七)----- read过程 源码分析

    在上一篇文章中,我们分析了processSelectedKey这个方法中的accept过程,本文将分析一下work线程中的read过程。 该方法主要... [阅读全文]
  • SpringBoot——HelloWorld

    SpringBoot——HelloWorld

    微服务和单体应用的宏观理解 微服务:一组小型应用通过HTTP的方式进行沟通的开发思想 单体应用:ALL IN ONE 单体应用的不足: 随着业务逻辑... [阅读全文]
  • Spring MVC的注解二

    Spring MVC的注解二

    概述Spring从2.5版本开始引入注解,虽然版本不断变化,但是注解的特性一直被延续下来并不断进行扩展,这里就来记录一下Spring MVC中常用的... [阅读全文]
  • Python_深拷贝和浅拷贝

    Python_深拷贝和浅拷贝

    深拷贝与浅拷贝 **拷贝只拷贝可变数据类型,浅拷贝只拷贝第一层,深拷贝拷贝所有层 不可变数据类型:int str bool 元组tuple 可变数据... [阅读全文]

版权声明:本文内容由互联网用户贡献,该文观点仅代表作者本人。本站仅提供信息存储服务,不拥有所有权,不承担相关法律责任。 如发现本站有涉嫌抄袭侵权/违法违规的内容, 请发送邮件至 2386932994@qq.com 举报,一经查实将立刻删除。

发表评论

验证码:
Copyright © 2017-2022  萬仟网 保留所有权利. 粤ICP备17035492号-1
站长QQ:2386932994 | 联系邮箱:2386932994@qq.com