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

Chrome插件开发 - Messaging


本章学习如何创建`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)


Chrome插件开发 - Creating the TurboReader browser extension


**协议没看懂~**

> 协议规定了用来实现某一特定功能所必需的方法和属性。
> 任意能够满足协议要求的类型被称为遵循(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 - 协议


Docker 的安装根据所使用的操作系统有很大的不同。但是普遍来说这是很简单的。Docker 可以在 Mac、 Windows 和 Linux 这三个主要平台上完美地运行。在这三者中，Mac 上的安装过程是最简单的。

## 在 Mac 上安装 Docker

1. brew 安装 docker

```bash
#搜索
==> Formulae
docker                          docker-credential-helper        docker-machine-completion       docker-machine-nfs              docker2aci
docker-clean                    docker-credential-helper-ecr    docker-machine-driver-hyperkit  docker-machine-parallels        dockerize
docker-completion               docker-gen                      docker-machine-driver-vmware    docker-slim                     lazydocker
docker-compose                  docker-ls                       docker-machine-driver-vultr     docker-squash
docker-compose-completion       docker-machine                  docker-machine-driver-xhyve     docker-swarm
==> Casks
docker

#安装
brew install docker
==> Downloading https://mirrors.ustc.edu.cn/homebrew-bottles/bottles/docker-19.03.14.big_sur.bottle.tar.gz
######################################################################## 100.0%
==> Pouring docker-19.03.14.big_sur.bottle.tar.gz
==> Caveats
zsh completions have been installed to:
  /usr/local/share/zsh/site-functions
==> Summary
🍺  /usr/local/Cellar/docker/19.03.14: 14 files, 71.6MB
```

2. 手动安装

下载[Stable](https://download.docker.com/mac/stable/Docker.dmg)，双击安装

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

安装完成后，通过命令检查 Docker 版本

```bash
docker --version

Docker version 19.03.14, build 5eb3275
```

3. 镜像加速

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

安装完成后，在 Terminal 执行`docker version` 命令，如果出现如下结果，说明安装成功。

```bash
docker --version
docker-compose --version
```

## 在 Windows 上安装 Docker

在 windows 上安装 docker，首先需求安装并启用 Hyper-V，类似于 VMWare 或 VirtualBox。

再去官网下载应用包，按照提示一步步安装即可。

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

## 在 Linux 上安装 Docker

在 Linux 上安装 Docker 是一个有点不同的过程，而且根据您所在的发行版本的不同，这个过程可能会更加不同。

但老实说，安装和其他两个平台一样容易(如果不是更容易的话)。

Windows 或 Mac 上的 Docker Desktop 软件包是一系列工具的集合，比如 Docker Engine、 Docker Compose、 Docker Dashboard、 Kubernetes 和其他一些好东西。然而，在 Linux 上，你不会得到这样一个包。相反，您需要手动安装所有必要的工具。不同发行版的安装程序如下:

1. 如果是 Ubuntu，按照[官方文档](https://docs.docker.com/engine/install/ubuntu/)操作。
2. 如果是其他发行版

- [Debian](https://docs.docker.com/engine/install/debian/)
- [Fedora](https://docs.docker.com/engine/install/fedora/)
- [Centos](https://docs.docker.com/engine/install/centos/)

3. 如果你使用的发行版没有在列表上，可以使用[二进制方式安装](https://docs.docker.com/engine/install/binaries/)

安装完成后，在 Terminal 执行`docker version` 命令，如果出现如下结果，说明安装成功。

```bash
docker --version
docker-compose --version
```

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


如何安装Docker？


## Node.js 是什么？

Node.js 是一个用于创建网络和服务器端应用程序的跨平台环境和库，使用 JavaScript 语言编写。Node.js 基于 Google Chrome 的 V8 JavaScript 引擎，具有以下特色：

## Node.js 的特色

- `极快`：Node.js 代码执行速度非常快。
- `I/O是异步和事件驱动的`：Node.js 库的所有 API 都是异步的，即非阻塞。因此，基于 Node.js 的服务器永远不会等待 API 返回数据。服务器在调用后移动到下一个 API，Node.js 事件的通知机制有助于服务器从之前的 API 调用中获得响应。这也是它非常快的原因。
- `单线程`：Node.js 遵循带有事件循环的单线程模型。
- `高度可扩展`：Node.js 具有高度可扩展性，因为事件机制有助于服务器以非阻塞方式响应。
- `无缓冲`：Node.js 在上传音频和视频文件时缩短了整体处理时间。Node.js 应用程序从不缓冲任何数据。这些应用程序只需以块为数据输出。
- `开源`：Node.js 有一个开源社区，该社区产生了许多优秀的模块，为 Node.js 应用程序添加其他功能。
- `许可证`：Node.js 在 MIT 许可证下发布。

## Install On Windows

从 Node.js 官方网站（https://nodejs.org）下载 Windows 版本的安装包。
![lNsHpN](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/lNsHpN.jpg)

运行下载的安装包，按照向导的指示进行安装。建议选择“Custom”安装，勾选“Add to PATH”，并选择“Entire feature will be installed on local hard drive”。运行下载的安装包，按照向导的指示进行安装。建议选择“Custom”安装，勾选“Add to PATH”，并选择“Entire feature will be installed on local hard drive”。
![VZs1Rk](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/VZs1Rk.jpg)
![ojUC1D](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/ojUC1D.jpg)
![2i1T66](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/2i1T66.jpg)
![YtZQqr](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/YtZQqr.jpg)
![2Hp0BM](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/2Hp0BM.jpg)

验证安装
![hhq3GT](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/hhq3GT.jpg)

## Install On Linux、Macos

```bash
# linux
sudo yum install nodejs #centos
sudo apt-get install nodejs #ubuntu debain

# macos
brew install nodejs
```


Node.js - Intro & Install


## Objects

- 对象是一组插槽（键值条目）
- 公共插槽称为属性
  - 属性`key`只能是`string`或者`symbol`
- 私有插槽称为私有方法，只能通过`class`创建

![1ayzHnjKYTA2F5s](https://s2.loli.net/2022/01/08/1ayzHnjKYTA2F5s.jpg)

### 单个对象 - Single objects

```js
// 创建object
const obj = {
  name: 'John',
  age: 30,
  isAdmin: false,
  sayHi() {
    console.log('Hi')
  },
  [Symbol.toStringTag]: 'Person'
}
obj.name // John
obj.age // 30
obj.isAdmin // false
obj.sayHi() // Hi
obj.toString() // [object Object]

// 解构object
const original = {
  a: 1,
  b: {
    c: 3
  }
}
const modified = {
  ...original,
  d: 4
} // { a: 1, b: { c: 3 }, d: 4 }

// 解构合并
const DEFAULTS = {alpha: 'a', beta: 'b'}
const providedData = {alpha: 1}
const allData = {...DEFAULTS, ...providedData} // {alpha: 1, beta: 'b'}

// `Object.assign`合并对象
const target = {a: 1}

const result = Object.assign(target, {b: 2}, {c: 3, b: true}) // { a: 1, b: true, c: 3 }
```

### 原型链 - Prototype chain

原型是 `JavaScript` 的基本继承机制。甚至 `class` 也基于此。每个对象都有 `null` 或一个对象作为其原型。

```js
const obj1 = Object.create(null) // 创建一个没有原型的对象
Object.getPrototypeOf(obj1) === null // true

const proto = {
  protoProp: 'protoProp'
}
const obj2 = {
  __proto__: proto, // 将proto设置为obj2的原型
  objProp: 'objProp'
}
Object.getPrototypeOf(obj2) === proto // true
```

每个对象都继承原型的所有属性，包括不可枚举的属性。

```js
obj2.protoProp // protoProp
Reflect.ownKeys(obj2) // ['objProp', '__proto__']
```

对象的非继承属性，可以通过 `Object.getOwnPropertyDescriptor()` 获取。

### getters & setters

通过`get`和`set`方法，可以设置和获取对象的属性。

```js
const jane = {
  first: 'Jane',
  last: 'Doe',
  get full() {
    return `${this.first} ${this.last}`
  },
  set full(fullName) {
    const parts = fullName.split(' ')
    this.first = parts[0]
    this.last = parts[1]
  }
}
jane.full // Jane Doe
```


Objects


> `useRef` 返回一个可变的 `ref` 对象，其 `.current` 属性被初始化为传入的参数（initialValue），返回的 `ref` 对象在组件的整个生命周期内保持不变。

例如：创建`VideoPlayer`组件

```tsx
import {useRef} from 'react'
import VideoPlayer from 'videoplayer'

function VideoPlayerComponent() {
  const playerRef = useRef(new VideoPlayer())
  //
}
```

对于上面的代码，在初始化组件时，调用`new VideoPlayer()`的结果将存储在`ref`中，在下一次渲染时，仍将调用`new VideoPlayer()`，但是`useef`不会再接收到其调用结果，这意味着`playerRef`可能为空。

同样的，`useState`也是存在这种情况，区别在于，`useState`可以接受初始化函数，比如

```tsx
import {useState} from 'react'
import VideoPlayer from 'videoplayer'
function VideoPlayerComponent() {
  const [player] = useState(() => new VideoPlayer())
  //
}
```

所以，在使用`playerRef`的时候，需要对它做个判断：

```tsx
import {useRef} from 'react'
import VideoPlayer from 'videoplayer'

function VideoPlayerComponent() {
  const playerRef = useRef<VideoPlayer | null>(null)

  if (playerRef.current === null) {
    playerRef.current = new VideoPlayer()
  }

  const onClick = () => {
    // Error: Object is possibly 'null'.
    playerRef.current.play()
  }
}
```

组件只会调用一次`new VideoPlayer()`并存储在`playerRef`中，但是 typescript 会检查并提示`Error: Object is possibly 'null'`

解决方法：

operation chaining - 可选链

`playerRef.current.play()` => `playerRef.current？.play()`

useImmutableRefValue

```tsx
import {useMemo, useRef} from 'react'

const useImmutableRefValue = <R,>(createRef: () => R) => {
  const ref = useRef<R>()

  const value = useMemo(() => {
    if (!ref.current) {
      ref.current = createRef()
    }

    return ref.current
    // Only one instance, no deps required.
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [])

  return value
}

export default useImmutableRefValue
```

```tsx
import VideoPlayer from 'videoplayer'
import useImmutableRefValue from 'useImmutableRefValue'

function Component() {
  const player = useImmutableRefValue(() => new VideoPlayer())

  const onClick = () => {
    player.play()
  }
}
```


useRef 返回一个可变的 ref 对象，其 .current 属性被初始化为传入的参数（initialValue），返回的 ref 对象在组件的整个生命周期内保持不变。