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

Chrome插件开发 - 新标签


## 通过 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


在 Postgresql 中，FULL OUTER JOIN 是一种结合左外连接和右外连接结果的连接类型。它返回左表中的所有行和右表中的所有行，包括在 ON 子句中不匹配的行。FULL OUTER JOIN 在想要在最终结果集中包含两个表中不匹配的行时非常有用。

以下查询使用`INNER JOIN`表连接到自身的查询

```sql
SELECT select_list
FROM table_name t1
INNER JOIN table_name t2 ON join_predicate;
```

此外还可以使用`LEFT JOIN`或`RIGHT JOIN`将表连接到自身：

```sql
SELECT select_list
FROM table_name t1
LEFT JOIN table_name t2 ON join_predicate;
```

## 示例

### 查询分层数据

假设有以下组织结构

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

创建`employee`表并将一些数据插入表中

```sql
CREATE TABLE employee (
	employee_id INT PRIMARY KEY,
	first_name VARCHAR (255) NOT NULL,
	last_name VARCHAR (255) NOT NULL,
	manager_id INT,
	FOREIGN KEY (manager_id)
	REFERENCES employee (employee_id)
	ON DELETE CASCADE
);
INSERT INTO employee (
	employee_id,
	first_name,
	last_name,
	manager_id
)
VALUES
	(1, 'Windy', 'Hays', NULL),
	(2, 'Ava', 'Christensen', 1),
	(3, 'Hassan', 'Conner', 1),
	(4, 'Anna', 'Reeves', 2),
	(5, 'Sau', 'Norman', 2),
	(6, 'Kelsie', 'Hays', 3),
	(7, 'Tory', 'Goff', 3),
	(8, 'Salley', 'Lester', 3);
```

使用自连接查询谁向谁报告

```sql
SELECT
    e.first_name || ' ' || e.last_name employee,
    m .first_name || ' ' || m .last_name manager
FROM
    employee e
INNER JOIN employee m ON m .employee_id = e.manager_id
ORDER BY manager;
```

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

以上查询两次引用`employee`表，一次作为雇员，另一次作为经理，通过匹配`employee_id`和`manager_id`查找雇员/经理对

使用`LEFT JOIN`instead of`INNER JOIN`查询结果集中包含最高管理者

```sql
SELECT
    e.first_name || ' ' || e.last_name employee,
    m .first_name || ' ' || m .last_name manager
FROM
    employee e
LEFT JOIN employee m ON m .employee_id = e.manager_id
ORDER BY manager;
```

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

### 比较同表的行

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

查询所有长度相同的电影

```sql
SELECT
    f1.title,
    f2.title,
    f1.length
FROM
    film f1
INNER JOIN film f2
    ON f1.film_id <> f2.film_id AND
       f1.length = f2.length;
```

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


在 Postgresql 中，FULL OUTER JOIN 是一种结合左外连接和右外连接结果的连接类型

Postgresql - FULL OUTER JOIN


`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


扩展（Extensions）是 Swift 中一种强大的特性，它允许我们向现有类型添加新的功能，包括方法、计算属性和下标等，而不需要修改原始类型的声明。

在 Swift 中，我们可以使用扩展来完成以下任务：

- 添加计算属性、存储属性、方法、下标和构造器等功能
- 定义协议的默认实现
- 整合协议的实现
- 分解类型实现

使用扩展可以使代码更加模块化，易于维护和扩展。以下是一个示例：

```swift
// 当前版本的 Swift 中，所有基本类型都是结构体

// 添加一个名为 squared 的计算属性来计算整数的平方，返回一个新的整数
extension Int {
    var squared: Int {
        return self * self
    }
    // 添加一个 mutating 方法来计算自身平方
    mutating func square() {
        self = self.squared
    }
}
// 对于给定的整数，可以使用点语法来访问 squared 属性和 square() 方法
let x = 5
print(x.squared) // 输出 "25"

var y = 7
y.square()
print(y) // 输出 "49"
```

在上面的示例中，我们向 Swift 中的 Int 类型添加了一个扩展。扩展中包含一个计算属性 squared 和一个 mutating 方法 square，用于计算整数的平方。可以通过使用点语法访问 squared 和调用 square() 方法在 Int 类型的所有实例中使用这些功能。

需要注意的是，扩展不能添加存储属性或添加必须由结构体或类定义的初始化器。此外，扩展也不能覆盖现有的方法或属性。除此之外，使用扩展的过程与定义原始类型的方法相同，因此扩展的函数和方法可以在同一文件中定义，并像原始代码一样被编译和执行。

总之，使用扩展的代码可以增强 Swift 中类型的灵活性和可读性，从而使代码更加模块化和高效，减少命名冲突和重复代码的出现。


扩展（Extensions）是 Swift 中一种强大的特性，它允许我们向现有类型添加新的功能，包括方法、计算属性和下标等，而不需要修改原始类型的声明。

Swift - 扩展


Flexbox 是一种 CSS 布局模式，用于在容器中快速、灵活地排列和对齐子元素，可以有效地实现自适应布局和响应式设计。Flexbox 的全称是 Flexible Box Layout，即“弹性盒子布局”。

Flexbox 的核心是容器和子元素之间的关系，容器称为 flex container（弹性容器），子元素称为 flex item（弹性子元素）。通过在容器上设置 display: flex 或 display: inline-flex 属性，可以将容器变为一个 flexbox，然后可以使用一系列的 CSS 属性来控制子元素的排列和对齐方式。

以下是 Flexbox 常用的属性和其作用：

- flex-direction：定义 flex container 的主轴方向，取值包括 row、row-reverse、column 和 column-reverse 四种方向。
- justify-content：定义 flex container 中子元素沿主轴方向的对齐方式，包括 flex-start、flex-end、center、space-between、space-around、space-evenly 六种取值。
- align-items：定义 flex container 中子元素沿交叉轴方向的对齐方式，包括 flex-start、flex-end、center、baseline、stretch 五种取值。
- flex-wrap：定义 flex container 中子元素在一行放不下时如何换行，取值包括 nowrap、wrap 和 wrap-reverse 三种。
- align-content：定义多行子元素在交叉轴方向的对齐方式，仅当 flex-wrap 属性为 wrap 或 wrap-reverse 时生效，包括 flex-start、flex-end、center、space-between、space-around、stretch 六种取值。
- flex-grow：定义子元素的放大比例，如果容器有多余的空间，子元素会按照各自的放大比例分配这些空间。
- flex-shrink：定义子元素的缩小比例，如果容器空间不足，子元素会按照各自的缩小比例缩小。
- flex-basis：定义子元素的基准尺寸，用于计算子元素的放大和缩小比例。
- order：定义子元素的排列顺序，数值越小的子元素越靠前。

Flexbox 的优点是可以简化布局代码，减少使用 float 和 position 的情况，同时可以实现自适应和响应式设计，提高页面的可维护性和可扩展性。但是需要注意的是，Flexbox 不适用于所有场景，例如多行文本的垂直居中需要结合其他技术实现。

以下是一个使用 Flexbox 实现的简单的响应式布局案例，包含一个 header、一个 sidebar 和一个 content 区域，可以根据屏幕尺寸自适应布局：

HTML 代码：

```html
<div class="container">
  <header>Header</header>
  <div class="content">
    <div class="sidebar">Sidebar</div>
    <div class="main">Main content</div>
  </div>
</div>
```

CSS 代码：

```css
.container {
  display: flex;
  flex-wrap: wrap;
}

header {
  width: 100%;
  background-color: #333;
  color: #fff;
  padding: 20px;
  text-align: center;
}

.content {
  display: flex;
  flex-wrap: wrap;
  flex-grow: 1;
  justify-content: flex-start;
  align-items: stretch;
}

.sidebar {
  flex-basis: 200px;
  background-color: #eee;
  padding: 20px;
}

.main {
  flex-grow: 1;
  padding: 20px;
}

@media screen and (max-width: 768px) {
  .sidebar {
    flex-basis: 100%;
  }
}
```

解释：

首先将容器设置为 flex 布局，使用 flex-wrap 属性允许子元素在需要时换行。

- header 元素使用宽度为 100%，背景颜色为深灰色，颜色为白色，使用 padding 属性来增加内边距，使其看起来更美观。

- content 元素作为 flex container，使用 flex-grow 属性让其占据剩余的空间，使用 justify-content 和 align-items 属性分别对子元素进行水平和垂直对齐。

- sidebar 元素使用 flex-basis 属性指定其基准尺寸为 200px，背景颜色为浅灰色，使用 padding 属性增加内边距。

- main 元素使用 flex-grow 属性让其占据剩余的空间，使用 padding 属性增加内边距。

- 在屏幕宽度小于 768px 时，将 sidebar 元素的基准尺寸设置为 100%，让其占据整行宽度。

这个案例展示了 Flexbox 的基本用法，通过简单的 CSS 属性设置，可以实现自适应和响应式布局。

更多请参考：[Flexbox 指南](/blog/css/tips/Flexbox指南)


css - flexbox


Swift 中的函数可以完成特定的任务，并且可以重复使用。函数使代码的组织和抽象化更加容易，也使代码更易于维护和重构。

以下是 Swift 中定义和调用函数的示例：

```swift
// 定义一个函数
func greet(person: String) -> String {
  let greeting = "Hello, " + person + "!"
  return greeting
}

// 调用函数
let result = greet(person: "Tom")
print(result)
```

Swift 中的函数有以下特点：

- 可以有多个参数，每个参数都有一个名字和一个类型。
- 可以有返回值，返回值可以是任何类型，也可以没有返回值。
- 可以有默认参数，使函数的调用更加方便。
- 可以使用可变参数，使函数的参数数量变得不确定。
- 可以使用 inout 参数，使函数可以修改传入参数的值。
- 可以使用函数类型，使函数作为参数或返回值传递。
  以下是上述特点的示例：

```swift
// 默认参数
func greet(person: String, greeting: String = "Hello") -> String {
  let result = greeting + ", " + person + "!"
  return result
}

let result2 = greet(person: "Tom")
let result3 = greet(person: "Tom", greeting: "Hi")

// 可变参数
func sum(numbers: Int...) -> Int {
  var result = 0
  for number in numbers {
    result += number
  }
  return result
}

let result4 = sum(numbers: 1, 2, 3, 4)

// inout 参数
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
  let temp = a
  a = b
  b = temp
}

var a = 10
var b = 20
swapTwoInts(&a, &b)

// 函数类型
func add(_ a: Int, _ b: Int) -> Int {
  return a + b
}

func subtract(_ a: Int, _ b: Int) -> Int {
  return a - b
}

func operate(_ a: Int, _ b: Int, operation: (Int, Int) -> Int) -> Int {
  return operation(a, b)
}

let result5 = operate(10, 5, operation: add)
let result6 = operate(10, 5, operation: subtract)
```

Swift 中的函数是一种非常有用的工具，可以使代码更加简洁、可读和易于维护。在编写代码时，应该考虑将代码组织成函数，以提高代码的重用性和可维护性。


Swift 中的函数可以完成特定的任务，并且可以重复使用。函数使代码的组织和抽象化更加容易，也使代码更易于维护和重构。