前端

服务端

计算机基础

在HTML中，`<script>`标签的`async`和`defer`属性用于控制外部JavaScript文件的加载和执行方式。

- `async`属性：当使用`async`属性时，脚本文件会被异步加载。这意味着脚本文件的下载会在HTML解析的同时进行，但不保证脚本会按顺序执行。一旦脚本下载完毕，它会立即执行，同时HTML的解析可能会暂停，直到脚本执行完毕。

- `defer`属性：使用`defer`属性时，脚本文件也会异步加载，但脚本的执行会被推迟到整个HTML文档解析完毕后。这保证了脚本的执行顺序是按照它们在HTML文档中出现的顺序。

总的来说，这两个属性都是为了改善页面的加载时间与用户体验，但`async`适用于那些不依赖于其他脚本且脚本顺序执行不重要的场景，而`defer`则适用于需要保证脚本执行顺序的场景。

script标签中的“async”和“defer”属性的作用是什么？

在Promise中，`.catch()`方法和`.then()`的第二个参数都用于处理Promise中发生的错误或拒绝(rejection)情况，但它们之间存在几个关键的区别：

1. **范围的不同**：
   - `.catch()`能够捕获在Promise链中任何之前的错误，包括前面的`.then()`中发生的错误。
   - `.then()`的第二个参数仅捕获它直接之前的Promise中的错误。

2. **链式调用的影响**：
   - 使用`.catch()`处理错误时，如果`.catch()`里面没有再次抛出错误，Promise链会继续执行后续的`.then()`方法。
   - 使用`.then()`的第二个参数处理错误，处理完错误后还会继续执行该`.then()`后续的`.then()`方法，不过这种用法使得代码的错误处理部分和成功处理部分耦合度较高。

3. **代码清晰性**：
   - `.catch()`使得错误处理逻辑集中和明确，更易于管理和维护。
   - `.then()`的第二个参数虽然功能相似，但可能会使得代码阅读和维护起来较为混乱，因为成功逻辑和错误处理逻辑都包含在同一个方法内。

总的来说，推荐使用`.catch()`来进行错误处理，因为它能提供更清晰、更强大且易于管理的错误捕获机制。

在Promise中，使用catch和then的第二个参数有什么区别？

在Rust中，直接迭代一个枚举的所有值并不是内置支持的，因为Rust的枚举可能包含不同类型的数据和不同数量的参数，这使得自动迭代变得复杂。然而，你可以通过实现一个迭代器或使用第三方库来实现这一功能。

一个常见的方法是使用`strum`库，这个库提供了枚举迭代的功能。首先，你需要在`Cargo.toml`中添加`strum`和`strum_macros`依赖：

```toml
[dependencies]
strum = "0.20"
strum_macros = "0.20"
```

然后，你可以在你的枚举类型上使用`EnumIter`宏来自动生成迭代相关的代码：

```rust
use strum_macros::EnumIter;
use strum::IntoEnumIterator;

#[derive(Debug, EnumIter)]
enum Color {
    Red,
    Blue,
    Green,
}

fn main() {
    for color in Color::iter() {
        println!("{:?}", color);
    }
}
```

这段代码会打印出所有的枚举值：`Red`、`Blue`和`Green`。使用`strum`库是迭代枚举值的一种方便方法。

在Rust中，是否有迭代枚举值的方法？

在软件工程中，元素和组件是两个关键概念，它们在构建应用程序时发挥着不同的作用。

**元素** 通常指的是构成界面的基本单元，它可以是HTML中的一个标签，如一个按钮、一个输入框或者一个图片等。在某些框架中，如React，元素描述了你想在屏幕上看到的内容。元素是不可变的，一旦被创建，你不能改变其子元素或属性。一个元素就像一个单纯的说明书，它告诉框架应该如何构建视图。

**组件** 则是更高级的概念，它封装了元素以及与之相关的逻辑。组件可以包含一个或多个元素，并且通常会包含一些内部状态或者行为，例如按钮的点击事件处理。组件可以是可复用的，且可以嵌套使用，构建复杂的UI结构。在许多现代前端框架中，如React, Vue, Angular等，组件是构建应用程序的基本单元。

简单来说，元素是静态的、不可变的描述，而组件是动态的、可复用的封装，包含了逻辑和界面。

说明元素和组件之间的区别？

在HTML5 Canvas上绘制多边形，您可以遵循以下步骤：

1. **创建画布**：
   首先，在HTML文件中添加一个`<canvas>`元素来创建一个画布。
   ```html
   <canvas id="myCanvas" width="500" height="500"></canvas>
   ```

2. **获取画布上下文**：
   在JavaScript中，使用`getContext()`方法获取画布的2D渲染上下文。
   ```javascript
   var canvas = document.getElementById("myCanvas");
   var ctx = canvas.getContext("2d");
   ```

3. **绘制多边形**：
   使用`beginPath()`方法开始一个新的路径，然后使用`moveTo()`将画笔移动到多边形的起始点。接着使用`lineTo()`方法添加多个线段，最后用`closePath()`闭合路径。
   ```javascript
   ctx.beginPath();
   ctx.moveTo(x1, y1); // 第一个顶点
   ctx.lineTo(x2, y2); // 第二个顶点
   ctx.lineTo(x3, y3); // 第三个顶点
   // 继续添加更多顶点
   ctx.closePath(); // 闭合路径
   ```

4. **设置样式和填充**：
   可以通过设置`strokeStyle`和`fillStyle`属性来自定义多边形的边框和填充颜色，然后使用`stroke()`和`fill()`方法对形状进行描边和填充。
   ```javascript
   ctx.strokeStyle = 'blue'; // 边框颜色
   ctx.fillStyle = 'red'; // 填充颜色
   ctx.stroke(); // 描边
   ctx.fill(); // 填充
   ```

以上就是在HTML5 Canvas上绘制一个多边形的基本步骤。您可以通过改变`lineTo()`方法中的坐标点来控制多边形的形状和大小。

如何在HTML5 Canvas上绘制多边形？

在Rust中，`@` 符号主要用于模式匹配的上下文中。它允许您在执行模式匹配的同时，将匹配的值绑定到一个变量。这样，您不仅可以检查值是否符合某个模式，还可以在之后的代码中再次使用这个值。

例如：
```rust
let value = Some(5);

match value {
    Some(x) @ Some(5) => println!("Got an Some with 5, and x is {:?}", x),
    _ => (),
}
```
在这个例子中，我们使用 `@` 将 `Some(5)` 匹配到的值绑定到变量 `x`，这样就可以在 `println!` 宏中使用 `x`。

Rust中的“@”符号有什么作用？

在Rust中，auto trait是一种特殊类型的trait，它们自动为符合特定条件的类型实现。最常见的例子是`Send`和`Sync`两个trait：

- `Send` trait标识一个类型的值可以安全地从一个线程转移到另一个线程。
- `Sync` trait表示一个类型的值可以在多个线程之间安全地共享，即从多个线程同时访问是安全的。

这些trait不需要在类型上显式实现，而是根据其内部成分自动推导。如果一个类型的所有成分都是`Send`，那么这个类型自动就是`Send`。同样，如果一个类型的所有成分都是`Sync`，那么这个类型自动就是`Sync`。

Auto traits的一个关键特性是，它们使用`negative reasoning`，意味着默认情况下所有类型都实现了这些trait，除非显示地通过`opt-out`（例如，通过使用`std::marker::PhantomData`类型在自定义类型中标记非`Send`或非`Sync`）。

总的来说，auto traits提供了一种高效的方式来处理多线程的安全性，让开发者可以更专注于逻辑实现，而不是每个类型的线程安全细节。

Rust中的auto trait是什么？

在Rust中，分号用来表示表达式结束，并开始下一个语句。通常，Rust中的分号不是可选的。每个语句的末尾必须有一个分号。不过，有一个例外：如果一个块的最后一个表达式没有末尾的分号，那么这个表达式的值会被作为整个块的返回值。例如，在函数或闭包中，最后一个表达式可以不用分号，以便返回值。

Rust中的分号是可选的吗？

在Rust中，动态数组通常是通过`Vec<T>`类型来实现的，其中`T`表示数组中元素的类型。`Vec<T>`是一个可增长的数组，可以动态地增加或减少其容量。

以下是如何创建和管理动态数组的基本步骤：

1. **创建新的动态数组**：
   ```rust
   let mut vec = Vec::new(); // 创建一个空的动态数组
   ```

   或者，如果你已知数组中的元素：
   ```rust
   let vec = vec![1, 2, 3, 4, 5]; // 使用宏创建并初始化数组
   ```

2. **向动态数组添加元素**：
   ```rust
   vec.push(6); // 在数组的末尾添加一个元素
   ```

3. **读取动态数组中的元素**：
   通过索引访问元素，这需要确保索引在数组范围内，否则可能会引起程序崩溃：
   ```rust
   if let Some(value) = vec.get(0) { // 安全地获取索引为0的元素
       println!("The first element is {}", value);
   } else {
       println!("No element at index 0");
   }
   ```

4. **移除动态数组中的元素**：
   ```rust
   let last_element = vec.pop(); // 移除并返回数组的最后一个元素
   if let Some(value) = last_element {
       println!("Popped element: {}", value);
   }
   ```

5. **迭代动态数组中的元素**：
   ```rust
   for elem in &vec { // 迭代数组中的每个元素
       println!("{}", elem);
   }
   ```

6. **调整数组的大小**：
   使用`resize`方法可以改变数组的大小，并为新元素指定默认值：
   ```rust
   vec.resize(10, 0); // 将数组大小调整为10，新元素初始化为0
   ```

以上步骤展示了在Rust中如何有效地使用和管理动态数组。`Vec<T>` 提供了多种方法来支持数组的动态修改和访问，是处理动态数组的首选方式。

如何在Rust中创建和管理动态数组？

在Rust中，可以进行递归闭包，但要实现递归闭包需要一些特别的处理。Rust中的闭包默认无法直接进行递归调用，因为闭包在定义时还未完全形成，无法在内部直接引用自身。

为了使闭包能递归调用，可以使用`Rc`（引用计数智能指针）和`RefCell`（提供内部可变性的类型）来实现。通过这种方式，可以在运行时动态地创建和修改闭包，从而实现递归。

下面是一个简单的例子，展示了如何在Rust中实现递归闭包：

```rust
use std::rc::Rc;
use std::cell::RefCell;

fn main() {
    // 使用 Rc 和 RefCell 来存储闭包，使其可以被修改和递归调用
    let factorial: Rc<RefCell<Box<dyn Fn(i32) -> i32>>> = Rc::new(RefCell::new(Box::new(|_| 0)));

    // 初始化闭包，使其可以递归调用自身
    *factorial.borrow_mut() = Box::new(move |n| {
        if n == 0 {
            1
        } else {
            n * factorial.borrow()(n - 1)
        }
    });

    let result = factorial.borrow()(5);
    println!("Factorial of 5 is {}", result);
}
```

在这个例子中，我们使用`Rc<RefCell<>>`来包装闭包，使得闭包可以在定义之后被修改，且可以通过`factorial.borrow()`来递归调用自身。这是实现闭包递归的一种方法，但需要注意的是，这种方法涉及到动态内存分配和额外的运行时开销。

前端面试题手册