常用时间方法
// 将时间格式转为时间戳
formatTime(time) {
return new Date(time).getTime();
},
// 将时间戳转为年月日
formatYear(time) {
const date = new Date(time);
const year = date.getFullYear();
const month = date.getMonth() + 1;
const day = date.getDate();
return `${year}-${month}-${day}`;
},
// 将时间戳转为年月日时分秒
formatDateTime(time) {
const date = new Date(time);
const year = date.getFullYear();
const month = date.getMonth() + 1;
const day = date.getDate();
const hour = date.getHours();
const minute = date.getMinutes();
const second = date.getSeconds();
return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
}
常用数组方法
// 判断是否是数组且不为空
isNotEmptyArray(arr) {
return Array.isArray(arr) && arr.length > 0;
},
isArray(arr) {
return Array.isArray(arr);
},
// 数组深拷贝
deepCopy(arr) {
return JSON.parse(JSON.stringify(arr));
},
// 数组中删除指定下标的元素
remove(arr, index) {
return arr.splice(index, 1);
},
// 数组中截取指定位置开始下标和结束下标的元素且不影响原数组
slice(arr, start, end) {
return arr.slice(start, end);
},
// 数组去重
unique(arr) {
return Array.from(new Set(arr));
},
// 数组求和
sum(arr) {
return arr.reduce((prev, next) => prev + next);
},
// 数组中对象的某一属性求和
sumBy(arr, key) {
return arr.reduce((prev, next) => prev + next[key], 0);
},
// 数组求平均值
average(arr) {
return this.sum(arr) / arr.length;
},
// 数组最大值
max(arr) {
return Math.max(...arr);
},
// 数组最小值
min(arr) {
return Math.min(...arr);
},
// 数组排序
sort(arr) {
return arr.sort((a, b) => a - b);
},
// 数组乱序
shuffle(arr) {
return arr.sort(() => Math.random() - 0.5);
},
// 数组分组
group(arr, size) {
const result = [];
for (let i = 0; i < arr.length; i += size) {
result.push(arr.slice(i, i + size));
}
return result;
},
// 数组扁平化
// 数组扁平化的意思就是将一个嵌套多层的数组 array (嵌套可以是任何层数)转换为只有一层的数组。
flatten(arr) {
return arr.reduce((prev, next) => prev.concat(Array.isArray(next) ? this.flatten(next) : next), []);
},
// 数组差集
difference(arr1, arr2) {
return arr1.filter(v => !arr2.includes(v));
},
// 数组交集
intersection(arr1, arr2) {
return arr1.filter(v => arr2.includes(v));
},
// 数组并集
union(arr1, arr2) {
return [...new Set([...arr1, ...arr2])];
},
// 数组对象去重
uniqueObject(arr, key) {
return [...new Map(arr.map(item => [item[key], item])).values()];
},
// 数组对象排序
sortObject(arr, key) {
return arr.sort((a, b) => a[key] - b[key]);
},
// 数组对象求和
sumObject(arr, key) {
return arr.reduce((prev, next) => prev + next[key], 0);
},
// 数组对象求平均值
averageObject(arr, key) {
return this.sumObject(arr, key) / arr.length;
},
// 数组对象最大值
maxObject(arr, key) {
return Math.max(...arr.map(item => item[key]));
},
// 数组对象最小值
minObject(arr, key) {
return Math.min(...arr.map(item => item[key]));
},
// 数组对象分组
groupObject(arr, key) {
return arr.reduce((prev, next) => {
(prev[next[key]] ? prev[next[key]] : prev[next[key]] = []).push(next);
return prev;
}, {});
},
// 数组对象扁平化
flattenObject(arr, key) {
return arr.reduce((prev, next) => prev.concat(next[key]), []);
},
// 数组对象差集
differenceObject(arr1, arr2, key) {
return arr1.filter(v => !arr2.some(item => item[key] === v[key]));
},
// 数组对象交集
intersectionObject(arr1, arr2, key) {
return arr1.filter(v => arr2.some(item => item[key] === v[key]));
},
// 数组对象并集
unionObject(arr1, arr2, key) {
return [...new Set([...arr1, ...arr2])];
}
常用对象方法
// 判断是否是对象且不为空
isNotEmptyObject(obj) {
return Object.prototype.toString.call(obj) === '[object Object]' && Object.keys(obj).length > 0;
},
// 对象深拷贝
deepClone(obj) {
return JSON.parse(JSON.stringify(obj));
},
// 判断是否是对象
isObject(obj) {
return Object.prototype.toString.call(obj) === '[object Object]';
},
// 对象转数组
objectToArray(obj) {
return Object.keys(obj).map(key => obj[key]);
},
// 对象key排序
objectKeySort(obj) {
return Object.keys(obj).sort().reduce((prev, next) => {
prev[next] = obj[next];
return prev;
}, {});
},
// 对象转查询字符串
objectToQueryString(obj) {
return Object.keys(obj).map(key => `${key}=${obj[key]}`).join('&');
},
// 对象深拷贝
deepClone(obj) {
return JSON.parse(JSON.stringify(obj));
},
// 对象合并
mergeObject(obj1, obj2) {
return Object.assign(obj1, obj2);
},
// 对象深合并
deepMergeObject(obj1, obj2) {
for (const key in obj2) {
obj1[key] = obj1.hasOwnProperty(key) && obj1[key].toString() === '[object Object]' ? this.deepMergeObject(obj1[key], obj2[key]) : obj1[key] = obj2[key];
}
return obj1;
},
// 对象深比较 两个对象是否相等
deepCompareObject(obj1, obj2) {
if (obj1 === obj2) return true;
if (obj1.length !== obj2.length) return false;
for (const key in obj1) {
if (!obj2.hasOwnProperty(key)) return false;
if (obj1[key] !== obj2[key]) return false;
}
return true;
},
// 对象深查找 指定key的值
deepFindObject(obj, key) {
for (const k in obj) {
if (k === key) return obj[k];
if (obj[k] && typeof obj[k] === 'object') {
const result = this.deepFindObject(obj[k], key);
if (result) return result;
}
}
},
// 对象深查找并删除
deepFindAndDeleteObject(obj, key) {
for (const k in obj) {
if (k === key) {
delete obj[k];
return true;
}
if (obj[k] && typeof obj[k] === 'object') {
const result = this.deepFindAndDeleteObject(obj[k], key);
if (result) return true;
}
}
},
// 对象深查找并修改
deepFindAndModifyObject(obj, key, value) {
for (const k in obj) {
if (k === key) {
obj[k] = value;
return true;
}
if (obj[k] && typeof obj[k] === 'object') {
const result = this.deepFindAndModifyObject(obj[k], key, value);
if (result) return true;
}
}
},
// 对象深查找并添加
deepFindAndAddObject(obj, key, value) {
for (const k in obj) {
if (k === key) {
obj[k] = value;
return true;
}
if (obj[k] && typeof obj[k] === 'object') {
const result = this.deepFindAndAddObject(obj[k], key, value);
if (result) return true;
}
}
},
// 对象深查找并替换
deepFindAndReplaceObject(obj, key, value) {
for (const k in obj) {
if (k === key) {
obj[k] = value;
return true;
}
if (obj[k] && typeof obj[k] === 'object') {
const result = this.deepFindAndReplaceObject(obj[k], key, value);
if (result) return true;
}
}
}