笔试经典题目

// 笔试经典题目
 let str = 'abc#name&defg'
// 01.测试字符串的翻转
const res = str.split('').reverse().join('')

 console.log('测试字符串的翻转',res);

02.取出里面的name

const index1 =str.indexOf('#')
 const index2 = str.indexOf('&')
const newName=str.slice(index1+1,index2)

03，数据扁平化
 const arr = [1,[2,[3,[4,5]]]]
 function fn(arr) {
 return arr.reduce((pre,cur)=>{
return pre.concat(Array.isArray(cur)? fn(cur):cur)
 })
}

 数据扁平化
 fi(list) {
 return arr.reduce((pre,cur)=>{
return pre.concat(Array.isArray(cur)?fi(cur):cur)
 })
 },
 const res = arr.flat(Infinity)

console.log('数据扁平化',res);
// 04.数组去重
const arr=[1,1,'1',true,false,true,'a']
// 第一种
// const res = Array.from(new Set(arr))

// 第二种
// const res = [...new Set(arr)]
// 第三种 include
 let res =[]
 arr.forEach(item=> {
 if(!res.includes(item)){
res.push(item)
}
 })

// 第4种 filter 与indexof
let arr=[]
 const res= arr.filter((item,index)=> arr.indexOf(item)===index) // 取反
 console.log('数组去重',res)
05.不确定参数求总和
 return this.list.reduce((sum,item)=> sum+ item.price,0)

// 第一种方法
sumCount(...arr) {
 return arr.reduce((sum,item)=> sum+item,0)
 },

console.log(this.sumCount(1,2,3,4,5))

// 第二种方法
 console.log(this.sumCount(1,2,3,4,5))
// 写一个sleep延时执行
sleep(time){
// return new Promise((res)=>{
// setTimeout(()=>{
// res(111)

// },time)
// })
// }
// console.log(22222);
// this.sleep(2000).then(res=>{
// console.log(res)
// })
// console.log(3333)
// this.sleep(2000).then(res=>{
// console.log(res)
// })

// 06 数组对象去重
// const newArr = [
// { goods:'1',quota:12,skuid:'1'},
// { goods:'2',quota:12,skuid:'2'},
// { goods:'1',quota:12,skuid:'1'},
// ]

// uniquerFn(arr,uniId) {
// const res = new Map()
// return newArr.filter(item=> !res.has(item[uniId]) && res.set(item[uniId],1))

// },

// console.log('uniqueFn(newArr, uniId)', this.uniquerFn(newArr, 'skuId'))
// console.log('数组对象去重',this.uniquerFn(newArr,goods));

// 给一个数组，返回结果，不要其中两个元素
// let arr = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
// 返回结果： [10, 9, 6, 5, 4, 3, 2, 1]

// 第一种方法
// const res =arr.slice(0,2).concat(arr.slice(4))
// 第二种方法 用数组来进行保留不等于index 的数据
// const res = arr.filter((item,index)=> index !==2 && index !==3)

// 组件 数据扁平转成数据结构

// getTreeData(arr,parentid) {
// function loop(parentId) {
// return arr.reduce((sum,item)=>{
// if(item.parentId===parentId) {
// item.children=loop(item.id)
// sum.push(item)
// }
// return sum

// },[])
// }
// return loop(parentid)

// }

// const flatArr = [
// { id: '01', parentId: 0, name: '节点1' },
// { id: '011', parentId: '01', name: '节点1-1' },
// { id: '0111', parentId: '011', name: '节点1-1-1' },
// { id: '02', parentId: 0, name: '节点2' },
// { id: '022', parentId: '02', name: '节点2-2' },
// { id: '023', parentId: '02', name: '节点2-3' },
// { id: '0222', parentId: '022', name: '节点2-2-2' },
// { id: '03', parentId: 0, name: '节点3' },

// ]
// const result = this.getTreeData(flatArr,0)
// console.log('reslut',result)

 

// 防抖

const throme=fn (fn,time){
const flag=true
return function() {
if(!flag) return
flag=false
setTimeout(()=>{
fn.apply(this)
flag=true
},time)
}
}

// 节流
const throttle=(fn,time) {
let flag=true
return function() {
if(!flag) return
flag=false
setTimeout(()=>{
fn.apply(this)
flag=true
},time)
}
}
<!-- 深拷贝 -->
deepCloneList() {
// 1.先校验传进来的对象类型
const isComplexDataType=obj=>
(typeof obj ==='object'
|| typeof obj==='function') &&
// eslint-disable-next-line valid-typeof
(typeof obj !== null)

const deepClone=function(obj,hash = new WeakMap()) {
if(obj.constructor===Date) {
return new Date(obj)
}
if(obj.constructor===RegExp) {
return new RegExp(obj)
}
if(hash.has(obj)) {
return hash.get(obj)
}

let allDesc=Object.getOwnPropertyDescriptor(obj)
let cloneObj=Object.create(Object.getPrototypeOf(obj),allDesc)

hash.set(obj,cloneObj)

for(let key of Reflect.ownKeys(obj)) {
cloneObj[key] =(isComplexDataType(obj[key])
&& typeof obj[key] !=='function')?
deepClone(obj[key],hash) : obj[key]
}
return cloneObj
}
},

// 基础版深度拷贝

// deepClone(obj) {
// 第二遍
// let cloneobj={}

// for(let key in obj) {
// if(typeof obj[key]==='object') {
// cloneobj[key] = this.deepClone(obj[key]) // 进行递归操作
// } else {
// cloneobj[key] = obj[key]
// }
// }
// return cloneobj

// 第一遍
// let cloneObj={}
// for(let key in obj) {
// if(typeof obj[key] ==='object') {
// cloneObj[key] =this.deepClone(obj[key])
// } else {
// cloneObj[key]=obj[key]
// }
// }
// return cloneObj
// },