前端面经整理三

js实现new方法

首先我们肯定需要知道new方法干了什么：
1.新建一个空对象
2.将新对象的原型设置到函数的原型对象
3.让函数的this指向这个新对象，执行构造函数也就是设置对象的属性
4.返回新对象
代码实现：

 var mynew=function(){
     
        let constructor=[].shift.call(arguments);
        if (typeof constructor !== "function") {
      console.error("type error"); return; }
        let newObj=Object.create(constructor.prototype);
        let result=constructor.apply(newObj,arguments);
        let flag = result && (typeof result === "object" || typeof result === "function"); // 判断返回结果 
        return flag ? result : newObj;
    }
    function person(name, age) {
     
  this.name = name
  this.age = age
}

let oobj = mynew(person, 'LL','100')
console.log(oobj) //{name: 'LL', age: 100}

这里我们会发现使用了Object.create方法，其实也有另外的方法来设置原型：

 newObj.__proto__=constructor.prototype;

TCP UDP HTTP的区别

TCP UDP是传输层的协议，HTTP是应用层的协议，一句话可以很好的概括两者的区别：
我们在传输数据时，可以只使用（传输层）TCP/IP协议，但是那样的话，如果没有应用层，便无法识别数据内容，如果想要使传输的数据有意义，则必须使用到应用层协议
而TCP和UDP的区别：
TCP 是面向连接的，UDP 是面向无连接的
UDP程序结构较简单
TCP 是面向字节流的，UDP 是基于数据报的
TCP 保证数据正确性，UDP 可能丢包
TCP 保证数据顺序，UDP 不保证

TCP 为什么是可靠连接？
通过 TCP 连接传输的数据无差错，不丢失，不重复，且按顺序到达。
TCP 报文头里面的序号能使 TCP 的数据按序到达
报文头里面的确认序号能保证不丢包，累计确认及超时重传机制
TCP 拥有流量控制及拥塞控制的机制

reduce()方法和应用

定义：reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值
语法：

array.reduce(function(prev, current, currentIndex, arr), initialValue)

prev：函数传进来的初始值或上一次回调的返回值
current：数组中当前处理的元素值
currentIndex：当前元素索引
arr：当前元素所属的数组本身
initialValue：传给函数的初始值

实现map方法

 Array.prototype.mymap=function(foo){
     
          if(typeof foo==='function'){
     
              let cur=this;
              return cur.reduce((prev,item,index,arr)=>{
     
                   prev.push(foo(item,index,arr));
                   return prev;
              },[]);
          }
          else{
     
              throw new console.error('不是函数');
          }
    }
    let arr=[2,3,4,5];
    function fn(n){
     
        return n+2;
    }
    console.log(arr.mymap(fn));

实现filter

 Array.prototype.myfilter=function(foo){
     
        if(typeof foo==='function'){
     
            let cur=this;
            return cur.reduce((prev,item,index,arr)=>{
     
                foo(item, index, arr) ? prev.push(item) : null;
                 return prev;
            },[])
        }
        else throw new console.error('错误');
    }
    let arr=[2,3,4]
    let res = arr.myfilter(n => n>2)
console.log(res)

实现compose

 function mycompose(){
     
        let args=[].slice.call(arguments).reverse();
        return function(x){
     
            return args.reduce((prev,cur)=>{
     
                return cur(prev);
            },x)
        }
    }
    function toUpperCase(str) {
     
  return str.toUpperCase();
}
 
function add(str) {
     
  return str += '!'
}
var fn=mycompose(add,toUpperCase);
var str='sbnyx';
console.log(fn(str));

实现数组扁平化

 function flatten(arr){
     
        if(Array.isArray(arr)){
     
            return arr.reduce((prev,cur)=>{
     
                return Array.isArray(cur)?prev.concat(flatten(cur)):prev.concat(cur);
            },[])
        }
        else throw new console.error('错误');
    }
    let arr=[2,3,4,[1,2,3]];
    console.log(flatten(arr));