Next.js - how-to-programmatically-navigate-in-next-js


## 总览

程序员经常会用到的集合，列表、字典、集合。比如：

- 股票池
- 股票价格

有多种选择来处理这一系列数据：

- 列表。表示一组有序的数据
- 字典。表示一组键值对的数据
- 集合。表示一组无序的数据

## 列表

当数据的顺序很重要时，使用列表。记住列表可以容纳任何类型的对象。例如，元组列表。

```python
portfolio = [
    ('GOOG', 100, 490.1),
    ('IBM', 50, 91.3),
    ('CAT', 150, 83.44)
]

portfolio[0]            # ('GOOG', 100, 490.1)
portfolio[2]            # ('CAT', 150, 83.44)

# 列表构造
records=[] #初始化一个空列表

records.append(('foo', 1, 2)) #添加元素
records.append(('bar', 'hello')) #添加元素

#从文件读取数据并写入列表
with open('data.csv', 'w') as f:
    next(f) #跳过第一行
    for line in f:
        row = line.strip().split(',')
        records.append((row[0], row[1], row[2]))
```

## 字典

如果你想要快速随机查找(按键名) ，字典是很有用的。例如，股票价格字典:

```python
prices = {
   'GOOG': 513.25,
   'CAT': 87.22,
   'IBM': 93.37,
   'MSFT': 44.12
}

prices['IBM']           # 93.37
prices['MSFT']          # 44.12

# 字典构造
prices = {} #初始化一个空字典

prices['GOOG'] = 513.25 #添加元素
prices['CAT'] = 87.22 #添加元素

#从文件读取数据并写入字典
with open('data.csv', 'w') as f:
    next(f) #跳过第一行
    for line in f:
        row = line.strip().split(',')
        prices[row[0]] = row[1]

# 字典查找
if 'GOOG' in prices:
    print('GOOG is in prices')

name = prices.get('GOOG', 'N/A') #N/A表示默认值

prices.get('GOOG', 0) # 513.25
prices.get('SCOX', 0) # 0

# 复合键 - 任何类型的数据都可以作为字典的键。例如，元组:

holidays = {
    (1, 1): 'New Year\'s Day',
    (7, 4): 'Independence Day',
    (12, 25): 'Christmas'
}
holidays[(1, 1)] # 'New Year\'s Day'
```

## 集合

集合是一种特殊的字典，表示一组无序的数据，数据不重复。

```python
tech_stocks = {'GOOG', 'IBM', 'CAT'}
tech_stocks = set(['GOOG', 'IBM', 'CAT'])

names = ['IBM', 'AAPL', 'GOOG', 'IBM', 'GOOG', 'YHOO']

unique = set(names)
# unique = set(['IBM', 'AAPL','GOOG','YHOO'])

unique.add('CAT')        # Add an item
unique.remove('YHOO')    # Remove an item

s1 = { 'a', 'b', 'c'}
s2 = { 'c', 'd' }
s1 | s2                 # Set union { 'a', 'b', 'c', 'd' }
s1 & s2                 # Set intersection { 'c' }
s1 - s2                 # Set difference { 'a', 'b' }

```


Collections of python - 集合


CSS 的继承是指某个元素的某个样式属性可以被它的后代元素继承。具体来说，如果一个元素的某个样式属性没有被显式地设置，那么这个属性就会从它的父元素继承。如果父元素也没有设置这个属性，那么这个属性就会继续向上寻找，直到找到有设置这个属性的元素或者到达根元素为止。

CSS 的继承是一种很方便的样式控制方式，它可以让页面的样式表更加简洁，同时也可以减少代码量，提高开发效率。下面是一些常见的继承属性：

- 字体属性：字体大小、字体样式、字体粗细、字体颜色等属性都是可以被继承的。
- 文本属性：文本对齐方式、文本缩进、行高、文字间距等属性也是可以被继承的。
- 列表属性：列表项的标志、列表项的编号等属性也可以被继承。
- 表格属性：表格的边框、单元格的边框、单元格的背景颜色等属性也可以被继承。

但是并不是所有的样式属性都可以被继承，例如定位、背景图像、边框样式等属性就不能被继承。此外，如果一个元素的某个样式属性被显式地设置了，那么它的后代元素就不会继承这个属性。

需要注意的是，虽然继承可以让样式表更加简洁，但是过度使用继承也可能会造成样式的混乱，特别是当嵌套层级比较深的时候。因此，在使用继承时需要注意权衡利弊，避免过度使用。

## 案例

1. 字体样式继承

```css
body {
  font-size: 16px;
  font-family: Arial, sans-serif;
  color: #333;
}

h1 {
  font-size: 24px; /* h1 标签继承了 body 的字体样式 */
  font-weight: bold; /* h1 标签自己设置了字体粗细 */
  color: red; /* h1 标签自己设置了颜色 */
}
```

2. 列表样式继承

```css
ul {
  list-style-type: disc;
  color: #333;
}

ul li {
  font-size: 14px;
  color: inherit; /* li 标签继承了 ul 的颜色 */
}
```

3. 表格样式继承

```css
table {
  border-collapse: collapse;
}

th {
  background-color: #ccc;
  font-weight: bold;
  text-align: center;
}

td {
  padding: 5px;
  border: 1px solid #ccc;
  text-align: center;
}
```

4. 表单样式继承

```css
label {
  font-weight: bold;
  color: #333;
}

input {
  border: 1px solid #ccc;
  padding: 5px;
  font-size: 14px;
}

input[type='submit'] {
  background-color: #333;
  color: #fff;
}
```


css - Inheritance


## 迭代器

在 JavaScript 中，迭代器是一种对象，它定义了一系列值以及访问这些值的方法。迭代器用于遍历集合的元素，例如数组或对象。

你可以在对象上实现 next() 方法来创建迭代器。next() 方法返回一个对象，该对象具有两个属性：value 和 done。value 属性是序列中的下一个值，done 属性是一个布尔值，表示迭代器是否到达了序列的末尾。

下面是一个迭代器的示例，它返回数组的元素：

```js
let array = [1, 2, 3]
let iterator = {
  index: 0,
  next: function () {
    if (this.index < array.length) {
      return {value: array[this.index++], done: false}
    } else {
      return {done: true}
    }
  }
}
```

你可以使用 for...of 循环来遍历迭代器返回的值：

```js
for (let value of iterator) {
  console.log(value)
}
```

上面的 for...of 循环的输出是：

```js
1
2
3
```

你还可以使用 iterator.next() 方法来手动遍历迭代器返回的值：

```js
let result = iterator.next()
while (!result.done) {
  console.log(result.value)
  result = iterator.next()
}
```

## 生成器

生成器是 JavaScript 中一种特殊的函数，它返回一个迭代器。生成器使用 function\* 语法定义，并使用 yield 关键字返回值。

下面是一个返回数组元素的生成器的示例：

```js
function* generateArrayValues(array) {
  for (let value of array) {
    yield value
  }
}

let iterator = generateArrayValues([1, 2, 3])
```

你可以使用 for...of 循环或 iterator.next() 方法来遍历生成器返回的值：

```js
for (let value of iterator) {
  console.log(value)
}

// or

let result = iterator.next()
while (!result.done) {
  console.log(result.value)
  result = iterator.next()
}
```

上面的 for...of 循环或使用 iterator.next() 的手动迭代的输出是：

```js
1
2
3
```

生成器还可以接受参数，并且可以使用 yield 关键字暂停和恢复。下面是一个生成数字序列的生成器的示例：

```js
function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    yield i
  }
}

let iterator = generateNumbers(1, 3)
for (let value of iterator) {
  console.log(value)
}
```

上面的 for...of 循环的输出是：

```bash
1
2
3

```

生成器对于创建无法一次性存储在内存中的大型值序列非常有用。它们允许你一次一个地遍历值，并在必要时暂停生成器，这可以提高代码的性能。

总之，生成器是 JavaScript 中返回迭代器的特殊函数。您可以使用 for... of 循环或 iterator.next ()方法来迭代生成器返回的值，生成器可以接受参数并使用 yield 关键字暂停和继续。


在 JavaScript 中，迭代器是一种对象，它定义了一系列值以及访问这些值的方法。迭代器用于遍历集合的元素，例如数组或对象。

iterators generators


- [插件介绍](/blog/translate/build-chrome-extensions/intro)
- [第一个插件](/blog/translate/build-chrome-extensions/first-extension)
- [第一个主题](/blog/translate/build-chrome-extensions/first-theme)
- [新标签](/blog/translate/build-chrome-extensions/new-tab)
- [使用 React 开发扩展](/blog/translate/build-chrome-extensions/spicing-with-react)
- [Switch to vite](/blog/translate/build-chrome-extensions/parcel-to-vite)
- [Popup extension](/blog/translate/build-chrome-extensions/popup-extension)
- [集成 tailwind](/blog/translate/build-chrome-extensions/add-tailwind)
- [External request](/blog/translate/build-chrome-extensions/external-requests-new-tab)
- [Popup weather extension](/blog/translate/build-chrome-extensions/popup-weather-extension)
- [Adding browser notifications](/blog/translate/build-chrome-extensions/adding-browser-notification)
- [Repeating notifications](/blog/translate/build-chrome-extensions/repeating-notifications)
- [Using storage](/blog/translate/build-chrome-extensions/using-storage)
- [Hooking into installs](/blog/translate/build-chrome-extensions/hooking-into-installs)
- [Custom options page](/blog/translate/build-chrome-extensions/custom-options-page)
- [Icon action](/blog/translate/build-chrome-extensions/icon-action)
- [Popup page modifications](/blog/translate/build-chrome-extensions/Popup-page-modifications)
- [Messaging](/blog/translate/build-chrome-extensions/messaging)
- [Modify images on the page](/blog/translate/build-chrome-extensions/modify-images-on-the-page)
- [Creating the turboreader extension](/blog/translate/build-chrome-extensions/creating-the-turboreader-extension)
- [Publishing a chrome browser extension](/blog/translate/build-chrome-extensions/publishing-a-chrome-browser-extension)


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

Chrome插件开发 - Series


[//]: # (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对象允许存储键值对。

Sets & Maps


可选链（Optional Chaining）是 Swift 中一种用于在调用属性、方法或下标脚本时处理值可能为空的机制。

在 Swift 中，如果一个对象的属性或方法返回值类型是可选类型（Optional Type），则在访问这个属性或方法时，需要使用可选链来避免空值引用导致的运行时错误。

可选链使用问号 ? 表示，如果一个属性、方法或下标脚本可能为空，则在其名称后面加上问号 ? 表示可选链：

```swift
class Person {
    var name: String?
}

let person: Person? = Person()

// 如果 person 为 nil，则不执行 name 的赋值操作
person?.name = "Tom"
```

在上述示例中，如果 person 对象为空，即使尝试给 name 属性赋值也不会引发运行时错误。

同时，可选链也可以用于调用方法或下标脚本：

```swift
class Person {
    var name: String?

    func sayHello() {
        print("Hello, my name is \(name ?? "")")
    }

    subscript(index: Int) -> String? {
        return name
    }
}

let person: Person? = Person()

// 如果 person 为空，则不执行 sayHello 方法
person?.sayHello()

// 如果 person 为空，则返回 nil
let name = person?[0]
```

在上述示例中，使用可选链调用 sayHello 方法和获取下标脚本，即使 person 为空也不会引发运行时错误。

需要注意的是，当使用可选链调用属性或方法时，如果这个属性或方法返回的是非可选类型，那么返回的值会被自动包装为可选类型。因此，当使用可选链调用方法或属性后需要对返回的值进行解包。

```swift
class Person {
    var name: String?

    func sayHello() {
        print("Hello, my name is \(name ?? "")")
    }

    func getAge() -> Int {
        return 18
    }
}

let person: Person? = Person()

// 返回值为可选类型，需要对返回值进行解包
let age = person?.getAge()

// age 的类型为 Optional<Int>，需要对其进行解包
if let age = age {
  print(age)
}
```

在上述示例中，调用 getAge 方法返回的是一个 Int 类型，但是由于使用了可选链，返回的值被自动包装成了可选类型，需要对其进行解包。


可选链（Optional Chaining）是 Swift 中一种用于在调用属性、方法或下标脚本时处理值可能为空的机制。