js高阶函数

高阶函数是个什么？

所谓高阶函数，就是函数中可以传入另一个函数作为参数的函数。

 

常用js方法封装
1、forEach
Array里面forEach是通过Array拓展原型方法实现的Array.prototype.forEach
下面我就使用两种方式实现forEach封装

//方法一 
let arr=[1,3,5,3,6,7,8];
function forEach(array,fn){
    for(let i=0;i<array.length;i++){
        fn(array[i],i);
    }
}
forEach(arr,function(item,index){
    console.log("forEach",item,index);
})

//方法二 使用原型拓展数组的原型方法
Array.prototype.myForEach=function(fn){
    console.log(this);//[1, 3, 5, 3,6, 7, 8]
    for(let i=0;i<this.length;i++){
        fn(this[i],i)//前面的是item 后面是index
    }
}
arr.myForEach(function(item,index){
    console.log("myForEach",item,index);
})

 2filter 下面我就使用两种方式实现filter封装

var arr=[1,2,4,6,7,8];
//方法一
let arr=[1,2,4,6,7,8];
function filter(array,fn){
    let result=[];
    for(let i=0;i<array.length;i++){
        if(fn(array[i],i)){
            result.push(array[i])
        }
    }
    return result;
}
var r=filter(arr,function(item,index){
    return item%4===0
})
console.log(r); //[ 4, 8 ]
//方法二
Array.prototype.myFilter=function(fn){
    console.log(this);
    let result=[];
    for(let i=0;i<this.length;i++){
        if(fn(this[i],i)){
            result.push(this[i])
        }
    }
    return result;
}

var s=arr.myFilter(function(item){
    return item%3===0
})
console.log(s)//[ 6 ]

map 

let arr=[2,4,5,6,7]
//方法一
function map(array,fn){
    var result=[];
    for(let value of array){
        result.push(fn(value))
    }
    return result
}
let aa=map(arr,function(item){
    return item+1;
})
console.log(aa); //[ 3, 5, 6, 7, 8 ]
//方法二
Array.prototype.mymap=function(fn){
    var result=[];
    console.log(this);
    for(let value of this){
        result.push(fn(value))
    }
    return result;
}
bb=arr.mymap(function(item){
    return item+1;
})
console.log(bb); //[ 3, 5, 6, 7, 8 ]

 every 每一样都是true

let arr=[2,4,5,6,7]
//方法一
function every(array,fn){
    let result=true;
    for(let value of array){
        result=fn(value);
        if(!result){
            break;
        }
    }
    return result
}
let aa=every(arr,function(item){
    return item>1
})
console.log(aa);//true
//方法二
Array.prototype.myEvery=function(fn){
    let result=true;
    for(let value of this){
        result=fn(value);
        if(!result){
            break;
        }
    }
    return result;
}
let mapArr=arr.every(function(item){
    return item>0;
})
console.log("mapArr",mapArr);//true

some 有一项为true即可

let arr=[2,4,5,6,7]
//方法一
function some(array,fn){
    let result=false;
    for(let value of array){
        result=fn(value);
        if(result){
            break;
        }
    }
    return result
}
let aa=some(arr,function(item){
    return item>7
})
console.log(aa);//false
//方法二
Array.prototype.mySome=function(fn){
    let result=false;
    for(let value of this){
        //调用fn检测值是否满足
        result=fn(value);
        if(result){
            break;
        }
    }
    return result;
}
let someArr=arr.mySome(function(item){
    return item>=7;
})
console.log("someArr",someArr);//true

 

once 函数只执行一次，这里使用了我们常见的闭包
一个函数调用另一个函数的局部变量这就是闭包
闭包的本质：函数在执行的时候会放在一个执行栈上，当函数执行完毕执候会从执行栈上移除，但是堆上的作用成员因为被外部引用不能释放，因此内部函数依然可以访问外部函数的成员

//高阶函数函数最为返回值

function once(fn){
let done=false;
return function(){
    if(!done){
        done=true;
        return fn.apply(this,arguments)
    }  
}        
}

let one=once(function(item){
console.log(item);
})
one(2) //只会打印2
one(3)

 

uniqu 数组去重

const arr=[2,3,5,4,2];
//方法一 ES6
function unique(array){
  return [...new Set(array)]
}
//方法二 使用indexOf()
function unique(array){
  if(!Array.isArray(array)){
    return false;
  }
  var result=[];
  for(let i=0;i<array.length;i++){
    if(result.indexOf(array[i])==-1){
      result.push(array[i])
    }
  }
  return result;
}
//方法三 双指针
function unique(array){
  for(var i=0;i<array.length;i++){
    for(var j=i+1;j<array.length;j++){
      if(array[i]==array[j]){
        array.splice(j,1);
        j--;
      }
    }
  }
  return array;
}
//方法四 
function unique(array){
  var obj={};
  return arr.filter(ele=>{
    if(!obj[ele]){
      obj[ele]=true;
      return true;
    }
  })
}
c=unique(arr)

判断数据返回类型

// typeof 遇到null,数组,对象 只会返回Object

//instanceof用于判断一个变量是否某个对象的实例

function type(params) {
    return Object.prototype.toString.call(params)
}