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

Chrome插件开发 - 插件介绍


## 运行 python

> Python 程序总是在解释器中运行。解释器是一个“基于控制台的”应用程序，通常使用命令运行。

```python
python3
Python 3.9.8 (main, Nov 10 2021, 03:55:42)
[Clang 13.0.0 (clang-1300.0.29.3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>
```

## 交互模式

当在终端运行`python3`后，就进入了交互模式，即 REPL。

- `>>>`表示开始新的语句
- `...`表示继续上一条语句
- `_`表示最后的返回值

```python
>>> print('hello world')
hello world
>>> 37*42
1554
>>> for i in range(5):
...     print(i)
...
0
1
2
3
4
>>>
```

## 创建程序

> python 程序以`.py`结尾，可以直接运行。

```python
# hello.py
print('hello world')
```

## 运行程序

> python 程序运行的命令是`python hello.py`

```python
$ python hello.py
$ python3 hello.py
```

## 样例程序

> 问题：一天早上，你出去，在芝加哥西尔斯大厦旁的人行道上放了一张美元钞票。从那以后，你每天出去的账单都会翻倍。这堆钞票超过塔的高度需要多长时间？

解决方法：

```python
# sears.py
bill_thickness = 0.11 * 0.001 # Meters (0.11 mm)
sears_height = 442 # Height (meters)
num_bills = 1
day = 1

while num_bills * bill_thickness < sears_height:
    print(day, num_bills, num_bills * bill_thickness)
    day = day + 1
    num_bills = num_bills * 2

print('Number of days', day)
print('Number of bills', num_bills)
print('Final height', num_bills * bill_thickness)
```

```bash
bash % python3 sears.py
1 1 0.00011
2 2 0.00022
3 4 0.00044
4 8 0.00088
5 16 0.00176
6 32 0.00352
...
21 1048576 115.34336
22 2097152 230.68672
Number of days 23
Number of bills 4194304
Final height 461.37344
```

### 语句

> 每行语句以换行符结束，但是不能以分号结束。

```python
a = 3 + 4
b = a * 2
print(b)
```

### 注释 comment

> 注释以#开始，不会被运行。

```python
a = 3 + 4
# This is a comment
b = a * 2
print(b)
```

### 类型与变量 type&variable

> python 属于动态类型语言，变量可以随时变化。python 变量名称可以包含字母、数字、下划线，但不能以数字或关键字开头。对大小写敏感。

```python
height = 442           # An integer
height = 442.0         # Floating point
height = 'Really tall' # A string

# 大小写敏感
name = 'Jake'
Name = 'Elwood'
NAME = 'Guido'

while x < 0:   # OK
WHILE x < 0:   # ERROR
```

### 循环 for/while

```python
while num_bills * bill_thickness < sears_height:
    print(day, num_bills, num_bills * bill_thickness)
    day = day + 1
    num_bills = num_bills * 2

print('Number of days', day)
```

### 缩进 indentation

> 缩进是用来表示一组连在一起的语句:

```python
while num_bills * bill_thickness < sears_height:
    print(day, num_bills, num_bills * bill_thickness)
    day = day + 1
    num_bills = num_bills * 2

print('Number of days', day)
```

- 使用空格代替 tab 来缩进
- 使用 4 个空格来缩进

### 条件语句 if-else

```python
if a > b:
    print('Computer says no')
elif a == b:
    print('Computer says yes')
else:
    print('Computer says maybe')
```

### 输出语句 print

```python
print('Hello world!') # Prints the text 'Hello world!'

#用户输出
name = input('Enter your name:')
print('Your name is', name)
```


First Program - 第一个程序


在上一篇文章[【First Extension】](/blog/translate/build-chrome-extensions/first-extension)学习了创建第一个插件。

这篇文章学习创建一个主题插件。

## 结构

```bash
mkdir theme-extension && cd theme-extension
```

更改`manifest.json`

```json
{
  "manifest_version": 3,
  "version": "2.6",
  "name": "daily dev tips theme",
  "theme": {
    "images": {
      "theme_frame": "images/frame-background.png",
      "theme_frame_overlay": "images/frame-background.png",
      "theme_tab_background": "images/tab-background.png",
      "theme_ntp_background": "images/ntp-background.png"
    },
    "colors": {
      "toolbar": [0, 185, 232],
      "tab_background_text": [255, 255, 255],
      "tab_text": [255, 255, 255],
      "bookmark_text": [255, 255, 255],
      "ntp_text": [218, 0, 96],
      "ntp_link": [218, 0, 96],
      "ntp_section": [255, 255, 255],
      "ntp_background": [255, 255, 255]
    },
    "tints": {
      "buttons": [1, 1, 1]
    },
    "properties": {
      "ntp_logo_alternate": 0,
      "ntp_background_alignment": "center"
    }
  }
}
```

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

上图解释了每个配置对应的效果

Images:

- `theme_frame`:无法为外部框架设置颜色，但是可以选择 1x1 像素的图像。
- `theme_frame_overlay`:左上角
- `theme_tab_background`:tab 每个标签的背景，包括标签栏的其他按钮背景
- `theme_ntp_background`:当前 tab 背景，建议用大图

Colors:

- `toolbar`:工具栏颜色
- `tab_background_text`:标签背景字体颜色
- `tab_text`:标签字体颜色
- `bookmark_text`:书签字体颜色
- `ntp_text`:新标签导航字体颜色
- `ntp_link`:新标签链接字体颜色
- `ntp_section`:新标签模块字体颜色？
- `ntp_background`:新标签背景颜色

Tints:

有六个值，分别是`background_tab`,`buttons`,`frame`,`frame_inactive`,`frame_incognito`,`frame_incognito_inactive`
他们的用法都一样，都是色调在色调饱和度（HSL）格式，使用范围 0 - 1.0：色调是绝对值，在 0 和 1 之间饱和是相对于当前的图像的。0.5 没有变化，0 完全不饱和，1 是完全饱和度。亮度也是相对的，0.5 没有变化，0 像素黑色，1 作为所有像素白色。

Properties:

- `ntp_logo_alternate`:新页面大图是否重复-`no-repeat`、`repeat_x`、`repeat_y`、`repeat`
- `ntp_background_alignment`:新页面大图的位置-`center`、`left`、`top`、`right`、`bottom`

## 测试扩展

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


Chrome插件开发 - 第一个主题


在 Swift 中，方法是与类、结构体、枚举等相关联的函数。方法允许我们在类、结构体、枚举等中定义某些行为。方法可以访问和修改实例属性，以及提供对实例的功能性访问。

Swift 中的方法分为两种：实例方法和类型方法。

## 实例方法

实例方法是与特定类、结构体、枚举等实例相关联的函数。实例方法提供对实例的访问和操作，可以访问和修改实例属性，也可以调用其他实例方法和全局函数。实例方法的定义和调用示例如下：

```swift
class Counter {
var count = 0

    func increment() {
        count += 1
    }

    func increment(by amount: Int) {
        count += amount
    }

    func reset() {
        count = 0
    }
}

let counter = Counter()
counter.increment()
counter.increment(by: 5)
counter.reset()
```

在上面的示例中，我们定义了一个 Counter 类，它有一个 count 实例属性和三个实例方法：increment、increment(by:) 和 reset。increment 方法将 count 属性加 1，increment(by:) 方法将 count 属性加上指定的 amount 值，reset 方法将 count 属性重置为 0。然后，我们创建了一个 Counter 实例 counter，并分别调用了它的三个实例方法。

## 类型方法

类型方法是与类型本身相关联的函数。类型方法是通过类型名称调用的，而不是通过实例调用的。类型方法可以访问和修改类型属性，也可以调用其他类型方法和全局函数。在 Swift 中，使用 static 关键字来定义类型方法，对于类类型，也可以使用 class 关键字来定义类型方法。类类型中的 class 方法可以被子类重写，而 static 方法不能被子类重写。类型方法的定义和调用示例如下：

```swift
class SomeClass {
  static func someTypeMethod() {
    // 在这里实现类型方法
  }
}

SomeClass.someTypeMethod()
```

在上面的示例中，我们定义了一个 SomeClass 类，它有一个 static 类型方法 someTypeMethod。在调用 someTypeMethod 时，我们使用类名来调用该类型方法，而不是使用实例。

总之，方法提供了一种方便的方式来定义类、结构体、枚举等的行为，以及提供对实例和类型的功能性访问。使用实例方法可以访问和修改实例属性，并提供对实例的访问和操作。使用类型方法可以访问和修改类型属性，并提供对类型的访问和操作。


在 Swift 中，方法是与类、结构体、枚举等相关联的函数。方法允许我们在类、结构体、枚举等中定义某些行为。方法可以访问和修改实例属性，以及提供对实例的功能性访问。

Swift - 方法


在 Swift 中，Opaque types（不透明类型）是一种声明方式，它可以隐藏类型的实现细节，同时提供一个公共接口供外部使用，这样可以使代码更加模块化和安全。

在 Swift 中，我们可以使用 protocol 关键字来声明一个协议，然后使用 associatedtype 关键字来声明一个不透明类型。例如：

```swift
protocol Container {
  associatedtype Item
  var count: Int { get }
  subscript(i: Int) -> Item { get }
}
```

在上面的代码中，我们定义了一个 Container 协议，它包含一个不透明类型 Item，以及一个 count 属性和一个下标操作符。这个协议的具体实现可以是任何符合该协议的类型，只要它们实现了 count 和下标操作符即可。

在使用该协议时，我们可以使用一种特殊的语法来创建一个不透明类型。例如：

```swift
struct Stack<Element>: Container {
// original Stack<Element> implementation
...

    // Opaque type
    typealias Item = Element
}
```

在上面的代码中，我们定义了一个 Stack 结构体，它实现了 Container 协议，并声明了一个不透明类型 Item，它的实际类型是 Element。这样，外部代码可以使用 Item 类型来访问 Stack 结构体的元素，但是无法直接访问 Element 类型。

例如，我们可以使用下面的代码来创建一个 Stack 实例，并向其中添加一些元素：

```swift
var stack = Stack<Int>()
stack.push(1)
stack.push(2)
stack.push(3)
```

然后，我们可以使用下面的代码来遍历 Stack 实例中的元素：

```swift
for i in 0..<stack.count {
  print(stack[i])
}
```

在上面的代码中，我们使用 count 属性和下标操作符来遍历 Stack 实例中的元素，而不需要直接访问 Element 类型。

通过使用不透明类型，我们可以隐藏底层类型的实现细节，同时提供一个公共接口供外部使用，这样可以使代码更加模块化和安全。同时，不透明类型还可以提高代码的灵活性和可维护性，因为它可以让我们在不影响外部代码的情况下修改底层类型的实现细节。


Opaque types（不透明类型）是一种声明方式，它可以隐藏类型的实现细节，同时提供一个公共接口供外部使用，这样可以使代码更加模块化和安全。

Swift - 模糊类型


## 为什么要使用 debounce 和 throttle

防抖和节流就是针对响应跟不上触发频率这类问题的两种解决方案。在给 DOM 绑定事件时，有些事件我们是无法控制触发频率的。 如鼠标移动事件 onmousemove, 滚动滚动条事件 onscroll，窗口大小改变事件 onresize，瞬间的操作都会导致这些事件会被高频触发。 如果事件的回调函数较为复杂，就会导致响应跟不上触发，出现页面卡顿，假死现象。 在实时检查输入时，如果我们绑定 onkeyup 事件发请求去服务端检查，用户输入过程中，事件的触发频率也会很高，会导致大量的请求发出，响应速度会大大跟不上触发。

## 在 watcher 中使用 debounce

1. 在`created`生命周期将`this.debounce`绑定到`this`上，这样`this.debounce`就可以在`created`生命周期中使用。
2. 在`watch`函数中，使用`this.debounce`调用`debounce`函数，并传入`this.debounce`的回调函数。
3. 在事件销毁前，使用`this.debounce`调用`clear`函数，清除定时器。

```html
<template>
  <input v-model="value" type="text" />
  <p>{{ value }}</p>
</template>
<script>
  import debounce from 'lodash.debounce'
  export default {
    data() {
      return {
        value: ''
      }
    },
    watch: {
      value(...args) {
        this.debouncedWatch(...args)
      }
    },
    created() {
      this.debouncedWatch = debounce((newValue, oldValue) => {
        console.log('New value:', newValue)
      }, 500)
    },
    beforeUnmount() {
      this.debouncedWatch.cancel()
    }
  }
</script>
```

## 使用 debounce 处理事件

```html
<template>
  <input v-on:input="debouncedHandler" type="text" />
</template>
<script>
  import debounce from 'lodash.debounce'
  export default {
    created() {
      this.debouncedHandler = debounce((event) => {
        console.log('New value:', event.target.value)
      }, 500)
    },
    beforeUnmount() {
      this.debouncedHandler.cancel()
    }
  }
</script>
```

为什么不适用`debounce`或`throttle`直接绑定函数呢？比如：

```html
<template>
  <input v-on:input="debouncedHandler" type="text" />
</template>
<script>
  import debounce from 'lodash.debounce'
  export default {
    methods: {
      // Don't do this!
      debouncedHandler: debounce(function (event) {
        console.log('New value:', event.target.value)
      }, 500)
    }
  }
</script>
```

**使用`export default { ... }`从组件导出的 options 对象，包括方法，将被组件的所有实例重用。如果网页中有 2 个或更多的组件实例，那么所有的组件都将使用相同的`debounce`或`throttle`的函数方法。**

## 总结

在 `vue` 中使用 `debounce` 和 `throttle` 函数，应该在 `created` 和 `beforeUnmount` 生命周期中使用，而不是在 `watch` 中使用。

```html
<template>
  <input v-on:input="debouncedHandler" type="text" />
</template>
<script>
  export default {
    created() {
      this.debouncedCallback = debounce((...args) => {
        // The debounced
        callback
      }, 500)
    },
    watch: {
      value(...args) {
        this.debouncedCallback(...args)
      }
    }
  }
</script>
```


如input、resize、scroll、intersection observer 等事件可能发生得非常频繁，例如每秒发生几次，因此调用一个动作，比如对每个事件发出读取请求，并不是一个明智的方法。

如何在 vue 中使用 Debounce、Throttle


JavaScript 中的 null 值表示没有值或空引用。它是语言中的基本值之一，其他基本值还有 undefined、true 和 false。

你可以这样将 null 值赋给变量：

```js
let x = null
```

null 经常用来表示对象值的缺失。例如，你可以使用 null 来表示函数的结果缺失：

```js
function getUser(id) {
  let user = database.get(id)
  if (!user) {
    return null
  }
  return user
}

let user = getUser(123)
if (user === null) {
  console.log('用户未找到')
} else {
  console.log(user.name)
}
```

在上面的例子中，如果在数据库中未找到用户，函数 getUser() 将返回 null。

请注意，null 与 undefined 不同，undefined 表示没有值。在 JavaScript 中，未初始化的变量的默认值是 undefined，而 null 是可以赋值给变量的值。

你还可以使用 null 值将对象重置为初始状态：

```js
let obj = {a: 1, b: 2}
obj = null // obj 现在为 null
```

最后，你可以使用 typeof 运算符来检查一个值是否为 null。typeof 运算符对于 null 值会返回字符串 "object"：

```js
console.log(typeof null) // "object"
```

但是，这种行为被视为语言中的 bug，不会改变。建议只在对象值的上下文中使用 null
