Swift是一种适用于iOS、macOS、watchOS和tvOS应用程序的编程语言。

Swift - 基础知识


当输出数据时，我们希望能够按照一定的格式输出，这个时候就可以使用 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 - 格式化


在上一篇文章[【Spicing with react】](/blog/translate/build-chrome-extensions/spicing-with-react)学习了使用 react 创建新标签插件。

这篇文章替换掉 parcel，切换到 vite

删除`.parcel`

删除`package.json`内的`"parcel": "^2.7.0","parcel-reporter-static-files-copy": "^1.3.4",`

添加`vite`

```json
{
  "scripts": {
    "dev": "vite",
    "build": "vite build",
    "preview": "vite preview"
  },
  "dependencies": {
    "vite": "^3.0.4"
  },
  "devDependencies": {
    "@vitejs/plugin-react": "^2.0.0"
  }
}
```

重命名文件

- `App.js`=>`App.jsx`
- `Counter.js`=>`Counter.jsx`
- `index.js`=>`index.jsx`

将`index.jsx`移动到`src`

重命名`static`为`public`

由于没有使用`index.html`，所以要在`vite.config.js`特殊声明一下

```js
import {defineConfig} from 'vite'
import react from '@vitejs/plugin-react'

export default defineConfig({
  plugins: [react()],
  build: {
    rollupOptions: {
      input: {
        app: './new-tab.html'
      }
    }
  }
})
```

跑起来

```bash
npm run build
```

[【Source Code】](https://github.com/rebelchris/new-tab-extension/tree/vite)


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

Chrome插件开发 - Switch to vite


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

即使是`context api`，最初也不是那么符合需求 ，因为刚出的时候只支持自身`props`。

当然，hooks 出现后一切都变了。不仅现有的解决方案变得更容易使用，而且新的解决方案也诞生了。

## Zustand

其中增长迅速的像`Zustand`，它非常小而精悍，提供了简易`api`创建全局状态以及通过`selectors`过来状态。它类似`Redux`，又比`Redux`简易。

就像`React`，`Zustand`提供丰富的扩展，可以结合[immer](https://github.com/pmndrs/zustand/tree/2b29d736841dc7b3fd7dec8cbfea50fee7295974#sick-of-reducers-and-changing-nested-state-use-immer)，也可以使用其他[middlewares](https://github.com/pmndrs/zustand/tree/2b29d736841dc7b3fd7dec8cbfea50fee7295974#middleware)

`Zustand` 将 `createStore` 函数的返回值作为一个自定义 hook 来实现，其中为了让 `React` 组件能感知到状态更新，是利用 `useEffect` 来完成订阅操作，而状态更新发布后，则通过 `forceUpdate()` 来强制组件进行 `rerender` 以获取最新的状态。

实际上，用法和 `react-redux` 非常相似，但获取状态与更新状态均只需要使用 `useStore` 一个 API 即可完成业务。

我从 2018 年开始在大小项目中使用`Zustand`，我也为`Zustand`开源做过贡献，以下是一些在实践中积累的技巧。

### 仅导出自定义钩子

这是首要技巧，对于任何 React 开发都满足，我之前列出了很多[Hooks 优点](https://tkdodo.eu/blog/simplifying-use-effect#3-write-custom-hooks)。

```js
// ⬇️ not exported, so no one can subscribe to the whole store
const useBearStore = create((set) => ({
  bears: 0,
  fish: 0,
  increasePopulation: (by) => set((state) => ({bears: state.bears + by})),
  eatFish: () => set((state) => ({fish: state.fish - 1})),
  removeAllBears: () => set({bears: 0})
}))

// 💡 exported - consumers don't need to write selectors
export const useBears = () => useBearStore((state) => state.bears)
```

它们将为您提供更清晰的界面，并且您不需要在所有您希望只订阅状态的一个值的地方编写选择器。此外，它还避免了意外地订阅整个状态:

```js
// ❌ we could do this if useBearStore was exported
const {bears} = useBearStore()
```

虽然结果可能是相同的(你会得到 bear 的数量) ，上面的代码将订阅你的整个状态，这意味着你的组件将在某个状态更新后全部重新渲染 ，即使 bear 没有改变，比如，fish 的状态改变了。`Selectors`在 `Zustand` 是可选择的，但对我来说，他们真的不是。即使我们有一个只有一个状态值的存储，我也会编写自定义钩子，以便将来能够添加更多的状态。

### 多使用原子选择器

这个在[官方文档](https://github.com/pmndrs/zustand/tree/2b29d736841dc7b3fd7dec8cbfea50fee7295974#selecting-multiple-state-slices)也解释了，所以我会尽量简短，但是非常重要，因为错用、滥用它可能会导致渲染性能下降。

`Zustand` 通过比较选择器的结果和之前渲染的结果来决定何时通知组件更新。默认情况下，它通过严格的相等检查来完成。

实际上，这意味着选择器必须返回稳定的结果。如果返回一个新的 `Array` 或 `Object`，它将始终被视为更改，即使内容相同:

```js
// 🚨 selector returns a new Object in every invocation
const {bears, fish} = useBearStore((state) => ({
  bears: state.bears,
  fish: state.fish
}))

// 😮 so these two are equivalent
const {bears, fish} = useBearStore()
```

如果要从选择器返回 Object 或 Array，可以将比较函数调整为使用浅比较:

```js
import shallow from 'zustand/shallow'

// ⬇️ much better, because optimized
const {bears, fish} = useBearStore(
  (state) => ({bears: state.bears, fish: state.fish}),
  shallow
)
```

然而我更倾向于导出两个独立的`selectors`

```js
export const useBears = () => useBearStore((state) => state.bears)
export const useFish = () => useBearStore((state) => state.fish)
```

假如组件需要多个值，引入多个 hooks 即可。

### actions 和 state 分离

actions 是不变的静态函数，它更新 state 中的值，所以它们不是真正的“状态”。将它们作为一个额外的对象在我们的存储中分离将允许我们将它们作为一个钩子暴露出来，然后我们可以在组件中使用它们:

```js
const useBearStore = create((set) => ({
  bears: 0,
  fish: 0,
  // ⬇️ separate "namespace" for actions
  actions: {
    increasePopulation: (by) => set((state) => ({bears: state.bears + by})),
    eatFish: () => set((state) => ({fish: state.fish - 1})),
    removeAllBears: () => set({bears: 0})
  }
}))

export const useBears = () => useBearStore((state) => state.bears)
export const useFish = () => useBearStore((state) => state.fish)

// 🎉 one selector for all our actions
export const useBearActions = () => useBearStore((state) => state.actions)
```

现在可以只使用一个 hooks 导出所有的 actions

```js
const {increasePopulation} = useBearActions()
```

这看起来和上面提到的原子选择器相反，但是事实并非如此，由于 `actions` 不会改变，`actions` 可以看出是一个原子块。

### Model Actions as Events, not Setters

这是一个通用的提示，无论你是否使用 `useReducer`、 `Redux` 或 `Zustand`。
事实上，这个技巧直接来自 [Redux 风格指南](https://redux.js.org/style-guide/style-guide#model-actions-as-events-not-setters)。
它将帮助您将业务逻辑保留在存储中，而不是保留在组件中。
上面的例子已经使用了这种模式——逻辑(例如“增加人口”)存在于状态中。
组件只是调用操作，而存储决定如何处理它。

### 保持状态小型化

与 `Redux` 不同的是，`Zustand` 鼓励您拥有多个小型状态。每个状态可以对单个状态负责。如果你需要组合它们，你可以使用自定义钩子:

```js
const currentUser = useCredentialsStore((state) => state.currentUser)
const user = useUsersStore((state) => state.users[currentUser])
```

> 注意: Zustand 确实有另外一种将状态组合成切片的方法，但是我从来不需要这种方法。对我来说，它看起来不是很简单，尤其是涉及到 TypeScript 的时候。如果我真的需要它，我可能会选择 Redux Toolkit。

### 结合其他库

老实说，我并不经常需要组合多个 `Zustand` 状态，因为应用程序中的大多数状态要么是服务器状态，要么是 URL 状态。与将两个状态组合起来相比，我更有可能将 `Zustand` 状态与 `useQuery` 或 `useParams` 结合起来。不过，同样的原则也适用于: 如果你需要将另一个钩子与 `Zustand` 状态结合起来，自定义钩子也许是你最好的选择:

```js
const useFilterStore = create((set) => ({
  applied: [],
  actions: {
    addFilter: (filter) =>
      set((state) => ({applied: [...state.applied, filter]}))
  }
}))

export const useAppliedFilters = () => useFilterStore((state) => state.applied)

export const useFiltersActions = () => useFilterStore((state) => state.actions)

// 🚀 combine the zustand store with a query
export const useFilteredTodos = () => {
  const filters = useAppliedFilters()
  return useQuery({
    queryKey: ['todos', filters],
    queryFn: () => getTodos(filters)
  })
}
```

在这里，应用的筛选器驱动查询，因为筛选器是查询键的一部分。
每次调用 `addFilter` (可以在 UI 中的任何地方执行)时，都会自动触发一个新查询，这个查询也可以在 UI 中的任何地方使用。
我觉得这是一个非常简洁明了的说明，但又不会太神奇。


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

Zustand-入门


在 Swift 中，高级运算符是那些执行特定任务或操作的运算符。Swift 支持大部分标准 C 语言中的运算符，并增加了一些新的运算符。高级运算符可以用于自定义类型和类库中，也可以用于 Swift 标准库中定义的类型。Swift 中支持的高级运算符包括：

- 位运算符：按位操作二进制数据，包括按位取反、按位与、按位或、按位异或等。
- 移位运算符：用来对二进制数据进行左移或右移操作。
- 溢出运算符：对于数值类型，当其存储的值超出其所能容纳的范围时，就会发生溢出。Swift 中提供了溢出加法运算符（&+）、溢出减法运算符（&-）和溢出乘法运算符（&\*）来处理这种情况。
- 比较运算符：用于比较两个值的大小关系，包括等于、不等于、大于、小于、大于等于和小于等于等。
- 逻辑运算符：用于组合和操作布尔值，包括逻辑非、逻辑与和逻辑或。
- 匹配模式运算符：用于判断一个值是否匹配某个模式，包括元组模式、可选模式、类型转换模式等。

Swift 还提供了一些自定义高级运算符的功能。开发者可以通过运算符函数来定义新的运算符，并对其进行重载。这使得 Swift 具有更高的可读性和可维护性，并能够实现更简洁和灵活的代码实现。


在 Swift 中，高级运算符是那些执行特定任务或操作的运算符。Swift 支持大部分标准 C 语言中的运算符，并增加了一些新的运算符。高级运算符可以用于自定义类型和类库中，也可以用于 Swift 标准库中定义的类型

Swift - 高级操作符


Swift 中的错误处理是一种机制，用于在程序执行期间检测和处理错误。错误是指在程序执行期间发生的意外事件，例如网络连接中断、文件未找到等等。Swift 使用 try，catch 和 throw 语句来支持错误处理。

当一个函数可能会抛出错误时，需要在函数的定义中使用 throws 关键字来表示这一点。这告诉调用者，调用该函数可能会导致一个错误，并且必须用 try 语句调用该函数。

## 抛出错误

在 Swift 中，抛出错误使用 throw 关键字。如果一个函数、方法或初始化器可能出现错误，需要在声明中使用 throws 关键字来标识。例如：

```swift
enum MyError: Error {
  case invalidValue
}

func divide(_ x: Int, by y: Int) throws -> Int {
  if y == 0 {
    throw MyError.invalidValue
  }
  return x / y
}
```

在上述示例中，divide(\_:by:) 函数可能会抛出一个 MyError.invalidValue 类型的错误。

## 处理错误

当一个函数、方法或初始化器可能抛出错误时，调用者必须使用 try 关键字来调用该函数，否则会编译错误。例如：

```swift
do {
let result = try divide(10, by: 2)
  print(result)
} catch {
  print(error)
}
```

在上述示例中，使用 try 关键字调用了 divide(\_:by:) 函数，并使用 do-catch 语句捕获可能抛出的错误。如果函数调用成功，result 的值将被打印，否则将打印错误信息。

当调用一个可能抛出错误的函数时，可以使用多种方式来处理错误。例如，可以使用 do-catch 语句捕获错误、使用 try? 关键字将错误转换为可选值，或使用 try! 关键字表示该函数不会抛出错误。例如：

```swift
// 使用 try? 关键字将错误转换为可选值
let result1 = try? divide(10, by: 0)
print(result1)

// 使用 try! 关键字表示该函数不会抛出错误
let result2 = try! divide(10, by: 2)
print(result2)
```

在上述示例中，try? 关键字将错误转换为可选值，如果函数调用成功，则返回结果，否则返回 nil。try! 关键字表示该函数不会抛出错误，如果函数调用失败，程序将崩溃。

自定义错误类型
在 Swift 中，可以自定义错误类型来表示具体的错误信息。自定义的错误类型需要实现 Error 协议。例如：

```swift
enum MyError: Error {
  case invalidValue
  case networkError(String)
  case fileError(String, Int)
}
```

在上述示例中，定义了一个 MyError 类型，包含了三种错误情况：invalidValue 表示无效的数值，networkError 表示网络错误，fileError 表示文件错误，并且每种错误情况都包含了不同的错误信息。

例如，以下是一个可能会抛出错误的函数：

```swift
Copy code
func divide(_ dividend: Int, by divisor: Int) throws -> Int {
guard divisor != 0 else {
throw NSError(domain: "com.example", code: 0, userInfo: [
NSLocalizedDescriptionKey: "Cannot divide by zero"
])
}

    return dividend / divisor
}
```

在这个函数中，如果除数为零，就会抛出一个错误。我们可以使用 do 和 catch 语句来捕获和处理错误：

```swift
do {
  let result = try divide(10, by: 2)
  print(result) // Output: 5
} catch {
  print("Error: \(error)") // Output: Error: Cannot divide by zero
}
```

在上面的代码中，我们将 divide 函数的返回值存储在 result 变量中。如果 divide 函数抛出一个错误，那么程序将跳转到 catch 块，并打印错误信息。

除了使用 do 和 catch 语句来处理错误之外，还可以使用 try?和 try!语句来简化错误处理过程。try?语句将函数的返回值转换为一个可选类型，如果函数抛出错误，则返回 nil。try!语句则在函数抛出错误时直接崩溃程序。建议使用 try?和 try!语句的场景非常有限，因为它们会让程序在运行时变得不可预测。例如，以下是一个可能会抛出错误的函数：

```swift
func divide(_ dividend: Int, by divisor: Int) throws -> Int {
  guard divisor != 0 else {
    throw NSError(domain: "com.example", code: 0, userInfo: [
    NSLocalizedDescriptionKey: "Cannot divide by zero"
  ])
}

    return dividend / divisor
}
```

在这个函数中，如果除数为零，就会抛出一个错误。我们可以使用 do 和 catch 语句来捕获和处理错误：

```swift
do {
  let result = try divide(10, by: 2)
  print(result) // Output: 5
} catch {
  print("Error: \(error)") // Output: Error: Cannot divide by zero
}
```

在上面的代码中，我们将 divide 函数的返回值存储在 result 变量中。如果 divide 函数抛出一个错误，那么程序将跳转到 catch 块，并打印错误信息。

除了使用 do 和 catch 语句来处理错误之外，还可以使用 try?和 try!语句来简化错误处理过程。try?语句将函数的返回值转换为一个可选类型，如果函数抛出错误，则返回 nil。try!语句则在函数抛出错误时直接崩溃程序。建议使用 try?和 try!语句的场景非常有限，因为它们会让程序在运行时变得不可预测。


错误处理是一种处理程序运行过程中可能出现错误的机制。

Swift - 错误处理


使用 Postgresql `IS NULL`运算符来检查值是否为 NULL。

## IS NULL

在数据库中，`NULL` 是一个特殊的值，它表示一个值没有被设置。

`NULL`和任何值比较都会返回 NULL，即使是`NULL`本身。

```sql
NULL = NULL
```

首先创建一个表，并且插入一些数据：

```sql
CREATE TABLE contacts(
    id INT GENERATED BY DEFAULT AS IDENTITY,
    first_name VARCHAR(50) NOT NULL,
    last_name VARCHAR(50) NOT NULL,
    email VARCHAR(255) NOT NULL,
    phone VARCHAR(15),
    PRIMARY KEY (id)
);

INSERT INTO contacts(first_name, last_name, email, phone)
VALUES ('John','Doe','john.doe@example.com',NULL),
    ('Lily','Bush','lily.bush@example.com','(408-234-2764)');
```

找出`contacts`表中没有电话号码的联系人

```sql
SELECT
    id,
    first_name,
    last_name,
    email,
    phone
FROM
    contacts
WHERE
    phone = NULL;
```

以上语句没有返回任何结果。因为`phone=NULL`总是返回`false`，应当使用`phone IS NULL`

```sql
SELECT
    id,
    first_name,
    last_name,
    email,
    phone
FROM
    contacts
WHERE
    phone IS NULL;
```

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

## IS NOT NULL

与`IS NULL`相反，`IS NOT NULL`检查值是否不为 NULL。

比如，查询有电话号码的联系人

```sql
SELECT
    id,
    first_name,
    last_name,
    email,
    phone
FROM
    contacts
WHERE
    phone IS NOT NULL;
```

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


使用 Postgresql LIKE 检索查询是否为NULL。