手写常用方法

手写debounce

function debounce(fn, wait) {
    let timer = null
    return function (...args) {
        clearTimeout(timer)
        timer = setTimeout(() => {
            fn.apply(this, args) // 需要保证fn内的this指向于函数调用者
        }, wait)
    }
}

手写throttle

function throttle(fn, wait) {
    let timer = new Date().getTime()
    return function (...args) {
        let now = new Date().getTime()
        if (now > timer + wait) {
            fn.apply(this, args) // 需要保证fn内的this指向于函数调用者
            timer = now
        }
    }
}

数组拍平flat

• 方式1：

function flat(listTree) {
    // return list.flat(Infinity)
    return listTree.reduce((a, b) => a.concat(Array.isArray(b) ? flat(b): b), [])
}
// 测试
let listTree = [1,2,[3,[4,5]]]
console.log(flat(listTree))

• 方式2：

function flat(listTree) {
    let res = []
    let stack = [...listTree]
    while (stack.length > 0) {
        let cur = stack.pop()
        if (Array.isArray(cur)) {
            stack.push(...cur)
        } else {
            res.push(cur)
        }
    }
    return res.reverse()
}

对象拍平flatten

将：{a: {b: 1, c: 2, d: [3,4]}, b: [1,2]} 转换为：{ 'a.b': 1, 'a.c': 2, 'a.d': [ 3, 4 ], b: [ 1, 2 ] }

function flatten(obj) {
    let res = {}
    function dfs(pre, cur) {
        if (typeof cur === 'object' && cur) {
            if (Array.isArray(cur)) {
                res[pre] = cur
            } else {
                for (let key in cur) {
                     dfs(pre? `${pre}.${key}` :key, cur[key])
                }
            }
        } else {
            res[pre] = cur
        }
    }
    dfs('', obj)
    return res
}
// 测试
let obj = {a: {b: 1, c: 2, d: [3,4]}, b: [1,2]}
console.log(flatten(obj))

手写get方法查找属性

var obj = {a: {b: {c: 2}}};
get(obj, 'a.b.c') // 输出 2

function get(obj, path) {
    let pathList = path.split('.')
    let cur = obj
    for (let key of pathList) {
        if (cur[key] !== undefined) {
            cur = cur[key]
        } else {
            return undefined
        }
    }
    return cur
}
// 测试
var obj = {a: {b: {c: 2}}};
console.log(get(obj, 'a.b'))

对象转数组

function treeToList(tree, pid) {
    let list = []
    for (let obj of tree) {
        let {children, ...current} = obj
        current['parentId'] = pid
        list.push(current)
        if (children) {
            list = list.concat(treeToList(children, obj.id))
        }
    }
    return list
}
// 测试
const tree2 = [
    {
        id: 1,
        text: '节点1',
        children: [
            {
                id: 2,
                text: '节点1_1',
            }
        ]
    }
];

console.log(treeToList(tree2, 0))

数组转对象

function listToTree(list, pid) {
    let tree = []
    for(let item of list) {
        if (pid === item.parentId) {
            tree.push({
                ...item,
                children: listToTree(list, item.id)
            })
        }
    }
    return tree
}
// 测试
let list = [
    {
        id: 1,
        text: '节点1',
        parentId: 0 //这里用0表示为顶级节点
    },
    {
        id: 2,
        text: '节点1_1',
        parentId: 1 //通过这个字段来确定子父级
    }
]
console.log(JSON.stringify(listToTree(list, 0)))

对象的key下划线转驼峰

function underLineToHump(obj) {
    let newObj = Array.isArray(obj) ? []:{}
    for (let key in obj) {
        let newKey = key.replace(/_([a-z])/g, (match, p1) => {
            return match[1].toUpperCase()
        })
        if (typeof obj[key] === 'object' && obj[key]) {
            newObj[newKey] = underLineToHump(obj[key])
        } else {
            newObj[newKey] = obj[key]
        }
    }
    return newObj
}
// 测试
let obj = {
    hello_world: {
        ni_hao: ['a_b', {a_c: 2}]
    },
    java_script: 1,
    is_null: null
}
console.log(underLineToHump(obj))

手写千分位

-123345.1234 => -123,345.1234

function format(str) {
    let pre = str.split('.')[0]
    // 将整数部分逆序
    let preReverse = pre.replace('-', '').split('').reverse().join('')
    let list = []
    for (let i = 0;i< preReverse.length; i++) {
        if (i % 3 === 0 && i !== 0) {
            list.unshift(',')
        }
        list.unshift(preReverse[i])
    }

    let decimalPart = str.split('.')[1] // 小数部分
    return (str.startsWith('-') ? '-': '') + list.join('') + (decimalPart ? '.'+decimalPart : '')
}
// 测试
console.log(format('-123345.1234'))