协议可以被任意类型实现，包括类、结构体、枚举和其他协议，从而让这些类型可以拥有相同的行为和接口。

Swift - 协议


**协议没看懂~**

> 协议规定了用来实现某一特定功能所必需的方法和属性。
> 任意能够满足协议要求的类型被称为遵循(conform)这个协议。
> 类，结构体或枚举类型都可以遵循协议，并提供具体实现来完成协议定义的方法和功能。

## 创建协议

```swift
protocol Identifiable {
    // 协议定义
    var id: String { get }
}
```

如果一个类型遵循协议，那么它必须提供协议中定义的所有要求。

```swift
struct User: Identifiable {
    var id: String
}
```

## 协议继承

协议之间可以继承，这样可以让遵循协议的类型拥有父协议中的属性和方法。

```swift
protocol Payable {
    func calculateWages() -> Int
}

protocol NeedsTraining {
    func study()
}

protocol HasVacation {
    func takeVacation(days: Int)
}

# 继承

protocol Payable: Payable, NeedsTraining, HasVacation {
    // 协议继承
}
```

## 扩展

`extension`允许向现有的类型添加方法，属性或者下标。类似于 js 的`prototype`。

```swift
extension Int {
    func squared() -> Int {
        return self * self
    }
}

let number = 8
number.squared() // 64
```

**不允许在扩展中添加存储属性**

```swift
extension Int {
    var isEven: Bool {
        return self % 2 == 0
    }
}
```

## 协议扩展

```swift
let pythons = ["Eric", "Graham", "John", "Michael", "Terry", "Terry"]
let beatles = Set(["John", "Paul", "George", "Ringo"])
```

Swift 的数组和集合都属于`Collection`，所以可以写个扩展来满足协议要求。

```swift
extension Collection {
    func summarize() {
        print("There are \(count) of us:")

        for name in self {
            print(name)
        }
    }
}

pythyon.summarize()
beatles.summarize()
```

## 总结

- 协议描述了一致类型必须具有的方法和属性，但不提供这些方法的实现。
- 您可以在其他协议之上构建协议，类似于类。
- 扩展允许您将方法和计算属性添加到特定类型，例如 Int.
- 协议扩展允许您向协议添加方法和计算属性。
- 面向协议的编程是将您的应用程序架构设计为一系列协议，然后使用协议扩展来提供默认方法实现的实践


协议规定了用来实现某一特定功能所必需的方法和属性。

Protocols - 协议


`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>
        <p>Host: {props.host}</p>
        <p>Username: {props.username}</p>
        <p>Password: {props.password}</p>
      </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


使用`BETWEEN`运算符将一个值与一系列值进行匹配

## 语法

```sql
value BETWEEN low AND high
```

如果`value`在`low`和`high`之间，则返回`TRUE`，否则返回`FALSE`。

`BETWEEN`可以使用大于等于和小于等于运算符，但是不能使用`LIKE`运算符。

```sql
value >= low and value <= high
```

检查是否超出范围，可以使用`NOT`和`BETWEEN`组合运算符。

```sql
value NOT BETWEEN low AND high
```

等价于

```sql
value < low OR value > high
```

## 示例

使用`BETWEEN`查询金额是否在 8 和 9 之间。

```sql
SELECT
	customer_id,
	payment_id,
	amount
FROM
	payment
WHERE
	amount BETWEEN 8 AND 9;
```

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

查询金额不在 8 和 9 之间。

```sql
SELECT
	customer_id,
	payment_id,
	amount
FROM
	payment
WHERE
	amount NOT BETWEEN 8 AND 9;
```

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


使用 Postgresql BETWEEN 检索查询是否处于列表区间。

Postgresql - BETWEEN


`react` 组件可以通过条件判断显示不同的内容。比如：

```jsx
function App() {
  const isAuthUser = useAuth()

  if (isAuthUser) {
    // if our user is authenticated, let them use the app
    return <AuthApp />
  }

  // if user is not authenticated, show a different screen
  return <UnAuthApp />
}
```

三元运算符简化条件判断

```jsx
function App() {
  const isAuthUser = useAuth()

  return (
    <>
      <h1>My App</h1>
      {isAuthUser ? <AuthApp /> : <UnAuthApp />}
    </>
  )
}
```


React是一个JavaScript库，致力于使UI开发变得简单

React Conditionals


ReactJS 是一个声明性、高效和灵活的 JavaScript 库，用于构建可重用的 UI 组件。这是一个开源的、基于组件的前端库，仅负责应用程序的视图层。它最初由 Facebook 开发和维护，后来用于 WhatsApp 和 Instagram 等产品。

## 前置技术

- babel
- webpack
- nodejs && npm
- html && css

## 基本概念

- <a href="/blog/react/React Elements">React Elements</a>
- <a href="/blog/react/React Elements Attributes">React Elements Attributes</a>
- <a href="/blog/react/React Elements Styles">React Elements Styles</a>
- <a href="/blog/react/React Fragments">React Fragments</a>
- <a href="/blog/react/React Components">React Components</a>
- <a href="/blog/react/React Props">React Props</a>
- <a href="/blog/react/React Children Props">React Children Props</a>
- <a href="/blog/react/React Conditionals">React Conditionals</a>
- <a href="/blog/react/React Lists">React Lists</a>
- <a href="/blog/react/React Context">React Context</a>
- <a href="/blog/react/React Hooks">React Hooks</a>


Learning React.js


`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转换为字符串