Swift 支持多种控制流语句，包括条件语句、循环语句和控制转移语句

Swift - 控制流


在 Swift 中，类型转换(Type Casting)指的是检查一个实例的类型，或将该实例视为其超类或子类之一的过程。

Swift 提供了两种类型转换方式：

- 通过类型检查来检查实例的类型是否与特定的类型相同（或是子类或父类）：使用 is 和 as 操作符来完成类型检查。

  - is 操作符用于检查一个实例是否属于某个特定类型或其子类。返回值为布尔类型。
  - as? 操作符用于尝试将实例转换为特定类型。如果转换成功，返回一个可选类型的实例，否则返回 nil。
  - as! 操作符强制将实例转换为特定类型。如果转换失败，会抛出一个运行时错误。

- 通过向下转换来将父类实例转换为其子类实例：使用 as? 或 as! 操作符完成向下转换。
  - as? 操作符尝试将父类实例转换为子类实例。如果转换成功，返回一个可选类型的子类实例，否则返回 nil。
  - as! 操作符强制将父类实例转换为子类实例。如果转换失败，会抛出一个运行时错误。

下面是一个示例代码：

```swift
class Animal {
  func makeSound() {
    print("I am an animal")
  }
}

class Dog: Animal {
  override func makeSound() {
    print("Woof!")
  }
}

let animal = Animal()
let dog = Dog()

// Type check
if dog is Animal {
  print("dog is an Animal")
}

// Downcasting
let maybeDog = animal as? Dog
if let dog = maybeDog {
  dog.makeSound()
} else {
  print("Not a dog")
}

// Forced downcasting
let definitelyDog = animal as! Dog // Runtime error!
```

在上面的代码中，我们创建了一个 Animal 类和一个继承自 Animal 的 Dog 类。使用 is 操作符检查 dog 实例是否是 Animal 类的子类，并使用 as? 操作符尝试将 Animal 实例转换为 Dog 实例。最后，使用 as! 操作符强制将 Animal 实例转换为 Dog 实例（如果尝试转换一个非 Dog 实例，则会引发运行时错误）


在Swift中，类型转换(Type Casting)指的是检查一个实例的类型，或将该实例视为其超类或子类之一的过程。。

Swift - 类型转换


## DNS

DNS 模块包含了域名解析的功能。

- `dns.getServers()` 返回一个数组，包含当前 DNS 服务器的 IP 地址。
- `dns.setServers(servers)` 设置 DNS 服务器的 IP 地址。
- `dns.lookup(domain, callback)` 查询域名的 IP 地址。
- `dns.lookupService(address, port, callback)` 查询 IP 地址和端口的服务名。
- `dns.resolve(domain, callback)` 查询域名的 IP 地址。
- `dns.resolve4(domain, callback)` 查询域名的 IPv4 地址。
- `dns.resolve6(domain, callback)` 查询域名的 IPv6 地址。
- `dns.resolveMx(domain, callback)` 查询域名的 MX 记录。
- `dns.resolveTxt(domain, callback)` 查询域名的 TXT 记录。
- `dns.resolveSrv(domain, callback)` 查询域名的 SRV 记录。
- `dns.resolveNs(domain, callback)` 查询域名的 NS 记录。
- `dns.resolveCname(domain, callback)` 查询域名的 CNAME 记录。
- `dns.reverse(domain, callback)` 查询 IP 地址的域名。

```js
const dns = require('dns')

dns.lookup('manon.icu', (err, address, family) => {
  console.log('ip 地址: %j 地址族: IPv%s', address, family)
})
```

## Net

模块提供了异步的网络 API，用于创建基于流的 `TCP` 或 `IPC` 服务器 `(net.createServer())` 和客户端

```js
const net = require('net')

const server = net
  .createServer((socket) => {
    socket.write('hello\r\n')
    socket.pipe(socket)
  })
  .on('error', (err) => {
    throw err
  })

server.listen(() => {
  const {port} = server.address()
  console.log('opened server on %j', port)
})
```


Node.js - DNS & Net


```bash
npm install @next/bundle-analyzer -D
```

修改`next.config.js`

```js
const withBundleAnalyzer = require('@next/bundle-analyzer')({
  enabled: process.env.ANALYZE === 'true'
})

module.exports = withBundleAnalyzer({
  //...other config
})
```

```bash
ANALYZE=true npm run build
```

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

修改`package.json`

```json
{
  "scripts": {
    "analyze": "ANALYZE=true next build"
  }
}
```

`npm run analyze`


Next.js - Integrate Bundle Analyzer


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


## Tutorials

- [Install](/blog/nodejs/01-install)
- [First Program](/blog/nodejs/02-first-program)
- [NPM & CLI](/blog/nodejs/03-npm&cli)
- [Globals](/blog/nodejs/04-globals)
- [OS](/blog/nodejs/05-os)
- [Error](/blog/nodejs/06-error)
- [DNS & NET](/blog/nodejs/07-dns&net)
- [Crypto](/blog/nodejs/08-crypto)
- [TSL & SSL & DEBUGGER](/blog/nodejs/09-tsl&ssl&debugger)
- [Process](/blog/nodejs/10-process)
- [Child Process](/blog/nodejs/11-child_process)
- [Buffers](/blog/nodejs/12-buffers)
- [Streams](/blog/nodejs/13-Streams)
- [File System](/blog/nodejs/14-File%20System)
- [Path](/blog/nodejs/15-Path)
- [StringDecoder](/blog/nodejs/16-StringDecoder)
- [Query String](/blog/nodejs/17-Query%20String)
- [zlib](/blog/nodejs/18-zlib)
- [Assertion](/blog/nodejs/19-Assertion)
- [V8](/blog/nodejs/20-V8)
- [Callbacks](/blog/nodejs/21-Callbacks)
- [Events](/blog/nodejs/22-Events)

## Node.js 技术栈学习指南路线图

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


Learning Node.js


> 作用域是管理变量可用性的一个重要概念。作用域在基本闭包处，定义了全局变量和局部变量的概念。

## 作用域 - The Scope

在深入理解作用域之前，先通过一个简单的例子看看是如何工作的。

```js
const message = 'hello'
console.log(message) // hello
```

你可以轻松访问`message`变量。

如果将`message`变量放在`if`语句内，比如：

```js
if (true) {
  const message = 'hello'
}
console.log(message) // ReferenceError: message is not defined
```

为什么？

`if` 代码块为消息变量创建一个作用域，而消息变量只能在这个作用域内访问。

![The Scope](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/7EzPUL.jpg)

在更高的级别上，变量的可访问性受到它们被创建的作用域的限制。您可以自由访问在其作用域内定义的变量。但是在它的作用域之外，变量是不可访问的。

## 块级作用域 - Block Scope

```js
if (true) {
  // if 块级作用域
  const message = 'hello'
  console.log(message) // hello
}
console.log(message) // ReferenceError: message is not defined
```

第一个`console.log`输出`hello`，因为`message`变量在`if`块级作用域内。

第二个`console.log`输出`ReferenceError: message is not defined`，因为`message`变量在`if`块级作用域之外。

`if`、`for`、`while`、`do`、`switch`、`with`、`function` 以及`catch`创建块级作用域。比如：

```js
for (const color of ['green', 'red', 'blue']) {
  // "for" block scope
  const message = 'Hi';
  console.log(color);   // 'green', 'red', 'blue'
  console.log(message); // 'Hi', 'Hi', 'Hi'
}
console.log(color);   // throws ReferenceError
console.log(message); // throws ReferenceError

while (/* condition */) {
  // "while" block scope
  const message = 'Hi';
  console.log(message); // 'Hi'
}
console.log(message); // => throws ReferenceError
```

### `var` 不是块级作用域

`var` 关键字不是块级作用域。比如：

```js
if (true) {
  // "if" block scope
  var count = 0
  console.log(count) // 0
}
console.log(count) // 0
```

使用`var`定义的变量，会产生变量提升，即变量会在它们被访问之前被创建。在除`function`外的所有块级作用域中，`var` 关键字都是不可访问的。

## 函数作用域 - Function Scope

```js
function run() {
  // "run" function scope
  var message = 'Run Forrest, run!'
  console.log(message) // Run Forrest, run!
}
run()
console.log(message) // ReferenceError: message is not defined
```

`run()`函数定义了一个块级作用域，它包含了`message`变量，`message`变量可以在`run()`函数内访问，但是不能在`run()`函数之外访问。

同样`let`和`const`也是块级作用域。可以在`run()`函数内访问， 但是不能在`run()`函数之外访问。

```js
function run() {
  // "run" function scope
  const two = 2
  let count = 0
  function run2() {}
  console.log(two) // 2
  console.log(count) // 0
  console.log(run2) // function
}
run()
console.log(two) // throws ReferenceError
console.log(count) // throws ReferenceError
console.log(run2) // throws ReferenceError
```

## 模块作用域 - Module Scope

ES2015 同样支持模块作用域。模块作用域是一个特殊的块级作用域，它可以在模块内部访问，但是不能在模块之外访问。

```js
// circle.js
const PI = 3.14
console.log(pi) // 3.14
```

`circle.js`模块定义了一个块级作用域，它包含了`PI`变量。但是未导出`PI`变量，因此不能在模块之外访问。

```js
import './circle'
consoel.log(pi) // throws ReferenceError
```

## 嵌套作用域 - Scopes can be nested

作用域可以嵌套。比如：

```js
function run() {
  // "run" function scope
  const message = 'Run, Forrest, Run!'
  if (true) {
    // "if" code block scope
    const friend = 'Bubba'
    console.log(message) // 'Run, Forrest, Run!'
  }
  console.log(friend) // throws ReferenceError
}
run()
```

`if`代码块作用域嵌套在`run()`函数作用域内。`if`代码块作用域内部可以访问`message`变量，但是不能`if`外部访问`friend`变量。

![Scopes can be nested](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/yE2fSE.jpg)

## 全局作用域 - Global Scope

全局作用域是一个特殊的作用域，它可以在整个程序的所有位置访问。`<script>`标签内的代码块是全局作用域。

```js
;<script src="myScript.js"></script>

// myScript.js
// 全局作用域
let counter = 1
```

在前面的代码片段中，`counter` 是一个全局变量。这个变量可以从网页的 JavaScript 的任何地方访问。

全局作用域是一种机制，它允许 JavaScript 的主机(浏览器、节点)为应用程序提供特定于主机的函数作为全局变量。

例如，`window` 和 `document` 是浏览器提供的全局变量。在 `Node` 环境中，可以将进程对象作为全局变量访问。

## 词法作用域 - Lexical Scope

定义两个函数，将函数`innerFunc`嵌套在函数`outerFunc`内部。

```js
function outerFunc() {
  // the outer scope
  let outerVar = 'I am from outside!'
  function innerFunc() {
    // the inner scope
    console.log(outerVar) // 'I am from outside!'
  }
  return innerFunc
}
const inner = outerFunc()
inner()
```

`inner()`函数执行时，`innerFunc()`函数定义了一个块级作用域，它包含了`outerVar`变量。

实际上是执行了`outerFunc`函数内的`innerFunc()`函数。`outerFunc`函数返回函数，形成了一个闭包。

所以`outerFunc`外部可以访问`innerFunc()`内部的`outerVar`变量。

## 变量隔离 - Variables isolation

您可以在不同的作用域中重用公共变量名(`count`、`index`、`current`、`value`、etc) ，而不会发生冲突。

`foo()`和`bar()`函数作用域有它们自己的。

```js
function foo() {
  // "foo" function scope
  let count = 0
  console.log(count) // 0
}
function bar() {
  // "bar" function scope
  let count = 1
  console.log(count) // 1
}
foo()
bar()
```
