css - Grid


枚举是一种定义通用类型的方式，它定义了一组相关值的列表。每个枚举成员都代表了一个具体的值，并且可以附加额外的信息，例如关联值或原始值。

以下是一个简单的示例，用于定义枚举类型 CompassPoint，该类型表示了四个基本的方向：

```swift
enum CompassPoint {
  case north
  case south
  case east
  case west
}

var direction = CompassPoint.north
```

在上面的示例中，CompassPoint 是一个枚举类型，它包含了四个成员，每个成员代表一个基本的方向。direction 是一个变量，它的类型是 CompassPoint，它被初始化为 CompassPoint.north。

枚举成员可以包含关联值，这些关联值可以是任何类型。例如，以下是一个枚举类型 Barcode，它可以表示一个标准的商品条形码或一个自定义的二维码：

```swift
  case upc(Int, Int, Int, Int)
  case qrCode(String)
}

var productBarcode = Barcode.upc(8, 85909, 51226, 3)
```

在上面的示例中，Barcode 是一个枚举类型，它包含了两个成员，一个是 upc，它使用四个 Int 类型的关联值表示商品的标准条形码；另一个是 qrCode，它使用一个 String 类型的关联值表示自定义的二维码。productBarcode 是一个变量，它的类型是 Barcode，它被初始化为 Barcode.upc。

枚举成员还可以包含原始值，这些原始值可以是任何类型，但必须是相同的类型。原始值可以是字符串、字符、整数或浮点数。例如，以下是一个枚举类型 Planet，它使用浮点数原始值表示每个行星的相对质量：

```swift
enum Planet: Double {
  case mercury = 0.055
  case venus = 0.815
  case earth = 1.0
  case mars = 0.107
  case jupiter = 318.0
  case saturn = 95.0
  case uranus = 14.0
  case neptune = 17.0
}

let earthWeight = 70.0
let planet = Planet.jupiter
let relativeWeight = planet.rawValue * earthWeight
```

在上面的示例中，Planet 是一个枚举类型，它使用浮点数原始值表示每个行星的相对质量。earthWeight 是一个 Double 类型的常量，表示一个人在地球上的体重。planet 是一个变量，它的类型是 Planet，它被初始化为 Planet.jupiter。relativeWeight 是一个常量，它的值是 Jupiter 相对于地球的质量与 earthWeight 的乘积。



枚举是一种定义通用类型的方式，它定义了一组相关值的列表。每个枚举成员都代表了一个具体的值，并且可以附加额外的信息，例如关联值或原始值。

Swift - 枚举


Next.js 的路由基于文件系统，当在`pages`目录下新建一个文件时，它的路由路径就会自动生成。

Next.js 的路由遵循以下规则：

- `index routes`
  1. 如果文件名为`index.js`，则路由路径为`/`
  2. 如果文件名为`posts/index.js`，则路由路径为`/posts`
- `nested routes`
  1. 如果文件名为`pages/settings/dashboard/about.js`，则路由路径为`/settings/dashboard/about`
  2. 如果文件名为`pages/posts/first.js`，则路由路径为`/posts/first`
- `dynamic routes`
  1. 如果文件名为`pages/posts/[slug].js`，则路由路径为`/posts/[slug]`，比如`/posts/first`
  2. 如果文件名为`pages/[user]/settings.js`，则路由路径为`/posts/:user/settings`，比如`/posts/manon/settings`
  3. 如果文件名为`pages/posts/[...slug].js`，则路由路径为`/posts/[...slug]`，比如`/posts/first/second/third`

## 页面链接

Next.js 的路由链接是通过`Link`组件来实现的，它的属性是：

- `href`: pages 目录下的路径

更新`index.js`文件，添加一个链接：

```jsx
import Head from 'next/head'
import Link from 'next/link'

function HomePage(props) {
  return (
    <>
      <Head>
        <title>Welcome to Next.js!</title>
      </Head>
      <div>Welcome to Next.js!</div>
      <Link href="/posts/first">
        <a>First Post</a>
      </Link>
      <div>Next stars: {props.stars}</div>
      <img src="/logo.jpg" alt="Logo" />
    </>
  )
}

export async function getServerSideProps(context) {
  const res = await fetch('https://api.github.com/repos/vercel/next.js')
  const json = await res.json()
  return {
    props: {stars: json.stargazers_count}
  }
}

export default HomePage
```

## 启动服务

```bash
npm run dev
```

## 检查结果

![emWf77](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/emWf77.png)


Next.js - Routing


Spacing（间距）是指在网页设计和排版中，用于描述元素（如文本、图片、容器等）之间的距离的一种概念。它可以通过 CSS 属性来设置，通常包括以下几种属性：

- margin（外边距）：用于设置元素与其它元素之间的距离，即元素外部空白区域与周围元素之间的距离。它可以设置四个方向的值，分别为 margin-top、margin-right、margin-bottom 和 margin-left。如果只设置一个值，它将被应用于所有四个方向；如果设置两个值，则第一个值应用于 top 和 bottom，第二个值应用于 left 和 right；如果设置三个值，则第一个值应用于 top，第二个值应用于 left 和 right，第三个值应用于 bottom。如果设置四个值，则分别应用于 top、right、bottom 和 left。
- padding（内边距）：用于设置元素内部空白区域与元素内容之间的距离，即元素内容区域与元素边界之间的距离。它可以设置四个方向的值，分别为 padding-top、padding-right、padding-bottom 和 padding-left。如果只设置一个值，它将被应用于所有四个方向；如果设置两个值，则第一个值应用于 top 和 bottom，第二个值应用于 left 和 right；如果设置三个值，则第一个值应用于 top，第二个值应用于 left 和 right，第三个值应用于 bottom。如果设置四个值，则分别应用于 top、right、bottom 和 left。
- line-height（行高）：用于设置文本行之间的距离，即每行文本的高度。它通常被用于控制段落和标题的行间距。它可以设置为一个无单位的数字值，表示倍数关系，如 1.5 表示当前字体大小的 1.5 倍；也可以设置为具有单位的像素或 em 等值。

除了这些属性外，还有一些其它的间距相关的属性，如：

- border-spacing：用于设置表格中的单元格之间的距离，即单元格边框之间的距离。
- grid-gap：用于设置网格布局中各个网格之间的距离，即网格行列之间的距离。
- column-gap：用于设置多列布局中各个列之间的距离，即列与列之间的距离。

以下是一个使用间距属性的示例代码，用于在网页中创建一个简单的图片库：

```html
<div class="image-gallery">
  <div class="image-container">
    <img src="image1.jpg" alt="Image 1">
  </div>
  <div class="image-container">
    <img src="image2.jpg" alt="Image 2">
  </div>
  <div class="image-container">
    <img src="image3.jpg" alt="Image 3">
  </div>
  <div class="image-container">
    <img src="image4.jpg" alt="Image 4">
  </div>
</div>
```

```css
.image-gallery {
  display: flex;
  flex-wrap: wrap;
  justify-content: center;
  gap: 20px;
}

.image-container {
  width: 200px;
  height: 200px;
  overflow: hidden;
}

.image-container img {
  width: 100%;
  height: 100%;
  object-fit: cover;
}
```

在这个示例中，我们使用了以下的间距相关属性：

- gap：用于设置元素之间的间距，这里用于设置图片之间的间距。
- width 和 height：用于设置图片容器的宽度和高度，这里设置为 200px，以便容纳图片。
- overflow：用于设置图片容器的溢出行为，这里设置为 hidden，以便保证图片不会溢出容器。
- object-fit：用于设置图片的填充方式，这里设置为 cover，以便让图片填充整个容器。

![ky9A4y](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/ky9A4y.png)


css - Spacing


**nohup**用于忽略 SIGHUP ("signal hang up" 译：挂断信号) 在系统后台不挂断地运行命令，退出终端不会影响程序的运行。

nohup 命令在默认情况下（非重定向时），会输出一个名叫 nohup.out 的文件到当前目录下，如果当前目录的 nohup.out 文件不可写，输出重定向到 $HOME/nohup.out 文件中。

## 使用方法

```bash
nohup <command>
```

停止运行

```bash
#使用如下命令找到进程pid，然后使用kill杀掉进程
ps -aux | grep <command>
```

## 参数

- Command：要执行的命令。
- Arg：一些参数，可以指定输出文件。
- &：让命令在后台执行，终端退出后命令仍旧执行。

nohup 命令可以在 Linux、macOS、WSL 和任何有 UNIX 环境的地方使用


用于忽略 SIGHUP (挂断信号) 在系统后台不挂断地运行命令，退出终端不会影响程序的运行

Linux命令nohup


所有的代码都是在执行上下文中执行的，执行上下文是一个抽象的概念，它是一种规范，用来定义变量或函数有权访问的其他数据，决定它们的各自行为。

在深入研究前，需要了解一些概念：

- 编译器：负责语法分析和代码生成
- JavaScript 引擎：负责执行代码
- 函数声明：指的是使用 function 关键字声明的函数
- 函数表达式：指的是使用 var 关键字声明的函数

## JavaScript 是如何被执行的

JavaScript 代码在执行之前，会经历三个阶段：

- 词法分析（Lexical Analysis）
- 语法分析（Syntactic Analysis）
- 代码生成（Code Generation）

词法分析阶段，会将代码分解成一个个词法单元，比如 var、function、if、else、for、while 等等。

语法分析阶段，会将词法单元转换成一个个语法单元，比如 var a = 1，会被转换成一个个词法单元，然后再转换成一个个语法单元，比如 var、a、=、1。

代码生成阶段，会将语法单元转换成可执行的代码，比如 var a = 1，会被转换成一个个语法单元，然后再转换成可执行的代码，比如 var a = 1。

## JavaScript 中的执行上下文

JavaScript 中的执行上下文是一个抽象的概念，它是一种规范，用来定义变量或函数有权访问的其他数据，决定它们的各自行为。

执行上下文分为三种：

- 全局执行上下文
- 函数执行上下文
- eval 函数执行上下文

### 全局执行上下文

全局执行上下文是默认的执行上下文，它会在 JavaScript 代码执行之前被创建，它会被放到执行上下文栈中，当 JavaScript 代码执行完毕后，它会被从执行上下文栈中移除。

全局执行上下文包含三个部分：

- 变量对象（Variable Object，VO）
- 作用域链（Scope Chain）
- this

#### 变量对象

变量对象是与执行上下文相关的数据作用域，存储了在上下文中定义的变量和函数声明。

变量对象包含两个部分：

- 函数的所有形参（如果是函数上下文）
- 函数声明
- 变量声明

变量对象的创建过程：

- 创建一个 VO
- 将所有形参，变量和函数声明添加到 VO 中
- 将 VO 赋值给活动对象（AO）

#### 作用域链

作用域链是一个指向变量对象的指针列表，它只引用但不实际包含变量对象。

作用域链的创建过程：

- 创建一个作用域链
- 将当前执行上下文的变量对象添加到作用域链中
- 将父级执行上下文的变量对象添加到作用域链中
- 将父级的父级执行上下文的变量对象添加到作用域链中
- 依次类推，直到全局执行上下文的变量对象添加到作用域链中

#### this

this 是一个指针，指向函数执行时所在的作用域。

[this 的指向](/blog/javascript/advance/this指向)

### 函数执行上下文

函数执行上下文是在函数被调用时被创建，它会被放到执行上下文栈中，当函数执行完毕后，它会被从执行上下文栈中移除。

## JavaScript 中的提升

JavaScript 中的提升是指变量和函数的声明会被提升到当前作用域的顶部。

### 变量提升

变量提升是指变量的声明会被提升到当前作用域的顶部，但是变量的赋值不会被提升。

```js
console.log(a) // undefined
var a = 1
```

### 函数提升

函数提升是指函数的声明会被提升到当前作用域的顶部，但是函数的赋值不会被提升。

```js
console.log(a) // function a() {}
function a() {}
```

## JavaScript 执行栈

JavaScript 执行栈是一个用于存储函数调用的栈结构，它遵循先进后出的原则。

当浏览器加载脚本，JS 引擎从全局上下文也就是默认上下文开始执行代码，所以全局上下文被放在执行栈的最底部。

然后 JS 引擎再搜索代码中被调用的函数。每一次函数被调用，一个新的 FEC 就会被创建，并被放置在当前执行上下文的上方。

执行栈最顶部的执行上下文会成为活跃执行上下文，并且始终是 JS 引擎优先执行。

一旦活跃执行上下文中的代码被执行完毕，JS 引擎就会从执行栈中弹出这个执行上下文，紧接着执行下一个执行上下文，以此类推。

为了了解执行栈的工作流，请考虑下面的代码：

```js
var name = 'Victor'

function first() {
  var a = 'Hi!'
  second()
  console.log(`${a} ${name}`)
}

function second() {
  var b = 'Hey!'
  third()
  console.log(`${b} ${name}`)
}

function third() {
  var c = 'Hello!'
  console.log(`${c} ${name}`)
}

first()
```

解释以上代码的执行过程：

1. 全局上下文被创建，全局上下文被压入执行栈中。
2. 全局上下文初始化，创建变量对象、作用域链、this。
3. 全局上下文代码被执行，遇到 first() 函数调用，创建 first() 函数执行上下文，first() 函数执行上下文被压入执行栈中。
4. first() 函数执行上下文初始化，创建变量对象、作用域链、this。
5. first() 函数执行上下文代码被执行，遇到 second() 函数调用，创建 second() 函数执行上下文，second() 函数执行上下文被压入执行栈中。
6. second() 函数执行上下文初始化，创建变量对象、作用域链、this。
7. second() 函数执行上下文代码被执行，遇到 third() 函数调用，创建 third() 函数执行上下文，third() 函数执行上下文被压入执行栈中。
8. third() 函数执行上下文初始化，创建变量对象、作用域链、this。
9. third() 函数执行上下文代码被执行，打印 `Hello Victor`。
10. third() 函数执行上下文被弹出执行栈。
11. second() 函数执行上下文代码被执行，打印 `Hey Victor`。
12. second() 函数执行上下文被弹出执行栈。
13. first() 函数执行上下文代码被执行，打印 `Hi Victor`。
14. first() 函数执行上下文被弹出执行栈。
15. 全局上下文代码被执行，打印 `Victor`。
16. 全局上下文被弹出执行栈。

![AsLji6](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/AsLji6.jpg)

## 全局执行上下文对比函数执行上下文

全局执行上下文和函数执行上下文的区别在于：

1. 全局执行上下文只有一个，但是函数执行上下文可以有很多个。
2. 全局执行上下文在浏览器关闭时被销毁，但是函数执行上下文在函数执行完毕后被销毁。

## 参考

1. [https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Function/Call](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Function/Call)
2. [JavaScript 执行上下文——JS 的幕后工作原理](https://www.freecodecamp.org/chinese/news/execution-context-how-javascript-works-behind-the-scenes/)


执行上下文


`Node.js`的错误有以下几种：

- 标准 JavaScript 错误，比如`eval error`、`syntax error`、`range error`、`reference error`、`type error`、`uri error`
- 系统错误
- 用户指定错误
- 断言错误

```js
try {
  const a = 1
  const c = a + b
} catch (err) {
  console.log(err)
}
```

以上代码输出`ReferenceError:b is not defined`

```js
const fs = require('fs')
function nodeStyleCallback(err, data) {
  if (err) {
    console.error('There was an error', err)
    return
  }
  console.log(data)
}
fs.readFile('/some/file/that/does-not-exist', nodeStyleCallback)
fs.readFile('/some/file/that/does-exist', nodeStyleCallback)
```

![TP1ULh](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/TP1ULh.png)
