javascript知识点

1.判断对象或数组类型。

let isArray = arrfn => Object.prototype.toString.call(arrfn)==='[object Array]'
console.log(isArray([]))
console.log(isArray({name:"hello"}))
// console.log(Object.prototype.toString.call({name:"hello"})==='[object Object]')

true
false
[Finished in 0.1s]

2.实现map方法

Array.prototype.selfMap = function(fn,context){
	if(!(fn instanceof Function)){
		throw new TypeError("第一个参数需为函数")
	}

	let arr  = [].slice.call(this)//将this转化为数组
	let mappedarr = []
	for(let i = 0 ; i < arr.length; i++){
		if(!arr.hasOwnProperty(i)) continue
			mappedarr.push(fn.call(context,arr[i],i,arr))//context对象，调用context的fn方法，fn传入三个参数
	}
	return mappedarr
}

var arr = [1,2,3]
var newarr = arr.selfMap(function(item,index,arr){
	return item**2;

})
console.log(newarr) //=>[1,4,9]

3.实现filter（）

Array.prototype.selfFilter = function(fn,context){
	let arr = [].slice.call(this)//this指代实例化的数组
	let filterarr = [] 
	for(let i = 0 ;i < arr.length;i++){
		if(fn.call(context,arr[i],i,arr))
		filterarr.push(arr[i])
	}
	return filterarr;
}


var arr = [1,5,4]
var newarr = arr.selfFilter(function(item,index,arr){
	return item%2 == 1;//返回奇数

})
console.log(newarr) //=>[1,4,9]

4.函数柯里化

实质就是将一次传入多个参数的一个函数改写成每次传一个参数的多层函数

var add = function(x,y){
	return x+y;
}
console.log(add(1,23))
var curringadd=function(x){
	return function(y){
		return x+y;
	}
}
console.log(curringadd(1)(23))

function curry(fn){
	if(fn.length<=1) return fn;
	var generator = (...args)=>{
		if(fn.length == args.length){
			return fn(...args);
		}else{
			return (...args2)=>{
				return generator(...args,...args2)
			}
		}
	}
	return generator;

}

let addr = (a,b,c,d)=>a+b+c+d
var curriedadd = curry(addr)
console.log(addr(1,2,4,5))
console.log(curriedadd(1)(2)(4)(5))


function add() {
    // 第一次执行时，定义一个数组专门用来存储所有的参数
    var _args = [].slice.call(arguments);

    // 在内部声明一个函数，利用闭包的特性保存_args并收集所有的参数值
    var adder = function () {
        var _adder = function() {
            [].push.apply(_args, [].slice.call(arguments));
            return _adder;
        };
        // 利用隐式转换的特性，当最后执行时隐式转换，并计算最终的值返回
        _adder.toString = function () {
            return _args.reduce(function (a, b) {
                return a + b;
            });
        }

        return _adder;
    }
    return adder.apply(null, [].slice.call(arguments));
}

// 输出结果，可*组合的参数
console.log(add(1, 2, 3, 4, 5).toString());  // 15
console.log(add(1, 2, 3, 4)(5).toString());  // 15
console.log(add(1)(2)(3)(4)(5).toString());  // 15