常见的 js 面试题以及答案

1. 有效括号匹配

/**
 * @return {Boolean}
 * @param {string} s
 */
const isValid = function (s) {
    if (s.length % 2 === 1) return false;
    let stack = [];
    const type = new Map([
        [')', '('],
        ['}', '{'],
        [']', '[']
    ]);
    for (let char of s) {
        if (type.has(char)) {
            if (stack.length === 0 || stack[stack.length - 1] !== type.get(char)) {
                return false;
            }
            stack.pop();
        } else {
            stack.push(char);
        }
    }
    return stack.length === 0;
};

2. 给你一棵二叉树，想象你站在他的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值,示例：输入：[1,2,3,null,5,null,4],输出：[1,3,4]

二叉树数组表示的映射关系是这样的：


所以示例的二叉线表示出来是：



下面看查看右侧视图的代码实现吧

/**
 * @return {Array}
 * @param {string} input
 * 输入：input = [1,2,3,null,5,null,4]
 * 输出：[1,3,4]
 */
const rightSideView = (input) => {
    // 定义二叉树节点
    function TreeNode(val, left = null, right = null) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
    function BFS(_root){
        if (!root) return [];

        const queue = [root];
        const result = [];

        while (queue.length > 0) {
            const levelSize = queue.length;

            for (let i = 0; i < levelSize; i++) {
                const node = queue.shift();

                // 如果是当前层的最后一个节点，添加到结果中
                if (i === levelSize - 1) {
                    result.push(node.val);
                }

                // 把左子节点和右子节点按顺序加入队列
                if (node.left) queue.push(node.left);
                if (node.right) queue.push(node.right);
            }
        }
        return result;
    }
    // 示例二叉树 [1,2,3,null,5,null,4]
    const root = new TreeNode(1);
    root.left = new TreeNode(2);
    root.right = new TreeNode(3);
    root.left.right = new TreeNode(5);
    root.right.right = new TreeNode(4);
    return BFS(root);
}

3 给指定的 key 属性给数组对象去重

/**
 * @return {Array}
 * @param {Array} arr
 * @param {string} key
 * 实例：
 * 输入：arr = const arr = [
 *   { id: 1, name: 'Alice' },
 *   { id: 2, name: 'Bob' },
 *   { id: 1, name: 'Alice' },
 *   { id: 3, name: 'Charlie' }
 * ];
 * key='id'
 * 输出：[{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Charlie' }]
 */
//1. 使用 set+filter
function uniqueArr(arr,key){
    return arr.filter((item, index, self) => index === self.findIndex(t => t[key] === item[key]));
}
//2. 使用 Map
function uniqueArr2(arr=[],key){
    return Array.from(new Map(arr.map(item=>[item[key],item])).values());
}
/**
* 注意：方式 1 和方式 2 的区别：
*    1. 方式 1 去重后的结果里面重复元素取的是第一条而方式 2 是取的最后一条
*    2. 方式 1 简洁，适合数组较小的场景，更加高效，适合较大数组的去重
*/
//3. 使用reduce，此方式灵活性较高，可以处理更复杂的场景
function uniqueArr3(arr=[],key){
    return arr.reduce((prev,cur)=>{
        const x = prev.find(item => item[key] === cur[key]);
        if(!x){
            prev.push(cur);
        }
        return prev;
    },[]);
}