Node.js - Crypto


在 Next.js 中，可以创建动态路由。比如：

- `[id].js`，表示 id 为相对路径的动态页面
- `lib/posts.js`，表示在 lib 目录下的 post 页面

创建`[id].js`

```jsx
import Link from 'next/link'
import Head from 'next/head'
import Container from '../../components/container'

import {getAllPostIds, getPostData} from '../../lib/posts'

export default function Post({postData}) {
  return (
    <Container>
      {postData.id}
      <br />
      {postData.title}
      <br />
      {postData.date}
    </Container>
  )
}
export async function getStaticPaths() {
  const paths = getAllPostIds()
  return {
    paths,
    fallback: false
  }
}

export async function getStaticProps({params}) {
  const postData = getPostData(params.id)
  return {
    props: {
      postData
    }
  }
}
```

创建`lib/posts.js`

```jsx
export function getPostData(id) {
  const postOne = {
    title: 'One',
    id: 1,
    date: '7/12/2020'
  }

  const postTwo = {
    title: 'Two',
    id: 2,
    date: '7/12/2020'
  }
  if (id == 'one') {
    return postOne
  } else if (id == 'two') {
    return postTwo
  }
}

export function getAllPostIds() {
  return [
    {
      params: {
        id: 'one'
      }
    },
    {
      params: {
        id: 'two'
      }
    }
  ]
}
```

启动服务

```bash
npm run dev
```

验证结果

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


在 Next.js 中，可以创建动态路由

Next.js - Dynamic API Routes


扩展（Extensions）是 Swift 中一种强大的特性，它允许我们向现有类型添加新的功能，包括方法、计算属性和下标等，而不需要修改原始类型的声明。

在 Swift 中，我们可以使用扩展来完成以下任务：

- 添加计算属性、存储属性、方法、下标和构造器等功能
- 定义协议的默认实现
- 整合协议的实现
- 分解类型实现

使用扩展可以使代码更加模块化，易于维护和扩展。以下是一个示例：

```swift
// 当前版本的 Swift 中，所有基本类型都是结构体

// 添加一个名为 squared 的计算属性来计算整数的平方，返回一个新的整数
extension Int {
    var squared: Int {
        return self * self
    }
    // 添加一个 mutating 方法来计算自身平方
    mutating func square() {
        self = self.squared
    }
}
// 对于给定的整数，可以使用点语法来访问 squared 属性和 square() 方法
let x = 5
print(x.squared) // 输出 "25"

var y = 7
y.square()
print(y) // 输出 "49"
```

在上面的示例中，我们向 Swift 中的 Int 类型添加了一个扩展。扩展中包含一个计算属性 squared 和一个 mutating 方法 square，用于计算整数的平方。可以通过使用点语法访问 squared 和调用 square() 方法在 Int 类型的所有实例中使用这些功能。

需要注意的是，扩展不能添加存储属性或添加必须由结构体或类定义的初始化器。此外，扩展也不能覆盖现有的方法或属性。除此之外，使用扩展的过程与定义原始类型的方法相同，因此扩展的函数和方法可以在同一文件中定义，并像原始代码一样被编译和执行。

总之，使用扩展的代码可以增强 Swift 中类型的灵活性和可读性，从而使代码更加模块化和高效，减少命名冲突和重复代码的出现。


扩展（Extensions）是 Swift 中一种强大的特性，它允许我们向现有类型添加新的功能，包括方法、计算属性和下标等，而不需要修改原始类型的声明。

Swift - 扩展


`string_decoder`用于把 Buffer 转换为字符串

## 基本用法

```js
const {StringDecoder} = require('string_decoder')
const decoder = new StringDecoder('utf8')
const buffer = Buffer.from('Hello World')
const str = decoder.write(buffer)
console.log(str)
```

## 方法

- stringDecoder.write(buffer[, encoding])
- stringDecoder.end(buffer[, encoding])

`write`方法把 buffer 转换为字符串，`end`方法把 buffer 转换为字符串并返回。

```js
const {StringDecoder} = require('string_decoder')
const decoder = new StringDecoder('utf8')

decoder.write(Buffer.from([0xe2]))
decoder.write(Buffer.from([0x82]))
console.log(decoder.end(Buffer.from([0xac])))
```


string_decoder用于把Buffer转换为字符串

Node.js - StringDecoder


ES6（ECMAScript 2015）引入了解构赋值（Destructuring Assignment）语法，它是一种方便地从数组或对象中提取值并赋给变量的方式。解构赋值可以简化代码，使得操作数据更加灵活和可读。

解构赋值可以用于数组和对象，下面分别解释它们的用法：

## 数组解构赋值：

数组解构赋值允许我们通过模式匹配的方式从数组中提取值并赋给变量。

示例：

```javascript
const numbers = [1, 2, 3, 4, 5]

// 通过解构赋值提取数组中的值
const [a, b, c, d, e] = numbers

console.log(a) // 输出: 1
console.log(b) // 输出: 2
console.log(c) // 输出: 3
console.log(d) // 输出: 4
console.log(e) // 输出: 5
```

在上述示例中，我们使用解构赋值从数组 `numbers` 中提取了每个元素的值，并将它们分别赋给变量 `a`、`b`、`c`、`d` 和 `e`。

解构赋值还可以使用默认值，以防提取的值为 `undefined`：

示例：

```javascript
const numbers = [1, 2]

const [a, b, c = 3] = numbers

console.log(a) // 输出: 1
console.log(b) // 输出: 2
console.log(c) // 输出: 3
```

在上述示例中，数组 `numbers` 只有两个元素，但我们通过解构赋值提取了三个变量。由于第三个元素不存在，变量 `c` 使用了默认值 `3`。

## 对象解构赋值：

对象解构赋值允许我们通过模式匹配的方式从对象中提取值并赋给变量。

示例：

```javascript
const person = {
  name: 'John',
  age: 30,
  address: '123 Main St'
}

// 通过解构赋值提取对象中的值
const {name, age, address} = person

console.log(name) // 输出: 'John'
console.log(age) // 输出: 30
console.log(address) // 输出: '123 Main St'
```

在上述示例中，我们使用解构赋值从对象 `person` 中提取了每个属性的值，并将它们赋给了同名的变量。

对象解构赋值也可以使用默认值：

示例：

```javascript
const person = {
  name: 'John',
  age: 30
}

const {name, age, address = 'Unknown'} = person

console.log(name) // 输出: 'John'
console.log(age) // 输出: 30
console.log(address) // 输出: 'Unknown'
```

在上述示例中，对象 `person` 中没有 `address` 属性，但我们通过解构赋值为变量 `address` 设置了默认值 `'Unknown'`。

解构赋值还可以嵌套使用，同时可以结合数组和对象的解构赋值。它还支持使用剩余运算符（Rest Operator）来获取剩余的数组元素或对象属性。

总结起来，ES6 的解构赋值语法提供了一种简洁而强大的方式来从数组和对象中提取值并赋给变量。它使得代码更加简洁可读，并且可以结合默认值、嵌套和剩余运算符等功能实现更复杂的数据操作。


ES6 - 解构赋值


**mkdir**命令用于创建目录，如果在目录名的前面没有加任何路径名，则在当前目录下创建由 dirname 指定的目录；如果给出了一个已经存在的路径，将会在该目录下创建一个指定的目录。在创建目录时，应保证新建的目录与它所在目录下的文件没有重名。

## 使用方法

```bash
#创建单个文件
mkdir folder

#创建多个文件
mkdir folder1 folder2

#使用-p参数创建文件夹，如果不存在即创建，如果不加-p，而且folder不存在，将会报错
mkdir -p folder/data
```


用于显示目前在 Linux 系统上的文件系统磁盘使用情况统计

Linux命令mkdir


Swift 中的错误处理是一种机制，用于在程序执行期间检测和处理错误。错误是指在程序执行期间发生的意外事件，例如网络连接中断、文件未找到等等。Swift 使用 try，catch 和 throw 语句来支持错误处理。

当一个函数可能会抛出错误时，需要在函数的定义中使用 throws 关键字来表示这一点。这告诉调用者，调用该函数可能会导致一个错误，并且必须用 try 语句调用该函数。

## 抛出错误

在 Swift 中，抛出错误使用 throw 关键字。如果一个函数、方法或初始化器可能出现错误，需要在声明中使用 throws 关键字来标识。例如：

```swift
enum MyError: Error {
  case invalidValue
}

func divide(_ x: Int, by y: Int) throws -> Int {
  if y == 0 {
    throw MyError.invalidValue
  }
  return x / y
}
```

在上述示例中，divide(\_:by:) 函数可能会抛出一个 MyError.invalidValue 类型的错误。

## 处理错误

当一个函数、方法或初始化器可能抛出错误时，调用者必须使用 try 关键字来调用该函数，否则会编译错误。例如：

```swift
do {
let result = try divide(10, by: 2)
  print(result)
} catch {
  print(error)
}
```

在上述示例中，使用 try 关键字调用了 divide(\_:by:) 函数，并使用 do-catch 语句捕获可能抛出的错误。如果函数调用成功，result 的值将被打印，否则将打印错误信息。

当调用一个可能抛出错误的函数时，可以使用多种方式来处理错误。例如，可以使用 do-catch 语句捕获错误、使用 try? 关键字将错误转换为可选值，或使用 try! 关键字表示该函数不会抛出错误。例如：

```swift
// 使用 try? 关键字将错误转换为可选值
let result1 = try? divide(10, by: 0)
print(result1)

// 使用 try! 关键字表示该函数不会抛出错误
let result2 = try! divide(10, by: 2)
print(result2)
```

在上述示例中，try? 关键字将错误转换为可选值，如果函数调用成功，则返回结果，否则返回 nil。try! 关键字表示该函数不会抛出错误，如果函数调用失败，程序将崩溃。

自定义错误类型
在 Swift 中，可以自定义错误类型来表示具体的错误信息。自定义的错误类型需要实现 Error 协议。例如：

```swift
enum MyError: Error {
  case invalidValue
  case networkError(String)
  case fileError(String, Int)
}
```

在上述示例中，定义了一个 MyError 类型，包含了三种错误情况：invalidValue 表示无效的数值，networkError 表示网络错误，fileError 表示文件错误，并且每种错误情况都包含了不同的错误信息。

例如，以下是一个可能会抛出错误的函数：

```swift
Copy code
func divide(_ dividend: Int, by divisor: Int) throws -> Int {
guard divisor != 0 else {
throw NSError(domain: "com.example", code: 0, userInfo: [
NSLocalizedDescriptionKey: "Cannot divide by zero"
])
}

    return dividend / divisor
}
```

在这个函数中，如果除数为零，就会抛出一个错误。我们可以使用 do 和 catch 语句来捕获和处理错误：

```swift
do {
  let result = try divide(10, by: 2)
  print(result) // Output: 5
} catch {
  print("Error: \(error)") // Output: Error: Cannot divide by zero
}
```

在上面的代码中，我们将 divide 函数的返回值存储在 result 变量中。如果 divide 函数抛出一个错误，那么程序将跳转到 catch 块，并打印错误信息。

除了使用 do 和 catch 语句来处理错误之外，还可以使用 try?和 try!语句来简化错误处理过程。try?语句将函数的返回值转换为一个可选类型，如果函数抛出错误，则返回 nil。try!语句则在函数抛出错误时直接崩溃程序。建议使用 try?和 try!语句的场景非常有限，因为它们会让程序在运行时变得不可预测。例如，以下是一个可能会抛出错误的函数：

```swift
func divide(_ dividend: Int, by divisor: Int) throws -> Int {
  guard divisor != 0 else {
    throw NSError(domain: "com.example", code: 0, userInfo: [
    NSLocalizedDescriptionKey: "Cannot divide by zero"
  ])
}

    return dividend / divisor
}
```

在这个函数中，如果除数为零，就会抛出一个错误。我们可以使用 do 和 catch 语句来捕获和处理错误：

```swift
do {
  let result = try divide(10, by: 2)
  print(result) // Output: 5
} catch {
  print("Error: \(error)") // Output: Error: Cannot divide by zero
}
```

在上面的代码中，我们将 divide 函数的返回值存储在 result 变量中。如果 divide 函数抛出一个错误，那么程序将跳转到 catch 块，并打印错误信息。

除了使用 do 和 catch 语句来处理错误之外，还可以使用 try?和 try!语句来简化错误处理过程。try?语句将函数的返回值转换为一个可选类型，如果函数抛出错误，则返回 nil。try!语句则在函数抛出错误时直接崩溃程序。建议使用 try?和 try!语句的场景非常有限，因为它们会让程序在运行时变得不可预测。


错误处理是一种处理程序运行过程中可能出现错误的机制。