this的指向


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


`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


CSS 中的权重（specificity）是用来确定在多个 CSS 规则中，哪个规则的样式应该优先被应用的一种机制。权重是由不同类型的选择器组成的值，通常用一个四元组（a, b, c, d）来表示，其中：

- a 代表内联样式（inline styles），它的值为 1。
- b 代表 ID 选择器（id selectors），它的值为 ID 选择器的个数。
- c 代表类选择器（class selectors）、属性选择器（attribute selectors）和伪类选择器（pseudo-class selectors），它的值为这些选择器的个数之和。
- d 代表元素选择器（type selectors）和伪元素选择器（pseudo-element selectors），它的值为这些选择器的个数之和。

举个例子，如果一个 CSS 规则为：

```css
div#myId.myClass {
  color: red;
}
```

那么它的权重为 (0, 1, 1, 2)。

当多个 CSS 规则应用于同一个元素时，CSS 引擎会根据它们的权重来确定哪一个规则的样式应该被应用。具体来说，CSS 引擎会选择权重最高的规则。如果有多个规则的权重相同，则后定义的规则会覆盖先定义的规则。

需要注意的是，!important 关键字可以用来提高一个规则的权重。具体来说，它会给这个规则的权重添加一个极高的值，相当于 (0, 0, 0, ∞)。因此，一般情况下应该避免使用 !important，除非必须这样做。

以下是一些关于 CSS 权重的案例，用来帮助理解权重的计算方法和作用：

内联样式的权重最高，例如：

```html
<p style="color: red;">Hello, world!</p>
```

这个样式规则的权重为 (1, 0, 0, 0)，因此它的样式会优先于其他样式被应用。

ID 选择器的权重比类选择器和元素选择器高，例如：

```html
<div id="myDiv" class="myClass"></div>
```

```css
#myDiv.myClass {
  color: red;
}
```

这个样式规则的权重为 (0, 1, 1, 0)，因此它的样式优先于其他样式被应用。

选择器的权重是可以叠加的，例如：

```html
<p class="myClass"></p>
```

```css
p.myClass {
  color: red;
}
```

这个样式规则的权重为 (0, 0, 1, 1)，因为它包含了一个类选择器和一个元素选择器。

通配选择器和关系选择器的权重较低，例如：

```html
<div>
  <p>Hello, world!</p>
</div>
```

```css
div p {
  color: red;
}
```

这个样式规则的权重为 (0, 0, 0, 2)，因为它包含了两个元素选择器，但没有类选择器或 ID 选择器。因此，如果有一个包含类或 ID 选择器的规则也适用于这个元素，那么它的样式会优先于这个规则被应用。

!important 关键字会覆盖其他所有样式，例如：

```css
p {
  color: blue !important;
}

p {
  color: red;
}
```

即使第二个规则的权重更高，但由于第一个规则使用了 !important，因此它的样式会优先于第二个规则被应用。这也是为什么应该谨慎使用 !important 的原因。

总之，了解 CSS 权重机制对于编写高效、可维护的 CSS 代码非常重要，可以避免样式冲突和覆盖等问题。


css - 权重


`Next.js` 的响应有着类似于 `express.js` 的方法，方便开发

- res.status(code)：设置响应状态码
- res.json(data)：设置响应数据，并设置响应类型为 `json`
- res.send(body)：设置响应数据，响应类型可以是`string`、`object`、`buffer`

创建`/api/user`接口

```jsx
export default (req, res) => {
  res.status(200).json({
    message: 'Hello World'
  })
}
```

访问`/api/user`接口

```bash
npm run dev

curl http://localhost:3000/api/user

#{message:'Hello World'}
```


Next.js的响应有着类似于express.js的方法，方便开发

Next.js - Response Helpers


## 创建列表

```python
names = ['Michael', 'Bob', 'Tracy']
nums = [1, 2, 3]
```

也可以使用其他方法`split()`创建

```python
line = 'Hello World!'
row = line.split(' ')
row # ['Hello', 'World!']
```

## 列表操作

```python
names.append('Adam') # 在末尾添加元素
names.insert(1, 'Jack') # 在指定位置添加元素
```

使用`+`连接两个列表

```python
s=[1,2,3]
t=[4,5,6]
s+t # [1,2,3,4,5,6]
```

列表索引从 0 开始

```python
names = ['Michael', 'Bob', 'Tracy']
names[0] # Michael
names[1] # Bob
names[-1] # Tracy
```

使用索引覆盖元素

```python
names[0] = 'Adam' # 修改第一个元素
names # ['Adam', 'Bob', 'Tracy']
```

使用`len`获取列表长度

```python
len(names) # 3
```

使用`in`判断元素是否在列表中

```python
'Adam' in names # True
'manon' in names # False
```

## 列表的循环

使用`for`循环遍历列表

```python
for name in names:
    print(name)
```

查找索引值

```python
names.index('Bob') # 1
```

## 移除元素

使用`del`或`remove`删除元素

```python
names.remove('Bob') # 删除第一个 Bob
del names[0] # 删除第一个元素
```

## 列表的排序

使用`sort`对列表进行排序

```python
s = [10, 1, 7, 3]
s.sort()                    # [1, 3, 7, 10]

# Reverse order
s = [10, 1, 7, 3]
s.sort(reverse=True)        # [10, 7, 3, 1]

# It works with any ordered data
s = ['foo', 'bar', 'spam']
s.sort()                    # ['bar', 'foo', 'spam']
```

使用`sorted`创建新的列表，不会修改原列表

```python
t = sorted(s)
```


列表（List）是 python 的基本类型

Lists - 列表


> 可选字符串可能包含像“Hello”这样的字符串，或者它们可能是 `nil`——什么都没有。

## 处理缺失数据 - handling missing data

当不知道数据是否存在时，可以使用可选类型来处理。

```swift
var age: Int? = nil

age = 38
```

当需要使用类型的方法又不知道变量是否存在值的时候，可以使用`if let`或者`guard let`来处理。

`unwrapped`可以让你确保变量有值，如果没有值，程序会崩溃。

```swift
var name: String? = nil

if let unwrapped = name {
    print("\(unwrapped.count) letters")
} else {
    print("name is nil")
}

guard let unwrapped = name else {
    print("name is nil")
    return
}
```

## 强制转换和隐式转换

只有确认变量有值时，才可以使用`!`强制转换。

```swift
let str = "5"
let num = Int(str) // 这是不安全的，因为str可能不是一个整数

let num = Int(str)! // 这是安全的，因为str一定有值
```

隐式转换

```swift
let age: Int! = nil
```

## 合并可选值

当程序需要两个可选值时，可以使用`??`运算符来合并可选值。

```swift
func username(for id: Int) -> String? {
    if id == 1 {
        return "Taylor Swift"
    } else {
        return nil
    }
}

let user = username(for: 15) ?? "Anonymous"
```

## 可选链

通过可选链可避免多层嵌套的可选值获取错误。

```swift
let names = ["John", "Paul", "George", "Ringo"]

let beatle = names.first?.uppercased()
```

## 异常处理

当程序抛出异常时，可以使用`try`和`catch`来处理异常。比如下面的代码

```swift
enum PasswordError: Error {
    case obvious
}

func checkPassword(_ password: String) throws -> Bool {
    if password == "password" {
        throw PasswordError.obvious
    }

    return true
}

do {
    try checkPassword("password")
    print("That password is good!")
} catch {
    print("You can't use that password.")
}
```

还有一种方式是使用`try?`来尝试调用方法，如果方法抛出异常，则返回`nil`。

```swift
if let result = try? checkPassword("password") {
    print("Result was \(result)")
} else {
    print("Password is incorrect.")
}
```

另外一种方式是使用`try!`来强制调用方法，如果方法抛出异常，则程序会崩溃。

```swift
try! checkPassword("sekrit")
print("That password is good!")
```

## 类型转换

`Swift`提供了两种类型转换：`as`和`as?`。

```swift
class Animal { }
class Fish: Animal { }

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

let pets = [Fish(), Dog(), Fish(), Dog()]
```

使用`as?`来检查类型转换是否成功。如果类型转换成功，则返回一个可选值，否则返回`nil`。

```swift
for pet in pets {
  if let dog = pet as? Dog{
    dog.makeNoise()
  }
}
```


可选是一个枚举类型，它可以是一个值或者空。类似于js的optional chaining