Vue有很多内置指令，比如v-for、v-if

自定义指令


使用`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


**nohup**用于忽略 SIGHUP ("signal hang up" 译：挂断信号) 在系统后台不挂断地运行命令，退出终端不会影响程序的运行。

nohup 命令在默认情况下（非重定向时），会输出一个名叫 nohup.out 的文件到当前目录下，如果当前目录的 nohup.out 文件不可写，输出重定向到 $HOME/nohup.out 文件中。

## 使用方法

```bash
nohup <command>
```

停止运行

```bash
#使用如下命令找到进程pid，然后使用kill杀掉进程
ps -aux | grep <command>
```

## 参数

- Command：要执行的命令。
- Arg：一些参数，可以指定输出文件。
- &：让命令在后台执行，终端退出后命令仍旧执行。

nohup 命令可以在 Linux、macOS、WSL 和任何有 UNIX 环境的地方使用


用于忽略 SIGHUP (挂断信号) 在系统后台不挂断地运行命令，退出终端不会影响程序的运行

Linux命令nohup


当你想为用户提供一些额外信息的时候

当你想在用户卸载的时候触发某个操作

当你希望在更新的时候重定向到更改日志

扩展 hooks 将非常有必要

## 在浏览器扩展中捕获`onInstall`操作

打开`public/background.js`

```js
chrome.runtime.onInstall.addListener((details) => {
  // do something
})
```

触发`onInstall`的可能操作

- install
- update
- chrome_update
- shared_module_update

以下代码展示了捕获安装和更新的动作

```js
chrome.runtime.onInstalled.addListener((details) => {
  if (details.reason === 'install') {
    chrome.notifications.create({
      type: 'basic',
      iconUrl: 'icons/icon-48.png',
      title: 'Hi there 👋',
      message: 'Welcome to the best extensions you ever installed',
      buttons: [{title: 'Thanks 😅️'}],
      priority: 0
    })
  }

  if (details.reason === 'update') {
    chrome.notifications.create({
      type: 'basic',
      iconUrl: 'icons/icon-48.png',
      title: 'Thank you',
      message: 'For updating this extensions',
      buttons: [{title: 'Cool'}],
      priority: 0
    })
  }
})
```

当你想在用户卸载的时候，可以重定向到某个 url

```js
chrome.runtime.onInstalled.addListener(details => {
    chrome.runtime.setUninstallURL('https://manon.icu/');
}
```

## Source Code

[【Source Code】](https://github.com/rebelchris/popup-extension/tree/installs)


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

Chrome插件开发 - Hooking into installs


## 通过 nvm 安装 nodejs

## 安装 nvm

```bash
curl https://raw.githubusercontent.com/creationix/nvm/master/install.sh | bash
```

或者

```bash
wget -qO- https://raw.githubusercontent.com/creationix/nvm/master/install.sh | bash
```

然后：

```bash
source ~/.bashrc
```

## 安装 nodejs

```bash
nvm install stable
```


安装nvm和nodejs


在Go语言中，接口（Interface）是一种类型，它定义了一组方法的契约。接口定义了方法的集合，而不关心方法的具体实现。接口提供了一种抽象的方式来描述对象的行为。

Go中的接口由一组方法签名组成，方法签名定义了方法的名称、参数列表和返回值类型。一个类型只要实现了接口中定义的所有方法，就被认为是实现了该接口。通过这种方式，接口实现了多态的特性，即不同类型的对象可以以相同的接口类型进行处理。

## 接口定义

```go
type 接口类型名 interface{
    方法名1(参数列表1) 返回值列表1
    方法名2(参数列表2) 返回值列表2
    …
}
```

## 接口实现

```go
type 类型名 struct{
    //字段
}
//实现接口方法
func (变量名 类型名) 方法名1(参数列表1) 返回值列表1{
    //方法体
}
func (变量名 类型名) 方法名2(参数列表2) 返回值列表2{
    //方法体
}
```

接口的实现是隐式的，不需要显式声明。只要一个类型实现了接口中定义的所有方法，即可视为实现了该接口。例如：

```go
type Animal interface {
    Speak() string
}

type Dog struct {}

func (d Dog) Speak() string {
    return "Woof!"
}

func main() {
    var animal Animal
    animal = Dog{}
    fmt.Println(animal.Speak()) // 输出: "Woof!"
}
```

在上面的例子中，我们定义了一个 Animal 接口，只有一个 Speak 方法。然后，我们创建了一个 Dog 结构体，并为 Dog 类型实现了 Speak 方法。在 main 函数中，我们将 Dog 类型赋值给 Animal 类型的变量 animal，并调用了 Speak 方法。
接口的特点和用途包括：

- 多态性：接口允许在不同的类型之间实现多态。通过将对象视为接口类型，可以处理不同类型的对象，而无需关心其具体的类型。
- 松耦合：接口可以实现组件之间的松耦合，组件只需要关注接口定义的方法，而不需要关心具体的实现。
- 可插拔性：接口可以作为插件或模块的契约，允许将不同的实现替换为其他实现，而不会影响使用该接口的其他代码。


Go Inteface是一种类型，一种抽象的类型。

Go - 接口


在 Go 中使用 Struct 表示结构体，结构体是由一系列具有相同或不同类型的数据构成的数据集合。

## 结构体的定义

```go
type identifier struct {
    field1 type1
    field2 type2
    ...
}
```

## 结构体的初始化

```go
type person struct {
    name string
    age int
}

func main() {
    var p1 person
    p1.name = "张三"
    p1.age = 18
    fmt.Println(p1) // {张三 18}

    p2 := person{"李四", 20}
    fmt.Println(p2) // {李四 20}

    p3 := person{name: "王五", age: 22}
    fmt.Println(p3) // {王五 22}

    p4 := new(person)
    p4.name = "赵六"
    p4.age = 24
    fmt.Println(p4) // &{赵六 24}
}
```

## 结构体的匿名字段

```go
type person struct {
    name string
    age int
}

type student struct {
    person
    school string
}

func main() {
    s1 := student{person{"张三", 18}, "清华大学"}
    fmt.Println(s1) // {{张三 18} 清华大学}
    fmt.Println(s1.name) // 张三
    fmt.Println(s1.age) // 18
    fmt.Println(s1.school) // 清华大学
}
```

## 结构体的嵌套

```go
type person struct {
    name string
    age int
}

type student struct {
    person
    school string
}

type teacher struct {
    person
    school string
}

func main() {
    s1 := student{person{"张三", 18}, "清华大学"}
    fmt.Println(s1) // {{张三 18} 清华大学}
    fmt.Println(s1.name) // 张三
    fmt.Println(s1.age) // 18
    fmt.Println(s1.school) // 清华大学

    t1 := teacher{person{"李四", 20}, "北京大学"}
    fmt.Println(t1) // {{李四 20} 北京大学}
    fmt.Println(t1.name) // 李四
    fmt.Println(t1.age) // 20
    fmt.Println(t1.school) // 北京大学
}
```

## 结构体的方法

```go
type person struct {
    name string
    age int
}

func (p person) say() {
    fmt.Printf("我叫 %s，今年 %d 岁。\n", p.name, p.age)
}

func main() {
    p1 := person{"张三", 18}
    p1.say() // 我叫 张三，今年 18 岁。
}
```

## 结构体的指针

```go
type person struct {
    name string
    age int
}

func (p *person) say() {
    fmt.Printf("我叫 %s，今年 %d 岁。\n", p.name, p.age)
}

func main() {
    p1 := person{"张三", 18}
    p1.say() // 我叫 张三，今年 18 岁。
}
```

## 结构体的匿名字段方法

```go
type person struct {
    name string
    age int
}

type student struct {
    person
    school string
}

func (p person) say() {
    fmt.Printf("我叫 %s，今年 %d 岁。\n", p.name, p.age)
}

func main() {
    s1 := student{person{"张三", 18}, "清华大学"}
    s1.say() // 我叫 张三，今年 18 岁。
}
```

## 结构体的嵌套方法

```go
type person struct {
    name string
    age int
}

type student struct {
    person
    school string
}

type teacher struct {
    person
    school string
}

func (p person) say() {
    fmt.Printf("我叫 %s，今年 %d 岁。\n", p.name, p.age)
}

func main() {
    s1 := student{person{"张三", 18}, "清华大学"}
    s1.say() // 我叫 张三，今年 18 岁。

    t1 := teacher{person{"李四", 20}, "北京大学"}
    t1.say() // 我叫 李四，今年 20 岁。
}
```

## 结构体的匿名字段嵌套方法

```go
type person struct {
    name string
    age int
}

type student struct {
    person
    school string
}

type teacher struct {
    person
    school string
}

func (p person) say() {
    fmt.Printf("我叫 %s，今年 %d 岁。\n", p.name, p.age)
}

func main() {
    s1 := student{person{"张三", 18}, "清华大学"}
    s1.say() // 我叫 张三，今年 18 岁。

    t1 := teacher{person{"李四", 20}, "北京大学"}
    t1.say() // 我叫 李四，今年 20 岁。
}
```


Go 语言中的结构体，以及结构体的嵌套和匿名字段。