在 JavaScript 中有一些问题会被拿出来经常讨论,这些问题每个人都有不同的思路,想要理解这些问题,最好的方法就是自己实现一遍,话不多说,开始正题。

数组扁平化

数组扁平化有很多方法,但最终最好的方法就是递归,实现一个指定深度的扁平化方法,这样基本的套路都会了解。

function flattenDepth(arr, depth) {
    let resultArr = []
    arr.forEach(item => {
        let d = depth
        if (Array.isArray(arr) && d > 1) {
            resultArr.push(...flattenDepth(item, --d))
        } else {
            resultArr.push(item)
        }
    })
    return resultArr
}

递归实现非常简洁,对数组每一项进行遍历,如果某一项是数组,判断当前扁平化深度,继续调用。

函数柯里化

函数curry化有很多种不同形式的实现方法,但是理解curry化 简单来说只有一句话,参数够了就执行,参数不够返回一个函数,将之前的参数存起来,知道参数够了为止。

function curry(fn) {
    var l = fn.length//获取函数的参数产生长度
    return function curried () {
        var args = Array.prototype.slice.call(arguments)
        if (args < l) {
            return function () {
                var argsInner = Array.prototype.slice.call(arguments)
                return curried.apply(null, args.concat(argsInner))
            }
        } else {
            return fn.apply(null, args)
        }
    }
}

其实上述代码不难看出,首先返回具名curried函数,在其中判断参数个数与被curry化函数参数进行比较,如果小于就返回函数,否则就执行。

函数防抖

函数防抖按照我的理解就是,不管触发多少次,都等到最后触发过后的一段时间才执行相应操作。

function debounce(fn, wait) {
    var timer
    return function () {
        var context = this
        var args = arguments
        clearTimeout(timer)
        setTimeout(function() {
            fn.apply(context, args)
        }, wait)
    }
}

函数节流

函数节流按照我的理解就是,不管如何触发,都是按照指定时间间隔执行。

function throttle(fn, wait) {
    var timer
    return function () {
        var context = this
        var args = arguments
        if (!timer) {
            timer = setTimeout(function() {
                timer = null
                fn.apply(context, args)
            }, wait)
        }
    }
}

对象拷贝

对象拷贝分为深拷贝和浅拷贝,这里有一个黑科技就是使用JSON

JSON.parse(JSON.stringify(obj))

关于深度拷贝,就是使用递归

function clone(value, isDeep) {
    if (value === null) {
        return null
    }
    if (typeof value !== "object") {
        return value
    }
    if (Array.isArray(value)) {
        if (isDeep) {
            return value.map( item => clone(item, true))
        }
        return [].concat(value)
    } else {
        if (isDeep) {
            var obj = {}
            Object.keys(value).forEach(key => {
                obj[key] = clone(value[key], true)
            })
            return obj
        } else {
            var obj = {}
            for(var key in value) {
                obj[key] = value[key]
            }
            return obj
        }
    }
}

对于基本类型直接返回,对于引用类型,遍历递归调用clone函数。

写在最后:

这些是最近发现经常出现的函数,故在此做一次总结。