Getting Familiar with Dart

本章学习如何创建`turboReader`插件，如下图：

<video
 src={
 'https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/turboreader_ghlbnk.webm'
 }
 autoPlay
></video>

## 初始化项目

```bash
mkdir turboReader && cd turboReader
```

添加`manifest.json.json`

```json
{
 "manifest_version": 3,
 "version": "1.0",
 "name": "TurboReader",
 "description": "Become a faster reader with TurboReader",
 "action": {},
 "icons": {
 "48": "icons/icon-48.png"
 },
 "background": {
 "service_worker": "background.js"
 },
 "permissions": ["activeTab", "scripting"]
}
```

添加`background.js`，获取活动标签，并注入名为`turboMode`的函数。

```js
const turboMode = () => {
 // do something
}

chrome.action.onClicked.addListener(async () => {
 const [tab] = await chrome.tabs.query({active: true, currentWindow: true})
 chrome.scripting.executeScript({
 target: {tabId: tab.id},
 function: turboMode
 })
})
```

## 创建函数

首先获取页面内所有段落

```js
const paragraphs = document.getElementsByTagName('p')
```

判断当前是否是阅读模式

```js
const isTurboMode = document.body.classList.contains('trms')
```

遍历并处理段落

```js
for (const paragraph of paragraphs) {
 if (isTurboMode) {
 // 阅读模式已开启就返回当前段落
 paragraph.innerText = paragraph.innerText
 } else {
 // 阅读模式未开启，返回处理后的段落
 paragraph.innerHTML = paragraph.innerText
 .split(' ')
 .map((word) => {
 const length = word.replace(/[^a-zA-Z0-9]+$/, '').length
 const boldLength = length === 1 ? 1 : Math.floor(length / 2)
 return `${word.substring(
 0,
 boldLength
 )}${word.substring(boldLength)}`
 })
 .join(' ')
 }
}
```

在循环外部加入判断

```js
isTurboMode
 ? document.body.classList.remove('trms')
 : document.body.classList.add('trms')
```

完整代码

```js
const turboMode = () => {
 const paragraphs = document.getElementsByTagName('p')
 const isTurboMode = document.body.classList.contains('trms')
 for (const paragraph of paragraphs) {
 if (isTurboMode) {
 paragraph.innerText = paragraph.innerText
 } else {
 paragraph.innerHTML = paragraph.innerText
 .split(' ')
 .map((word) => {
 const length = word.replace(/[^a-zA-Z0-9]+$/, '').length
 const boldLength = length === 1 ? 1 : Math.floor(length / 2)
 return `${word.substring(
 0,
 boldLength
 )}${word.substring(boldLength)}`
 })
 .join(' ')
 }
 }

 isTurboMode
 ? document.body.classList.remove('trms')
 : document.body.classList.add('trms')
}
```

## Source Code

[【Source Code】](https://github.com/rebelchris/turbo-reader)

基于react、tailwindcss开发自己的chrome插件

Chrome插件开发 - Creating the TurboReader browser extension

`Next.js` 内置了对环境变量的支持，让你可以执行以下操作：

- 使用 `.env.local` 加载环境变量
- 通过给环境变量添加 `NEXT_PUBLIC_` `前缀将环境变量暴露给浏览器

## 创建环境变量

```bash
DB_HOST=localhost
DB_USR=root
DB_PWD=123456
```

## 创建 env.js

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

export default function FirstPost(props) {
 return (
 <>
 <Container>
 <Head>
 <title>Environment Variables</title>
 </Head>
 <h1>Database Credentials</h1>
 Host: {props.host}
 Username: {props.username}
 Password: {props.password}
 </Container>
 </>
 )
}

export async function getStaticProps() {
 // Connect to Database using DB properties
 return {
 props: {
 host: process.env.DB_HOST,
 username: process.env.DB_USER,
 password: process.env.DB_PASS
 }
 }
}
```

`Next.js`会在`.env*`中自动扩展变量，即可以定义变量

```bash
HOSTNAME=localhost
PORT=3000
HOST=http://$HOSTNAME:$PORT
```

Next.js 内置了对环境变量的支持

Next.js - Environment Variables


`crypto`模块提供了加密功能，其中包括了用于 OpenSSL 散列、HMAC、加密、解密、签名、以及验证的函数的一整套封装。

几种常见的加密、解密算法：

- hash HMAC
- cipher
- decipher
- sign
- verify

## 什么是 hash

hash 是一种散列函数，用于生成一个唯一的值，用于比较两个值是否相同。

## 什么是 HMAC

HMAC 是一种基于 hash 的密钥的认证算法，它可以用于验证数据的完整性，以及防止被篡改。

```js
const {createHmac} = require('crypto')

const secret = 'abcdefg'
const hash = createHmac('sha256', secret)
  .update('I love cupcakes')
  .digest('hex')
console.log(hash)
// c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
```

使用`cipher`加密

```js
const crypto = require('crypto')
const cipher = crypto.createCipher('aes192', 'a password')

var encrypted = cipher.update('some clear text data', 'utf8', 'hex')
encrypted += cipher.final('hex')

console.log(encrypted)
```

使用`decipher`解密

```js
const crypto = require('crypto')
const decipher = crypto.createDecipher('aes192', 'a password')

var encrypted =
  'c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e'
var decrypted = decipher.update(encrypted, 'hex', 'utf8')
decrypted += decipher.final('utf8')
console.log(decipher)
```

使用`sign`签名

```js
const crypto = require('crypto')
const buffer = require('buffer')

const {privateKey, publicKey} = crypto.generateKeyPairSync('rsa', {
  modulusLength: 2048
})

const data = Buffer.from('I Love GeeksForGeeks')

const sign = crypto.sign('SHA256', data, privateKey)

const signature = sign.toString('base64')

console.log(`Signature:\n\n ${signature}`)
```

使用`verify`验证

```js
const crypto = require('crypto')
const buffer = require('buffer')

const {privateKey, publicKey} = crypto.generateKeyPairSync('rsa', {
  modulusLength: 2048
})
const algorithm = 'SHA256'

const data = Buffer.from('I Love GeeksForGeeks')

const signature = crypto.sign(algorithm, data, privateKey)

const isVerified = crypto.verify(algorithm, data, publicKey, signature)

console.log(`Is signature verified:${isVerified}`)
```


Node.js - Crypto

> 引用类型是把数据和功能组织在一起的结构

## 原始包装类型

### Boolean

Boolean 有两个值 true/false。

| 数据类型 | 转换为 true 的值 | 转换为 false 的值 |
| --------- | ---------------- | ----------------- |
| Boolean | true | false |
| String | 任意飞空字符串 | 空字符串 |
| Number | 任何非零值 | 0 和 NaN |
| Object | 任何对象 | null |
| Undefined | | undefined |

### Number

```js
const age = 36
typeof age //number

const age = Number(36)
typeof age //number

//使用new声明的Number返回object类型，可使用valueOf获取原始值
const age = new Number(36)
typeof age //object
```

#### 属性

1. EPSILON - 两个数字之间的最小间隔
2. MAX_SAFE_INTEGER - 可表示的最大整数值
3. MAX_VALUE - 可表示的最大正值
4. MIN_SAFE_INTEGER - 可表示的最小整数值
5. MIN_VALUE - 可表示的最小正值
6. NAN - not a number
7. NEGATIVE_INFINITY - 正向无穷大
8. POSITIVE_INFINITY - 负向无穷大

```js
Number.EPSILON //2.220446049250313e-16
Number.MAX_SAFE_INTEGER //9007199254740991
Number.MAX_VALUE //1.7976931348623157e+308
Number.MIN_SAFE_INTEGER //-9007199254740991
Number.MIN_VALUE //5e-324
Number.NAN //NaN
Number.NEGATIVE_INFINITY //-Infinity
Number.POSITIVE_INFINITY //Infinity
```

#### 方法

- Number.isNaN(value) //当 value 为非 number 时返回 true
- Number.isFinite(value) //当 value 是有穷值返回 true
- Number.isInteger(value) //当 value 是整型值返回 true
- Number.isSafeInteger(value) //当 value 是安全整型值返回 true
- Number.parseFloat(value) //将值转换成浮点类型并返回
- Number.parseInt(value) //将值转换成整形并返回

#### 实例方法

当使用 new 关键词声明一个数值，将会返回 object，并且提供如下方法。

```js
const age = new Number(36)
typeof age //object
```

- .toExponential() //将值转换成指数计数法
- .toFixed() //返回小数点后 N 位
- .toLocaleString() //将值转换成字符类型
- .toPrecision() //返回指定的精度
- .toString() //将值转换成字符类型
- .valueOf() //返回原始值

### String

- String.fromCharCode() //通过一串 Unicode 创建字符串。
- String.fromCodePoint() //通过一串 码点 创建字符串。
- String.raw() //通过模板字符串创建字符串。

#### 实例方法

- charAt(i)
- charCodeAt(i)
- codePointAt(i)
- concat(str)
- endsWith(str)
- includes(str)
- indexOf(str)
- lastIndexOf(str)
- localeCompare()
- match(regex)
- normalize()
- padEnd()
- padStart()
- repeat()
- replace(str1, str2)
- search(str)
- slice(begin, end)
- split(separator)
- startsWith(str)
- substring()
- toLocaleLowerCase()
- toLocaleUpperCase()
- toLowerCase()
- toString()
- toUpperCase()
- trim()
- trimEnd()
- trimStart()
- valueOf()

#### charAt

> 返回指定位置的字符,且返回的字符长度为 1，**_js 没有一种有别于字符串类型的字符数据类型_**

```js
string.charAt(index)

'porhub'.charAt(0) //'p'
'porhub'.charAt(1) //'o'
'porhub'.charAt(2) //'r'
```

#### charCodeAt

> 返回在指定的位置的字符的 Unicode 编码

**字符串中第一个字符的下标是 0。如果 index 是负数，或大于等于字符串的长度，则 charCodeAt() 返回 NaN。**

```js
string.charCodeAt(index)

'porhub'.charCodeAt(0) //112
'porhub'.charCodeAt(1) //111
'porhub'.charCodeAt(2) //114
```

#### codePointAt

> ES2015 引入的，用于处理 2 UTF-16 字符的，比如中文，在 ES2015 之前 charCodeAt 只能处理单个字符，处理双字符必须一个个处理然后拼接。

```js
string.codePointAt(index)

//ES2015之前
'𠮷'.charCodeAt(0).toString(16) //d842
'𠮷'.charCodeAt(1).toString(16) //dfb7
;('\ud842\udfb7') //𠮷

//ES2015
'𠮷'.codePointAt(0) //20bb7
;('\u{20bb7}') //𠮷
```

#### concat

> 类似 Array 的 concat

```js
stringObject.concat(stringX,stringX,...,stringX)

"browser".concat("porhub");
```

通常使用 + 拼接来得更方便，或者使用 ES2015 的``字符扩展。

#### endWith

> 用来判断当前字符串是否是以另外一个给定的子字符串“结尾”的，根据判断结果返回 true 或 false。

```js
str.endsWith(searchString, position)

'JavaScript'.endsWith('Script') //true
'JavaScript'.endsWith('script') //false
'JavaScript'.endsWith('Script', 5) //false
'JavaScript'.endsWith('as', 5) //true
```

#### includes

> 用于判断一个字符串是否包含在另一个字符串中，根据情况返回 true 或 false

```js
str.includes(searchString, position)

'JavaScript'.includes('Script') //true
'JavaScript'.includes('script') //false
'JavaScript'.includes('nice') //true
'JavaScript'.includes('nice', 3) //false
```

#### indexOf

> 用于返回字符串中出现某个字符的初始位置，如果没有找到，返回-1.

```js
str.indexOf(searchString, startPosition)

'JavaScript'.indexOf('a') //1
'JavaScript'.indexOf('a', 2) //3
```

#### lastIndexOf

> 用于返回某个字符最后出现的位置，如果没有，返回-1

```js
str.lastIndexOf(searchString, startPosition)

'JavaScript'.lastIndexOf('a') //3
'JavaScript'.lastIndexOf('a', 1) //1
```

#### padEnd

> 用一个字符串填充当前字符串（如果需要的话则重复填充），返回填充后达到指定长度的字符串。从当前字符串的末尾（右侧）开始填充。

```js
str.padEnd(targetLength, string)

'abc'.padEnd(10) // "abc "
'abc'.padEnd(10, 'foo') // "abcfoofoof"
'abc'.padEnd(6, '123456') // "abc123"
'abc'.padEnd(1) // "abc"
```

#### padStart

> 用另一个字符串填充当前字符串(重复，如果需要的话)，以便产生的字符串达到给定的长度。填充从当前字符串的开始(左侧)应用的

```js
str.padStart(targetLength, string)

'abc'.padStart(10) // " abc"
'abc'.padStart(10, 'foo') // "foofoofabc"
'abc'.padStart(6, '123465') // "123abc"
'abc'.padStart(8, '0') // "00000abc"
'abc'.padStart(1) // "abc"
```

#### repeat

> 构造并返回一个包含被连接在一起的指定数量的新字符串。

```js
str.repeat(count)

'abc'.repeat(-1) // RangeError: repeat count must be positive and less than inifinity
'abc'.repeat(0) // ""
'abc'.repeat(1) // "abc"
'abc'.repeat(2) // "abcabc"
'abc'.repeat(3.5) // "abcabcabc" 参数count将会被自动转换成整数.
'abc'.repeat(1 / 0) // RangeError: repeat count must be positive and less than inifinity
```

#### slice

> 截取字符串的一部分，并返回一个新的字符串

```js
str.slice(startPosition, endPosition)

'abc'.slice(0, 1) //a
'abc'.slice(0, -1) //ab
```

#### split

> 将字符串切割成数组

```js
str.split(separator, limit)

'abc'.split() //"[a,b,c]";
'a,b,c'.split(',', 1) //[a]
```

#### startWith

> 判断字符串是否以给定的字符串开始，返回 true/false

```js
str.startsWith(searchString, poistion)

'abc'.startsWith('a') //true
'abc'.startsWith('a', 1) //false
```

#### substring

> 根据开始索引到结束索引截取字符串

```js
str.substring(startPosition, endPosition)

'abc'.substring(0, 1) //a
'abc'.substring(-1) //abc
```

1. 如果 startPosition 等于 indexEnd，substring 返回一个空字符串。
2. 如果省略 indexEnd，substring 提取字符一直到字符串末尾。
3. 如果任一参数小于 0 或为 NaN，则被当作 0。
4. 如果任一参数大于 stringName.length，则被当作 stringName.length。
5. 如果 startPosition 大于 indexEnd，则 substring 的执行效果就像两个参数调换了一样。见下面的例子。

### toLocaleLowerCase/toLocaleUpperCase/toUpperCase/toLowerCase

> 将字符串转换成小写/大写

```js
str.toLocaleLowerCase() /
 str.toLocaleUpperCase() /
 str.toUpperCase() /
 str.toLowerCase()

'ABC'.toLocaleLowerCase() //abc
'abc'.toLocaleUpperCase() //ABC
```

#### toString

> 将\*转换成字符串

```js
var x = new String('Hello world')

alert(x.toString()) // 输出 "Hello world"
```

#### trim/trimStart/trimEnd

> 移除空白字符/起始位置空白字符/结尾位置空白字符

```js
str.trim() / str.trimStart() / str.trimEnd()

'Testing'.trim() //'Testing'
' Testing'.trim() //'Testing'
' Testing '.trim() //'Testing'
'Testing '.trim() //'Testing'
```

#### valueOf

> 返回 str 的原始值，等同于 String.prototype.toString

```js
str.valueOf()

x = new String('Hello world')
alert(x.valueOf()) // Displays "Hello world"
```

#### 扩展学习

```js
1 +
 '5'[(1, 3, 5)] + //"15"
 1 //"1,3,51"
10 + true // 11
15 + {} // "15[object Object]"
8 + null // 8
'queen' + null // "queennull"
12 + undefined // NaN
```

[See examples in jsbin](http://jsbin.com/fiwemir/2/edit?js,console)

## 单例内置对象

### global

在全局作用域中定义的变量和函数都会成为`global`对象的属性。

常见的 global 对象属性和方法：

- 基本类型和引用类型等
- isNaN
- Infinity
- isFinate
- parseInt
- parseFloat
- encodeURI
- encodeURIComponent
- decodeURI
- decodeURIComponent
- eval

也可以通过`console.log(window)`来查看

### Math

除 global 之外，`Math`也是单例内置对象，提供了一组用于执行常见数学运算的方法。例如，可以使用 Math.max()方法来计算一组数值中的最大值，使用 Math.round()方法来对数值进行四舍五入等。

- Math.max(val1, val2, ...)：计算一组数值的最大值。
- Math.min(val1, val2, ...)：计算一组数值的最小值。
- Math.round(val)：对数值进行四舍五入。
- Math.ceil(val)：向上取整。
- Math.floor(val)：向下取整。
- Math.random()：生成一个 0 到 1 之间的随机数。

例如，下面的代码计算了一组数值的最大值、最小值、平均值：

```js
var values = [3, 5, 8, 10, 12]

// 计算最大值
var max = Math.max.apply(null, values)
console.log(max) // 12

// 计算最小值
var min = Math.min.apply(null, values)
console.log(min) // 3

// 计算平均值
var sum = 0
for (var i = 0; i < values.length; i++) {
 sum += values[i]
}
var avg = sum / values.length
console.log(avg) // 7.4
```

上面的代码中，首先使用 Math.max.apply(null, values)计算了一组数值的最大值，其中 apply 方法用于指定 Math.max 方法的作用对象为 null，并将 values 数组作为参数传入该方法。接着，使用类似的方法计算了一组数值的最小值。最后，通过遍历数组计算所有数值的和，然后除以数值的个数，得平均值。

## Date

JavaScript 的 Date 对象用于处理日期和时间。它可以获取当前日期和时间，也可以处理其他日期和时间。

要在 JavaScript 中使用 Date 对象，需要使用 Date 构造函数创建一个日期对象。语法如下：

```js
var date = new Date(
 [year],
 [month],
 [day],
 [hours],
 [minutes],
 [seconds],
 [milliseconds]
)
```

其中，参数 year、month、day、hours、minutes、seconds、milliseconds 表示年份、月份、日、小时、分钟、秒、毫秒，可以省略。如果省略，则表示使用当前日期和时间。

例如，下面的代码创建了一个日期对象，表示当前日期和时间：

```js
var date = new Date()
```

JavaScript 的 Date 对象提供了很多方法，用于处理日期和时间。例如，可以使用 getFullYear 方法来获取年份，使用 getMonth 方法来获取月份，使用 getDate 方法来获取日期等。

例如，下面的代码获取了当前日期对象的年份、月份、日期：

```js
var date = new Date()
var year = date.getFullYear()
var month = date.getMonth()
var day = date.getDate()
```

此外，JavaScript 的 Date 对象还提供了一些静态方法，可以用于创建特定日期和时间的日期对象。例如，可以使用 Date.parse 方法来解析日期字符串

Date 对象提供了许多方法来处理日期和时间信息，下面列出一些常用的方法：

- getFullYear()：获取当前日期所在年份。
- getMonth()：获取当前日期所在月份（0-11）。
- getDate()：获取当前日期所在月份的日期（1-31）。
- getDay()：获取当前日期所在周的星期（0-6，0 表示星期天，1 表示星期一，以此类推）。
- getHours()：获取当前时间的小时数（0-23）。
- getMinutes()：获取当前时间

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

## Regexp

正则表达式（Regular Expression，简称 regexp 或 regex）是用来描述、匹配文本模式的一种工具。在 JavaScript 中，可以使用正则表达式来搜索、替换、提取字符串中的指定文本，从而实现对文本的高级操作。

要在 JavaScript 中使用正则表达式，需要使用 RegExp 构造函数来创建一个正则表达式对象。语法如下：

```js
var regexp = new RegExp(pattern[, flags]);
```

其中，pattern 是正则表达式的模式字符串，flags 是可选的标志字符串，用来指定正则表达式的匹配方式。

例如，下面的代码创建了一个正则表达式对象，该对象可以匹配字符串"hello"：

```js
var regexp = new RegExp('hello')
```

JavaScript 的正则表达式有两种匹配方式：全局匹配和非全局匹配。

在全局匹配模式下，正则表达式会尝试匹配整个字符串，并返回所有匹配结果。要在正则表达式中使用全局匹配，需要在模式字符串中加入一个"g"标志，如下所示：

```js
var regexp = new RegExp('hello', 'g')
```

在非全局匹配模式下，正则表达式会尝试匹配字符串的一部分

Javascript - 基本引用类型


Postgresql join 用于连接两个或多个表的数据。下图是所有的 join 类型级语法

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

使用方式包括 inner join、left join、right join、full outer join。

首先创建两个表：

```sql
CREATE TABLE basket_a (
    a INT PRIMARY KEY,
    fruit_a VARCHAR (100) NOT NULL
);

CREATE TABLE basket_b (
    b INT PRIMARY KEY,
    fruit_b VARCHAR (100) NOT NULL
);

INSERT INTO basket_a (a, fruit_a)
VALUES
    (1, 'Apple'),
    (2, 'Orange'),
    (3, 'Banana'),
    (4, 'Cucumber');

INSERT INTO basket_b (b, fruit_b)
VALUES
    (1, 'Orange'),
    (2, 'Apple'),
    (3, 'Watermelon'),
    (4, 'Pear');
```

新建的表中有一些相同的数据，比如`apple`和`orange`

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

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

### 内连接

内连接检查第一个表 ( `basket_a`) 中的每一行。它将`fruit_a`列中的值 fruit_b 与第二个表 ( `basket_b`) 中每一行的列中的值进行比较。如果这些值相等，则内部连接会创建一个包含两个表中的列的新行，并将这个新行添加到结果集中。

```sql
SELECT
    a,
    fruit_a,
    b,
    fruit_b
FROM
    basket_a
INNER JOIN basket_b
    ON fruit_a = fruit_b;
```

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

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

### 左连接

使用左连接子句将`basket_a`表与`basket_b`表连接起来。在左连接上下文中，第一个表称为左表，第二个表称为右表。

```sql
SELECT
    a,
    fruit_a,
    b,
    fruit_b
FROM
    basket_a
LEFT JOIN basket_b
   ON fruit_a = fruit_b;
```

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

左连接开始从左表中选择数据。它将 fruit_a 列中的值与 basket_b 表中 fruit_b 列中的值进行比较。

如果这些值相等，则左连接会创建一个包含两个表的列的新行，并将此新行添加到结果集中。（参见结果集中的第 1 行和第 2 行）。

如果值不相等，左连接还会创建一个包含两个表中的列的新行，并将其添加到结果集中。但是，它 basket_b 用空值填充右表 ( ) 的列。（参见结果集中的第 3 行和第 4 行）。

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

要从左表中选择右表中没有匹配行的行，请使用带 WHERE 子句的左连接。例如：

```sql
SELECT
    a,
    fruit_a,
    b,
    fruit_b
FROM
    basket_a
LEFT JOIN basket_b
    ON fruit_a = fruit_b
WHERE b IS NULL;
```

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

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

### 右连接

右连接是左连接的反转版本。右连接开始从右表中选择数据。它将右表中每一行的 fruit_b 列中的每个值与 fruit_a 表中每一行的 fruit_a 列中的每个值进行比较。

如果这些值相等，则右连接会创建一个包含两个表中的列的新行。

如果这些值不相等，右连接还会创建一个包含两个表中的列的新行。但是，它用 NULL 填充左表中的列。

以下语句使用右连接将`basket_a`表与`basket_b`表连接起来：

```sql
SELECT
    a,
    fruit_a,
    b,
    fruit_b
FROM
    basket_a
RIGHT JOIN basket_b ON fruit_a = fruit_b;
```

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

### 全连接

完全外连接或完全连接返回一个结果集，其中包含左右表中的所有行，如果可用，则两边都有匹配的行。如果没有匹配，表的列将被填充为 NULL。

```sql
SELECT
    a,
    fruit_a,
    b,
    fruit_b
FROM
    basket_a
FULL OUTER JOIN basket_b
    ON fruit_a = fruit_b;
```

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

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

要返回一个表中没有匹配行的行，请使用带有`WHERE`如下子句的完全连接：

```sql
SELECT
    a,
    fruit_a,
    b,
    fruit_b
FROM
    basket_a
FULL JOIN basket_b
   ON fruit_a = fruit_b
WHERE a IS NULL OR b IS NULL;
```

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


Postgresql join包括inner join、left join、right join、full outer join。

Postgresql - JOIN


在 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)指的是检查一个实例的类型，或将该实例视为其超类或子类之一的过程。。