前端知识点two

哎嘿，我又又又来了，准备好接招了嘛😀

1. 实现一个对象的flatten方法
   实现以下转换：

const obj={
 a:{
  b:1,
    c:2,
    d:{
     e:5
    }
  },
  b:[1,3,{a:2,b:3}],
  c:3
}

flatten(obj){}结果返回如下：

//{
//  'a.b':1,
//  'a.c':2,
//  'a.d.e':5,
//  'b[0]':1,
//  'b[1]':3,
//  'b[2].a':2
//  'b[2].b':3
//  c:3
//}

思考好了吗？我公布答案咯🙃---------------------------------------------------------------------------------------------------------------------------------------------------

答案：这个题目需要从结果入手，可以看出需要对象进行遍历，把里面的属性值一次输出，其核心方法题就是传入的对象key值和value，对value再进行递归遍历就可以了。在js中的数据类型有基础数据类型和引用数据类型，对于该题，基础数据类型无需再进行深层次遍历，引用数据类型需要再次进行递归。

function flat(obj,key="",res={},isArray=false){
 for(let [k,v] of Object.entries(obj)){
  let tmp=isArray ? key +"["+ k +"]":key + k
  flat(v,tmp,res,true)
 }else if (typeof v==="object"){
  let tmp=isArray ? key+"["+k+"].":key+k+"."
  flat(v,tmp,res)
 }else{
  let tmp=isArray ? key +"["+k+"]":key+k
  res[tmp]=v
  }
 }
 return res
}

另一种解法（代码写法不一样,但是更好理解）：

function objectFlat(obj=''){
 const res={}
 function flat(item,preKey=''){
  Object.entries(item).forEach(([key,value])=>{
   let newKey=key
   if(Array.isArray(item)){
    newKey=preKey ? '${preKEy}[${key}]':key
   }else{
    newKey=preKey ? '${preKey}.${key}':key
   }
   if(value && typeof value==='object'){
    flat(value,newKey)
   }else{
     res[newKey]=value
    }
   })
  }
  flat(obj)
  return res
}
const source={a:{b:{c: 1,d: 2},e: 3},f{g: 2}}
console.log(objectFlat(source));
const obj={
 a:1,
 b:[1,2,{c:ture}],
 c:{e:2,f:3},
 g:null,
};
console.log(objectFlat(obj));

2. 介绍些setTimeout的运行机制
   答案：setTimeout()函数：用来指定某个函数或某段代码在多少毫秒之后执行。它返回一个整数，表示定时器timer的编号，可以用来取消该定时器。
   例如：看看最后打印的顺序是什么

console.log(1);
setTimeout(function(){
 console.log(2);
},0);
console.log(3);

答案：1 3 2（无论setTimeout的执行时间是0还是1000，结果都是先输出3，后输出2，这就牵扯到了js运行机制问题了）
JavaScript单线程：JavaScript引擎是基于事件驱动和单线程执行的，js引擎一直等待着任务队列中的任务的到来，然后加以处理，浏览器无论什么时候都只有一个js线程在运行程序，即主线程，而单线程的JavaScript是通过任务队列来实现“非阻塞执行”的。
所有任务可以分为两种：异步任务和同步任务。同步任务是指在主线程上排队执行的任务，只有前一个任务执行完毕，才能执行后一个任务；异步任务是指不进入主线程，而进入“任务队列”的任务，只有主线程执行完成，主线程去通知“任务队列”，某个异步任务可以执行了，该任务才会进入主线程执行。
js的运行机制：①所有同步任务都在主线程上执行，形成一个执行栈
②主线程之外，还要存在一个“任务队列”，只要有异步任务有了运行结果，就在“任务队列”之中放置一个事件
③一旦“执行栈”中所有同步任务执行完毕，系统就会读取“任务队列”，看一下里面有哪些事件，然后对应的异步任务就会结束等待状态，进入执行栈开始执行
④主线程不断重复上面的第三步操作
setTimeout的运行机制：setTimeout和setInterval的运行机制，其实就是将指定的代码移出本次执行，等到下一轮EventLoop时，再检查是否到了指定时间，如果到了，就等下一轮EventLoop时重新判断，即setTimeout指定的代码必须等到本次执行所有同步代码都执行完，才会执行
3. 寻找两个正序数组的中位数：给定两个大小分别为m和n的正序（从小到大）数组num1和num2，请你找出返回这两个正序数组的中位数。
示例：

输入:num1=[1,3],nums2=[2]
输出:2.00000
解释:合并数组=[1,2,3]，中位数 2

输入:num1=[1,2],num2=[3,4]
输出:2.50000
解释:合并数组=[1,2,3,4]，中位数 (2+3)/2=2.5

输入：num1=[0,0],num2=[0,0]
输出：0.00000

输入：num1=[1],num2=[0,0]
输出：1.00000

输入：num1=[2],num2=[0,0]
输出：2.00000

提示：

num1.length==m---
num2.length==n
0<=m<=1000
0<=n<=1000
1<=m+n<=2000
-106<=num1[i],num2[i]<=106

这个问题得好好思考思考🤔-----------------------------------------------------------------------------------------------------------------------------------------------------------
暴力解法：合并两个代码后从小到大排序，数组总数是奇数取nums[n/2]，是偶数则取(nums[n/2]+nums[n/2-1])/2，代码如下：

var findMedianSortedArrays=function(nums1,,nums2){
 let n=nums1.length+nums2.length;
 let nums=nums1.concat(nums2).sort((a,b)=>a-b);
 let result=n%2==0
  ?(nums[n/2]+nums[n/2-1])/2
  :nums[Math.floor(n/2)];
return result;
};

双指针法：因为是两个有序数组，所以求中位数不需要把两个数组合并。当两数组合并后的数组长度len为奇数时，只要知道索引为len/2上的数就行了，如果该数为偶数，只要知道索引为len/2-1和len/2上的书即可，即不管是偶数还是奇数只要遍历len/2就行了，用两个值来存储遍历过程中的len/2-1和len/2就行了。定义两个指针point1和point2分别指向nums1和nums2，当nums1[point1]<nums2[poimt2]，则point1指针移动，否则point2指针移动，代码如下：

var findMedianSortedArrays=function(nums1,nums2){
 let n1=nums1.length;
 let n2=nums2.length;
 let len=n1+n2;
 let preValue=-1;
 let curValue=-1;
 let point1=0;
 let point2=0;
 for(let i=0;i<Math.floor(len/2);i++){
  preValue=curValue;
  if(point1<n1&&(point2>=n2||nums1[point1]<nums2[point2])){
   curValue=nums1[point1];
   point1++;
  }else{
   curValue=nums2[point2];
   point2++;
  }
 }
 return len%2==0
 ?(preValue+curValue)/2
 :cueValue
};

小伙伴，先到这了，先好好思考这三题吧，🤣我跑路啦，后期会更新哦，敬请期待😊