js实现深拷贝 1. 使用递归let str = "我是string基本数据类型" let arr = [1, 6, [1, 3, 5, 7, 9], 5, 8, { a: 4, b: 7 }, 9, 0] let obj = { a: 1, b: 2, c: 3, d: [123, 456], e: { ea: 789, eb: 666 } } let nu = null function deepClone(ob) { if (typeof ob === "object") { if (Object.prototype.toString.call(ob).slice(8, -1) === 'Null') return ob if (ob instanceof Array) { // 数组 let newArr = [] ob.forEach((item, index, arr) => { newArr[index] = deepClone(item) }) return newArr } else { // 对象 let newObj = {} // for (let k in ob) { // newObj[k] = deepClone(ob[k]) // } Object.keys(ob).forEach((key, index, arr) => { newObj[key] = deepClone(ob[key]) }) return newObj } } else { return ob } } console.log(deepClone(str)) console.log(deepClone(arr)) console.log(deepClone(obj)) console.log(deepClone(nu))2. JSON.parse()和JSON.stringify()JSON.stringify() // 将对象转化为json字符串 JSON.parse() // 将json转化为json对象 console.log(JSON.parse(JSON.stringify({a: 1, b: [4,5,6]})))该方法可能会出现如下问题undefined、任意的函数以及 symbol 值，在序列化过程中会被忽略Date 日期调用了 toJSON() 将其转换为了 string 字符串（Date.toISOString()），因此会被当做字符串处理。NaN 和 Infinity 格式的数值及 null 都会被当做 null。其他类型的对象，包括 Map/Set/WeakMap/WeakSet，仅会序列化可枚举的属性。对包含循环引用的对象（对象之间相互引用，形成无限循环）执行此方法，会抛出错误。请谨慎使用3. Object.assign() （该方法只能浅拷贝）

js如何判断数据类型 一、常用的js数据类型基本数据类型 ：String、Number、Boolean、Null、Undefined 复杂数据类型 ：Object二、js数据类型判断// 初始化一些数据用来判断 let str = "字符串类型" let bool = true let num = 123 let nulll = null let undef let arr = [] let obj = {} let sum = function () {} 1.使用typeof进行判断console.log(typeof str) // string console.log(typeof bool) // boolean console.log(typeof num) // number console.log(typeof nulll) // object console.log(typeof undef) // undefined console.log(typeof arr) // object console.log(typeof obj) // object console.log(typeof sum) // function{callout color="#66edff"}使用typeof进行判断数据类型，只能够判断基本数据类型string number boolean 以及 function，而null和object不能够进一步的判断。{/callout} 2.使用A instanceof B进行判断console.log(str instanceof String) // false console.log(bool instanceof Boolean) // false console.log(num instanceof Number) // false console.log(nulll instanceof Object) // false console.log(undef instanceof Object) // false console.log(arr instanceof Array) // true console.log(obj instanceof Object) // true console.log(sum instanceof Function) // true{callout color="#66edff"}使用A instanceof B的方式进行判断，字面意思，A是否是B的实例，可以判断出Array和Object类型，但是undefined和null不能区分数据类型，基础的数据类型，因为不是使用new出来的，也测试不出来。{/callout} 3.使用Object.prototype.toString.call()进行判断console.log(Object.prototype.toString.call(str)) // [object String] console.log(Object.prototype.toString.call(bool)) // [object Boolean] console.log(Object.prototype.toString.call(num)) // [object Number] console.log(Object.prototype.toString.call(nulll)) // [object Null] console.log(Object.prototype.toString.call(undef)) // [object Undefined] console.log(Object.prototype.toString.call(arr)) // [object Array] console.log(Object.prototype.toString.call(obj)) // [object Object] console.log(Object.prototype.toString.call(sum)) // [object Function]{callout color="#66edff"}Object.prototype.toString()方法可以返回一个表示该对象的字符串'[object type]'，为了每个对象都能通过 Object.prototype.toString() 来检测，需要以 Function.prototype.call() 或者 Function.prototype.apply() 的形式来调用，传递要检查的对象作为第一个参数，称为 thisArg。{/callout}三、封装成函数function judgeType (data) { return Object.prototype.toString.call(data).slice(8, -1) } judgeType('jkl') // 'String' judgeType(123) // 'Number' judgeType(true) // 'Boolean' judgeType(null) // 'Null' judgeType(undefined) // 'Undefined' judgeType([]) // 'Array' judgeType({}) // 'Object' judgeType(function sum () {}) // 'Function' judgeType(new Set()) // 'Set' judgeType(new Map()) // 'Map'

封装localStorage本地存储 封装本地存储是为了更好更方便的实现本地存储，简洁明了实现本地存储的步骤1. 首先创建枚举列表，用来记录本地存储的键，可以清楚地知道，你本地都存了啥// storageEnum枚举列表 const storageEnum = { user: ['user', '用户'], // key：简写名称 value array[0]: 本地存储的键名， array[1]:描述是干嘛的 userToken: ['user::access_token', '用户token'], userInfo: ['sc_selfInfo', '用户信息'], cart: ['cart', 'cart购物车'], } module.exports = storageEnum2. 定义枚举工具/** * 枚举定义工具 * 示例： * const AA = createEnum({ * b: [1, '审核中'], * C: [2, '审核通过'] * }) * 获取枚举值：AA.b * 获取枚举描述：AA.getDesc('b') * 通过枚举值获取描述：AA.getDescFromValue(AA.b) * */ export function createEnum(definition) { const strToValueMap = {} const numToDescMap = {} for (const enumName of Object.keys(definition)) { const [value, desc] = definition[enumName] strToValueMap[enumName] = value numToDescMap[value] = desc } return { ...strToValueMap, getDesc(enumName) { return (definition[enumName] && definition[enumName][1]) || '' }, getDescFromValue(value) { return numToDescMap[value] || '' } } }3. 封装本地存储方法/* * @param param {Object} key值为 method name data */ Vue.prototype.$storageEnum = (param) => { let that = this; let { method, // get / set name, // 存储storageEnum的键名简写 data // 要存储的数据 } = param let storagelist = createEnum(storageEnum) let storageAction = new Map() .set('set', () => { uni.setStorageSync(storagelist[name], data) }) .set('get', () => { return uni.getStorageSync(storagelist[name]); }) try { return storageAction.get(method)(); } catch (e) { uni.showToast({ icon: 'none', title: `<${name}>缓存,使用错误请检查！` }); } }4. 使用this.$storageEnum({ method: 'set', name: 'userInfo', data: { username: 'zs', age: 18 } })

js如何实现复制功能 复制功能实现方法先创建一个 textarea 文本域dom元素将要复制的文本放到文本域中将dom元素添加到body中调用select()将文本域的内容全选使用document.execCommand('copy')方法进行复制dom.remove() 将文本域自身移除封装成函数/* * @description js复制功能 * @param text {String} 要复制的文本 * @param fn {Function} 复制成功的回调函数 参数为复制成功的text */ function copy(text, fn) { const input = document.createElement('textarea') // 创建文本域 input.value = text // 将要复制的文本放到文本域中 document.body.appendChild(input) // 添加到body中 input.select() // 全选 document.execCommand('copy') // 复制 input.remove() // 删除自身 fn && fn(text) // 复制成功的回调... }

数组常用的方法函数（整理） 1. Array.push() 在原数组末尾追加一个或多个元素，返回该数组的长度let arr = [ 1 , 2 , 3 ] arr.push( 4 , 5 ) // 返回值为数组的长度 5 console.log(arr) // [1, 2, 3, 4, 5]2. Array.pop() 删除数组的最后一个元素，并返回该元素let arr = [ 1 , 2 , 3 , 4 ] arr.pop() // 返回值为删除的元素 4 console.log(arr) // [1, 2, 3]3. Array.unshift() 在原数组前边添加一个或多个元素，返回该数组的长度let arr = [ 1 , 2 , 3 ] arr.unshift( 4 , 5 ) // 返回值为数组的长度 5 console.log(arr) // [4, 5, 1, 2, 3]4. Array.shift() 删除数组的第一个元素，并返回该元素let arr = [ 4 , 5 , 1 , 2 , 3 ] arr.shift() // 返回值为删除的元素 4 console.log(arr) // [5, 1, 2, 3]5. Array.splice() 从原数组某个位置删除/添加元素，返回删除的元素数组let arr = [ 4 , 5 , 1 , 2 , 3 ] arr.splice( 0 , 1 ) // 从 0 的位置，删除一个元素，返回值为删除的元素数组 [4] console.log(arr) // [5, 1, 2, 3] arr.splice( 0 , 1 , 11 ) // 从 0 的位置，删除一个元素，并添加一个 11 元素 返回值为删除的元素数组 [5] console.log(arr) // [11, 1, 2, 3]6. Array.slice() 返回选定的元素数组，原数组不会改变let arr = ['a','b','c','d'] arr.slice( 1 , 3 ) // 从索引为 1 的位置，取到 3 的位置，但不包含 3 ，返回值为 新数组 ['b', 'c'] console.log(arr) // ['a', 'b', 'c', 'd'] 原数组不会改变7. Array.join() 使用某个拼接符，将数组转化为字符串，返回该字符串，原数组不会改变let arr = [ 1 , 2 , 3 , 4 , 5 ] arr.join('-') // 返回拼接后的字符串 '1-2-3-4-5' console.log(arr) // [1, 2, 3, 4, 5] 原数组不会改变8. Array.forEach() 遍历数组，为每一个元素调用一次函数let arr = ['a','b','c'] arr.forEach((item, index, arr) => { console.log(item) // 当前遍历元素项 console.log(index) // 当前遍历元素的索引 console.log(arr) // 原数组 })9. Array.map() 遍历数组，为每一个元素调用一次函数，根据函数return返回的结果组成一个新的数组let arr = ['a','b','c'] const newArr = arr.map((item, index, arr) => { console.log(item, index, arr) // 元素项，索引，当前数组 return item += 2 }) console.log(arr) // 原数组不会改变 console.log(newArr) // 返回一个处理过的新数组 ['a2', 'b2', 'c2']10. Array.filter() 遍历数组，根据筛选出的符合条件的元素，组成一个新的数组let arr = [ 1 , 2 , 3 , 4 ] const newArr = arr.filter((item,index,arr) => { return item > 2 // 返回元素项大于 2 的元素，组成一个新的数组 }) console.log(arr) // [1,2,3,4] 不会改变元素组 console.log(newArr) // [3, 4]11. Array.find() 遍历数组，返回第一个通过测试的元素项let arr = [ 1 , 2 , 3 , 2 , 4 ] const num = arr.find((item, index) => { console.log(item, index) // index 到 1 的位置就不会在打印了，循环结束 return item >= 2 // 返回item >= 2的第一个元素项，找到之后结束遍历，不会继续 }) console.log(arr) // [1,2,3,2,4] 不会改变元素组 console.log(num) // 212. Array.findIndex() 遍历数组，返回第一个通过测试的元素的索引值let arr = [ 1 , 2 , 3 , 2 , 4 ] const num = arr.findIndex((item, index) => { console.log(item, index) // index 到 1 的位置就不会在打印了，循环结束 return item >= 2 // 返回item >= 2的第一个元素项的索引值，找到之后结束遍历，不会继续 }) console.log(arr) // [1,2,3,2,4] 不会改变元素组 console.log(num) // 索引值为 113. Array.indexOf() 数组中是否存在某个元素，存在返回该索引，不存在返回-1，出现多次，也只会返回第一次出现时的索引let arr = ['a','b','c','d', 'c', 'c'] arr.indexOf('c') // 返回值为 索引 2 arr.indexOf('ff') // 返回值为 -1 ff不存在数组中14. Array.reduce() 遍历数组，将函数的返回值，存储到累加器中let arr = [ 1 , 2 , 3 , 4 , 5 ] const total = arr.reduce((total, item) => { // 每次遍历将total + item，下一次的遍历时，total为上一次返回的结果 console.log(total) // 1 3 6 10 return total + item }) console.log(total) // 1515. Array.from() 将具有length属性或者可迭代的对象转化为数组Array.from('abcdef') // 返回值['a', 'b', 'c', 'd', 'e', 'f'] Array.from(new Map([['b', 1 ], ['a', 2 ]])) Array.from(new Set([ 1 , 2 , 3 ]))

js获取昨天今天明天日期 /* * @params date 日期 * @params type 日期 prev/current/next 昨天/今天/明天 * @params fmt 日期拼接符 */ function getDays(date, type, fmt) { let currentDate = new Date(date) let y = currentDate.getFullYear() let m = currentDate.getMonth() + 1 let d = currentDate.getDate() function dateFormat(date, fmt) { let y = new Date(date).getFullYear() let m = new Date(date).getMonth() + 1 let d = new Date(date).getDate() return `${y}${fmt}${m}${fmt}${d}` } switch (type) { case "prev": if (d - 1 < 1) { if (m - 1 < 1) { y = y - 1 m = 12 } else { m = m - 1 } d = new Date(y, m, 0).getDate() } else { d = d - 1 } break case "current": break case "next": if (d + 1 > new Date(y, m, 0).getDate()) { if (m + 1 > 12) { y = y + 1 m = 1 d = 1 } else { m = m + 1 d = 1 } } else { d = d + 1 } break; default: break; } return dateFormat(new Date(`${y}-${m}-${d}`), fmt) } console.log(getDays(new Date('2021-1-1'), "prev", "-"));

map数据结构 <!-- index-menu -->一、简介　　map数据结构类似于键值对的集合，和Object区别是键可以存任何数据类型。二、Map实例的方法和属性Map实例的方法：1. Map.prototype.set(key, value) 添加 2. Map.prototype.get(key) 获取 3. Map.prototype.has(key) 判断 4. Map.prototype.delete(key) 删除 5. Map.prototype.clear() 清空 6. Map.prototype.keys() 获取所有的键组成的数组 [key, key1, key2]形式 7. Map.prototype.values() 获取所有的值组成的数组 [value, value1, value2]形式 8. Map.prototype.entries() 获取所有的成员组成的数组 [ [key, value], [key2, value2] ]形式 9. Map.prototype.forEach() 遍历方法类似于数组的forEach循环Map的属性：1. size 获取map长度三、map增删改查// html <div class="box">box</div> const boxEl = document.querySelector('.box') // dom1. set 存储数据 返回值 整个map数据结构，如果键存在，会更新，否则添加新的键map.set('a', 1) map.set(boxEl, 2) map.set(undefined, 3) map.set(222, '数字') map.set(null, 'null')2. get 获取数据 返回值 对应键的值，没有返回undefinedconsole.log(map.get('a')); // 1 console.log(map.get(boxEl)); // 2 console.log(map.get(undefined)); // 3 console.log(map.get(222)); // 数字 console.log(map.get(5)); // undefined3. has 判断map数据结构中有没有该数据 返回值 true / falseconsole.log(map.has('a')); // true console.log(map.has(boxEl)); // true console.log(map.has(undefined)); // true console.log(map.has(222)); // true console.log(map.has(5)); // false4. delete 删除map数据结构中的键 返回值 true / falseconsole.log(map.delete('a')); // true console.log(map.delete('b')); // false5. clear 清空map中所有的数据 无返回值map.clear() console.log(map); // Map(0) {}四、map遍历1. Map.prototype.keys() 返回键名集合，通过for of遍历数组for(let key of map.keys()) {     console.log(key); // 键 }2. Map.prototype.values() 返回键值的集合，通过for of遍历数组for(let value of map.values()) {     console.log(value); // 值 }3. Map.prototype.entries() 返回所有的成员，通过for of遍历数组for(let [key, value] of map.entries()) { // 数组的解构赋值     console.log(key, value); // 键 值 }4. Map.prototype.forEach() 直接遍历map结构，类似于数组的forEach方法遍历map.forEach((value, key, map) => {     console.log(key, 1); // 键     console.log(value); // 值     console.log(map); // 原map结构 })五、数组对象和map之间的转换1. map转数组 使用展开符(...)[...map] // [ [key, value], [key, value], [key, value]]2. 数组转map 使用new Map()传入一个包含键和值的数组集合let arr = [ ['a', 1], ['b', 2] ] new Map(arr) // Map(2) {'a' => 1, 'b' => 2}3. map转对象 当map的键名是字符串，可以完全转换，如果非字符串，会先转化为字符串let map = new Map().set('a', 1).set('b', 2) let obj = {} for(let [key, value] of map.entries()) { // 数组的解构赋值     console.log(key, value); // 键 值 obj[key] = value } console.log(obj)// {a: 1, b: 2}4. 对象转map 可以通过对象的Object.entries()方法，该方法返回 键值对组成的数组集合[ [key, value], [key, value], [key, value]]let obj = {"a":1, "b":2}; let map = new Map(Object.entries(obj)); // 实际上是遍历对象，通过set给map设置值 for (let k in obj) { map.set(k, obj[k]) }

js如何获取本周上周下周的日期 /* *@params date 时间对象/时间字符串/时间戳等等 *@params type {String} 值：prev/current/next 上周/本周/下周 *@params fmt {String} 日期连接符 */ function getWeekList(date, type, fmt) { let arr = [] // 格式化日期 const dateFormat = (date, fmt) => { console.log(date, "datefoemat") let y = date.getFullYear() // 年 console.log(y) let m = date.getMonth() + 1 // 月 let d = date.getDate() // 日 return `${y}${fmt}${m}${fmt}${d}` } console.log(dateFormat(new Date("2021-12-28"), "```")) let currentDate = new Date(date) let w = currentDate.getDay() // 当前星期 0-6 let y = currentDate.getFullYear() // 当前年 let m = currentDate.getMonth() + 1 // 当前月 let d = currentDate.getDate() // 当前日期 if (w === 0) w = 7 // 先算出周一是几号 根据type类型计算 let Monday = 0 // 获取周一的年份 月份 日期 const getMonday = (zf) => { if (zf <= 0) { // 日期小于0 且当前星期不是0 if (m - 1 <= 0) { // 月份<=0 年份-1 y = y - 1 // 年份 -1 m = 12 // 月份 = 12 let n = d - (w - 1) // 负的星期 Monday = new Date(y, m, 0).getDate() + n console.log(y, m, Monday) } else { m = m - 1 // 月份 -1 let n = d - (w - 1) // 负的星期 Monday = new Date(y, m, 0).getDate() + n console.log(y, m, Monday) } } else if (zf > 0) { // 日期大于0 Monday = d - (w - 1) console.log(y, m, Monday) } } // 本周一 switch (type) { case "current": // 本周 break case "prev": // 上一周 if (d - 7 < 0) { if (m - 1 < 1) { m = 12 y = y - 1 d = new Date(y, m, 0).getDate() + (d - 7) } else { m = m - 1 d = new Date(y, m, 0).getDate() + (d - 7) } } else { d = d - 7 } break case "next": // 下一周 if (d + 7 > new Date(y, m, 0).getDate()) { if (m + 1 > 12) { m = 1 y = y + 1 d = d + 7 - new Date(y - 1, 12, 0).getDate() // d + 7 大于 12月的天数多少天 就是几号 } else { m = m + 1 d = d + 7 - new Date(y, m - 1, 0).getDate() } } else { d = d + 7 } break } getMonday(d - (w - 1)) // 获取周一日期 // 获取日期 const getDate = (mon, i) => { if (mon + i > new Date(y, m, 0).getDate()) { // 大于当月天数 Monday = -i + 1 mon = 1 if (m + 1 > 12) { y += 1 m = 1 } else { m += 1 } console.log(m, i, "大于当月天数") return dateFormat(new Date(`${y}-${m}-${mon}`), fmt) } console.log(y, m, mon + i) console.log(dateFormat(new Date(y, m, mon + i, 0), fmt)) return dateFormat(new Date(`${y}-${m}-${mon + i}`), fmt) } // currentDate = new Date(y, m, Monday, 0) console.log(currentDate, "currentDate") // 往后推7天 for (let i = 0; i < 7; i++) { arr[i] = getDate(Monday, i) } return arr } console.log(getWeekList(new Date(), "prev", "-"))

时间格式化函数 /* *@params date {Date Object} 日期 *@params fmt {String} 格式化方式 *@params bool {Boolean} 是否返回周几 */ function dateFormat(date, fmt, bool) { date = new Date(date) console.log(date.getMonth() + 1, "月") console.log(date.getFullYear(), "年") console.log(date.getDate(), "日") console.log(date.getHours(), "时") console.log(date.getMinutes(), "分") console.log(date.getSeconds(), "秒") console.log(date.getDay(), "星期") date = new Date(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(), //毫秒 } let weekStr = "" // 星期几 const weekList = [ { text: "周日", index: 0 }, { text: "周一", index: 1 }, { text: "周二", index: 2 }, { text: "周三", index: 3 }, { text: "周四", index: 4 }, { text: "周五", index: 5 }, { text: "周六", index: 6 }, ] weekList.forEach((item) => (item.index === date.getDay() ? (weekStr = item.text) : "")) if (/(y+)/.test(fmt)) { 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) ) } } if (bool) fmt = fmt + " " + weekStr return fmt } console.log(dateFormat(+new Date(), "yyyy-MM-dd hh:mm:ss", 1))

数组去重的几种方法 第一种：使用filter()筛选函数搭配indexOf()进行数组去重实现思路：filter遍历数组，需要有返回值，返回值是一个条件表达式，满足条件返回出去，最后会返回一个新数组。indexOf()会返回该值在数组中第一次出现的索引，当该值第一次出现的索引，和当前对应的索引不一致，说明之前出现过。let arr = [1, 5, 6, 8, 5, 7, 3, 1, 2, 2, 2, 6, 7] function notRepeat1(arr) { let newArr = [] newArr = arr.filter((item, index, arr) => { return arr.indexOf(item) === index }) return newArr } console.log(notRepeat1(arr)) // [1, 5, 6, 8, 7, 3, 2]第二种：双重for循环加数组的splice()方法实现去重实现思路：拿到数组第一项，和数组后边的每一项进行比较，如果有相等的就删除这个元素。然后就是拿到第二项，和后边每一项比较，再删除，当循环结束，去重结束。注意：删除数组其中一项，遍历时循环索引要往前进1，不然会漏掉一个。let arr = [1, 5, 6, 8, 5, 7, 3, 1, 2, 2, 2, 6, 7] function notRepeat2(arr) { let newArr = [...arr] // 不要动原数组 for (let i = 0; i < newArr.length; i++) { for (let j = i + 1; j < newArr.length; j++) { if (newArr[j] === newArr[i]) { newArr.splice(j, 1) j-- } } } return newArr } console.log(notRepeat2(arr)) // [1, 5, 6, 8, 7, 3, 2]第三种：利用forEach循环配合数组的push()方法进行追加实现思路：使用forEach遍历传进来的数组，创建一个空数组，通过indexOf()判断这个空数组有没有这个值，也就是等不等于-1，等于-1说明里边没有该值，使用push()追加进去。let arr = [1, 5, 6, 8, 5, 7, 3, 1, 2, 2, 2, 6, 7] function notRepeat3(arr) { let newArr = [] arr.forEach((item, index, arr) => { if (newArr.indexOf(item) === -1) { newArr.push(item) } }) return newArr } console.log(notRepeat3(arr)) // [1, 5, 6, 8, 7, 3, 2]第四种：最简单，使用es6的set数据结构结合展开符，一行实现去重实现思路：set数据结构里边的值不会有重复，使用new Set()会返回一个类数组，配合es6的展开符转化为真数组。let arr = [1, 5, 6, 8, 5, 7, 3, 1, 2, 2, 2, 6, 7] function notRepeat4(arr) { let newArr = [...new Set(arr)] return newArr } console.log(notRepeat4(arr)) // [1, 5, 6, 8, 7, 3, 2]如果你们有其他方式去重，可以在评论区下方一起探讨一下哦