string_decoder用于把Buffer转换为字符串

Node.js - StringDecoder


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


打开终端，输入以下命令：

```shell
docker run hello-world

# Unable to find image 'hello-world:latest' locally
# latest: Pulling from library/hello-world
# 0e03bdcc26d7: Pull complete 
# Digest: sha256:4cf9c47f86df71d48364001ede3a4fcd85ae80ce02ebad74156906caff5378bc
# Status: Downloaded newer image for hello-world:latest
# 
# Hello from Docker!
# This message shows that your installation appears to be working correctly.
# 
# To generate this message, Docker took the following steps:
#  1. The Docker client contacted the Docker daemon.
#  2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
#     (amd64)
#  3. The Docker daemon created a new container from that image which runs the
#     executable that produces the output you are currently reading.
#  4. The Docker daemon streamed that output to the Docker client, which sent it
#     to your terminal.
#
# To try something more ambitious, you can run an Ubuntu container with:
#  $ docker run -it ubuntu bash
# 
# Share images, automate workflows, and more with a free Docker ID:
#  https://hub.docker.com/
#
# For more examples and ideas, visit:
#  https://docs.docker.com/get-started/
```

hello-world 是一个测试镜像，它会在终端输出一段文字，说明 docker 安装成功。

现在在终端输入以下命令：

```shell
docker ps -a
# CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                     PORTS               NAMES
# 128ec8ceab71        hello-world         "/hello"            14 seconds ago      Exited (0) 13 seconds ago                      exciting_chebyshev
```

可以看到，docker 会自动创建一个容器，容器名为 exciting_chebyshev，容器 ID 为 128ec8ceab71。


Hello world in docker


Next.js 的静态资源存储，将静态资源放到根目录的 public 文件夹下即可。

在 Next.js 里，页面即组件，每个页面通过文件系统路由关联起来。

创建 public 文件夹，将图片放到该文件夹，修改 first.js

```js
import Link from 'next/link'

export default function FirstPost() {
  return (
    <>
      <h1>My First Post</h1>
      <h2>
        <Link href="/">
          <a>Home</a>
        </Link>
      </h2>
      <br />
      <img src="/logo.png" alt="TS" />
    </>
  )
}
```

启动服务

```bash
npm run dev
```

查看效果

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


Next.js的静态资源存储，将静态资源放到根目录的public文件夹下即可

Next.js - Static File Serving


Go 是一种强类型的编程语言，因此在使用变量时需要明确指定其类型。变量是用于存储数据的容器，可以在程序执行的过程中被修改。在 Go 中，变量需要先声明后使用，可以使用 var 关键字来声明变量并指定其类型，也可以使用 := 运算符来进行简化声明。
以下是一些关于 Go 变量的详细解释：

## 变量声明

使用 var 关键字可以声明一个变量，语法如下：

```go
var variable_name data_type
```

例如，以下代码声明了一个整型变量 x 和一个字符串变量 s：

```go
var x int
var s string
```

变量声明时也可以初始化变量的值，例如：

```go
var x int = 5
var s string = "Hello, World!"
```

同时也可以使用 := 运算符来简化变量的声明和初始化，例如：

```go
x := 5
s := "Hello, World!"
```

注意：使用 := 运算符时，变量的类型会由编译器自动推断出来。

## 变量赋值

使用赋值运算符 = 可以将一个值赋给一个变量。例如：

```go
x := 5
x = 10
```

在赋值时，变量的类型必须与赋给它的值的类型相同，否则会报错。

## 变量类型

在 Go 中，每个变量都必须有一个类型。常见的类型包括整型（int）、浮点型（float）、字符串（string）、布尔型（bool）等。例如：

```go
var x int
var f float64
var s string
var b bool
```

同时，Go 也支持使用类型别名来定义自己的类型。例如：

```go
type myInt int
var x myInt
```

## 多个变量声明

可以同时声明多个变量，例如：

```go
var x, y int
var s1, s2 string
```

在同时声明多个变量时，可以使用 := 运算符来简化，例如：

```go
x, y := 1, 2
s1, s2 := "Hello", "World"
```

## 常量

与变量类似，常量也是用于存储数据的容器，但是它们的值在程序执行期间不能被修改。在 Go 中，使用 const 关键字来声明常量，例如：

```go
const pi float64 = 3.14159265358979323846
const daysOfWeek = 7
```

在声明常量时，可以不指定类型，编译器会根据常量的值自动推断类型，例如：

```go
const pi = 3.14159265358979323846
const daysOfWeek = 7
```

常量的值必须在编译时就能确定，不能在运行时修改。


Go - 变量、类型、常量


颜色是设计中一个非常重要的元素，对于网站、移动应用、平面设计、产品设计等多个领域都有着至关重要的作用。在 Web 设计中，我们通常使用 CSS 来定义颜色。

CSS 中，颜色的表示方法有以下几种：

- 关键词表示法：通过关键词来表示颜色，如 red、green、blue 等。这种方法简单易懂，但是可用的关键词数量有限，且颜色表达不够精确。
- 十六进制表示法：通过三个或六个十六进制数值来表示颜色，如 #FF0000 表示红色。这种方法可以表示任何颜色，且具有较高的精确度和灵活性，是 Web 设计中最常用的颜色表示方法之一。
- RGB 表示法：通过三个 RGB 值来表示颜色，如 rgb(255, 0, 0) 表示红色。这种方法也可以表示任何颜色，与十六进制表示法相比，更易于计算和调整。
- RGBA 表示法：与 RGB 表示法类似，但是增加了一个 alpha 通道，用于表示颜色的透明度。如 rgba(255, 0, 0, 0.5) 表示半透明的红色。
- HSL 表示法：通过色相（Hue）、饱和度（Saturation）、亮度（Lightness）三个值来表示颜色，如 hsl(0, 100%, 50%) 表示红色。这种方法更接近人类感知颜色的方式，也更容易理解和调整。
- HSLA 表示法：与 HSL 表示法类似，但是增加了一个 alpha 通道，用于表示颜色的透明度。如 hsla(0, 100%, 50%, 0.5) 表示半透明的红色。

以上就是 CSS 中常用的颜色表示方法。除了这些方法，还有其他一些颜色表示方法，如系统色、渐变色等，但在 Web 设计中应用较少。在实际设计中，我们需要根据设计需求和效果选择最合适的颜色表示方法。

## 案例

使用十六进制表示法定义背景颜色：

```css
body {
  background-color: #f7df1e; /* 黄色 */
}
```

使用 RGB 表示法定义字体颜色：

```css
h1 {
  color: rgb(255, 0, 0); /* 红色 */
}
```

使用 HSLA 表示法定义边框颜色和透明度：

```css
div {
  border: 2px solid hsla(240, 100%, 50%, 0.5); /* 半透明的蓝色边框 */
}
```

使用关键词表示法定义按钮颜色：

```css
button {
  background-color: deepskyblue; /* 深天蓝色 */
  color: white; /* 白色文字 */
}
```

使用渐变色定义背景颜色：

```css
body {
  background-image: linear-gradient(
    to bottom,
    #2980b9,
    #6dd5fa,
    #ffffff
  ); /* 从上到下渐变色背景 */
}
```


css - Color


本章学习如何创建`turboReader`插件，如下图：

<video
  src={
    'https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/turboreader_ghlbnk.webm'
  }
  autoPlay
></video>

## 初始化项目

```bash
mkdir turboReader && cd turboReader
```

添加`manifest.json.json`

```json
{
  "manifest_version": 3,
  "version": "1.0",
  "name": "TurboReader",
  "description": "Become a faster reader with TurboReader",
  "action": {},
  "icons": {
    "48": "icons/icon-48.png"
  },
  "background": {
    "service_worker": "background.js"
  },
  "permissions": ["activeTab", "scripting"]
}
```

添加`background.js`，获取活动标签，并注入名为`turboMode`的函数。

```js
const turboMode = () => {
  // do something
}

chrome.action.onClicked.addListener(async () => {
  const [tab] = await chrome.tabs.query({active: true, currentWindow: true})
  chrome.scripting.executeScript({
    target: {tabId: tab.id},
    function: turboMode
  })
})
```

## 创建函数

首先获取页面内所有段落

```js
const paragraphs = document.getElementsByTagName('p')
```

判断当前是否是阅读模式

```js
const isTurboMode = document.body.classList.contains('trms')
```

遍历并处理段落

```js
for (const paragraph of paragraphs) {
  if (isTurboMode) {
    // 阅读模式已开启就返回当前段落
    paragraph.innerText = paragraph.innerText
  } else {
    // 阅读模式未开启，返回处理后的段落
    paragraph.innerHTML = paragraph.innerText
      .split(' ')
      .map((word) => {
        const length = word.replace(/[^a-zA-Z0-9]+$/, '').length
        const boldLength = length === 1 ? 1 : Math.floor(length / 2)
        return `<strong>${word.substring(
          0,
          boldLength
        )}</strong>${word.substring(boldLength)}`
      })
      .join(' ')
  }
}
```

在循环外部加入判断

```js
isTurboMode
  ? document.body.classList.remove('trms')
  : document.body.classList.add('trms')
```

完整代码

```js
const turboMode = () => {
  const paragraphs = document.getElementsByTagName('p')
  const isTurboMode = document.body.classList.contains('trms')
  for (const paragraph of paragraphs) {
    if (isTurboMode) {
      paragraph.innerText = paragraph.innerText
    } else {
      paragraph.innerHTML = paragraph.innerText
        .split(' ')
        .map((word) => {
          const length = word.replace(/[^a-zA-Z0-9]+$/, '').length
          const boldLength = length === 1 ? 1 : Math.floor(length / 2)
          return `<strong>${word.substring(
            0,
            boldLength
          )}</strong>${word.substring(boldLength)}`
        })
        .join(' ')
    }
  }

  isTurboMode
    ? document.body.classList.remove('trms')
    : document.body.classList.add('trms')
}
```

## Source Code

[【Source Code】](https://github.com/rebelchris/turbo-reader)


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