2023/5/30面试小结

news2024/11/22 13:57:58

一、本应会但并不会的题

1.用js写一个栈

class Stack {
  constructor() {
    this.items = [];
  }
  // 添加元素到栈顶
  push(element) {
    this.items.push(element);
  }
  // 移除栈顶元素并返回
  pop() {
    return this.items.pop();
  }
  // 返回栈顶元素
  peak() {
    return this.items[this.items.length - 1];
  }
  // 判断栈是否为空
  isEmpty() {
    return this.items.length === 0;
  }
  // 返回栈中元素个数
  size() {
    return this.items.length;
  }
}

const stack = new Stack();
stack.push(1);
stack.push(2);
console.log(stack); // Stack { items: [1, 2]}
console.log(stack.peak()); // 2
console.log(stack.pop()); // 2
console.log(stack.isEmpty()); // false
console.log(stack.size()); // 1

2.二叉树的深度优先遍历的三种实现

二叉树的深度优先遍历（Depth-First Search，DFS）是指从根节点开始，沿着一条路径尽可能向下访问每个节点，直到无法继续为止，然后返回上一个节点继续访问。具体来说深度优先遍历分为三种：

前序遍历（Preorder Traversal）：根节点->左子树->右子树
中序遍历（Inorder Traversal）：左子树->根节点->右子树
后序遍历（Postorder Traversal）：左子树->右子树->根节点
下面是一个使用递归实现二叉树前序、中序和后序遍历的示例代码：

// 树节点
class TreeNode {
  constructor(value) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}

// 二叉树
class BinaryTree {
  constructor() {
    this.root = null;
  }
  // 向树中插入新节点
  insert(value) {
    let newNode = new TreeNode(value);
    // 如果根节点不存在则将新节点设置为根节点，否则递归插入节点
    if (!this.root) {
      this.root = newNode;
    } else {
      this.insertNode(this.root, newNode);
    }
  }
  // 递归地插入节点 左中右
  insertNode(node, newNode) {
    if (newNode.value < node.value) {
      // 新节点在左侧的情况
      if (!node.left) {
        // 左侧没节点直接插入
        node.left = newNode;
      } else {
        // 左侧有节点递归插入
        this.insertNode(node.left, newNode);
      }
    } else {
      // 新节点在右侧的情况
      if (!node.right) {
        // 右侧没节点直接插入
        node.right = newNode;
      } else {
        // 右侧有节点递归插入
        this.insertNode(node.right, newNode);
      }
    }
  }
  // 先序遍历 根->左->右  要传入一个节点参数
  preOrderTraversal(root, result = []) {
    if (root) {
      // 访问根节点
      result.push(root.value);
      // 再访问左子树
      this.preOrderTraversal(root.left, result);
      // 再访问右子树
      this.preOrderTraversal(root.right, result);
    }
    return result;
  }
  // 中序遍历 左->根->右
  inOrderTraversal(root, result = []) {
    if (root) {
      // 访问左子树
      this.inOrderTraversal(root.left, result);
      // 访问根节点
      result.push(root.value);
      // 访问右子树
      this.inOrderTraversal(root.right, result);
    }
    return result;
  }
  // 后序遍历 左->右->根
  postOrderTraversal(root, result = []) {
    if (root) {
      this.postOrderTraversal(root.left, result);
      this.postOrderTraversal(root.right, result);
      result.push(root.value);
    }
    return result;
  }
}

// 测试
const binaryTree = new BinaryTree();

binaryTree.insert(4);
binaryTree.insert(2);
binaryTree.insert(7);
binaryTree.insert(1);
binaryTree.insert(3);
binaryTree.insert(10);
binaryTree.insert(8);
binaryTree.insert(5);
console.log(binaryTree.preOrderTraversal(binaryTree.root)); // [4, 2, 1, 3, 7, 5, 10, 8]
console.log(binaryTree.inOrderTraversal(binaryTree.root)); // [1, 2, 3, 4, 5, 7, 8, 10]
console.log(binaryTree.postOrderTraversal(binaryTree.root)); // [1, 3, 2, 5, 8, 10, 7, 4]

在这里插入图片描述

3.Vue2到Vue3实现响应式为什么要从Object.defineProperty()转为使用Proxy代理

在Vue 2中，对象响应式是通过Object.defineProperty()来实现的。但是这种方式存在一些局限性，比如无法监测到新增属性和删除属性。另外，由于Object.defineProperty()只能对属性进行劫持，所以需要遍历对象的每个属性进行劫持，性能不够优秀。

Vue 3中引入了Proxy代理，它能够监测到更多类型的变化，包括新增属性和删除属性。同时，它可以一次性监听整个对象，而不需要遍历每个属性，因此在性能方面比Object.defineProperty()更加优秀。

除此之外，使用Proxy代理还可以实现更为复杂的监听操作，比如监听数组的变化、深度监听等。因此，在Vue 3中采用Proxy代理来实现响应式更加灵活和高效。

4.实现{name:‘xiaoming’,id:0, age:18}->‘name=xiaoming&id=0&age=18’

const obj = {
  name: "xiao5",
  id: 0,
  age: 18,
};
function objToQueryString(obj) {
  return Object.keys(obj)
    .map((key) => key + "=" + obj[key])
    .join("&");
}
const result = objToQueryString(obj);
console.log(result); // name=xiao5&id=0&age=18

5.如何实现一个抽象类，抽象类和普通类有什么不同

在ES6中可以通过class关键字和constructor方法来实现一个类，但是ES6并没有提供直接创建抽象类的关键字。不过，我们可以通过在类中定义抽象方法来模拟实现一个抽象类。

一个抽象方法就是只有方法签名，而没有具体实现的方法。在ES6中，我们可以通过抛出错误的方式来提示子类必须实现该抽象方法。

以下是实现抽象类的示例代码：

// 定义一个抽象类Animal
class Animal {
  constructor(name) {
    this.name = name;
  }
  
  // 声明一个抽象方法speak，该方法必须由子类继承并且实现
  speak() {
    throw new Error('This method must be implemented by the subclass.');
  }
}

// 继承自Animal的子类
class Dog extends Animal {
  constructor(name, breed) {
    super(name);
    this.breed = breed;
  }
  
  // 实现抽象方法speak
  speak() {
    console.log('Woof!');
  }
}

const myDog = new Dog('Buddy', 'Labrador');
myDog.speak(); // 'Woof!'