js常用方法

2020-09-03 本文已影响0人北上广_d8bd

类型判断

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 只允许输入数字

服务器时间处理

猜你喜欢

热点阅读

js常用方法

类型判断

数组 对象 去重方法（一）

数组 对象 去重方法（二）

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

删除数组中一个元素

获取(对象数组)某些项

数组扁平化

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

检测字符串是否符合类型

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

检测密码强度

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

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

找出最长单词

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

对象扁平化处理

rem适配

手机类型判断

到某一个时间的倒计时

获取当前时间

随机产生颜色

随机返回一个范围的数字

设置url参数

获取url参数

函数节流

两个数组取相同值

input 只允许输入数字

服务器时间处理

猜你喜欢

热点阅读

数组对象去重方法（一）

数组对象去重方法（二）