全局(客户端)状态管理并不总是像今天这样。我清楚地记得有一段时间，在高阶组件中的状态管理最佳选择是使用Redux， connect 连接 mapStateToProps 和 mapDispatchToProps。

Zustand-入门


## 3 种数组去重方法

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

## Set

```js
const arr=[1,2,🤩,🤩,🤩,2,1]
console.log([...new Set(arr)])
```

## filter

```js
const arr=[1,2,🤩,🤩,🤩,2,1]
arr.filter((item,index)=>arr.indexOf(item)===index)
```

## reduce

```js
const arr=[1,2,🤩,🤩,🤩,2,1]
arr.reduce((unique,item)=>unique.includes(item)?unique:[...unique,item],[])
```


数组去重


当输出数据时，我们希望能够按照一定的格式输出，这个时候就可以使用 format()函数。比如：

```python
      Name      Shares        Price
----------  ----------  -----------
        AA         100        32.20
       IBM          50        91.10
       CAT         150        83.44
      MSFT         200        51.23
        GE          95        40.37
      MSFT          50        65.10
       IBM         100        70.44
```

## 字符输出格式化

在`python 3.6+`使用`f-strings`格式化字符串，如下：

```python
name = 'IBM'
shares = 100
price = 91.1
f'{name:>10s} {shares:>10d} {price:>10.2f}'
#'       IBM        100      91.10'

# 通常配合 print()函数使用，如下：
print(f'{name:>10s} {shares:>10d} {price:>10.2f}')
```

## 格式化代码

格式代码(在`{}`中`:` 之后)类似于 c `printf ()`。常见代码包括:

```python
d       # 整数
b       # 十六进制
x       # 十六进制
f       # 浮点数
e       # 指数
g       # 指数或浮点数
s       # 字符串
c       # 字符
```

常用的修饰符调整字段宽度和十进制精度。这是一个部分列表:

```python
:>10d   # 宽度为10，十进制精度无限制
:<10d   # 宽度为10，十进制精度无限制
:^10d   # 宽度为10，十进制精度无限制
:0.2f   # 宽度为无限制，十进制精度为2
```

## 字典格式化

使用`format_map`函数可以将字典中的键和值对应输出，如下：

```python
s = {
    'name': 'IBM',
    'shares': 100,
    'price': 91.1
}
'{name:>10s} {shares:10d} {price:10.2f}'.format_map(s)
#'       IBM        100      91.10'
```

## format()函数

```python
'{name:>10s} {shares:10d} {price:10.2f}'.format(name='IBM', shares=100, price=91.1)
#'       IBM        100      91.10'
'{:10s} {:10d} {:10.2f}'.format('IBM', 100, 91.1)
#'       IBM        100      91.10'
```

## C 语言格式化

使用`%`可以格式化字符串，如下：

```python
'The value is %d' % 3
#'The value is 3'
'%5d %-5d %10d' % (3,4,5)
#'    3 4              5'
'%0.2f' % (3.1415926,)
#'3.14'
```


Formatting - 格式化


Automatic Reference Counting（ARC）是一种内存管理机制，它是由苹果公司在其 Objective-C 和 Swift 语言中使用的。ARC 的作用是在程序运行时自动管理对象的内存，从而避免了手动管理内存的繁琐和容易出错的问题。

在 Objective-C 中，ARC 是默认开启的，它通过计算对象的引用计数来自动管理对象的内存。每当一个对象被创建时，它的引用计数会被初始化为 1，每当一个对象被引用时，它的引用计数会增加 1，每当一个对象不再被引用时，它的引用计数会减少 1。当一个对象的引用计数为 0 时，它就会被自动释放掉。

在 Swift 中，ARC 同样是默认开启的，它采用了和 Objective-C 相同的引用计数机制。不同的是，在 Swift 中，我们可以使用强引用、弱引用和无主引用来管理对象的内存。强引用是最常见的引用类型，它会使对象的引用计数增加 1，并且只有在没有任何强引用指向对象时，对象的引用计数才会减少 1；弱引用和无主引用则可以用来避免循环引用的问题。

在使用 ARC 时，我们只需要遵循一些基本规则即可避免内存泄漏和野指针等问题。例如，我们可以使用 weak 或 unowned 来避免循环引用的问题；我们不应该手动管理内存，例如使用 retain、release 和 autorelease 等方法；我们需要避免在闭包中持有 self 等对象，以避免循环引用的问题等。

除了基本规则外，ARC 还提供了一些高级特性，例如自动闭包和无主引用等。下面我们来看一些常见的 ARC 特性。

## 自动闭包

自动闭包是一种方便的语法结构，它可以让我们把一个表达式封装成一个闭包，并在需要时自动调用它。在 Swift 中，我们可以使用 @autoclosure 关键字来声明一个自动闭包。例如：

```swift
func printIfTrue(_ predicate: @autoclosure () -> Bool) {
  if predicate() {
    print("True")
  } else {
    print("False")
  }
}

printIfTrue(2 + 2 == 4)
```

在上面的代码中，我们定义了一个 printIfTrue 函数，它接受一个返回 Bool 类型的自动闭包作为参数，并在需要时自动调用它。在调用该函数时，我们可以传递一个表达式，例如 2 + 2 == 4，这个表达式会被自动封装成一个闭包，并在 printIfTrue 函数中被调用。

## 无主引用

无主引用是一种特殊的弱引用，它用来避免弱引用在使用时被意外释放的问题。在 Swift 中，我们可以使用 unowned 关键字来声明一个无主引用。例如：

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

    init(name: String) {
        self.name = name
    }

    deinit {
        print("\(name) is being deinitialized")
    }
}

class Apartment {
  let number: Int
  weak var tenant: Person?

    init(number: Int) {
        self.number = number
    }

    deinit {
        print("Apartment #\(number) is being deinitialized")
    }
}

var john: Person?
var number73: Apartment?

john = Person(name: "John")
number73 = Apartment(number: 73)

john!.apartment = number73
number73!.tenant = john

john = nil
number73 = nil
```

在上面的代码中，我们定义了一个 Person 类和一个 Apartment 类，它们之间通过弱引用和无主引用进行关联。具体来说，Person 类中的 apartment 属性是一个可选的 Apartment 类型，并且它是通过弱引用来实现的；而 Apartment 类中的 tenant 属性是一个可选的 Person 类型，并且它是通过无主引用来实现的。这样，在我们释放 john 和 number73 变量所占用的内存时，它们之间的引用关系就可以正确地被解除。

总的来说，ARC 是一种非常方便和安全的内存管理机制，它可以自动管理对象的内存，从而避免了手动管理内存的繁琐和容易出错的问题。在使用 ARC 时，我们只需要遵循一些基本规则和高级特性即可，从而让我们更加专注于应用程序的业务逻辑。


ARC 的作用是在程序运行时自动管理对象的内存，从而避免了手动管理内存的繁琐和容易出错的问题。

Swift - ARC(内存管理机制)


Go 是一种强类型的编程语言，因此在使用变量时需要明确指定其类型。变量是用于存储数据的容器，可以在程序执行的过程中被修改。在 Go 中，变量需要先声明后使用，可以使用 var 关键字来声明变量并指定其类型，也可以使用 := 运算符来进行简化声明。
以下是一些关于 Go 变量的详细解释：

## 变量声明

使用 var 关键字可以声明一个变量，语法如下：

```go
var variable_name data_type
```

例如，以下代码声明了一个整型变量 x 和一个字符串变量 s：

```go
var x int
var s string
```

变量声明时也可以初始化变量的值，例如：

```go
var x int = 5
var s string = "Hello, World!"
```

同时也可以使用 := 运算符来简化变量的声明和初始化，例如：

```go
x := 5
s := "Hello, World!"
```

注意：使用 := 运算符时，变量的类型会由编译器自动推断出来。

## 变量赋值

使用赋值运算符 = 可以将一个值赋给一个变量。例如：

```go
x := 5
x = 10
```

在赋值时，变量的类型必须与赋给它的值的类型相同，否则会报错。

## 变量类型

在 Go 中，每个变量都必须有一个类型。常见的类型包括整型（int）、浮点型（float）、字符串（string）、布尔型（bool）等。例如：

```go
var x int
var f float64
var s string
var b bool
```

同时，Go 也支持使用类型别名来定义自己的类型。例如：

```go
type myInt int
var x myInt
```

## 多个变量声明

可以同时声明多个变量，例如：

```go
var x, y int
var s1, s2 string
```

在同时声明多个变量时，可以使用 := 运算符来简化，例如：

```go
x, y := 1, 2
s1, s2 := "Hello", "World"
```

## 常量

与变量类似，常量也是用于存储数据的容器，但是它们的值在程序执行期间不能被修改。在 Go 中，使用 const 关键字来声明常量，例如：

```go
const pi float64 = 3.14159265358979323846
const daysOfWeek = 7
```

在声明常量时，可以不指定类型，编译器会根据常量的值自动推断类型，例如：

```go
const pi = 3.14159265358979323846
const daysOfWeek = 7
```

常量的值必须在编译时就能确定，不能在运行时修改。


Go - 变量、类型、常量


在这篇文章，我们将把我们已经非常出色的弹出式浏览器扩展变得更加个性化。

为了维护用户选择的内容，我们将利用 chrome 的存储能力。

<video
  src="https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/storage_fdefvm.webm"
  autoPlay
></video>

## 增加浏览器扩展存储权限

修改`manifest.json`，在权限数组新增`storage`

```json
{
  "permissions": ["alarms", "notifications", "storage"]
}
```

编写扩展主体

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

const colorMatch = {
  indigo: 'bg-indigo-400',
  pink: 'bg-pink-400',
  purple: 'bg-purple-400'
}

export function App() {
  const [color, setColor] = useState('indigo')

  const createNotification = () => {
    chrome.alarms.create('motivation_alarm', {
      periodInMinutes: 60
    })
    window.close()
  }

  const stopNotification = () => {
    chrome.alarms.clearAll()
    window.close()
  }

  chrome.storage.sync.get('color', (storedColor) => {
    setColor(storedColor.color)
  })

  const pickColor = (pickedValue) => {
    setColor(pickedValue)
    chrome.storage.sync.set({color: pickedValue})
  }

  return (
    <div
      className={`flex flex-col items-center justify-center w-screen h-auto ${colorMatch[color]} p-4`}
    >
      <select
        onChange={(event) => pickColor(event.target.value)}
        value={color}
        className="bg-gray-50 border border-gray-300 text-gray-900 text-sm rounded-lg focus:ring-indigo-500 focus:border-indigo-500 block w-full p-2.5 dark:bg-gray-700 dark:border-gray-600 dark:placeholder-gray-400 dark:text-white dark:focus:ring-indigo-500 dark:focus:border-indigo-500"
      >
        <option>Pick a color</option>
        <option value="indigo">Indigo</option>
        <option value="pink">Pink</option>
        <option value="purple">Purple</option>
      </select>
      <br />
      <button
        className="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 text-2xl px-4 rounded"
        onClick={createNotification}
      >
        Motivate me 🎉
      </button>
      <br />
      <button
        className="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 text-2xl px-4 rounded"
        onClick={stopNotification}
      >
        Stop motivating me 😅
      </button>
    </div>
  )
}
```

## Source Code

[【Source Code】](https://github.com/rebelchris/popup-extension/tree/storage)


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

Chrome插件开发 - Using storage


在上一篇文章[【Add Tailwind】](/blog/translate/build-chrome-extensions/add-tailwind)学习了集成 tailwind。

这篇文章学习使用 react 创建一个新标签插件，类似如图：

也可以使用其他自己喜欢的框架：vue、angular、svlete 等

<video
  src="https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/react-browser_jqqqkk.webm"
  autoPlay
/>

## 安装 React

```bash
npm install react react-dom
touch -p index.js src/{App,Counter}.js
vim new-tab.html
```

**new-tab.html**

```html
<body>
  <div id="app"></div>
  <script type="module" src="index.js"></script>
</body>
```

**index.js**

```js
import ReactDOM from 'react-dom'
import {App} from './src/App'

const app = document.getElementById('app')
ReactDOM.render(<App />, app)
```

**App.js**

```js
import Counter from './Counter'
export function App() {
  return (
    <div className="flex flex-col items-center justify-center w-screen h-screen bg-indigo-400 text-6xl font-bold text-white">
      <p>Welcome 👋</p>
      <Counter />
    </div>
  )
}
```

**Counter.js**

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

export default function Counter() {
  const [counter, setCounter] = useState(0)
  const increase = () => setCounter((count) => count + 1)
  const decrease = () => setCounter((count) => count - 1)
  return (
    <div>
      <button onClick={decrease}>-</button>
      <span className="px-4">{counter}</span>
      <button onClick={increase}>+</button>
    </div>
  )
}
```

跑起来

```bash
npm run build
```

## 测试插件

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

可以在这里找到[【Source Code】](https://github.com/rebelchris/new-tab-extension/tree/react)
