一般来说，一个函数是可以通过外部代码调用的一个“子程序”（或在递归的情况下由内部函数调用）。像程序本身一样，一个函数由称为函数体的一系列语句组成。值可以传递给一个函数，函数将返回一个值。

Functions - 函数、参数、错误


[示例数据库](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/dvdrental.zip)

使用数据库时，最常见的就是使用`SELECT`语句来查询数据。

`SELECT`语句是 Postgresql 最复杂的一种查询语句，它可以查询数据库中的所有数据，也可以查询指定的数据。

- `DISTINCT`查询不同行的数据
- `ORDER BY`排序查询结果
- `WHERE`条件过滤查询结果
- `LIMIT`或`FETCH`限制查询结果的数量
- `GROUP BY`分组查询结果
- `HAVING`条件过滤分组查询结果
- `INNER JOIN`内连接查询结果
- `LEFT JOIN`左连接查询结果
- `FULL OUTER JOIN`全连接查询结果
- `CROSS JOIN`交叉连接查询结果
- `UNION`查询结果的并集
- `INTERSECT`查询结果的交集
- `EXCEPT`查询结果的差集

## SELECT 语法

`SELECT [select_list] FROM [table_name]`

- select_list:指定一个或多个查询字段，也可以使用`*`来查询所有字段
- table_name:指定查询的表名

## SELECT 语句的示例

#### 查询所有客户的名字

```sql
SELECT first_name FROM customer;
```

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

> `;`表示语句结束

#### 查询多个字段

```sql
SELECT first_name, last_name, email FROM customer;
```

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

#### 查询所有数据

```sql
SELECT * FROM customer;
```

> 尽量避免使用`*`，因为它会查询所有字段，会影响性能。

#### 表达式查询

使用`||`连接姓名查询

```sql
SELECT first_name || ' ' || last_name, email FROM customer;
```

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

```sql
SELECT 5*3;
```

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


Postgresql - Select


在 Swift 中，取消初始化通常指的是在初始化器中出现了错误或某些情况下无法完成初始化时，通过返回 nil 或抛出异常来表示初始化的失败或取消。

取消初始化的常用方法有两种：

使用可失败初始化器（Failable initializer）：可失败初始化器是指在初始化时可能会失败并返回 nil 的初始化器。可以通过在初始化方法后面加上问号来声明可失败初始化器。

```swift
class Person {
    var name: String

    init?(name: String) {
        if name.isEmpty {
            return nil
        }
        self.name = name
    }
}
```

在上述示例中，如果传入的 name 为空，则初始化失败并返回 nil。

使用抛出错误（Throwing Errors）：抛出错误是指在初始化时如果遇到错误就会抛出一个异常，这可以让调用者来决定如何处理错误。可以通过在初始化方法中使用 throw 语句抛出一个异常。

```swift
enum InvalidInputError: Error {
  case emptyName
}

class Person {
  var name: String

    init(name: String) throws {
        if name.isEmpty {
            throw InvalidInputError.emptyName
        }
        self.name = name
    }
}
```

在上述示例中，如果传入的 name 为空，则会抛出 InvalidInputError.emptyName 异常，调用者可以使用 do-catch 语句来处理异常。

当然，取消初始化并不是一种推荐的行为，我们应该尽量避免在初始化器中使用返回 nil 或抛出异常的方式来取消初始化，而应该尽量保证初始化器的顺利完成，或者在初始化器中处理可能会导致初始化失败的情况。


在 Swift 中，取消初始化通常指的是在初始化器中出现了错误或某些情况下无法完成初始化时，通过返回 nil 或抛出异常来表示初始化的失败或取消。

Swift - 取消初始化


JavaScript 中的作用域绑定是指确定变量和函数在代码中的可见性和访问权限的机制。作用域定义了变量和函数的可访问范围，以及它们在代码中的生命周期。

JavaScript 中有两种主要的作用域绑定机制：词法作用域和动态作用域。

## 词法作用域

词法作用域是在代码编写阶段确定的作用域，它基于变量和函数在源代码中的位置进行绑定。也就是说，词法作用域是由代码的结构来决定的，不会被函数调用的位置或上下文影响。

在词法作用域中，当定义一个变量或函数时，它们会被绑定到最近的包含它们的函数或全局作用域中。当在代码中引用一个变量或函数时，JavaScript 解释器会按照词法结构从内层作用域向外层作用域进行查找，直到找到匹配的标识符或达到全局作用域。

示例：

```javascript
var globalVariable = 'Global'

function outerFunction() {
  var outerVariable = 'Outer'

  function innerFunction() {
    var innerVariable = 'Inner'
    console.log(globalVariable) // 可以访问全局变量
    console.log(outerVariable) // 可以访问外层函数的变量
    console.log(innerVariable) // 可以访问当前函数的变量
  }

  innerFunction()
}

outerFunction()
```

## 动态作用域

动态作用域是在运行时确定的作用域，它基于当前的执行上下文和调用链来绑定变量和函数。与词法作用域不同，动态作用域的可见性和访问权限取决于函数调用的位置和上下文。

JavaScript 并没有内置的动态作用域机制，它使用的是词法作用域。但是，一些编程语言（如 Bash 脚本）使用动态作用域来确定变量的可见性。

JavaScript 的作用域绑定机制是词法作用域，它基于代码的结构来决定变量和函数的可见性和访问权限。词法作用域通过将变量和函数绑定到最近的包含它们的作用域来实现。动态作用域是一种在运行时确定作用域的机制，但 JavaScript 并不支持动态作用域。


作用域绑定


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

JavaScript 是一种基于原型的面向对象编程语言。每一个 JavaScript 对象都有一个原型，它指向另一个对象。当试图访问一个对象的属性或方法时，如果对象本身不存在这个属性或方法，JavaScript 引擎会在对象的原型中寻找。

原型链是指一系列从一个对象到其他对象的链接。当我们试图访问一个对象的属性或方法时，JavaScript 引擎会沿着这个原型链一直向上搜索，直到找到该属性或方法，或者到达链的末端。

举个例子：如果我们有一个 "Person" 对象，它可以有一个原型 "Human"，而 "Human" 又有一个原型 "Animal"。当我们试图访问 "Person" 对象的某个属性或方法时，如果 "Person" 不存在该属性或方法，JavaScript 引擎就会在 "Human" 中寻找，如果 "Human" 中也不存在，就会在 "Animal" 中寻找。

简单来说，JavaScript 原型和原型链是为了解决对象继承问题，使得我们可以在多个对象之间共享属性和方法。


原型和原型链


`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


在 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 中，可以创建动态路由