打造自己的js库

格式化现在距${str}过去了的时间 formatDate(str)

/**
* 格式化现在距${str}过去了的时间
*
* @param {String} str
* @returns {String} 格式化后的时间
*/
export const formatDate = (str) => {
if (!str) return '';
const date = new Date(str);
const time = new Date().getTime() - date.getTime(); // 现在的时间-传入的时间 = 相差的时间(单位 = 毫秒)
if (time < 0) {
return '';
} else if ((time / 1000 < 30)) {
return '刚刚';
} else if (time / 1000 < 60) {
return parseInt((time / 1000)) + '秒前';
} else if ((time / 60000) < 60) {
return parseInt((time / 60000)) + '分钟前';
} else if ((time / 3600000) < 24) {
return parseInt(time / 3600000) + '小时前';
} else if ((time / 86400000) < 31) {
return parseInt(time / 86400000) + '天前';
} else if ((time / 2592000000) < 12) {
return parseInt(time / 2592000000) + '个月前';
} else {
return parseInt(time / 31536000000) + '年前';
}
};

格式化现在距${endTime}的剩余时间formatRemainTime(endTime)

/**
*
* @desc 格式化现在距${endTime}的剩余时间
* @param {Date} endTime
* @return {String}
*/
export const formatRemainTime = (endTime) => {
const startDate = new Date(); // 开始时间
const endDate = new Date(endTime); // 结束时间
const t = endDate.getTime() - startDate.getTime(); // 时间差
let 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 + '秒';
};

格式化日期时间字符串 formatDateStr(d,format)(d: Date对象,格式pattern:默认为’yyyy-MM-dd’,常用格式比如:’yyyy-MM-dd hh:mm:ss’…)

/**
* 格式化日期时间字符串
*
* @param {Object} d Date对象
* @param {String} format 格式pattern,默认为'yyyy-MM-dd',常用格式比如:'yyyy-MM-dd hh:mm:ss'
* @returns {String} 格式化后的字符串
*/
export const formatDateStr = (d, format = 'yyyy-MM-dd') => {
if (!d || !d.getTime) return '';
const o = {
'M+': d.getMonth() + 1, // month
'd+': d.getDate(), // day
'h+': d.getHours(), // hour
'm+': d.getMinutes(), // minute
's+': d.getSeconds(), // second
'q+': Math.floor((d.getMonth() + 3) / 3), // quarter
S: d.getMilliseconds() // millisecond
};
if (/(y+)/.test(format)) {
format = format.replace(RegExp.$1, (d.getFullYear() + '').substr(4 - RegExp.$1.length));
}
Object.keys(o).forEach(k => {
if (new RegExp('(' + k + ')').test(format)) {
format = format.replace(RegExp.$1, RegExp.$1.length === 1 ? o[k] : ('00' + o[k]).substr(('' + o[k]).length));
}
});
return format;
};


检索url ?后的参数, 根据name查找并返回匹配的=后的值 getQueryStringByName(name)

/**
* 检索url, 查找并返回匹配正则表达式的值
*
* @param {String} name 需要匹配的字段
* @returns {String} 匹配到字段的值
*/
export const getQueryStringByName = function(name) {
const result = location.search.match(new RegExp('[\?\&]' + name + '=([^\&]+)', 'i'));
if (result == null || result.length < 1) {
return '';
}
return result[1];
};

按属性过滤数组中的对象 propsFilter(items, props, exactly)

/**
* 按属性过滤数组中的对象
*
* @param {Array} items 数组
* @param {Object} props 属性过滤条件对象
* @param {Boolean} exactly 是否使用===判定, 默认false
* @returns {Array} 过滤后的数组
*/
export const propsFilter = function(items, props, exactly) {
if (!Array.isArray) {
Array.isArray = function(arg) {
return Object.prototype.toString.call(arg) === '[object Array]';
};
}
if (Array.isArray(items)) {
const keys = Object.keys(props);
return items.filter(function(item) {
return keys.some(function(key) {
if (exactly) {
return item[key] === props[key];
} else {
const text = (props[key] + '').toLowerCase();
return item[key] && item[key].toString().toLowerCase().indexOf(text) > -1;
}
});
});
} else {
return items;
}
};

清除对象中值为空的属性 过滤params cleanParams(obj)

/**
* 清除对象中值为空的属性
*
* @param {Object} 需要清理的对象
* @returns {Object} 清理后的对象
*/
export const cleanParams = (data) => {
const p = {};
Object.keys(data).forEach((key) => {
const obj = data[key];
if (obj !== '') {
p[key] = obj;
}
});
return p;
};

判断obj是否为空 isEmptyObject(obj)

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

获取文件扩展名filePostfix

/**
* 获取文件扩展名
*
* @param {String} fileName 文件名
* @returns {String} 文件扩展名
*/
export const filePostfix = function(fileName) {
const pattern = /(.*)\.(.*)$/gi;
pattern.exec(fileName.toLowerCase());
return RegExp.$2;
};

深拷贝 deepClone(values)

/**
* @desc 深拷贝,支持常见类型
* @param {Any} values
*/
export const deepClone = (values) => {
let copy;

// Handle the 3 simple types, and null or undefined
if (values == null || typeof values !== 'object') 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 (let i = 0, len = values.length; i < len; i++) {
copy[i] = deepClone(values[i]);
}
return copy;
}

// Handle Object
if (values instanceof Object) {
copy = {};
for (const 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.");
};


上一篇

Hello World