前端算法

instanceof

只有函数存在prototype，对象都有_proto_

function instanceof(L,R){
  var Rp = R.prototype;
  L = L._proto_;
  while(true){
    if(L===null) return false;
    if(a === Rp) return true;
    L = L._proto_;
  }
}

var o = new Foo();

实际上执行的是

var o = new Object();
o._proto_ = Foo.prototype;
Foo.call(o)

new的实现

function myNew(fn){
//创建一个空对象
  let obj = new Object();
  //获取构造函数
  let Constructor = [].shift.call(arguments);
  //链接到原型
  obj.__proto__ = Constructor.prototype;
  //绑定this值
  let result = Constructor.apply(obj,arguments);//使用apply，将构造函数中的this指向新对象，这样新对象就可以访问构造函数中的属性和方法
  //返回新对象
  return typeof result === "object" ? result : obj;//如果返回值是一个对象就返回该对象，否则返回构造函数的一个实例对象
}

bind

调用bind就会返回新的函数。这个函数里面的this就指向bind的第一个参数，同时this后面的参数会提前传给这个新的函数。调用该新的函数时，再传递的参数会放到预置的参数后一起传递进新函数。

Function.prototype.bind = function(newThis){
   var arg = Array.prototype.slice.call(arguments,1);
   //拿到除了newThis之外的预置参数序列`
   var that = this;
      return function(){
           return that.apply(newThis,arg.concat(Array.prototype.slice.call(arguments))
          //绑定this同时将调用时传递的序列和预置序列进行合并`
      }
}

深拷贝

1.使用递归实现

function deepClone1(obj){
// 判断要进行深拷贝的是对象还是数组
  var objClone = Array.isArray(obj)?[]:{};
  if(obj && typeof obj == "object"){
    for(var i in obj){
        if(obj.hasOwnPropotype(key)){
          if(typeof obj[key] == "object"){
             objClone[key] = deepClone1(obj[key])
          }else{
             objClone[key] = obj[key]
          }
        }
     }
  }
  return objClone
}

2.通过JSON对象进行深拷贝，特别是用在接口返回的JSON中。无法对对象中的方法进行深拷贝。

function deepClone2(obj){
   var _obj = JSON.stringify(obj);
   return JSON.parse(_obj);
   
}

3.jQuery的extend方法

var array = [1,2,3,4];
var newArray = $.extend(true,[],array);

4.object.assign 只能对一级对象进行深拷贝，不能对二级对象深拷贝，在二级以后是浅拷贝

二分查找

有序数组中找到特定值

function binary_search(arr, key){
   var low = 0, high = arr.length - 1;
   while(low <= hight){
      var mid = parseInt((low + high)/2);
      if(arr[mid] == key){
          return mid;
      }else if(arr[mid] < key){
          low = mid + 1;
      }else{
          high = mid - 1;
      }
   }
}

function binary_search(arr,low,high, key){
      var mid = parseInt((low + high)/2);
      if(arr[mid] == key){
          return mid;
      }else if(arr[mid] < key){
          low = mid + 1;
          return binary_search(arr,low,high, key);
      }else{
          high = mid - 1;
          return binary_search(arr,low,high, key);
      }
  
}

数组去重

function a(arr){
  var newArr = [];
  for(var i=0;i<arr.length;i++){
    if(newArr.indexof(arr[i])<0){
       newArr.push(arr[i])
    }
  }
  return newArr;
}

function b(arr){
  return Array.form(new Set(arr));
}

function a(arr){
  for(var i=0;i<arr.length - 1;i++){
    for(var j=i;i<arr.length;j++){
      if(arr[i] == arr[j]){
      arr.splice(j,1);
      j--;
      }
     }
  }
  return arr;
}

排序（冒泡、快速）

1. 冒泡

function maopao(arr){
  for(var i=0;i<arr.length - 1;i++){
    for(var j=i;i<arr.length;j++){
      if(arr[i] > arr[j]){
        var temp = arr[i],
        arr[i] = arr[j],
        arr[j] = temp;
      }
     }
  }
  return arr;
}

1. 快速

function quickSort(arr){
  if(arr.length <= 1) return false;
  var middleIndex =  parseInt(arr.length / 2);
  var middleItem = arr.splice(middleIndex, 1)[0];
  var left = [], right = [];
  for(var i = 0 ; i < arr.length; i++){
    if(arr[i] <= middleItem){
      left.push(arr[i]);
    }else{
      right.push(arr[i]);
    }
  }
  return quickSort(left).concat(middleItem,quickSort(right))
}