js常用方法

类型判断

function istype(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)
            return false;
    }
}

数组对象去重方法（一）

function removeRepeatArray(arr, key) {
    var arrResult = [];
    if (this.istype(arr[0], "object") && this.istype(key, "string")) {
        for (var i = 0; i < arr.length; i++) {
            var state = true;
            for (var j = 0; j < arrResult.length; j++) {
                if (arr[i][key] == arrResult[j][key]) {
                    state = false;
                }
            }
            if (state) {
                arrResult.push(arr[i]);
            }
        }
    } else {
        arrResult = arr.filter(function (item, index, self) {
            return self.indexOf(item) === index;
        });
    }
    return arrResult;
}

数组对象去重方法（二）

function setArrObj(data) {
      let obj = {};
      return data.reduce((cur, next) => {
        obj[next.id] ? "" : obj[next.id] = true && cur.push(next);
        return cur;
      }, [])
    }

数组（字符串）一个元素出现的次数

function getEleCount(obj, ele) {
    var num = 0;
    for (var i = 0, len = obj.length; i < len; i++) {
        if (ele === obj[i]) {
            num++;
        }
    }
    return num;
}

删除数组中一个元素

function removeArrayForValue(arr, val, type) {
    return arr.filter(function (item) {
        return type ? item.indexOf(val) === -1 : item !== val;
    });
}

获取(对象数组)某些项

function getOptionArray(arr, keys, val) {
    var newArr = [];
    if (!keys) {
        return arr;
    }
    var _keys = keys.split(',');
    if (val) {
        var _vals = val;
        newArr = arr.filter(function (i) {
            var state = _keys.every(function (j, index) {
                if (i[j] == _vals[index]) {
                    return true;
                } else {
                    return false;
                }
            });
            return state;
        });
        return newArr;
    }
    if (_keys.length === 1) {
        for (var i = 0, len = arr.length; i < len; i++) {
            newArr.push(arr[i][keys]);
        }
        return newArr;
    }
    var newArrOne = {};
    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;
}

数组扁平化

function steamroller(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;
}

去空 1-所有空格 2-前后空格 3-前空格 4-后空格

function trim(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;
    }
}

检测字符串是否符合类型

email ：邮箱 phone ：手机号 tel ：电话号 number ：数值 english ：英文 text ：文本 chinese ：中文 lower ：小写 upper ：大写

function checkType(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;
    }
}

检测密码强度

0：密码小于6位 1：密码为纯数字 2：密码为数字加小写或者大写字母 3：密码为数字，大小写字母 4：密码为数字，大小写字母，.-_等

function checkPwd(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;
}

查找字符串，出现在原字符串里的次数

function countStr(str, strSplit) {
    return str.split(strSplit).length - 1;
}

找出最长单词

function longestWord(str, splitType) {
    var _splitType = splitType || /\s+/g,
        _max = 0,
        result = null;
    var strArr = str.split(_splitType);
    strArr.forEach(function (item) {
        if (_max < item.length) {
            _max = item.length;
            result = item;
        }
    });
    return result;
}

实现字符串长度截取，并添加省略符

function cutstr(str, len) {
    var temp;
    var icount = 0;
    var patrn = /[^\x00-\xff]/;
    var strre = "";
    for (var i = 0; i < str.length; i++) {
        if (icount < len - 1) {
            temp = str.substr(i, 1);
            if (patrn.exec(temp) == null) {
                icount = icount + 1;
            } else {
                icount = icount + 2;
            }
            strre += temp;
        } else {
            break;
        }
    }
    return strre + "...";
}

对象扁平化处理

function steamObject(obj) {
    var newObj = {},
        _this = this;
    for (var key in obj) {
        if (obj.hasOwnProperty(key)) {
            var element = obj[key];
            if (_this.istype(element, "object")) {
                var secObj = this.steamObject(element);
                for (var keys in secObj) {
                    if (secObj.hasOwnProperty(keys)) {
                        newObj[keys] = secObj[keys];
                    }
                }
            } else {
                newObj[key] = element;
            }
        }
    }
    return newObj;
}

rem适配

function getFontSize(psdW) {
    var doc = document,
        win = window;
    var docEl = doc.documentElement,
        resizeEvt = 'orientationchange' in window ? 'orientationchange' : 'resize',
        recalc = function recalc() {
            var clientWidth = docEl.clientWidth;
            if (!clientWidth) return;
            if (clientWidth > psdW) {
                clientWidth = psdW;
            } //设置根元素font-size大小
            docEl.style.fontSize = 100 * (clientWidth / psdW) + 'px';
        }; //屏幕大小改变，或者横竖屏切换时，触发函数
    win.addEventListener(resizeEvt, recalc, false); //文档加载完成时，触发函数
    doc.addEventListener('DOMContentLoaded', recalc, false);
}

手机类型判断

function browserInfo(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();
    }
}

到某一个时间的倒计时

function getEndTime(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];
    } else {
        return [];
    }
}

获取当前时间

function getFormetTime(fmt, time) {
    //author: meizz
    var date = time ? new Date(time) : new Date();
    var o = {
        "M+": date.getMonth() + 1,
        //月份
        "d+": date.getDate(),
        //日
        "h+": date.getHours(),
        //小时
        "m+": date.getMinutes(),
        //分
        "s+": date.getSeconds(),
        //秒
        "q+": Math.floor((date.getMonth() + 3) / 3),
        //季度
        "S": date.getMilliseconds() //毫秒
    };
    if (/(y+)/.test(fmt)) {
        //RegExp.$1返回上一次正则匹配结果中的子表达式结果，这里是yyyy
        fmt = fmt.replace(RegExp.$1, (date.getFullYear() + "").substr(4 - RegExp.$1.length));
    }

    for (var k in o) {
        if (new RegExp("(" + k + ")").test(fmt)) {
            fmt = fmt.replace(RegExp.$1, RegExp.$1.length == 1 ? o[k] : ("00" + o[k]).substr(("" + o[k]).length));
        }
    }
    return fmt;
}

随机产生颜色

function randomColor() {
    return '#' + Math.random().toString(16).substring(2).substr(0, 6); //写法3
}

随机返回一个范围的数字

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

设置url参数

function setUrlPrmt(obj) {
    var _rs = [];
    for (var p in obj) {
        if (obj[p] != null && obj[p] != '') {
            _rs.push(p + '=' + obj[p]);
        }
    }
    return _rs.join('&');
}

获取url参数

function getUrlPrmt(url) {
    url = url ? url : "";
    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] = _arrS[i].substring(pos + 1);
    }
    return _rs;
}

函数节流

function delayFn(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);
        }
    };
}

两个数组取相同值

        var arr = [1, 2];
        var arr1 = [1, 2, 3];
        var arr2 = [];
        function ArrayDef(arr, arr1) {
            if (arr.length >= arr1.length) {
                arr.forEach(item => {
                    if (arr1.every(it => it != item)) {
                        arr2.push(item)
                    }
                })
            } else {
                arr1.forEach(item => {
                    if (arr.every(it => it != item)) {
                        arr2.push(item)
                    }
                })
            }
            return arr2
        }
        console.log(ArrayDef(arr, arr1))

input 只允许输入数字

<input type="number"  oninput="if(! /^\d+$/.test(this.value)) value=''">
onkeyup="value=value.replace(/[^\d^\.]+/g,'')"  // 只允许输入数字和小数点

服务器时间处理

 function dateFormat(inputstr, showsplit, showweek) {
            //Wed Mar 22 13:38:37 CST 2017
            inputstr = inputstr + ""; //末尾加一个空格
            var date = "";
            var month = new Array();
            month["Jan"] = '01'; month["Feb"] = '02'; month["Mar"] = '03'; month["Apr"] = '04'; month["May"] = '05'; month["Jun"] = '06';
            month["Jul"] = '07'; month["Aug"] = '08'; month["Sep"] = '09'; month["Oct"] = '10'; month["Nov"] = '11'; month["Dec"] = '12';
            var str = inputstr.split(" ");
            date = str[5];
            date += showsplit + month[str[1]] + showsplit + str[2];
            return date;
        }

js常用方法

类型判断

数组 对象 去重方法（一）

数组 对象 去重方法（二）

数组（字符串）一个元素出现的次数

删除数组中一个元素

获取(对象数组)某些项

数组扁平化

去空 1-所有空格 2-前后空格 3-前空格 4-后空格

检测字符串是否符合类型

email ：邮箱 phone ：手机号 tel ：电话号 number ：数值 english ：英文 text ：文本 chinese ：中文 lower ：小写 upper ：大写

检测密码强度

0：密码小于6位 1：密码为纯数字 2：密码为数字加小写或者大写字母 3：密码为数字，大小写字母 4：密码为数字，大小写字母，.-_等

查找字符串，出现在原字符串里的次数

找出最长单词

实现字符串长度截取，并添加省略符

对象扁平化处理

rem适配

手机类型判断

到某一个时间的倒计时

获取当前时间

随机产生颜色

随机返回一个范围的数字

设置url参数

获取url参数

函数节流

两个数组取相同值

input 只允许输入数字

服务器时间处理

数组对象去重方法（一）

数组对象去重方法（二）