buffer是Node.js提供用来存放二进制数据的缓存区

Node.js - Buffers


## 前置

[【上一篇】](/blog/javascript/nextjs/tips/add-theme-mode-switch-to-blog)完成了使用 Next.js 构建 blog 并添加了主题切换功能。

好的 SEO 将有助于提高网站权重，带来更多流量。作为前端工程师的我们，就有着得天独厚的优势，我们不需要做到优化工程师的级别，我们只需要做好几个方面，就能完成一个网站 80%左右的 SEO 优化工作了～因为我研究下来发现 SEO 针对点大部分都是前端基础～

## 创建组件

创建`components/SEO/index.tsx`

```tsx
import {NextSeo} from 'next-seo'

export default function SEO(props) {
  const {url, cover, description, title} = props
  return (
    <NextSeo
      titleTemplate="%s - Manon.icu"
      openGraph={{
        type: 'website',
        url,
        description:
          description ??
          'The personal website for Manon, Frontend Web Developer.',
        site_name: title ?? 'Manon | manon.icu',
        images: [
          {
            url: cover ?? 'https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/9oh25b.jpg',
            width: 900,
            height: 900
          }
        ]
      }}
      canonical={url}
      twitter={{
        handle: '@Manonicu',
        cardType: 'summary_large_image'
      }}
    />
  )
}
```

修改`pages/_app.tsx`，引入`components/SEO/index.tsx`，在`Head`下添加 SEO 组件，组件加上 props`url`

在 blog 内页同样引入，分别传入`title`、`description`、`cover`

```tsx
// pages/[...slug].tsx
// <SEO
//   title={title}
//   description={description}
//   cover={cover}
//   openGraph={{title, description}}
// />
```

[Source Code](https://github.com/Manonicu/blog-demo/tree/feat-seo)


从性能、打包大小、SEO来看，Next.js可能是最适合写blog的React框架。

Next.js - Add Next-seo


`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


## 简介

Docker 是一个开源的应用容器引擎，基于 Go 语言 并遵从 Apache2.0 协议开源。

Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。

容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低。

## 应用场景

- Web 应用的自动化打包和发布。
- 自动化测试和持续集成、发布。
- 在服务型环境中部署和调整数据库或其他的后台应用。
- 从头编译或者扩展现有的 OpenShift 或 Cloud Foundry 平台来搭建自己的 PaaS 环境。

## 优点

- 快速，一致地交付您的应用程序
- 响应式部署和扩展
- 在同一硬件上运行更多工作负载

## 目录

- [x] [Docker 镜像](./Docker镜像)
- [x] [Docker 容器](./Docker容器)
- [x] [Dockerfiles](./Dockerfiles)
- [x] [Docker 更新容器](./Docker更新容器)
- [x] [Docker 更新镜像](./Docker更新镜像)
- [ ] [How to access files outside a Docker image]()
- [ ] [Sharing Docker Images on Docker Hub]()
- [ ] [Working with Docker Images from the command line]()
- [ ] [Working with Docker Containers from the command line]()
- [ ] [What to do if a Docker container immediately exits]()
- [ ] [Create a simple Node.js Hello World Docker Container from scratch]()
- [ ] [Using Docker Desktop to manage a Container]()
- [ ] [First steps with Docker after the installation]()
- [x] [Macos 安装 Docker](./Macos安装Docker)


Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。

Docker入门


## 运行 python

> Python 程序总是在解释器中运行。解释器是一个“基于控制台的”应用程序，通常使用命令运行。

```python
python3
Python 3.9.8 (main, Nov 10 2021, 03:55:42)
[Clang 13.0.0 (clang-1300.0.29.3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>
```

## 交互模式

当在终端运行`python3`后，就进入了交互模式，即 REPL。

- `>>>`表示开始新的语句
- `...`表示继续上一条语句
- `_`表示最后的返回值

```python
>>> print('hello world')
hello world
>>> 37*42
1554
>>> for i in range(5):
...     print(i)
...
0
1
2
3
4
>>>
```

## 创建程序

> python 程序以`.py`结尾，可以直接运行。

```python
# hello.py
print('hello world')
```

## 运行程序

> python 程序运行的命令是`python hello.py`

```python
$ python hello.py
$ python3 hello.py
```

## 样例程序

> 问题：一天早上，你出去，在芝加哥西尔斯大厦旁的人行道上放了一张美元钞票。从那以后，你每天出去的账单都会翻倍。这堆钞票超过塔的高度需要多长时间？

解决方法：

```python
# sears.py
bill_thickness = 0.11 * 0.001 # Meters (0.11 mm)
sears_height = 442 # Height (meters)
num_bills = 1
day = 1

while num_bills * bill_thickness < sears_height:
    print(day, num_bills, num_bills * bill_thickness)
    day = day + 1
    num_bills = num_bills * 2

print('Number of days', day)
print('Number of bills', num_bills)
print('Final height', num_bills * bill_thickness)
```

```bash
bash % python3 sears.py
1 1 0.00011
2 2 0.00022
3 4 0.00044
4 8 0.00088
5 16 0.00176
6 32 0.00352
...
21 1048576 115.34336
22 2097152 230.68672
Number of days 23
Number of bills 4194304
Final height 461.37344
```

### 语句

> 每行语句以换行符结束，但是不能以分号结束。

```python
a = 3 + 4
b = a * 2
print(b)
```

### 注释 comment

> 注释以#开始，不会被运行。

```python
a = 3 + 4
# This is a comment
b = a * 2
print(b)
```

### 类型与变量 type&variable

> python 属于动态类型语言，变量可以随时变化。python 变量名称可以包含字母、数字、下划线，但不能以数字或关键字开头。对大小写敏感。

```python
height = 442           # An integer
height = 442.0         # Floating point
height = 'Really tall' # A string

# 大小写敏感
name = 'Jake'
Name = 'Elwood'
NAME = 'Guido'

while x < 0:   # OK
WHILE x < 0:   # ERROR
```

### 循环 for/while

```python
while num_bills * bill_thickness < sears_height:
    print(day, num_bills, num_bills * bill_thickness)
    day = day + 1
    num_bills = num_bills * 2

print('Number of days', day)
```

### 缩进 indentation

> 缩进是用来表示一组连在一起的语句:

```python
while num_bills * bill_thickness < sears_height:
    print(day, num_bills, num_bills * bill_thickness)
    day = day + 1
    num_bills = num_bills * 2

print('Number of days', day)
```

- 使用空格代替 tab 来缩进
- 使用 4 个空格来缩进

### 条件语句 if-else

```python
if a > b:
    print('Computer says no')
elif a == b:
    print('Computer says yes')
else:
    print('Computer says maybe')
```

### 输出语句 print

```python
print('Hello world!') # Prints the text 'Hello world!'

#用户输出
name = input('Enter your name:')
print('Your name is', name)
```


First Program - 第一个程序


## 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/)


Next.js - CLI & Deployment


Swift 是一种适用于 iOS、macOS、watchOS 和 Apple tvOS app 开发的新编程语言。尽管如此，Swift的许多部分将从您在C和Objective-C中开发的经验中熟悉。

Swift提供所有基本C和Objective-C类型的版本，包括用于整数的Int、用于浮点值的Double和Float、用于布尔值的Bool和用于文本数据的String。Swift还提供了三种主要集合类型的强大版本，例如Array、Set和Dictionary，如Collection Types中所述。

与C一样，Swift使用变量通过标识名称存储和引用值。Swift还广泛使用其值无法更改的变量。这些被称为常数，比C中的常数强大得多。当您处理不需要更改的值时，整个Swift都使用常量，以使代码的意图更安全、更清晰。

除了熟悉的类型外，Swift还引入了Objective-C中没有的高级类型，例如元组。元组使您能够创建和传递值分组。您可以使用元组将函数中的多个值作为单个复合值返回。

Swift还引入了可选类型，用于处理缺少值的情况。可选的说“有一个值，它等于x”或“根本没有值”。使用可选选项类似于在Objective-C中使用带有指针的nil，但它们适用于任何类型，而不仅仅是类。可选选项不仅比Objective-C中的nil指针更安全、更具表现力，而且是Swift许多最强大功能的核心。

Swift是一种类型安全的语言，这意味着该语言可以帮助您清楚地了解代码可以使用的值类型。如果您的部分代码需要String，类型安全性会阻止您错误地将其传递给Int。同样，类型安全可防止您意外地将可选String传递给需要非可选String的代码。类型安全可帮助您尽早在开发过程中捕获和修复错误。

## 常量和变量

常量和变量将值分配给特定的标识符，以便您可以在代码中引用它们。常量的值一旦设置就无法更改，而变量的值可以更改。

### 声明常量和变量

您可以使用let关键字声明常量，使用var关键字声明变量。常量和变量的名称可以包含任何字符，包括Unicode字符：

```swift
let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0
```

常量和变量的名称不能包含空格、数学符号、箭头、保留的（或者非法的）Unicode代码点、连线和制表符。也不能以数字开头，但可以在名称的其他地方包含数字。

打印常量和变量的值：

```swift
print(maximumNumberOfLoginAttempts)
print(currentLoginAttempt)
```

使用反斜杠（\）将常量和变量的名称放在括号中，以在字符串插值中包含它们的当前值：

```swift
print("Maximum number of login attempts is \(maximumNumberOfLoginAttempts)")
```

### 类型标注

您可以在声明常量或变量时提供类型标注（type annotation），以明确常量或变量可以存储的值的类型。在类型标注后面加上一个冒号和空格，然后加上类型名称，以指定常量或变量可以存储的值的类型：

```swift
var welcomeMessage: String
```

类型标注是一种为常量或变量提供关于其允许存储的值类型的方法。它不会为常量或变量的值分配任何实际的值；它只是说明了常量或变量可以存储的值的类型。如果您在声明常量或变量时提供了类型标注，您可以在该常量或变量的赋值语句中省略对其类型的说明。类型标注的使用可以使您的代码更具可读性，因为它允许您立即知道常量或变量可以存储的值的类型。

## 注释

您可以使用单行注释（single-line comments）将注释嵌入到代码中。单行注释以两个正斜杠（//）开头：

```swift
// This is a comment
```

您可以使用多行注释（multi-line comments）将注释嵌入到代码中。多行注释以正斜杠后跟星号（/*）开头，以星号后跟正斜杠（*/）结尾：

```swift
/* This is also a comment
but is written over multiple lines. */
```

## 分号

Swift不要求您在每个语句结尾处使用分号（;），但是您可以使用分号将多个独立的语句写在同一行上：

```swift
let cat = "🐱"; print(cat)
```

## 整数

整数是没有小数部分的数字，例如42和-23。Swift提供了8、16、32和64位有符号和无符号整数类型。这些整数类型的名称与它们的位数相同，例如UInt8表示8位无符号整数，Int32表示32位有符号整数。

整数范围：

```swift
let minValue = UInt8.min
let maxValue = UInt8.max
```

## 浮点数

浮点数是有小数部分的数字，例如3.14159、0.1和-273.15。Swift提供了两种有符号的浮点数类型：

- Double表示64位浮点数。
- Float表示32位浮点数。

如果您需要在您的代码中选择浮点数类型，推荐使用Double类型，除非你特别需要它的性能。

## 类型安全和类型推断

Swift是一种类型安全（type-safe）语言。类型安全语言可以让您清楚地知道代码可以处理的值的类型。如果部分代码期望得到String，您就不能传递一个Int来代替。

Swift通过类型推断（type inference）来选择合适的类型。如果您没有明确指定类型，Swift使用类型推断来选择合适的类型。例如，如果您给一个新的浮点值赋值，Swift会推断您想要创建一个Double而不是Float：

```swift
let meaningOfLife = 42
// meaningOfLife is inferred to be of type Int
let pi = 3.14159
// pi is inferred to be of type Double
```

如果您在一行中声明多个同类型的值，您可以在一行中写出所有值，用逗号隔开，Swift会自动推断出这些值的类型：

```swift
let x = 0.0, y = 0.0, z = 0.0
```

## 数值型字面量

整数字面量可以被写作：

- 一个十进制数，没有前缀
- 一个二进制数，前缀是0b
- 一个八进制数，前缀是0o
- 一个十六进制数，前缀是0x

十进制数的例子：

```swift
let decimalInteger = 17
let binaryInteger = 0b10001       // 17 in binary notation
let octalInteger = 0o21           // 17 in octal notation
let hexadecimalInteger = 0x11     // 17 in hexadecimal notation
```

浮点字面量可以是十进制（没有前缀），或者是十六进制（前缀是0x）。十进制浮点字面量还可以有一个可选的指数（exponent），通过大写或小写的e来指定。十六进制浮点字面量必须有一个指数；指数通过大写或小写的p来指定。十进制浮点字面量的例子：

```swift
let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0
```

## 数值型类型转换

整数和浮点数类型转换必须显式指定类型：

```swift
let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
let twoThousandAndOne = twoThousand + UInt16(one)
// twoThousandAndOne is equal to 2001
```

## 类型别名

类型别名（type aliases）就是给现有类型定义另一个名字。你可以使用typealias关键字来定义类型别名。

```swift
typealias AudioSample = UInt16
var maxAmplitudeFound = AudioSample.min
// maxAmplitudeFound is now 0
```

## 布尔值

Swift有一个基本的布尔（Boolean）类型，叫做Bool。布尔值指逻辑上的值，因为它们只能是真或者假。Swift提供两个布尔常量，true和false：

```swift
let orangesAreOrange = true
let turnipsAreDelicious = false
```

## 元组

元组（tuples）把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型。

```swift
let http404Error = (404, "Not Found")
// http404Error is of type (Int, String), and equals (404, "Not Found")
```

元组的内容可以分解（decompose）成单独的常量和变量，然后你就可以正常使用它们了：

```swift
let (statusCode, statusMessage) = http404Error
print("The status code is \(statusCode)")
// Prints "The status code is 404"
print("The status message is \(statusMessage)")
// Prints "The status message is Not Found"
```

如果你只需要一部分元组值，分解的时候可以把要忽略的部分用下划线（_）标记：

```swift
let (justTheStatusCode, _) = http404Error
print("The status code is \(justTheStatusCode)")
// Prints "The status code is 404"
```

你也可以通过下标来访问元组中的单个元素，下标从零开始：

```swift
print("The status code is \(http404Error.0)")
// Prints "The status code is 404"
print("The status message is \(http404Error.1)")
// Prints "The status message is Not Found"
```

你可以在定义元组的时候给单个元素命名：

```swift
let http200Status = (statusCode: 200, description: "OK")
```

这个元组的名字叫做http200Status，它的类型是(Int, String)。你可以通过名字来获取元素的值：

```swift
print("The status code is \(http200Status.statusCode)")
// Prints "The status code is 200"
print("The status message is \(http200Status.description)")
// Prints "The status message is OK"
```

## 可选类型

Swift的可选类型（optional types）表示：

* 这个值可能有值，等于x
* 这个值可能没有值

可选类型有点像Objective-C中的nil指针，但是它们可以用于任何类型，不仅仅是类。可选类型表示的是值缺失，而不是值为nil。这样的设计可以让你避免在你的代码中使用nil值。


## 可选绑定

可选绑定（optional binding）用来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或变量。可选绑定可以用在if和while语句中来对可选类型的值进行判断并把值赋给一个常量或变量。

```swift
if let constantName = someOptional {
    statements
}
```

## 隐式解析可选类型

有时候在变量的生命周期中，会确定一个可选类型变量总会有值。在这种情况下，每次都需要判断和解析可选值是非常麻烦的。这时候可以选择隐式解析可选类型（implicitly unwrapped optionals）。

```swift
let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // requires an exclamation point

let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString // no need for an exclamation point
```

## 错误处理

Swift提供了一种在运行时表示和抛出错误的机制。这个机制让你能够表示和抛出你自己的错误，并且把函数抛出的错误传递到程序的某个地方。

```swift
enum VendingMachineError: ErrorType {
    case InvalidSelection
    case InsufficientFunds(coinsNeeded: Int)
    case OutOfStock
}

throw VendingMachineError.InsufficientFunds(coinsNeeded: 5)
```

## 断言和先决条件

断言和先决条件用来检查在运行时一个必要的条件是否为真。如果条件判断的结果为true，代码继续运行。如果条件判断的结果为false，代码执行结束，你的应用被终止。

```swift
let age = -3
assert(age >= 0, "A person's age cannot be less than zero")
// This assertion fails because -3 is not >= 0.

if age > 10 {
    print("You can ride the roller-coaster or the ferris wheel.")
} else if age >= 0 {
    print("You can ride the ferris wheel.")
} else {
    assertionFailure("A person's age can't be less than zero.")
}
// Prints "You can ride the ferris wheel."
```




Swift是一种适用于iOS、macOS、watchOS和tvOS应用程序的编程语言。