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

Chrome插件开发 - 第一个插件


伪元素（Pseudo elements）是 CSS 中的一个重要概念，它允许开发者创建一个在文档树之外的元素，并且给这个元素添加样式，从而实现各种效果。

伪元素使用双冒号（::）来表示，与伪类选择器的单冒号（:）区分开来。伪元素可以用在 CSS 选择器中，表示要选择的元素的一部分。在选择器中使用伪元素时，它们会被插入到指定的元素之前或之后，并且可以用样式属性来设置它们的内容、颜色、位置等。

下面是常见的伪元素：

- ::before：在元素内容之前插入一个元素，常用来添加内容或图标等。
- ::after：在元素内容之后插入一个元素，常用来添加内容或图标等。
- ::first-line：选择元素的第一行文本，常用来设置文本的样式，如颜色、字体等。
- ::first-letter：选择元素的第一个字母，常用来设置文本的样式，如颜色、大小等。
- ::selection：选择用户选中的文本，常用来设置选中文本的样式，如背景颜色、字体颜色等。

伪元素的语法如下：

```bash
selector::pseudo-element {
/* styles */
}
```

在上面的代码中，selector 表示要选择的元素，pseudo-element 表示要使用的伪元素。例如，使用 ::before 伪元素在元素前插入一个内容为“hello”的元素，可以写成下面的代码：

```css
p::before {
  content: 'hello';
}
```

注意，伪元素必须有 content 属性，否则在页面上不会显示任何内容。此外，伪元素可以用来实现各种效果，如添加箭头、制作单选按钮、实现字体图标等。掌握伪元素的使用可以让你的 CSS 技能更上一层楼


css - Pseudo-elements


在 CSS 中，z-index 和层叠上下文（Stacking Context）是用于控制元素的层叠顺序和叠放顺序的两个关键概念。它们通常用于解决重叠元素的显示问题。

1. z-index：z-index 是一个 CSS 属性，用于控制元素在层叠顺序中的位置。它的取值可以是数字或 auto。数字越大，元素越靠近视口，也就是显示在前面。如果两个元素的 z-index 相同，它们的顺序将由它们在 HTML 中出现的顺序决定。z-index 只对已经定位（position）的元素有效。

2. 层叠上下文（Stacking Context）：层叠上下文是一种 HTML 元素的层叠环境。每个层叠上下文都有自己的层叠顺序，元素在其中的位置由层叠顺序和 z-index 值共同决定。当一个元素有层叠上下文时，它的子元素的层叠顺序和 z-index 将相对于其父元素进行计算。

层叠上下文有多种创建方式，包括：

- 根元素（HTML）和 window 对象是层叠上下文的根元素。
- position 值为 absolute 或 relative 且 z-index 值不为 auto 的元素。
- position 值为 fixed 或 sticky 的元素。
- 具有 opacity 值小于 1 的元素。
- 具有 transform、filter、perspective、clip-path、mask、mix-blend-mode 等属性的元素。
- 具有 isolation 属性设置为 isolate 的元素。
- 具有 will-change 属性的元素（例如 will-change: transform）。

当元素发生重叠时，可以通过改变层叠顺序和 z-index 值来控制它们的显示顺序。但是，应该注意避免滥用 z-index 和层叠上下文，因为它们可能会导致布局问题和难以维护的代码。建议尽可能使用更简单和可预测的布局方法，如 Flexbox 和 Grid，来避免这些问题。

以下是一个示例，说明如何使用 z-index 和层叠上下文来控制元素的层叠顺序：

HTML 代码：

```html
<div class="parent">
  <div class="child child1"></div>
  <div class="child child2"></div>
</div>
```

CSS 代码：

```css
.parent {
  position: relative;
}

.child {
  position: absolute;
  width: 100px;
  height: 100px;
}

.child1 {
  background-color: red;
  z-index: 1;
}

.child2 {
  background-color: blue;
  z-index: 2;
}
```

在这个例子中，父元素 .parent 有定位属性 position: relative;，使它成为一个层叠上下文。子元素 .child 都有绝对定位属性 position: absolute;，并设置了相同的宽度和高度。.child1 的 z-index 值为 1，.child2 的 z-index 值为 2，因此 .child2 会显示在 .child1 的前面，即蓝色盒子会显示在红色盒子上面。

通过使用 z-index 和层叠上下文，可以方便地控制元素的层叠顺序，以达到所需的布局效果。


css - Z-index & Stacking Context


`JavaScript`没有二进制数据类型，`buffer`是`Node.js`提供的专门用来存放二进制数据的缓存区。

## 创建 buffer

```js
// 创建10字节的未启动的缓存区
var buf = Buffer.alloc(10)

// 从数组创建缓存区
var buf = Buffer.from([10, 20, 30, 40, 50])

// 从字符串创建缓存区
var buf = Buffer.from('Node.js', 'utf-8')
```

## 写入 buffer

语法：`buf.write(string[, offset[, length]][, encoding])`

```js
var buf = Buffer.alloc(256)
len = buf.write('Node.js')
console.log(len) // 7
```

## 读取 buffer

语法：`buf.toString(encoding,start,end)`

- `encoding`：使用编码，默认`utf-8`
- `start`：读取初始索引位置
- `end`：读取结束位置

```js
buf = Buffer.alloc(26)
for (var i = 0; i < 26; i++) {
  buf[i] = i + 97
}

console.log(buf.toString('ascii')) // 输出: abcdefghijklmnopqrstuvwxyz
console.log(buf.toString('ascii', 0, 5)) //使用 'ascii' 编码, 并输出: abcde
console.log(buf.toString('utf8', 0, 5)) // 使用 'utf8' 编码, 并输出: abcde
console.log(buf.toString(undefined, 0, 5)) // 使用默认的 'utf8' 编码, 并输出: abcde
```

## 将 buffer 转换为 json 对象

语法：`buf.toJson`

```js
const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5])
const json = JSON.stringify(buf)

// 输出: {"type":"Buffer","data":[1,2,3,4,5]}
console.log(json)

const copy = JSON.parse(json, (key, value) => {
  return value && value.type === 'Buffer' ? Buffer.from(value.data) : value
})

// 输出: <Buffer 01 02 03 04 05>
console.log(copy)
```

## buffer 合并

语法：`Buffer.contact(list,totalLength)`

- `list`：用于合并的`Buffer`对象数组列表
- `totalLength`：合并后`Buffer`对象的总长度

```js
var buf1 = Buffer.from('Hello')
var buf2 = Buffer.from(' World!')
var buf3 = Buffer.concat([buf1, buf2])

console.log(buf3) //<Buffer 48 65 6c 6c 6f 20 57 6f 72 6c 64 21>
```

## buffer 比较

语法：`buf.compare(..)`

返回数字，0 表示相同，小于 0 表示 buf 在 bufToCompare 之前，大于 0 则相反

```js
var buf = Buffer.from('Hello')
var bufToCompare = Buffer.from('hello')

var result = buf.compare(bufToCompare)
console.log(result) // -1
```

## buffer 拷贝

语法：`buf.copy(target,targetStart,sourceStart,sourceEnd)`

- `target`：要拷贝的`Buffer`对象
- `targetStart`：默认 0
- `sourceStart`：默认 0
- `sourceEnd`：默认 0

```js
var buf = Buffer.from('Hello')
var bufToCopy = Buffer.from('World')

bufToCopy.copy(buf, 2)
console.log(buf.toString()) //HeWor
```

## buffer 切片

语法：`buf.slice(start,end)`

- `start`：切片初始位置，默认 0
- `end`：切片结束位置，默认为`buffer.length`

```js
var buf = Buffer.from('Hello World')
var result = buf.slice(0, 5)
console.log(result.toString()) //Hello
```

[入门教程](http://nodejs.cn/learn/nodejs-buffers)
[Node.js 文档](http://nodejs.cn/api/buffer.html)


buffer是Node.js提供用来存放二进制数据的缓存区

Node.js - Buffers


PostgreSQL 中的自连接是一种连接方式，可以让您将表连接到自身。当您有一个包含层次数据的表时，这很有用，比如员工表包含一个参考员工经理的 manager_id 列。

要执行自连接，首先在 SELECT 语句的 FROM 子句中指定要连接到自身的表。然后，您可以给表分配两个不同的别名，比如 a 和 b，以区分连接条件中的两个表实例。

例如，假设您有一个 employee 表，具有以下列： id、name 和 manager_id。要获取所有员工及其经理的列表，可以使用以下自连接查询：

```sql
SELECT a.name AS employee_name, b.name AS manager_name
FROM employee a
JOIN employee b ON a.manager_id = b.id
```

该查询将返回两列的结果集：employee_name 和 manager_name。结果集中的每一行都包含一个员工的姓名和他们的经理的姓名。

自连接可以非常强大，因为它可以轻松地在数据库中处理层次数据。但是，它们也可能很难编写和理解，因此在使用自连接查询前，要仔细考虑是否自连接是问题的最佳解决方案。


PostgreSQL 中的自连接是一种连接方式，可以让您将表连接到自身

Postgresql - SELF JOIN


Swift 中有三种主要的集合类型：数组、集合和字典。

## 数组（Arrays）

数组是一组有序的值的集合，可以使用下标来访问每个值。Swift 中的数组可以存储相同类型的值，也可以使用泛型来存储不同类型的值。

以下是创建和操作数组的示例：

```swift

// 创建数组
var numbers: [Int] = [1, 2, 3, 4, 5]
var strings = ["Apple", "Banana", "Orange"]

// 访问数组中的值
let firstNum = numbers[0] // 1
let lastStr = strings[strings.count - 1] // "Orange"

// 修改数组中的值
numbers[2] = 10
strings.append("Grape")

// 遍历数组中的所有值
for number in numbers {
print(number)
}
```

## 集合（Sets）

集合是一组无序的唯一值的集合。Swift 中的集合可以存储任何可哈希的值（Hashable），例如数字、字符串和布尔值等。集合中不允许存在重复的值。

以下是创建和操作集合的示例：

```swift

// 创建集合
var set1: Set<Int> = [1, 2, 3, 4, 5]
var set2: Set<String> = ["Apple", "Banana", "Orange"]

// 访问集合中的值
let hasThree = set1.contains(3) // true

// 修改集合中的值
set1.insert(6)
set2.remove("Banana")

// 遍历集合中的所有值
for element in set2 {
print(element)
}
```

## 字典（Dictionaries）

字典是一组无序的键值对的集合，每个键都唯一且与一个值相关联。Swift 中的字典可以存储任何可哈希的键（Hashable）和任何值，例如数字、字符串和布尔值等。

以下是创建和操作字典的示例：

```swift

// 创建字典
var dict1: [String: Int] = ["One": 1, "Two": 2, "Three": 3]
var dict2 = ["Red": "#FF0000", "Green": "#00FF00", "Blue": "#0000FF"]

// 访问字典中的值
let redCode = dict2["Red"] // "#FF0000"

// 修改字典中的值
dict1["One"] = 10
dict2["Yellow"] = "#FFFF00"

// 遍历字典中的所有键值对
for (key, value) in dict1 {
print("\(key): \(value)")
}
```

Swift 中的集合类型还提供了各种方法和属性，以支持常见的集合操作，例如排序、筛选、合并、查找等。如果您需要更深入地了解 Swift 中的集合类型，可以查看 Swift 官方文档中的相关章

## 元组（Tuples）

元组是将多个值组合在一起的一种方式，这些值可以是任何类型，并不要求是相同类型。元组中的每个值都可以通过名称或下标来访问。

以下是创建和操作元组的示例：

```swift

// 创建元组
let person = ("Tom", 25, true)

// 访问元组中的值
let name = person.0 // "Tom"
let age = person.1 // 25
let isMale = person.2 // true

// 创建带有标签的元组
let student = (name: "Alice", age: 20, isMale: false)

// 访问带有标签的元组中的值
let studentName = student.name // "Alice"
let studentAge = student.age // 20
let studentIsMale = student.isMale // false
```

## Range（区间）

区间是表示一定范围内值的类型。Swift 中有两种类型的区间：半开区间和闭区间。半开区间包含起始值，不包含结束值。闭区间包含起始值和结束值。

以下是创建和操作区间的示例：

```swift

// 创建区间
let range1 = 1..<5 // 半开区间，包含1，不包含5
let range2 = 1...5 // 闭区间，包含1和5

// 遍历区间中的所有值
for i in range1 {
print(i)
}

for i in range2.reversed() {
print(i)
}
```

Swift 的集合类型和区间类型提供了丰富的功能和操作，可以满足各种不同的需求。因此，在编写 Swift 代码时，选择正确的集合类型和区间类型非常重要，可以使代码更加简洁和高效。

## 字典（Dictionary）

字典是一种存储键值对的集合类型。在字典中，每个值都与一个唯一的键相关联。字典中的键必须是唯一的，并且必须是可哈希的（即可以用作字典键的类型必须符合 Hashable 协议）。

以下是创建和操作字典的示例：

```swift

// 创建字典
var scores = ["Tom": 80, "Jerry": 90, "Alice": 95]

// 添加和更新字典中的值
scores["Bob"] = 85 // 添加
scores["Tom"] = 85 // 更新

// 删除字典中的值
scores.removeValue(forKey: "Jerry")

// 遍历字典中的键值对
for (name, score) in scores {
print("\(name) scored \(score)")
}

// 获取字典中所有的键和值
let names = Array(scores.keys)
let scoresArray = Array(scores.values)
```

## 集合（Set）

集合是一种无序的、不重复的元素集合类型。集合中的每个元素必须是唯一的，并且必须是可哈希的（即可以用作集合元素的类型必须符合 Hashable 协议）。

以下是创建和操作集合的示例：

```swift

// 创建集合
var set1: Set<Int> = [1, 2, 3, 4, 5]
var set2: Set<Int> = [4, 5, 6, 7, 8]

// 集合运算
let union = set1.union(set2) // 并集
let intersection = set1.intersection(set2) // 交集
let difference = set1.symmetricDifference(set2) // 对称差集

// 添加和删除集合中的元素
set1.insert(6)
set1.remove(5)

// 遍历集合中的所有元素
for element in set1 {
print(element)
}
```

Swift 的集合类型提供了丰富的功能和操作，可以方便地对数据进行处理和操作。选择正确的集合类型可以使代码更加简洁和高效。

## 可选类型（Optional）

Swift 的可选类型是一种用于处理值缺失的类型。可选类型可以表示一个值存在或不存在。如果一个值存在，可选类型就包含这个值；如果一个值不存在，可选类型就是 nil。

以下是创建和操作可选类型的示例：

```swift

// 创建可选类型
var name: String? = "Tom"

// 访问可选类型中的值
if let unwrappedName = name {
print("Name is \(unwrappedName)")
} else {
print("Name is nil")
}

// 强制解包可选类型中的值
let unwrappedName2 = name!
print("Name is \(unwrappedName2)")

// 可选绑定
if let name = name {
print("Name is \(name)")
} else {
print("Name is nil")
}

// nil 合并运算符
let defaultName = "John"
let finalName = name ?? defaultName
print("Name is \(finalName)")
```

可选类型在 Swift 中经常使用，因为它可以很好地处理值缺失的情况。如果不使用可选类型，代码会变得非常冗长和复杂。因此，在 Swift 中，使用可选类型来处理值缺失的情况是一种很好的实践。


Swift中的集合类型（Collection Types）是一组相同类型的值的集合，可以使用这些集合类型来存储和操作数据

Swift - 集合类型


## 简介

Docker 是一个开源的应用容器引擎，基于 Go 语言 并遵从 Apache2.0 协议开源。

Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。

容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低。

## 应用场景

- Web 应用的自动化打包和发布。
- 自动化测试和持续集成、发布。
- 在服务型环境中部署和调整数据库或其他的后台应用。
- 从头编译或者扩展现有的 OpenShift 或 Cloud Foundry 平台来搭建自己的 PaaS 环境。

## 优点

- 快速，一致地交付您的应用程序
- 响应式部署和扩展
- 在同一硬件上运行更多工作负载

## 目录

- [x] [Docker 镜像](./Docker镜像)
- [x] [Docker 容器](./Docker容器)
- [x] [Dockerfiles](./Dockerfiles)
- [x] [Docker 更新容器](./Docker更新容器)
- [x] [Docker 更新镜像](./Docker更新镜像)
- [ ] [How to access files outside a Docker image]()
- [ ] [Sharing Docker Images on Docker Hub]()
- [ ] [Working with Docker Images from the command line]()
- [ ] [Working with Docker Containers from the command line]()
- [ ] [What to do if a Docker container immediately exits]()
- [ ] [Create a simple Node.js Hello World Docker Container from scratch]()
- [ ] [Using Docker Desktop to manage a Container]()
- [ ] [First steps with Docker after the installation]()
- [x] [Macos 安装 Docker](./Macos安装Docker)


Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。