前端

服务端

计算机基础

JavaScript 是一种动态类型语言，这意味着在声明变量时不需要指定数据类型，数据类型会在脚本执行时自动确定。JavaScript 的数据类型主要分为两大类：原始数据类型和对象类型。

### 原始数据类型

1. **undefined**：表示变量未定义，即声明了变量但未初始化。
2. **null**：表示一个空值。
3. **boolean**：布尔类型，有两个值：`true` 和 `false`。
4. **string**：表示文本数据，例如 `"Hello, World!"`。
5. **number**：可以是整数或浮点数，例如 `42` 或 `3.14159`。
6. **bigint**：表示大于2^53 - 1的整数。
7. **symbol**：表示唯一的、不可变的数据值。

### 对象类型

- **Object**：JavaScript 中的对象是键值对的集合，几乎所有的 JavaScript 值都是对象类型的，包括数组、函数以及其他内置对象。

### 类型检测的方法

在 JavaScript 中，检测变量的类型常用的有几种方法：

1. `typeof` 运算符：用来检测一个变量的类型，对于原始数据类型非常有效，但对于对象类型和 `null`，会有一些局限性。

```javascript
let num = 42;
console.log(typeof num); // "number"

let str = "Hello";
console.log(typeof str); // "string"

let flag = true;
console.log(typeof flag); // "boolean"

let bigIntNumber = 1234567890123456789012345678901234567890n;
console.log(typeof bigIntNumber); // "bigint"

let sym = Symbol('foo');
console.log(typeof sym); // "symbol"

let und;
console.log(typeof und); // "undefined"

let obj = { key: 'value' };
console.log(typeof obj); // "object"

let arr = [1, 2, 3];
console.log(typeof arr); // "object", 尽管它是数组

let func = function() {};
console.log(typeof func); // "function", 函数是对象的一种特殊类型

let nul = null;
console.log(typeof nul); // "object", 这是一个历史上的错误
```

2. `instanceof` 运算符：用来检测一个对象是否是另一个对象的实例。

```javascript
let arr = [1, 2, 3];
console.log(arr instanceof Array); // true
console.log(arr instanceof Object); // true

let d = new Date();
console.log(d instanceof Date); // true

// 注意，instanceof 无法检测原始数据类型
```

3. `Array.isArray()`：用来确定一个值是否是数组。

```javascript
let arr = [1, 2, 3];
console.log(Array.isArray(arr)); // true
```

4. 对象的 `constructor` 属性：可以用来判断对象的构造函数。

```javascript
let arr = [1, 2, 3];
console.log(arr.constructor === Array); // true

let obj = {};
console.log(obj.constructor === Object); // true
```

5. `Object.prototype.toString.call()`：这是一个通用的类型检测方法，可以准确判断各种类型的值。

```javascript
let d = new Date();
console.log(Object.prototype.toString.call(d)); // "[object Date]"

let num = 42;
console.log(Object.prototype.toString.call(num)); // "[object Number]"

let str = "Hello";
console.log(Object.prototype.toString.call(str)); // "[object String]"
```

注意，当使用类型检测方法时，应当根据具体情况选择最适合的方法，因为每种方法都有其适用场景和限制。

javascript 的类型以及如何检测

React 的虚拟DOM（VDOM）是React用于提升应用性能的核心概念之一。它是对真实DOM的一个轻量级抽象。虚拟DOM本质上是一个JavaScript对象，它是真实DOM结构的一个简化版本。React使用虚拟DOM来模拟真实DOM的更新，这样就可以最小化对真实DOM的操作，因为真实DOM操作的开销通常比较大。

当组件的状态变化时，React会创建一个新的虚拟DOM树并将其与上一次的虚拟DOM树进行比较。这个过程被称为Diff算法。通过Diff算法，React可以确定实际DOM需要进行的最小更新。以下是Diff算法的简要步骤：

1. **树的比较**：React首先比较两棵树的根节点，如果根节点的类型不同（例如从`<div>`变到`<span>`），React会销毁旧树并建立一棵新树。如果类型相同，则保留根节点，并继续进行递归比较。

2. **组件的比较**：如果是React组件节点，React会检查组件的类型是否相同。如果相同，组件将接收新的props并重新渲染。然后，React会比较返回的虚拟DOM。

3. **子元素的比较**：当比较两个相同类型的元素时，React会继续比较它们的子元素。React有两种不同的策略来比较子元素：
    - **同层比较**：React只比较同一层级的子元素。如果在不同层级有相同的元素，React不会尝试复用这些元素。
    - **key属性**：当开发者提供了key属性时，React会使用这个key来匹配旧的虚拟DOM树中的元素和新的虚拟DOM树中的元素。这有助于保持状态和提高性能，特别是在处理列表时。

4. **更新DOM**：一旦Diff算法确定了需要变更的最小部分，React会批量执行这些更新，尽量减少对真实DOM的操作，从而提高性能。

**例子**：

假设有一个列表，列表项组件`<ListItem />`有一个唯一的`key`属性，并且列表的状态更新导致列表项的顺序颠倒。由于每个`<ListItem />`都有唯一的`key`，React能够识别出这些组件只是顺序改变了，而不是完全不同的组件。因此，React仅会改变DOM中这些列表项的顺序，而不是销毁整个列表并重新创建，这大大提高了性能。

**总结**：

React的虚拟DOM和Diff算法共同工作，以提供高效的更新机制。虚拟DOM使得React可以在内存中进行计算，而Diff算法确保只对真实DOM做必要的、最小的修改。这种机制使得React在处理大型、动态的应用时能够保持良好的性能。

React 的 vdom 是什么？以及虚拟DOM 是如何做 diff 算法的？

### 什么是"use strict"？

`"use strict";` 是一个JavaScript中的指令，也称作严格模式（strict mode），它用于将整个脚本或单个函数置于一个更加严格的操作环境中。当在代码的开始处使用该指令时，它有助于捕获一些常见的编程错误，同时防止或抛出错误，以及在某些情况下提高编译器的优化水平。由于这些原因，它会改善代码的运行速度和效率。

### 使用它有什么优点？

1. **提前捕获错误：** 严格模式会在代码执行前就发现一些错误，这些在非严格模式下可能不会被检测到。例如，对不可写的属性赋值，或对只读属性（如`undefined`，`NaN`）赋值。

2. **避免意外的全局变量：** 在严格模式下，如果不使用`var`、`let`或`const`来声明变量，将会抛出错误，这样可以避免全局变量的隐式声明，减少代码中的潜在错误。

3. **消除`this`的混乱：** 在严格模式下，如果没有指定上下文对象，函数内的`this`值将是`undefined`，这比默认指向全局对象要安全。

4. **更安全的`eval`：** 严格模式下，`eval`函数内部声明的变量不会影响到外部作用域，这使得`eval`的使用更加安全。

5. **提高编译器优化：** 代码在执行之前可以进行更多的检查，这为JavaScript引擎的优化打下基础，可能会提高执行速度。

### 使用它有什么缺点？

1. **兼容性问题：** 在老旧的浏览器或JavaScript环境中，可能不支持严格模式，或者其行为与新版的解释器不一致。

2. **代码修改成本：** 如果要在已有项目中引入严格模式，可能需要对现有代码进行较大范围的修改，以确保兼容性和正确性。

3. **学习曲线：** 对于初学者来说，严格模式下的某些限制可能会增加学习难度，因为它们需要更好地理解JavaScript的工作原理。

4. **可能隐藏的问题：** 在非严格模式写的代码中可能含有在严格模式中会失败的部分，如果不进行彻底的测试，这些隐藏的问题在切换到严格模式后可能会导致运行时错误。

### 示例：

以下是一个简单的例子，展示了在使用严格模式时变量必须声明，否则会抛出错误：

```javascript
"use strict";

function myFunction() {
  undeclaredVariable = 123; // 这里会抛出错误，因为变量没有声明
}

myFunction();
```

如果没有`"use strict";` 指令，上面的代码中的`undeclaredVariable`会被创建为一个全局变量，这可能是一个潜在的问题。使用严格模式，我们可以避免这种情况。

什么是"use strict";？使用它有什么优缺点？​

`bind`、`call`和`apply`都是JavaScript中的函数对象的方法，它们都可以用来改变函数的`this`指向。每个方法的使用场景和方式有所不同：

### call
`call`方法可以让我们在调用一个函数的同时，指定函数内部`this`的值，也就是改变函数运行时的上下文。`call`的第一个参数是`this`要指向的对象，其余参数依次传入。

**例子**：
```javascript
function introduce(name, age) {
  console.log(`My name is ${name}, and I am ${age} years old. I work as a ${this.job}.`);
}

const person = {
  job: 'developer'
};

introduce.call(person, 'Alice', 30); // 输出：My name is Alice, and I am 30 years old. I work as a developer.
```

在以上例子中，我们使用`call`将`introduce`函数内部的`this`绑定到`person`对象，同时传入了`name`和`age`作为参数。

### apply
`apply`方法与`call`非常相似，区别在于`apply`传入参数的方式。`apply`的第一个参数同样是`this`的值，但第二个参数是一个数组，数组中包含了所有传给函数的参数。

**例子**：
```javascript
function introduce(name, age) {
  console.log(`My name is ${name}, and I am ${age} years old. I work as a ${this.job}.`);
}

const person = {
  job: 'developer'
};

introduce.apply(person, ['Alice', 30]); // 输出：My name is Alice, and I am 30 years old. I work as a developer.
```

在这个例子中，`apply`被用来将`introduce`函数的`this`绑定到`person`对象，参数以数组形式传入。

### bind
`bind`方法创建一个新的函数，可以在稍后时间里执行，它允许我们绑定`this`及初始参数。与`call`和`apply`不同，`bind`并不立即执行函数，而是返回一个改变了上下文`this`后的新函数。

**例子**：
```javascript
function introduce(name, age) {
  console.log(`My name is ${name}, and I am ${age} years old. I work as a ${this.job}.`);
}

const person = {
  job: 'developer'
};

const boundIntroduce = introduce.bind(person, 'Alice', 30);
boundIntroduce(); // 输出：My name is Alice, and I am 30 years old. I work as a developer.
```

在这里，`bind`被用来创建了一个新的`introduce`函数，该函数的`this`被永久绑定到`person`对象。

**总结**：`call`和`apply`都是立即调用函数，但是参数传递方式不同；`call`将参数按顺序传递，而`apply`则是传入参数数组。而`bind`则是返回一个新的函数，可以在以后任何时间点调用，其`this`值和参数都已经预设好了。

bind、call、apply 的区别

在优化Go代码的性能时，可以考虑以下几个方面：

1. **使用性能更好的算法和数据结构**：选择合适的算法和数据结构是提升性能的关键。例如，使用哈希表（如`map`）而不是列表（`slice`）进行查找操作，可以显著降低时间复杂度。

2. **并发执行**：Go语言的并发是其一大特色。通过`goroutine`和`channel`，可以简化并发编程，利用多核CPU优势，提高程序性能。但需注意合理设计并发，避免资源竞争和死锁。

3. **避免内存分配**：频繁的内存分配和回收会导致性能下降。可以通过复用对象、减少临时对象的创建等方式优化。使用内置的性能分析工具如`pprof`查看内存分配情况，有助于发现问题并优化。

4. **优化内存访问模式**：减少缓存未命中，可以通过减少数据结构的大小，优化数据布局，或者尽量让热点数据在内存中连续集中。

5. **编译器优化**：利用Go编译器的优化选项，例如通过设置`-gcflags "-m"`查看编译器的优化决策，或使用较新版本的Go编译器，因为每个版本的编译器都可能在优化方面有所改进。

6. **减少锁的使用**：锁会导致运行时开销和潜在的竞争条件。尽可能使用无锁编程技术，或者使用更为精细的锁，如读写锁（`sync.RWMutex`），以减少锁的竞争。

7. **使用性能分析工具**：Go提供了多种性能分析工具，如`pprof`进行CPU和内存分析，`trace`工具查看程序运行时的调度情况和垃圾回收统计等。定期进行性能分析，可以帮助识别瓶颈，有针对性地进行优化。

通过这些策略，可以有效地提升Go代码的运行效率和整体性能。

如何优化Go代码的性能？

在使用Yarn管理npm模块时，如果需要调试特定的模块，可以采取以下步骤：

1. **本地链接模块**：首先，如果对某个npm模块进行修改并想实时反映这些更改，可以在模块的目录下运行 `yarn link`。这会创建一个全局链接。然后在项目目录下运行 `yarn link [模块名]`，将这个链接关联到你的本地项目中。

2. **查看详细日志**：在运行Yarn命令时，可以加上 `--verbose` 参数，这样Yarn会打印出更详细的输出信息，帮助你了解命令背后的具体执行过程和状态。

3. **使用调试工具**：对于Node.js环境中运行的模块，可以使用Node的内置调试工具，如 `node --inspect` 或 `node --inspect-brk`，配合Chrome DevTools进行源代码的断点调试。

4. **分析依赖树**：使用 `yarn why [模块名]` 命令来分析为什么某个模块被安装，它的依赖来源，以及版本信息等。

5. **环境变量**：可以利用环境变量来控制和调试npm模块的行为。例如，设置 `NODE_ENV=development` 可以让某些模块启用开发模式，可能会输出更多的调试信息或启用额外的功能。

通过以上步骤，可以有效地调试和管理通过Yarn安装的npm模块。

Yarn 如何调试npm模块？

在处理GraphQL中的错误时，通常采用以下几种策略：

1. **使用错误字段**：在GraphQL响应中，通常包括一个`errors`字段，用来包含任何在查询过程中发生的错误。务必确保每个错误都包括足够的信息，例如错误类型、错误消息和可能的错误位置。

2. **定义错误类型**：创建自定义错误类型来更准确地描述遇到的具体问题。例如，可以定义`AuthenticationError`、`ValidationError`等，这有助于客户端更好地理解错误并作出相应处理。

3. **错误处理策略**：在服务器端实现错误处理逻辑，如使用try/catch块捕获异常，并将它们转换为GraphQL错误。这样可以在逻辑层面统一错误处理方式，便于维护和调试。

4. **使用错误日志**：记录错误日志对于后续的错误分析和监控非常重要。确保记录关键信息，如错误发生的时间、错误类型、相关的用户和请求数据等。

5. **客户端错误处理**：在客户端也应实现错误处理逻辑，如根据错误类型显示不同的错误消息或执行不同的操作。这样可以提升用户体验，让用户明白发生了什么问题，以及可能的解决方案。

6. **避免敏感信息泄露**：在设计错误信息时，需注意不要暴露敏感信息，如数据库细节或系统架构，这可能会带来安全风险。

通过上述方法，可以有效地管理和处理GraphQL中的错误，同时提高系统的健壮性和用户的体验。

如何处理GraphQL中的错误？

完全外部连接（Full Outer Join）和交叉连接（Cross Join）在数据库管理系统中是两种不同的连接类型，主要区别如下：

1. **结果集的不同**：
   - **完全外部连接**：返回左表和右表中的所有记录。如果左表中的记录在右表中没有匹配项，则相应的右表中的字段会用NULL填充，反之亦然。这意味着完全外部连接会包含左连接和右连接的结果。
   - **交叉连接**：返回左表和右表的笛卡尔积。如果左表有N行，右表有M行，那么结果集将有N*M行。交叉连接不考虑表间的任何关联条件，简单地将左表的每一行与右表的每一行组合。

2. **应用场景**：
   - **完全外部连接**：常用于需要查看两个表中全部数据，并找出在对方表中没有匹配的记录的场景。
   - **交叉连接**：适用于需要生成基于两个表所有可能组合的场景，比如生成可能的产品组合或测试数据等。

3. **性能影响**：
   - **完全外部连接**：由于需要匹配左表和右表中的所有记录，可能会消耗较多的计算资源，尤其是表很大时。
   - **交叉连接**：由于生成的是两个表的笛卡尔积，可能会产生庞大的结果集，这在大多数业务场景中可能不是必要的，也会显著增加查询处理时间和资源消耗。

总结来说，完全外部连接用于合并两个表并找出无匹配项的记录，而交叉连接用于生成两个表所有可能的行组合。在实际应用中，选择适合具体需求的连接类型是很重要的。

完全外部连接和交叉连接之间有什么区别？

抽象方法和虚拟方法主要的区别在于它们的定义和使用目的：

1. **抽象方法（Abstract Method）**：
   - 抽象方法是在抽象类中声明的，但它没有任何实现（即没有方法体）。这要求任何继承该抽象类的子类必须提供该抽象方法的具体实现，除非该子类也是抽象类。
   - 抽象方法用于设定派生类应遵循的一种模板，确保所有派生类都具有相同的行为接口。

2. **虚拟方法（Virtual Method）**：
   - 虚拟方法是在类中使用 `virtual` 关键字声明的方法，它提供了一个基本的实现，这个实现可以被任何继承它的子类重写（Override）。
   - 虚拟方法允许子类在不改变接口规范的情况下，改变或扩展父类的方法行为。

总结来说，抽象方法强制要求派生类实现特定的方法，而虚拟方法则提供了一个可以被派生类自由覆写的实现基础。

抽象方法和虚拟方法有什么区别？

接口（Interface）和抽象类（Abstract Class）都是在面向对象编程中用于实现抽象概念的方法，但它们之间存在几个关键区别：

1. **目的不同**：
   - **接口**：提供了一种形式，强制实现类必须遵守的规则，主要用于定义对象间的协议。
   - **抽象类**：主要用于为一组类提供通用的、预定义的状态（变量）或行为（方法），部分行为可以通过抽象方法来实现多态。

2. **实现继承与接口继承**：
   - **接口**：只能声明方法和常量，不能实现方法（Java 8之后，接口可以包含默认方法和静态方法）。
   - **抽象类**：可以声明和实现方法，抽象类中可以包含非抽象方法（即已实现的方法）。

3. **构造函数**：
   - **接口**：不能包含构造函数。
   - **抽象类**：可以包含构造函数，用于初始化类的一些基本状态。

4. **多重继承**：
   - **接口**：一个类可以实现多个接口，支持多重继承。
   - **抽象类**：一个类只能继承一个抽象类，不支持多重继承。

5. **访问修饰符**：
   - **接口**：默认方法和变量是public的。
   - **抽象类**：可以有public、protected和private方法和变量。

综上，接口和抽象类都有其特定的使用场景，选择使用哪一个取决于具体需求。接口更适合定义不同类之间的协议，抽象类更适合为一组相关的类提供公共的代码和抽象的方法。

前端面试题手册

javascript 的类型以及如何检测

React 的 vdom 是什么？以及虚拟DOM 是如何做 diff 算法的？

什么是"use strict";？使用它有什么优缺点？

bind、call、apply 的区别

如何优化Go代码的性能？

Yarn 如何调试npm模块？

如何处理GraphQL中的错误？

完全外部连接和交叉连接之间有什么区别？

抽象方法和虚拟方法有什么区别？

接口和抽象类有什么区别？

前端面试题手册

javascript 的类型以及如何检测

React 的 vdom 是什么？以及虚拟DOM 是如何做 diff 算法的？

什么是"use strict";？使用它有什么优缺点？​

bind、call、apply 的区别

如何优化Go代码的性能？

Yarn 如何调试npm模块？

如何处理GraphQL中的错误？

完全外部连接和交叉连接之间有什么区别？

抽象方法和虚拟方法有什么区别？

接口和抽象类有什么区别？

什么是"use strict";？使用它有什么优缺点？