JavaScript项目常用方法整理,复制即用, 一定要收藏, 不然刷着刷着就找不到了

判断是否为数组

var arrJudge = function(arr) {
    
    
	if (Array.isArray(arr)) {
    
    
		return true;
	}
	return false;
};

数组去重es6和es5方法

/**
 * 
 * @param arr
 * @returns {Array}
 */
// 数组去重es6方法
function uniqueEs6 (arr) {
    
    
    return Array.from(new Set(arr))
}
function uniqueEs5 (arr) {
    
    
    for (var i = 0; i < arr.length; i++) {
    
    
        for (var j = i + 1; j < arr.length; j++) {
    
    
            if (arr[i] == arr[j]) {
    
    
                arr.splice(j, 1);
                j--;
            }
        }
    }
    return arr;
}

数组最大值

var arrMax = function(arr) {
    
    
	return Math.max.apply(Math, arr);
};

数组求和

var arrSum = function(arr) {
    
    
	return arr.reduce(function(prev, cur) {
    
    
		return Number(prev) + Number(cur);
	}, 0);
};

数组对象求和

var arrObjSum = function(arrObj, key) {
    
    
	return arrObj.reduce(function(prev, cur) {
    
    
		return Number(prev) + Number(cur[key]);
	}, 0);
};

数组合并,目前合并一维

var arrConcat = function(arrOne, arrTwo) {
    
    
	return arrOne.concat(arrTwo);
};

检测数组中是否包含某值

/*
 * 
 * 严格区分数据类型
 */
var arrIncludeValue = function(arr, value) {
    
    
	return arr.includes(value);
};

判断是否是数字

var checkNum = function(data) {
    
    
	var reg = /^\d{1,}$/g;
	if (reg.test(data)) {
    
    
		return true;
	};
	return false;
};

判断是否是字母

var checkLetter = function(data) {
    
    
	var reg = /^[a-zA-Z]+$/g;
	if (reg.test(data)) {
    
    
		return true;
	};
	return false;
};

判断是否全部是小写字母

var checkLowercaseLetter = function(data) {
    
    
	var reg = /^[a-z]+$/g;
	if (reg.test(data)) {
    
    
		return true;
	};
	return false;
};

判断是否是大写字母

var checkCapitalLetter = function(data) {
    
    
	var reg = /^[A-Z]+$/g;
	if (reg.test(data)) {
    
    
		return true;
	};
	return false;
};

判断是否是字母或数字

var checkNumOrLetter = function(data) {
    
    
	var reg = /^[0-9a-zA-Z]*$/g;
	if (reg.test(data)) {
    
    
		return true;
	};
	return false;
};

判断是否是中文

var checkChinese = function(data) {
    
    
	var reg = /^[\u4E00-\u9FA5]+$/g;
	if (reg.test(data)) {
    
    
		return true;
	};
	return false;
};

判断是否是中文，数字或字母

var checkChineseNumberLettter = function(data) {
    
    
	var reg = /^[a-zA-Z0-9\u4e00-\u9fa5]+$/g;
	if (reg.test(data)) {
    
    
		return true;
	};
	return false;
};

判断是否是邮箱地址

var checkEmail = function(data) {
    
    
	var reg =
		/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/g;
	if (reg.test(data)) {
    
    
		return true;
	};
	return false;
};

判断是否是手机号，只要是13,14,15,16,17,18,19开头即可

var checkTelphone = function(data) {
    
    
	var reg = /^((\+|00)86)?1[3-9]\d{9}$/g;
	if (reg.test(data)) {
    
    
		return true;
	};
	return false;
};

判断是否是正确的网址

var checkUrl = function(url) {
    
    
	var a = document.createElement('a');
	a.href = url;
	return [/^(http|https):$/.test(a.protocol), a.host, a.pathname !== url, a.pathname !== "/" + url].find(function(x) {
    
    
		return !x;
	}) === undefined;
};

localStorage 存贮

/**
 * 
 * 目前对象值如果是函数 、RegExp等特殊对象存贮会被忽略
 * param {String} key  属性
 * param {Object} value 值
 */
var localStorageSet = function(key, value) {
    
    
	if (typeof value === 'object'){
    
    
		value = JSON.stringify(value);
	};
	localStorage.setItem(key, value);
};

localStorage 获取

/**
 * 
 * param {String} key  属性
 */
var localStorageGet = function(key) {
    
    
	return localStorage.getItem(key);
};

localStorage 移除

/**
 * 
 * param {String} key  属性
 */
var localStorageRemove = function(key) {
    
    
	localStorage.removeItem(key);
};

localStorage 存贮某一段时间失效

/**
 * 
 * param {String} key  属性
 * param {*} value 存贮值
 * param {String} expire 过期时间,毫秒数
 */
var localStorageSetExpire = function(key, value, expire) {
    
    
	if (typeof value === 'object')
		value = JSON.stringify(value);
	localStorage.setItem(key, value);
	setTimeout(function() {
    
    
		localStorage.removeItem(key);
	}, expire);
};

sessionStorage 存贮

/**
 * 
 * param {String} key  属性
 * param {*} value 值
 */
var sessionStorageSet = function(key, value) {
    
    
	if (typeof value === 'object'){
    
    
		value = JSON.stringify(value);
	};
	sessionStorage.setItem(key, value);
};

sessionStorage 获取

/**
 * 
 * param {String} key  属性
 */
var sessionStorageGet = function(key) {
    
    
	return sessionStorage.getItem(key);
};

sessionStorage 删除

/**
 *
 * param {String} key  属性
 */
var sessionStorageRemove = function(key, value) {
    
    
	sessionStorage.removeItem(key, value);
};

sessionStorage 存贮某一段时间失效

/**
 * 
 * param {String} key  属性
 * param {*} value 存贮值
 * param {String} expire 过期时间,毫秒数
 */
var sessionStorageSetExpire = function(key, value, expire) {
    
    
	if (typeof value === 'object')
		value = JSON.stringify(value);
	sessionStorage.setItem(key, value);
	setTimeout(function() {
    
    
		sessionStorage.removeItem(key);
	}, expire);
};

cookie 获取

/**
 * 
 * param {String} key  属性
 */
var cookieGet = function(key) {
    
    
	var cookieStr = unescape(document.cookie);
	var arr = cookieStr.split('; ');
	var cookieValue = '';
	for (var i = 0; i < arr.length; i++) {
    
    
		var temp = arr[i].split('=');
		if (temp[0] === key) {
    
    
			cookieValue = temp[1];
			break;
		}
	}
	return cookieValue;
};

cookie 删除

/**
 * 
 * param {String} key  属性
 */
var cookieRemove = function(key) {
    
    
	document.cookie = encodeURIComponent(key) + "=;expires=" + new Date();
};

节流

/**
 * 
 * param {*} func 执行函数
 * param {*} delay 节流时间,毫秒
 */
var throttle = function(func, delay) {
    
    
	var timer = null;
	return function() {
    
    
		var _this = this;
		if (!timer) {
    
    
			timer = setTimeout(function() {
    
    
				func.apply(_this, arguments);
				// 或者直接 func()
				timer = null;
			}, delay);
		}
	};
};

防抖

/**
 *
 * param {*} fn 执行函数
 * param {*} wait 防抖时间,毫秒
 */
var debounce = function(fn, wait) {
    
    
	var timeout = null;
	return function() {
    
    
		var _this = this;
		if (timeout !== null)
			clearTimeout(timeout); // 如果多次触发将上次记录延迟清除掉
		timeout = setTimeout(function() {
    
    
			fn.apply(_this, arguments);
			// 或者直接 fn()
			timeout = null;
		}, wait);
	};
};

获取年份

/**
 * 
 */
var getYear = function() {
    
    
	return new Date().getFullYear();
};
/**

获取当前月份

 * 获取当前月份
 * param {
    
    Boolean} fillFlag 布尔值,是否补 0,默认为 true
 */
var getMonth = function(fillFlag) {
    
    
	if (fillFlag === void 0) {
    
    
		fillFlag = true;
	}
	var mon = new Date().getMonth() + 1;
	var monRe = mon;
	if (fillFlag)
		mon < 10 ? "0" + mon : mon;
	return monRe;
};

获取日

/**
 * 获取日
 * param {Boolean} fillFlag 布尔值,是否补 0
 */
var getDay = function(fillFlag) {
    
    
	if (fillFlag === void 0) {
    
    
		fillFlag = true;
	}
	var day = new Date().getDate();
	var dayRe = day;
	if (fillFlag)
		day < 10 ? "0" + day : day;
	return dayRe;
};

获取星期几

/**
 * 获取星期几
 */
var getWhatDay = function() {
    
    
	return new Date().getDay() ? new Date().getDay() : 7;
};
/**
 * 获取当前月天数
 * param {String} year 年份
 * param {String} month 月份
 */
var getMonthNum = function(year, month) {
    
    
	var d = new Date(year, month, 0);
	return d.getDate();
};

获取当前时间 yyyy-mm-dd,hh:mm:ss

/**
 * 获取当前时间 yyyy-mm-dd,hh:mm:ss
 */
var getYyMmDdHhMmSs = function() {
    
    
	var date = new Date();
	var year = date.getFullYear();
	var month = date.getMonth() + 1;
	var day = date.getDate();
	var hours = date.getHours();
	var minu = date.getMinutes();
	var second = date.getSeconds();
	var arr = [month, day, hours, minu, second];
	arr.forEach(function(item) {
    
    
		item < 10 ? '0' + item : item;
	});
	return year + '-' + arr[0] + '-' + arr[1] + ' ' + arr[2] + ':' + arr[3] + ':' + arr[4];
};

function getzf(time) {
    
    
	return +time < 10 ? "0" + time : time;
}

时间戳转化为年月日

/**
 * 时间戳转化为年月日
 * param times 时间戳
 * param ymd 格式类型(yyyy-mm-dd,yyyy/mm/dd)
 * param hms 可选,格式类型(hh,hh:mm,hh:mm:ss)
 * returns {年月日}
 */
var timesToYyMmDd = function(times, ymd, hms) {
    
    
	var oDate = new Date(times);
	var oYear = oDate.getFullYear();
	var oMonth = oDate.getMonth() + 1;
	var oDay = oDate.getDate();
	var oHour = oDate.getHours();
	var oMin = oDate.getMinutes();
	var oSec = oDate.getSeconds();
	var oTime; // 最后拼接时间
	// 年月日格式
	switch (ymd) {
    
    
		case 'yyyy-mm-dd':
			oTime = oYear + '-' + getzf(oMonth) + '-' + getzf(oDay);
			break;
		case 'yyyy/mm/dd':
			oTime = oYear + '/' + getzf(oMonth) + '/' + getzf(oDay);
			break;
	}
	// 时分秒格式
	switch (hms) {
    
    
		case 'hh':
			oTime = ' ' + oTime + getzf(oHour);
			break;
		case 'hh:mm':
			oTime = oTime + getzf(oHour) + ':' + getzf(oMin);
			break;
		case 'hh:mm:ss':
			oTime = oTime + getzf(oHour) + ':' + getzf(oMin) + ':' + getzf(oSec);
			break;
	}
	return oTime;
};

将年月日转化成时间戳

/**
 * 将年月日转化成时间戳
 * param {String} time yyyy/mm/dd 或yyyy-mm-dd 或yyyy-mm-dd hh:mm 或yyyy-mm-dd hh:mm:ss
 */
var YyMmDdToTimes = function(time) {
    
    
	return new Date(time.replace(/-/g, '/')).getTime();
};

比较时间 1 小于时间 2

/**
 *  比较时间 1 小于时间 2
 * 	param {String} timeOne  时间 1
 * 	param {String} timeTwo  时间 2
 */
var compareTimeOneLessTwo = function(timeOne, timeTwo) {
    
    
	// 判断 timeOne 和 timeTwo 是否
	return new Date(timeOne.replace(/-/g, '/')).getTime() < new Date(timeTwo.replace(/-/g, '/')).getTime();
};

获取 url 后面通过?传参的参数

/**
 *  获取 url 后面通过?传参的参数
 * 	param {String} name
 */
var getQueryString = function(name) {
    
    
	var reg = new RegExp('(^|&)' + name + '=([^&]*)(&|$)', 'i');
	var url = window.location.href;
	var search = url.substring(url.lastIndexOf('?') + 1);
	var r = search.match(reg);
	if (r != null)
		return unescape(r[2]);
	return null;
};

图片压缩

/*
 * 图片压缩
 * param {Object} path
 *   pc端传入的路径可以为相对路径，但是在移动端上必须传入的路径是照相图片储存的绝对路径
 * param {Object} obj
 *   obj 对象 有 width， height， quality(0-1)
 * param {Object} callback
 *   回调函数有一个参数，base64的字符串数据
 */
var dealImage = function(path, obj, callback) {
    
    
	var img = new Image();
	img.src = path;
	img.onload = function() {
    
    
		var that = this;
		// 默认按比例压缩
		var w = that.width,
			h = that.height,
			scale = w / h;
		w = obj.width || w;
		h = obj.height || (w / scale);
		var quality = 0.7; // 默认图片质量为0.7
		//生成canvas
		var canvas = document.createElement('canvas');
		var ctx = canvas.getContext('2d');
		// 创建属性节点
		var anw = document.createAttribute("width");
		anw.nodeValue = w;
		var anh = document.createAttribute("height");
		anh.nodeValue = h;
		canvas.setAttributeNode(anw);
		canvas.setAttributeNode(anh);
		ctx.drawImage(that, 0, 0, w, h);
		// 图像质量
		if (obj.quality && obj.quality <= 1 && obj.quality > 0) {
    
    
			quality = obj.quality;
		}
		// quality值越小，所绘制出的图像越模糊
		var base64 = canvas.toDataURL('image/jpeg', quality);
		// 回调函数返回base64的值
		callback(base64);
	}
};

判断两个数组是否相等

/**
 *
 * @desc 判断两个数组是否相等
 * @param {Array} arr1
 * @param {Array} arr2
 * @return {Boolean}
 */
function arrayEqual (arr1, arr2) {
    
    
    // 首先要判断是否是数组,传进来的非数组,返回false
    if (!(arr1 instanceof Array) || !(arr2 instanceof Array)) {
    
    
        return false;
    }
    if (arr1 === arr2) return true;
    if (arr1.length != arr2.length) return false;
    for (var i = 0; i < arr1.length; ++i) {
    
    
        if (arr1[i] !== arr2[i]) return false;
    }
    return true;
}

获取浏览器类型和版本

/**
 * @desc 获取浏览器类型和版本
 * @return {String}
 */
function getExplore () {
    
    
    var sys = {
    
    },
        ua = navigator.userAgent.toLowerCase(),
        s;
    (s = ua.match(/rv:([\d.]+)\) like gecko/)) ? sys.ie = s[1] :
        (s = ua.match(/msie ([\d\.]+)/)) ? sys.ie = s[1] :
            (s = ua.match(/edge\/([\d\.]+)/)) ? sys.edge = s[1] :
                (s = ua.match(/firefox\/([\d\.]+)/)) ? sys.firefox = s[1] :
                    (s = ua.match(/(?:opera|opr).([\d\.]+)/)) ? sys.opera = s[1] :
                        (s = ua.match(/chrome\/([\d\.]+)/)) ? sys.chrome = s[1] :
                            (s = ua.match(/version\/([\d\.]+).*safari/)) ? sys.safari = s[1] : 0;

    // 根据关系进行判断
    if (sys.ie) return ('IE: ' + sys.ie);
    if (sys.edge) return ('EDGE: ' + sys.edge);
    if (sys.firefox) return ('Firefox: ' + sys.firefox);
    if (sys.chrome) return ('Chrome: ' + sys.chrome);
    if (sys.opera) return ('Opera: ' + sys.opera);
    if (sys.safari) return ('Safari: ' + sys.safari);
    return 'Unkonwn';
}

获取操作系统类型

/**
 *
 * @desc 获取操作系统类型
 * @return {String}
 */
function getOS () {
    
    
    var userAgent = 'navigator' in window
        && 'userAgent' in navigator
        && navigator.userAgent.toLowerCase() || '';
    var vendor = 'navigator' in window
        && 'vendor' in navigator
        && navigator.vendor.toLowerCase() || '';
    var appVersion = 'navigator' in window
        && 'appVersion' in navigator
        && navigator.appVersion.toLowerCase() || '';

    if (/mac/i.test(appVersion))
        return 'MacOSX';
    if (/win/i.test(appVersion))
        return 'windows';
    if (/linux/i.test(appVersion))
        return 'linux';
    if (/iphone/i.test(userAgent) || /ipad/i.test(userAgent) || /ipod/i.test(userAgent))
        return 'ios';
    if (/android/i.test(userAgent))
        return 'android';
    if (/win/i.test(appVersion) && /phone/i.test(userAgent))
        return 'windowsPhone';
}

深拷贝，支持常见类型

/**
 * @desc 深拷贝，支持常见类型
 * @param {Any} values
 */
function deepClone (values) {
    
    
    var copy = {
    
    };

    // Handle the 3 simple types, and null or undefined
    if (null == values || "object" != typeof values) return values;

    // Handle Date
    if (values instanceof Date) {
    
    
        copy = new Date();
        copy.setTime(values.getTime());
        return copy;
    }

    // Handle Array
    if (values instanceof Array) {
    
    
        copy = [];
        for (var i = 0, len = values.length; i < len; i++) {
    
    
            copy[i] = deepClone(values[i]);
        }
        return copy;
    }

    // Handle Object
    if (values instanceof Object) {
    
    
        copy = {
    
    };
        for (var attr in values) {
    
    
            if (values.hasOwnProperty(attr)) {
    
    
                copy[attr] = deepClone(values[attr]);
            }
        }
        return copy;
    }

    throw new Error("Unable to copy values! Its type isn't supported.");
}

判断obj是否为空

/**
 *
 * @desc   判断`obj`是否为空
 * @param  {Object} obj
 * @return {Boolean}
 */
function isEmptyObject (obj) {
    
    
    if (!obj || typeof obj !== 'object' || Array.isArray(obj))
        return false
    return !Object.keys(obj).length
}

生成指定范围随机数

/**
 *
 * @desc 生成指定范围随机数
 * @param  {Number} min
 * @param  {Number} max
 * @return {Number}
 */
function randomNum (min, max) {
    
    
    return Math.floor(min + Math.random() * (max - min));
}

现金额转大写

/**
 *
 * @desc   现金额转大写
 * @param  {Number} n
 * @return {String}
 */
function digitUppercase (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;
    }
    return head + s.replace(/(零.)*零元/, '元')
        .replace(/(零.)+/g, '零')
        .replace(/^整$/, '零元整');
}

检测密码强度

/**
 * 检测密码强度
 * @param str
 * @returns {number}
 */
function checkPwd (str) {
    
    
    var nowLv = 0;
    if (str.length < 6) {
    
    
		return nowLv;
		// returns 0  
		/* 
			长度较短,不足6位数字
		*/
    }
    if (/[0-9]/.test(str)) {
    
    
		nowLv++;
		// returns 1  
		/* 
			6位数字
		*/
    }
    if (/[a-z]/.test(str)) {
    
    
		nowLv++;
		// returns 2  
		/* 
			6位以上数字和小写字母组合
		*/
    }
    if (/[A-Z]/.test(str)) {
    
    
		nowLv++;
		// returns 3
		/* 
			6位以上数字和大小写字母组合
		*/
    }
    if (/[\.|-|_]/.test(str)) {
    
    
		nowLv++;
		// returns 4
		/* 
			6位以上数字、大小写字母以及特殊字符组合
		*/
    }
    return nowLv;
}