Swift 结构体是构建代码所用的一种通用且灵活的构造体。

Structs - 结构体


在 HTML 中，列表（Lists）是一种用于组织信息的结构。列表可以分为有序列表（Ordered Lists）和无序列表（Unordered Lists）两种类型。

无序列表：用于表示没有特定顺序或层次的项目列表。在 HTML 中，无序列表使用ul标签来定义，每个项目使用li标签来定义。示例如下：

```html
<ul>
  <li>项目 1</li>
  <li>项目 2</li>
  <li>项目 3</li>
</ul>
```

有序列表：用于表示按照特定顺序或层次的项目列表。在 HTML 中，有序列表使用ol标签来定义，每个项目使用li标签来定义。示例如下：

```html
<ol>
  <li>第一项</li>
  <li>第二项</li>
  <li>第三项</li>
</ol>
```

除了基本列表之外，HTML 还提供了其他类型的列表，如描述列表（Description Lists）和嵌套列表（Nested Lists）。

描述列表：用于表示一组术语及其定义的列表。在 HTML 中，描述列表使用dl标签来定义，每个术语使用dt标签来定义，每个定义使用dd标签来定义。示例如下：

````html
<dl>
  <dt>术语 1</dt>
  <dd>定义 1</dd>
  <dt>术语 2</dt>
  <dd>定义 2</dd>
  <dt>术语 3</dt>
  <dd>定义 3</dd>
</dl>
``` 嵌套列表：用于表示列表项目之间的嵌套关系。在 HTML
中，可以将一个列表放置在另一个列表的项目中，以创建嵌套列表。示例如下： `html
<ul>
  <li>项目 1</li>
  <li>
    项目 2
    <ul>
      <li>项目 2.1</li>
      <li>项目 2.2</li>
    </ul>
  </li>
  <li>项目 3</li>
</ul>
`
通过使用列表，可以有效地组织和呈现信息，使其更易于阅读和理解。在实际项目中，通常会使用
CSS 对列表进行样式设计，以使其更加美观和有用。
````


css - Lists


css 盒模型（Box Model）是指在网页中，每个 HTML 元素都可以看作是一个矩形的盒子，这个盒子有四个边界，分别是：内容区（content）、内边距（padding）、边框（border）和外边距（margin）。这四个边界分别对应了 HTML 元素的不同属性，通过这些属性的设置，我们可以控制盒子的大小、边框、内外边距等特征，从而实现布局和样式的控制。

下面对盒模型的四个部分进行详细解释：

1. 内容区（content）
   内容区是指 HTML 元素的实际内容，即文本、图像、视频、音频等。我们可以通过设置 width 和 height 属性来控制内容区的尺寸。

2. 内边距（padding）
   内边距是指内容区和边框之间的距离，也就是内容区的内部空白区域。我们可以通过设置 padding 属性来控制内边距的大小。padding 属性可以设置为一个值，表示四个方向的内边距大小都相等，也可以分别设置为四个值，表示各个方向的内边距大小不同。

3. 边框（border）
   边框是包围内容区和内边距的线条，我们可以通过设置 border 属性来控制边框的样式、粗细和颜色等。border 属性可以分别设置为三个值或四个值，分别表示边框的样式、粗细和颜色，以及边框的位置（上、右、下、左）。

4. 外边距（margin）
   外边距是指边框和相邻元素之间的距离，也就是元素的外部空白区域。我们可以通过设置 margin 属性来控制外边距的大小。margin 属性可以设置为一个值，表示四个方向的外边距大小都相等，也可以分别设置为四个值，表示各个方向的外边距大小不同。

盒模型分为标准盒模型和 IE 盒模型。

## 标准盒模型

标准盒模型是有`width`、`height`、`margin`、`padding`、`border`计算的。

标准盒模型的内容高度为 content+padding+border。

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

## IE 盒模型

与标准盒模型不同的是，IE 盒模型的内容高度为 content+padding。不包含 border。

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

## box-sizing

`box-sizing`是一个属性，它指定了内容高度的计算方式。

- content-box: 内容高度为 content+padding+border。
- border-box: 内容高度为 content+padding。

总之，css 盒模型提供了一种灵活的方式来控制 HTML 元素的大小、位置和样式。通过设置内容区、内边距、边框和外边距的属性，我们可以实现各种布局效果，从而达到设计的要求。


css 显示的所有对象都是盒模型。因此，了解 css 方框模型的工作原理是 css 的核心基础。

css - 盒模型


边框（border）是 CSS 中一种用于围绕 HTML 元素的线条，用于美化和分隔元素的外观和布局。边框由三个部分组成：边框线、边框样式和边框颜色。

边框线（border-width）指定边框的宽度，可以使用像素、百分比、em、rem 等单位。边框线可以分别设置上下左右四个方向的宽度，也可以使用 border-width 属性同时设置四个方向的宽度。

边框样式（border-style）指定边框的样式，常见的样式包括实线（solid）、虚线（dashed）、点状线（dotted）、双线（double）等。边框样式也可以分别设置上下左右四个方向的样式，也可以使用 border-style 属性同时设置四个方向的样式。

边框颜色（border-color）指定边框的颜色，可以使用颜色名、RGB 值、十六进制值等方式指定。边框颜色也可以分别设置上下左右四个方向的颜色，也可以使用 border-color 属性同时设置四个方向的颜色。

CSS 还提供了 border-top、border-right、border-bottom 和 border-left 等属性来单独设置每个方向的边框样式、宽度和颜色。

除了这些基本属性，CSS 还提供了一些边框相关的高级属性，例如：

- border-radius：指定边框的圆角半径，可以将矩形边框变成圆形、椭圆形或者带有圆角的矩形。
- border-image：指定边框使用图片作为样式。
- border-collapse：指定表格边框的合并方式，有分隔（separate）和合并（collapse）两种方式。

边框是网页设计中重要的元素，通过合理地使用边框属性，可以实现各种复杂的界面布局和设计效果。

## 案例：

HTML 代码：

```html
<div class="container">
  <div class="box"></div>
  <div class="box"></div>
  <div class="box"></div>
  <div class="box"></div>
</div>
```

CSS 代码：

```css
.container {
  display: flex;
  justify-content: center;
  align-items: center;
  height: 400px;
}

.box {
  width: 100px;
  height: 100px;
  border: 2px solid #000;
  margin: 10px;
}
```

上面的代码实现了一个由四个边框组成的正方形布局。通过设置容器元素为 flex 布局，让四个正方形元素水平和垂直居中。然后给每个正方形元素添加 2px 的实线边框和 10px 的外边距，形成一个整齐的正方形布局。


css - borders


`Streams` 允许从源读取数据或写入数据到目标对象。在`Node.js`中有四种 stream

- `Writeable`：可写
- `Readable`：可读
- `Duplex`：双向，即可用于读写
- `Transform`：根据输入计算输出

每种类型的`stream`都是`EventEmitter`实例，在不同的实例抛出多个事件。常用的事件：

- `data`：当数据可读抛出
- `end`：当数据读取结束
- `error`：当数据读取错误
- `finish`：在调用 `stream.end()` 方法之后，并且所有数据都已刷新到底层系统

## 读取数据

```js
var fs = require('fs')
var data = ''

// Create a readable stream
var readerStream = fs.createReadStream('input.txt')

// Set the encoding to be utf8.
readerStream.setEncoding('UTF8')

// Handle stream events --> data, end, and error
readerStream.on('data', function (chunk) {
  data += chunk
})

readerStream.on('end', function () {
  console.log(data)
})

readerStream.on('error', function (err) {
  console.log(err.stack)
})

console.log('Program Ended') // Program Ended Tutorials Point is giving self learning content to teach the world in simple and easy way!!!!!
```

## 写入数据

```js
var fs = require('fs')
var data = 'Simply Easy Learning'

// Create a writable stream
var writerStream = fs.createWriteStream('output.txt')

// Write the data to stream with encoding to be utf8
writerStream.write(data, 'UTF8')

// Mark the end of file
writerStream.end()

// Handle stream events --> finish, and error
writerStream.on('finish', function () {
  console.log('Write completed.')
})

writerStream.on('error', function (err) {
  console.log(err.stack)
})

console.log('Program Ended')
```

## Pipe-管道流

`pipe`是一种机制，我们将一个`stream`的输出作为另一个`stream`的输入。它通常用于从一个`stream`中获取数据，并将该`stream`的输出传递给另一个`stream`。`pipe`操作没有限制。

```js
var fs = require('fs')

var readerStream = fs.createReadStream('input.txt')
var writerStream = fs.createWriteStream('output.txt')

readerStream.pipe(writerStream)

console.log('Program Ended')
```

## 链式流

`chaining`是一种将一个`stream`的输出连接到另一个`stream`并创建多个`stream`操作链的机制，它通常用于管道操作。

```js
var fs = require('fs')
var zlib = require('zlib')

// Compress the file input.txt to input.txt.gz
fs.createReadStream('input.txt')
  .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream('input.txt.gz'))

console.log('File Compressed.')
```


Streams允许从源读取数据或写入数据到目标对象。

Node.js - Streams


嵌套类型（nested types）指的是在一个类，结构体或枚举中定义的另一个类，结构体或枚举。嵌套类型可以在外部类型中使用，但也可以在内部类型的范围内使用。

Swift 中的嵌套类型具有以下特性：

- 嵌套类型可以在外部类型中使用，可以像外部类型的属性或方法一样使用嵌套类型。
- 嵌套类型可以访问外部类型的所有成员，包括私有成员。
- 嵌套类型可以继承自外部类型，也可以作为外部类型的类型成员。

使用嵌套类型可以使代码更加有组织性，也可以减少全局作用域中的名称冲突。

以下是嵌套类型示例：

```swift
struct Outer {
    var outerProperty: Int

    struct Inner {
        var innerProperty: String
    }

    func outerMethod() {
        let outerInner = Inner(innerProperty: "Inner property")
        print("outerMethod called with inner property: \(outerInner.innerProperty)")
    }
}

let outer = Outer(outerProperty: 10)
let outerInner = Outer.Inner(innerProperty: "Inner property")
outer.outerMethod()  // 输出 "outerMethod called with inner property: Inner property"
```

在上面的示例中，Outer 的内部有一个嵌套类型 Inner。Inner 中有一个成员 innerProperty。outerMethod 可以访问 Inner，并使用它创建一个实例，然后访问其成员。在外部类型中，我们可以像使用普通类型一样使用 Inner。

另外，嵌套类型还可以被用于支持泛型类型的实现。当你定义一个泛型类型时，你可以定义嵌套类型作为泛型类型的一部分，这有助于在更加抽象化的层次上组织和定义代码，从而使泛型类型更加通用化和模块化。

以下是一个嵌套类型用于支持泛型的示例：

```swift
struct Container<T> {
    var value: T

    struct Nested {
        var nestedValue: T
    }

    var nested: Nested {
        return Nested(nestedValue: value)
    }
}

let container = Container(value: 42)
let nested = container.nested // 生成一个 nestedValue 为 42 的 Container.Nested 实例
```

在这个示例中，嵌套类型 Nested 中的成员 nestedValue 的类型与容器的泛型类型参数 T 一样。实例化容器时，使用 42 初始化元素 value，然后访问其嵌套类型 Nested。内部类型 Nested 通过嵌套容器类型的泛型类型参数 T 来支持类型实例化。

总之，在 Swift 中，嵌套类型有助于组织和定义代码，减少名称冲突，提高代码可读性和可管理性，并支持泛型类型实现。


嵌套类型（nested types）指的是在一个类，结构体或枚举中定义的另一个类，结构体或枚举。嵌套类型可以在外部类型中使用，但也可以在内部类型的范围内使用。

Swift - 嵌套类型


## cli

`Next.js`提供了一个简单的命令行工具，可以帮助我们快速部署和管理应用。

```bash
npx next -h

#设置端口
npx next dev -p 4000 #开发模式
PORT=4000 npx next dev #开发模式

npx next start -p 4000 #生产模式
PORT=4000 next start #生产模式

next lint #检查代码规范

next build #构建静态资源
next export #导出静态资源
```

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

```bash
➜  demo npm run build

> demo@1.0.0 build
> next build

info  - Checking validity of types
warn  - No ESLint configuration detected. Run next lint to begin setup
info  - Creating an optimized production build
info  - Compiled successfully
info  - Collecting page data
info  - Generating static pages (3/3)
info  - Finalizing page optimization

Page                                       Size     First Load JS
┌ λ /                                      470 B          75.4 kB
├   /_app                                  0 B            74.9 kB
├ ○ /404                                   193 B          75.1 kB
├ λ /api                                   0 B            74.9 kB
└ ○ /posts/first                           2.75 kB        77.7 kB
    └ css/9871d7e98c5c71df.css             103 B
+ First Load JS shared by all              74.9 kB
  ├ chunks/framework-a87821de553db91d.js   45 kB
  ├ chunks/main-d8b1ff545a609496.js        28.6 kB
  ├ chunks/pages/_app-05a4472bc3e8727e.js  507 B
  ├ chunks/webpack-69bfa6990bb9e155.js     769 B
  └ css/5d2c4ba91281dd0f.css               175 B

λ  (Server)  server-side renders at runtime (uses getInitialProps or getServerSideProps)
○  (Static)  automatically rendered as static HTML (uses no initial props)
```

## deployment

通过`next build`构建静态资源，然后通过`next export`导出静态资源。

- `.next/static/chunks/pages`–此文件夹中的每个 JavaScript 文件都与具有相同名称的路由相关联。例如，.next/static/chunks/pages/about.js 将是在应用程序中查看/about 路由时加载的 JavaScript 文件
- `.next/static/media`–从 next/image 静态导入的图像在这里散列和复制
- `.next/static/css`–应用程序中所有页面的全局 CSS 文件
- `.next/server/pages`–从服务器预呈现的 HTML 和 JavaScript 入口点`.nft.json` 文件在启用输出文件跟踪时创建，并包含依赖于给定页面的所有文件路径。
- `.next/server/chunks`– 在整个应用程序的多个地方使用的共享 JavaScript 块
- `.next/cache`–从 Next.js 服务器输出构建缓存和缓存的图像、响应和页面。使用缓存有助于减少构建时间并提高加载图像的性能

部署方式

- Vercel
- netlify
- github pages
- firebase
- self-hosted
- node.js server
- docker

## SSG vs SSR

[SSG vs SSR](https://blog.logrocket.com/ssg-vs-ssr-in-next-js/)
