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

Chrome插件开发 - Repeating notifications


在 JavaScript 中，undefined 是一个原始值，表示没有值。它是未初始化变量的默认值，也是没有返回值的函数返回的值。

你可以使用 undefined 值来检查变量是否已初始化或函数是否已返回值：

```js
let x
console.log(x === undefined) // true

function f() {}
console.log(f() === undefined) // true
```

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

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

```js
console.log(typeof undefined) // "undefined"
```

此外，你还可以使用 undefined 值将变量重置为其默认值：

```js
let x = 1
x = undefined // x 现在为 undefined
```

通常认为使用 undefined 值重置变量是不好的做法，因为它会导致混淆，使代码难以理解。相反，最好是明确将变量设置为 null 或其他在代码上下文中有意义的值。

总之，undefined 是 JavaScript 中的原始值，表示没有值。它是未初始化变量的默认值，也是没有返回值的函数返回的值。您可以使用“未定义”值来检查变量是否已初始化，或者函数是否已返回值，您还可以使用`typeof`操作符来检查值是否为 undefined。然而，使用 typeof 来检查值是否为 undefined 来重置变量通常被认为是一种不好的做法。


Undefined


Hook 是 React 16.8 的新增特性。它可以让你在不编写 class 的情况下使用 state 以及其他的 React 特性。

- useState
- useEffect
- useRef
- useContext
- useCallback
- useMemo

## 使用 useState

`useState` 可以让你在不编写 class 的情况下使用 state。

```jsx
import {useState} from 'react'

function Counter() {
  const [count, setCount] = useState(0)

  function updateCount() {
    setCount(count + 1)
  }

  return <button onClick={updateCount}>Count is: {count}</button>
}
```

`useState`第一个参数是初始值，第二个参数是一个函数，这个函数可以更新初始值。

如果更新函数返回值与初始值相同，那么组件不会更新。否则将组件的重新渲染加入队列。

## 使用 useEffect

`useEffect(callback[, dependencies]);`

- `callback`是包含副作用逻辑的函数
- `dependencies`是一个数组，表示依赖的数据发生变化时，`callback`函数才会执行。

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

当`dependecies`未提供时，每次渲染都会执行`callback`函数。

当`dependencies`提供的是一个空数组时，`callback`函数只会执行一次。

当`dependencies`提供的是一个不为空的数组时，`callback`函数会在依赖的数据发生变化时执行。

```jsx
import {useEffect} from 'react'

function MyComponent() {
  useEffect(() => {
    // perform side effect here
  }, [])
}
```

[A Simple Explanation of React.useEffect()](https://dmitripavlutin.com/react-useeffect-explanation/)

## 使用 useRef

`useRef`允许直接访问 JSX 元素的 DOM 元素。

```jsx
import {useRef} from 'react'

function MyComponent() {
  const ref = useRef()

  return <div ref={ref} />
}
```

此时，可以使用`ref.current`访问到 DOM 元素。比如：

```jsx
import {useWindowEvent} from '@mantine/hooks'
import {useRef} from 'react'

function Header() {
  const inputRef = useRef()

  useWindowEvent('keydown', (event) => {
    if (event.code === 'KeyK' && event.ctrlKey) {
      event.preventDefault()
      inputRef.current.focus()
    }
  })

  return <input ref={inputRef} />
}
```

## 使用 useContext

`useContext`提供比`Context.Consumer`更简单的方式来访问 Context。比如：

```jsx
import { createContext, useContext } from 'react';

const NameContext = createContext('');

function App() {
  return (
    <NameContext.Provider value="John Doe">
      <Body />
    <NameContext.Provider>
  );
}

function Body() {
  return <Greeting />;
}

function Greeting() {
	const name = useContext(NameContext);

  return (
    <h1>Welcome, {name}</h1>
  );
}
```

## 使用 useCallback

`useCallback`返回一个 memoized 函数，这个函数会在组件的每次渲染时被调用。

`useCallback(fn,deps)`，类似于 vue 中的 computed

```jsx
function App() {
  const [player, setPlayer] = React.useState('')
  const [players, setPlayers] = React.useState(['Messi', 'Ronaldo', 'Laspada'])

  function handleChangeInput(event) {
    setPlayer(event.target.value)
  }
  function handleAddPlayer() {
    setPlayers(players.concat(player))
  }
  const handleRemovePlayer = useCallback(
    (player) => {
      setPlayers(players.filter((p) => p !== player))
    },
    [players]
  )

  return (
    <>
      <input onChange={handleChangeInput} />
      <button onClick={handleAddPlayer}>Add Player</button>
      <PlayerList players={players} handleRemovePlayer={handleRemovePlayer} />
    </>
  )
}

function PlayerList({players, handleRemovePlayer}) {
  return (
    <ul>
      {players.map((player) => (
        <li key={player} onClick={() => handleRemovePlayer(player)}>
          {player}
        </li>
      ))}
    </ul>
  )
}
```

## 使用 useMemo

`useMemo`返回一个 memoized 值，与`useEffect`、`useCallback`类似，接收函数和依赖项作为参数。

```jsx
import * as React from 'react'
import {getMDXComponent} from 'mdx-bundler/client'

function Post({code, frontmatter}) {
  const Component = React.useMemo(() => getMDXComponent(code), [code])

  return (
    <>
      <header>
        <h1>{frontmatter.title}</h1>
        <p>{frontmatter.description}</p>
      </header>
      <main>
        <Component />
      </main>
    </>
  )
}
```


Hook 是 React 16.8 的新增特性。它可以让你在不编写 class 的情况下使用 state 以及其他的 React 特性。

React Hooks


枚举是一种定义通用类型的方式，它定义了一组相关值的列表。每个枚举成员都代表了一个具体的值，并且可以附加额外的信息，例如关联值或原始值。

以下是一个简单的示例，用于定义枚举类型 CompassPoint，该类型表示了四个基本的方向：

```swift
enum CompassPoint {
  case north
  case south
  case east
  case west
}

var direction = CompassPoint.north
```

在上面的示例中，CompassPoint 是一个枚举类型，它包含了四个成员，每个成员代表一个基本的方向。direction 是一个变量，它的类型是 CompassPoint，它被初始化为 CompassPoint.north。

枚举成员可以包含关联值，这些关联值可以是任何类型。例如，以下是一个枚举类型 Barcode，它可以表示一个标准的商品条形码或一个自定义的二维码：

```swift
  case upc(Int, Int, Int, Int)
  case qrCode(String)
}

var productBarcode = Barcode.upc(8, 85909, 51226, 3)
```

在上面的示例中，Barcode 是一个枚举类型，它包含了两个成员，一个是 upc，它使用四个 Int 类型的关联值表示商品的标准条形码；另一个是 qrCode，它使用一个 String 类型的关联值表示自定义的二维码。productBarcode 是一个变量，它的类型是 Barcode，它被初始化为 Barcode.upc。

枚举成员还可以包含原始值，这些原始值可以是任何类型，但必须是相同的类型。原始值可以是字符串、字符、整数或浮点数。例如，以下是一个枚举类型 Planet，它使用浮点数原始值表示每个行星的相对质量：

```swift
enum Planet: Double {
  case mercury = 0.055
  case venus = 0.815
  case earth = 1.0
  case mars = 0.107
  case jupiter = 318.0
  case saturn = 95.0
  case uranus = 14.0
  case neptune = 17.0
}

let earthWeight = 70.0
let planet = Planet.jupiter
let relativeWeight = planet.rawValue * earthWeight
```

在上面的示例中，Planet 是一个枚举类型，它使用浮点数原始值表示每个行星的相对质量。earthWeight 是一个 Double 类型的常量，表示一个人在地球上的体重。planet 是一个变量，它的类型是 Planet，它被初始化为 Planet.jupiter。relativeWeight 是一个常量，它的值是 Jupiter 相对于地球的质量与 earthWeight 的乘积。



枚举是一种定义通用类型的方式，它定义了一组相关值的列表。每个枚举成员都代表了一个具体的值，并且可以附加额外的信息，例如关联值或原始值。

Swift - 枚举


CSS 动画（CSS Animations）是一种使用 CSS 属性来实现元素动态变化的技术。它允许您在不使用 JavaScript 或 Flash 等技术的情况下，通过使用 CSS 属性来创建动态效果。

CSS 动画由两个主要组成部分组成：关键帧（Keyframes）和动画属性（Animation Properties）。

关键帧是指定义了动画在不同时间点上应该显示的样式。例如，您可以定义一个在动画开始时显示元素，然后在 50% 处旋转元素，最后在动画结束时将其变形的关键帧。

动画属性用于指定动画如何进行，包括动画持续时间、延迟、动画速度和重复次数等。通过指定这些属性，您可以控制动画的时序和执行方式。

下面是一个简单的 CSS 动画示例，该示例将使元素在 2 秒内从左侧滑动到右侧：

```css
/* 定义动画关键帧 */
@keyframes slide {
  from {
    margin-left: 0;
  }
  to {
    margin-left: 100px;
  }
}

/* 应用动画属性 */
.element {
  animation-name: slide;
  animation-duration: 2s;
}
```

在这个例子中，我们首先定义了一个名为 slide 的关键帧，该关键帧定义了元素的初始样式（from）和结束样式（to）。然后，我们将 slide 动画应用于一个类名为 .element 的元素，通过设置 animation-name 和 animation-duration 属性来指定动画名称和持续时间。

CSS 动画有许多属性可以用于自定义动画效果，包括动画延迟、动画速度、动画方向、动画填充模式等。通过熟练使用这些属性，您可以创建出非常丰富的动画效果，从简单的平移和旋转到复杂的路径动画和变形效果。


css - Animations


JavaScript 中的函数执行过程可以分为两个阶段：函数定义和函数调用。

## 函数定义阶段：

在 JavaScript 中，函数可以通过函数声明或函数表达式的方式进行定义。在函数定义阶段，JavaScript 解析器会扫描代码，将函数声明和函数表达式提升到作用域的顶部。这意味着函数可以在其定义之前被调用。
例如：

```javascript
foo() // 函数调用在函数定义之前

function foo() {
  console.log('Hello, world!')
}
```

在上述代码中，函数 foo 在被定义之前就被调用了，这是因为函数定义在代码执行之前被提升到了作用域的顶部。

## 函数调用阶段：

在函数调用阶段，JavaScript 解释器会执行函数体中的代码。当函数被调用时，会创建一个新的执行上下文（Execution Context），并且将该执行上下文推入执行上下文栈（Execution Context Stack）中。

执行上下文包含了函数的作用域、参数、变量以及函数内部的代码执行位置等信息。在函数执行过程中，JavaScript 解释器根据代码的执行顺序逐行执行函数内部的语句。

函数执行过程中涉及以下几个重要的步骤：

- 创建函数的作用域链：在函数执行前，JavaScript 解释器会创建一个作用域链，该链包含了函数自身作用域以及所有外部作用域。作用域链的顶部是全局作用域。
- 创建函数的活动对象（Activation Object）：活动对象是函数执行过程中的一个内部对象，用于存储函数的参数、局部变量和内部函数的引用。活动对象会被添加到作用域链的顶部，成为当前执行上下文的变量对象。
- 解析和执行函数的代码：JavaScript 解释器会逐行解析和执行函数体中的代码。在执行过程中，变量会根据作用域链进行查找和访问。
- 返回结果或继续执行：函数执行过程中可能会返回一个值，也可能不返回任何值。当函数执行完毕或遇到 return 语句时，会将结果返回给调用者，并将当前执行上下文从执行上下文栈中弹出，恢复到上一个执行上下文继续执行。

总结起来，JavaScript 中的函数执行包括函数定义阶段和函数调用阶段。在函数定义阶段，函数声明和函数表达式被提升到作用域的顶部。在函数调用阶段，创建执行上下文，建立作用域链和活动对象，执行函数体中的代码，最后返回结果或继续执行其他代码。理解函数的执行过程对于编写和调试 JavaScript 代码非常重要。


理解函数的执行过程


**协议没看懂~**

> 协议规定了用来实现某一特定功能所必需的方法和属性。
> 任意能够满足协议要求的类型被称为遵循(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.
- 协议扩展允许您向协议添加方法和计算属性。
- 面向协议的编程是将您的应用程序架构设计为一系列协议，然后使用协议扩展来提供默认方法实现的实践


协议规定了用来实现某一特定功能所必需的方法和属性。