在 Swift 中，下标(subscript)是访问集合、列表或序列等值的快捷方式

Swift - 下标


> `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 对象在组件的整个生命周期内保持不变。

useImmutableRefValue - 帮助你更好的使用Typescript开发React应用


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

Chrome插件开发 - Creating the TurboReader browser extension


import CanIUse from 'components/CanIUse.tsx'

## Battery Api

> 提供了有关系统充电级别的信息并提供了通过电池等级或者充电状态的改变提醒用户的事件，Battery Status API 向 window.navigator 扩展了一个 navigator.getBattery 方法，其返回了一个 battery promise, 完成后传递一个 BatteryManager 对象，并提供了一些新的可以操作电池状态的事件。

<CanIUse tag="will-change" />

## 方法

- chargingchange
- levelchange
- chargingtimechange
- dischargingtimechange

```js
navigator.getBattery().then(function (battery) {
  console.log('Battery charging? ' + (battery.charging ? 'Yes' : 'No'))
  console.log('Battery level: ' + battery.level * 100 + '%')
  console.log('Battery charging time: ' + battery.chargingTime + ' seconds')
  console.log(
    'Battery discharging time: ' + battery.dischargingTime + ' seconds'
  )

  battery.addEventListener('chargingchange', function () {
    console.log('Battery charging? ' + (battery.charging ? 'Yes' : 'No'))
  })

  battery.addEventListener('levelchange', function () {
    console.log('Battery level: ' + battery.level * 100 + '%')
  })

  battery.addEventListener('chargingtimechange', function () {
    console.log('Battery charging time: ' + battery.chargingTime + ' seconds')
  })

  battery.addEventListener('dischargingtimechange', function () {
    console.log(
      'Battery discharging time: ' + battery.dischargingTime + ' seconds'
    )
  })
})
```

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

[chrome-image]: https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/CDWccX.jpg
[firefox-image]: https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/mqRvLw.jpg
[ie-image]: https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/uKn6gH.jpg
[opera-image]: https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/mpzJp6.jpg
[safari-image]: https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/mIxpPG.jpg
[edge-image]: https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/aoF7l0.jpg


Battery Api提供了有关系统充电级别的信息并提供了通过电池等级或者充电状态的改变提醒用户的事件

Battery Api


## cli

`Next.js`提供了一个简单的命令行工具，可以帮助我们快速部署和管理应用。

```bash
npx next -h

#设置端口
npx next dev -p 4000 #开发模式
PORT=4000 npx next dev #开发模式

npx next start -p 4000 #生产模式
PORT=4000 next start #生产模式

next lint #检查代码规范

next build #构建静态资源
next export #导出静态资源
```

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

```bash
➜  demo npm run build

> demo@1.0.0 build
> next build

info  - Checking validity of types
warn  - No ESLint configuration detected. Run next lint to begin setup
info  - Creating an optimized production build
info  - Compiled successfully
info  - Collecting page data
info  - Generating static pages (3/3)
info  - Finalizing page optimization

Page                                       Size     First Load JS
┌ λ /                                      470 B          75.4 kB
├   /_app                                  0 B            74.9 kB
├ ○ /404                                   193 B          75.1 kB
├ λ /api                                   0 B            74.9 kB
└ ○ /posts/first                           2.75 kB        77.7 kB
    └ css/9871d7e98c5c71df.css             103 B
+ First Load JS shared by all              74.9 kB
  ├ chunks/framework-a87821de553db91d.js   45 kB
  ├ chunks/main-d8b1ff545a609496.js        28.6 kB
  ├ chunks/pages/_app-05a4472bc3e8727e.js  507 B
  ├ chunks/webpack-69bfa6990bb9e155.js     769 B
  └ css/5d2c4ba91281dd0f.css               175 B

λ  (Server)  server-side renders at runtime (uses getInitialProps or getServerSideProps)
○  (Static)  automatically rendered as static HTML (uses no initial props)
```

## deployment

通过`next build`构建静态资源，然后通过`next export`导出静态资源。

- `.next/static/chunks/pages`–此文件夹中的每个 JavaScript 文件都与具有相同名称的路由相关联。例如，.next/static/chunks/pages/about.js 将是在应用程序中查看/about 路由时加载的 JavaScript 文件
- `.next/static/media`–从 next/image 静态导入的图像在这里散列和复制
- `.next/static/css`–应用程序中所有页面的全局 CSS 文件
- `.next/server/pages`–从服务器预呈现的 HTML 和 JavaScript 入口点`.nft.json` 文件在启用输出文件跟踪时创建，并包含依赖于给定页面的所有文件路径。
- `.next/server/chunks`– 在整个应用程序的多个地方使用的共享 JavaScript 块
- `.next/cache`–从 Next.js 服务器输出构建缓存和缓存的图像、响应和页面。使用缓存有助于减少构建时间并提高加载图像的性能

部署方式

- Vercel
- netlify
- github pages
- firebase
- self-hosted
- node.js server
- docker

## SSG vs SSR

[SSG vs SSR](https://blog.logrocket.com/ssg-vs-ssr-in-next-js/)


Next.js - CLI & Deployment


嵌套类型（nested types）指的是在一个类，结构体或枚举中定义的另一个类，结构体或枚举。嵌套类型可以在外部类型中使用，但也可以在内部类型的范围内使用。

Swift 中的嵌套类型具有以下特性：

- 嵌套类型可以在外部类型中使用，可以像外部类型的属性或方法一样使用嵌套类型。
- 嵌套类型可以访问外部类型的所有成员，包括私有成员。
- 嵌套类型可以继承自外部类型，也可以作为外部类型的类型成员。

使用嵌套类型可以使代码更加有组织性，也可以减少全局作用域中的名称冲突。

以下是嵌套类型示例：

```swift
struct Outer {
    var outerProperty: Int

    struct Inner {
        var innerProperty: String
    }

    func outerMethod() {
        let outerInner = Inner(innerProperty: "Inner property")
        print("outerMethod called with inner property: \(outerInner.innerProperty)")
    }
}

let outer = Outer(outerProperty: 10)
let outerInner = Outer.Inner(innerProperty: "Inner property")
outer.outerMethod()  // 输出 "outerMethod called with inner property: Inner property"
```

在上面的示例中，Outer 的内部有一个嵌套类型 Inner。Inner 中有一个成员 innerProperty。outerMethod 可以访问 Inner，并使用它创建一个实例，然后访问其成员。在外部类型中，我们可以像使用普通类型一样使用 Inner。

另外，嵌套类型还可以被用于支持泛型类型的实现。当你定义一个泛型类型时，你可以定义嵌套类型作为泛型类型的一部分，这有助于在更加抽象化的层次上组织和定义代码，从而使泛型类型更加通用化和模块化。

以下是一个嵌套类型用于支持泛型的示例：

```swift
struct Container<T> {
    var value: T

    struct Nested {
        var nestedValue: T
    }

    var nested: Nested {
        return Nested(nestedValue: value)
    }
}

let container = Container(value: 42)
let nested = container.nested // 生成一个 nestedValue 为 42 的 Container.Nested 实例
```

在这个示例中，嵌套类型 Nested 中的成员 nestedValue 的类型与容器的泛型类型参数 T 一样。实例化容器时，使用 42 初始化元素 value，然后访问其嵌套类型 Nested。内部类型 Nested 通过嵌套容器类型的泛型类型参数 T 来支持类型实例化。

总之，在 Swift 中，嵌套类型有助于组织和定义代码，减少名称冲突，提高代码可读性和可管理性，并支持泛型类型实现。


嵌套类型（nested types）指的是在一个类，结构体或枚举中定义的另一个类，结构体或枚举。嵌套类型可以在外部类型中使用，但也可以在内部类型的范围内使用。

Swift - 嵌套类型


[//]: # (https://www.freecodecamp.org/news/set-and-map-in-javascript/)
## Sets

`Sets`对象是值的集合，它不允许重复的值，并且是无序的。

```js
// 创建 Set 对象
const emptySet = new Set()
// 添加元素到 Set 对象
emptySet.add('red').add('green').add('blue')
// 移除元素
emptySet.delete('red')
// 检查是否包含某个值
emptySet.has('green') // true
// 清除所有元素
emptySet.clear()
// 迭代 Set 对象
for (let item of emptySet) {
  console.log(item) // 'green', 'blue'
}
// 将 Set 对象转换为数组
;[...emptySet] // ['green', 'blue']
Array.from(emptySet) // ['green', 'blue']
```

去重

```js
Array.from(new Set(['red', 'green', 'blue', 'red', 'green', 'blue'])) // ['red', 'green', 'blue']
```

创建一组 Unicode 字符

```js
new Set('abc')
new Set(['a', 'b', 'c'])
assert.deepEqual(new Set('abc'), new Set(['a', 'b', 'c'])) // true
```

与映射键一样，`Set`元素与===进行比较，唯一不同的是`NaN`等于自身，但是`object`不等于自身。

```js
const set = new Set([NaN, NaN, NaN]) // Set { NaN }
set.size // 1
set.has(NaN) // true

const set2 = new Set()
set2.add({})
set2.size === 1 // true
set2.add({})
set2.size === 2 // true
```

合并两个 Set

> 计算两个集合 a 和 b 的并集意味着创建一个包含 a 和 b 元素的集合。

```js
const a = new Set([1, 2, 3]) // Set { 1, 2, 3 }
const b = new Set([4, 3, 2]) // Set { 2, 3, 4 }
const union = new Set([...a, ...b]) // Set { 1, 2, 3, 4 }
```

Set 的交集

> 计算两个集合 a 和 b 的交集意味着创建一个集合，其中包含 a 中也在 b 中的元素。

```js
const a = new Set([1, 2, 3]) // Set { 1, 2, 3 }
const b = new Set([4, 3, 2]) // Set { 2, 3, 4 }
const intersection = new Set(Array.from(a).filter((x) => b.has(x))) // Set { 2, 3 }
```

Set 的差集

> 计算两个集合 a 和 b 之间的差意味着创建一个集合，其中包含不在 b 中的 a 元素。此操作有时也称为减号(−).

```js
const a = new Set([1, 2, 3]) // Set { 1, 2, 3 }
const b = new Set([4, 3, 2]) // Set { 2, 3, 4 }
const difference = new Set(Array.from(a).filter((x) => !b.has(x))) // Set { 1 }
```

遍历 Set

> Set 没有 map 方法

```js
const set = new Set([1, 2, 3]) // Set { 1, 2, 3 }
const mappedSet = new Set(Array.from(set).map((x) => x * 2)) // Set { 2, 4, 6 }
```

过滤 Set

> Set 没有 filter 方法

```js
const set = new Set([1, 2, 3, 4, 5]) // Set { 1, 2, 3, 4, 5 }
const filteredSet = new Set(
  Array.from(set).filter((x) => x % 2 === 0) // Set { 2, 4 }
)
```

## Maps

`Map` 对象保存键值对，并且能够记住键的原始插入顺序。任何值(对象或者原始值) 都可以作为一个键或一个值。

一个 `Map` 对象在迭代时会根据对象中元素的插入顺序来进行 — 一个 `for...of` 循环在每次迭代后会返回一个形式为`[key，value]`的数组。

创建 `Map` 对象

```js
const emptyMap = new Map() // Map {}
emptyMap.size === 0 // true

// 添加键值对
emptyMap.set('foo', 'bar') // Map { 'foo' => 'bar' }

// 复制一个 Map 对象
const copy = new Map(emptyMap) // Map { 'foo' => 'bar' }

//获取键值对
emptyMap.get('foo') // 'bar'

//判断是否存在某个键
emptyMap.has('foo') // true

// 删除键值对
emptyMap.delete('foo') // true
emptyMap.has('foo') // false

// 获取Map对象大小
emptyMap.size // 0

// 删除所有键值对
emptyMap.clear() // Map {}
```

遍历 `Map`

```js
const map = new Map().set(false, 'no').set(true, 'yes') // Map { false => 'no', true => 'yes' }
for (const key of map.keys()) {
  console.log(key) // false, true
}
```

`entries()` 方法返回一个新的包含 `[key, value]` 对的 Iterator 对象，返回的迭代器的迭代顺序与 `Map` 对象的插入顺序相同。

```js
const map = new Map().set(false, 'no').set(true, 'yes') // Map { false => 'no', true => 'yes' }
for (const entry of map.entries()) {
  console.log(entry) // [false, 'no'], [true, 'yes']
}
```

`keys()` 返回一个引用的 `Iterator` 对象。它包含按照顺序插入 `Map` 对象中每个元素的 key 值。

```js
const map = new Map([
  ['a', 1],
  ['b', 2]
])
map.keys() // MapIterator { 'a', 'b' }
```

`values()` 方法返回一个新的 `Iterator` 对象。它包含按顺序插入 `Map` 对象中每个元素的 `value` 值。

```js
const map = new Map([
  ['a', 1],
  ['b', 2]
])
map.values() // MapIterator { 1, 2 }
```

合并两个 `Map` 对象

```js
const map1 = new Map().set(1, '1a').set(2, '1b').set(3, '1c') // Map { 1 => '1a', 2 => '1b', 3 => '1c' }
const map2 = new Map().set(2, '2b').set(3, '2c').set(4, '2d') // Map { 2 => '2b', 3 => '2c', 4 => '2d' }
const map3 = new Map(map1).set(4, '2d') // Map { 1 => '1a', 2 => '2b', 3 => '2c', 4 => '2d' }
```


Sets对象允许存储唯一的值，而Map对象允许存储键值对。