当浏览器从在线与离线状态中切换时，这两个事件会在页面的 body 上触发

online&offline


Swift 是一种适用于 iOS、macOS、watchOS 和 Apple tvOS app 开发的新编程语言。尽管如此，Swift的许多部分将从您在C和Objective-C中开发的经验中熟悉。

Swift提供所有基本C和Objective-C类型的版本，包括用于整数的Int、用于浮点值的Double和Float、用于布尔值的Bool和用于文本数据的String。Swift还提供了三种主要集合类型的强大版本，例如Array、Set和Dictionary，如Collection Types中所述。

与C一样，Swift使用变量通过标识名称存储和引用值。Swift还广泛使用其值无法更改的变量。这些被称为常数，比C中的常数强大得多。当您处理不需要更改的值时，整个Swift都使用常量，以使代码的意图更安全、更清晰。

除了熟悉的类型外，Swift还引入了Objective-C中没有的高级类型，例如元组。元组使您能够创建和传递值分组。您可以使用元组将函数中的多个值作为单个复合值返回。

Swift还引入了可选类型，用于处理缺少值的情况。可选的说“有一个值，它等于x”或“根本没有值”。使用可选选项类似于在Objective-C中使用带有指针的nil，但它们适用于任何类型，而不仅仅是类。可选选项不仅比Objective-C中的nil指针更安全、更具表现力，而且是Swift许多最强大功能的核心。

Swift是一种类型安全的语言，这意味着该语言可以帮助您清楚地了解代码可以使用的值类型。如果您的部分代码需要String，类型安全性会阻止您错误地将其传递给Int。同样，类型安全可防止您意外地将可选String传递给需要非可选String的代码。类型安全可帮助您尽早在开发过程中捕获和修复错误。

## 常量和变量

常量和变量将值分配给特定的标识符，以便您可以在代码中引用它们。常量的值一旦设置就无法更改，而变量的值可以更改。

### 声明常量和变量

您可以使用let关键字声明常量，使用var关键字声明变量。常量和变量的名称可以包含任何字符，包括Unicode字符：

```swift
let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0
```

常量和变量的名称不能包含空格、数学符号、箭头、保留的（或者非法的）Unicode代码点、连线和制表符。也不能以数字开头，但可以在名称的其他地方包含数字。

打印常量和变量的值：

```swift
print(maximumNumberOfLoginAttempts)
print(currentLoginAttempt)
```

使用反斜杠（\）将常量和变量的名称放在括号中，以在字符串插值中包含它们的当前值：

```swift
print("Maximum number of login attempts is \(maximumNumberOfLoginAttempts)")
```

### 类型标注

您可以在声明常量或变量时提供类型标注（type annotation），以明确常量或变量可以存储的值的类型。在类型标注后面加上一个冒号和空格，然后加上类型名称，以指定常量或变量可以存储的值的类型：

```swift
var welcomeMessage: String
```

类型标注是一种为常量或变量提供关于其允许存储的值类型的方法。它不会为常量或变量的值分配任何实际的值；它只是说明了常量或变量可以存储的值的类型。如果您在声明常量或变量时提供了类型标注，您可以在该常量或变量的赋值语句中省略对其类型的说明。类型标注的使用可以使您的代码更具可读性，因为它允许您立即知道常量或变量可以存储的值的类型。

## 注释

您可以使用单行注释（single-line comments）将注释嵌入到代码中。单行注释以两个正斜杠（//）开头：

```swift
// This is a comment
```

您可以使用多行注释（multi-line comments）将注释嵌入到代码中。多行注释以正斜杠后跟星号（/*）开头，以星号后跟正斜杠（*/）结尾：

```swift
/* This is also a comment
but is written over multiple lines. */
```

## 分号

Swift不要求您在每个语句结尾处使用分号（;），但是您可以使用分号将多个独立的语句写在同一行上：

```swift
let cat = "🐱"; print(cat)
```

## 整数

整数是没有小数部分的数字，例如42和-23。Swift提供了8、16、32和64位有符号和无符号整数类型。这些整数类型的名称与它们的位数相同，例如UInt8表示8位无符号整数，Int32表示32位有符号整数。

整数范围：

```swift
let minValue = UInt8.min
let maxValue = UInt8.max
```

## 浮点数

浮点数是有小数部分的数字，例如3.14159、0.1和-273.15。Swift提供了两种有符号的浮点数类型：

- Double表示64位浮点数。
- Float表示32位浮点数。

如果您需要在您的代码中选择浮点数类型，推荐使用Double类型，除非你特别需要它的性能。

## 类型安全和类型推断

Swift是一种类型安全（type-safe）语言。类型安全语言可以让您清楚地知道代码可以处理的值的类型。如果部分代码期望得到String，您就不能传递一个Int来代替。

Swift通过类型推断（type inference）来选择合适的类型。如果您没有明确指定类型，Swift使用类型推断来选择合适的类型。例如，如果您给一个新的浮点值赋值，Swift会推断您想要创建一个Double而不是Float：

```swift
let meaningOfLife = 42
// meaningOfLife is inferred to be of type Int
let pi = 3.14159
// pi is inferred to be of type Double
```

如果您在一行中声明多个同类型的值，您可以在一行中写出所有值，用逗号隔开，Swift会自动推断出这些值的类型：

```swift
let x = 0.0, y = 0.0, z = 0.0
```

## 数值型字面量

整数字面量可以被写作：

- 一个十进制数，没有前缀
- 一个二进制数，前缀是0b
- 一个八进制数，前缀是0o
- 一个十六进制数，前缀是0x

十进制数的例子：

```swift
let decimalInteger = 17
let binaryInteger = 0b10001       // 17 in binary notation
let octalInteger = 0o21           // 17 in octal notation
let hexadecimalInteger = 0x11     // 17 in hexadecimal notation
```

浮点字面量可以是十进制（没有前缀），或者是十六进制（前缀是0x）。十进制浮点字面量还可以有一个可选的指数（exponent），通过大写或小写的e来指定。十六进制浮点字面量必须有一个指数；指数通过大写或小写的p来指定。十进制浮点字面量的例子：

```swift
let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0
```

## 数值型类型转换

整数和浮点数类型转换必须显式指定类型：

```swift
let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
let twoThousandAndOne = twoThousand + UInt16(one)
// twoThousandAndOne is equal to 2001
```

## 类型别名

类型别名（type aliases）就是给现有类型定义另一个名字。你可以使用typealias关键字来定义类型别名。

```swift
typealias AudioSample = UInt16
var maxAmplitudeFound = AudioSample.min
// maxAmplitudeFound is now 0
```

## 布尔值

Swift有一个基本的布尔（Boolean）类型，叫做Bool。布尔值指逻辑上的值，因为它们只能是真或者假。Swift提供两个布尔常量，true和false：

```swift
let orangesAreOrange = true
let turnipsAreDelicious = false
```

## 元组

元组（tuples）把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型。

```swift
let http404Error = (404, "Not Found")
// http404Error is of type (Int, String), and equals (404, "Not Found")
```

元组的内容可以分解（decompose）成单独的常量和变量，然后你就可以正常使用它们了：

```swift
let (statusCode, statusMessage) = http404Error
print("The status code is \(statusCode)")
// Prints "The status code is 404"
print("The status message is \(statusMessage)")
// Prints "The status message is Not Found"
```

如果你只需要一部分元组值，分解的时候可以把要忽略的部分用下划线（_）标记：

```swift
let (justTheStatusCode, _) = http404Error
print("The status code is \(justTheStatusCode)")
// Prints "The status code is 404"
```

你也可以通过下标来访问元组中的单个元素，下标从零开始：

```swift
print("The status code is \(http404Error.0)")
// Prints "The status code is 404"
print("The status message is \(http404Error.1)")
// Prints "The status message is Not Found"
```

你可以在定义元组的时候给单个元素命名：

```swift
let http200Status = (statusCode: 200, description: "OK")
```

这个元组的名字叫做http200Status，它的类型是(Int, String)。你可以通过名字来获取元素的值：

```swift
print("The status code is \(http200Status.statusCode)")
// Prints "The status code is 200"
print("The status message is \(http200Status.description)")
// Prints "The status message is OK"
```

## 可选类型

Swift的可选类型（optional types）表示：

* 这个值可能有值，等于x
* 这个值可能没有值

可选类型有点像Objective-C中的nil指针，但是它们可以用于任何类型，不仅仅是类。可选类型表示的是值缺失，而不是值为nil。这样的设计可以让你避免在你的代码中使用nil值。


## 可选绑定

可选绑定（optional binding）用来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或变量。可选绑定可以用在if和while语句中来对可选类型的值进行判断并把值赋给一个常量或变量。

```swift
if let constantName = someOptional {
    statements
}
```

## 隐式解析可选类型

有时候在变量的生命周期中，会确定一个可选类型变量总会有值。在这种情况下，每次都需要判断和解析可选值是非常麻烦的。这时候可以选择隐式解析可选类型（implicitly unwrapped optionals）。

```swift
let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // requires an exclamation point

let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString // no need for an exclamation point
```

## 错误处理

Swift提供了一种在运行时表示和抛出错误的机制。这个机制让你能够表示和抛出你自己的错误，并且把函数抛出的错误传递到程序的某个地方。

```swift
enum VendingMachineError: ErrorType {
    case InvalidSelection
    case InsufficientFunds(coinsNeeded: Int)
    case OutOfStock
}

throw VendingMachineError.InsufficientFunds(coinsNeeded: 5)
```

## 断言和先决条件

断言和先决条件用来检查在运行时一个必要的条件是否为真。如果条件判断的结果为true，代码继续运行。如果条件判断的结果为false，代码执行结束，你的应用被终止。

```swift
let age = -3
assert(age >= 0, "A person's age cannot be less than zero")
// This assertion fails because -3 is not >= 0.

if age > 10 {
    print("You can ride the roller-coaster or the ferris wheel.")
} else if age >= 0 {
    print("You can ride the ferris wheel.")
} else {
    assertionFailure("A person's age can't be less than zero.")
}
// Prints "You can ride the ferris wheel."
```




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

Swift - 基础知识


`Node.js`的错误有以下几种：

- 标准 JavaScript 错误，比如`eval error`、`syntax error`、`range error`、`reference error`、`type error`、`uri error`
- 系统错误
- 用户指定错误
- 断言错误

```js
try {
  const a = 1
  const c = a + b
} catch (err) {
  console.log(err)
}
```

以上代码输出`ReferenceError:b is not defined`

```js
const fs = require('fs')
function nodeStyleCallback(err, data) {
  if (err) {
    console.error('There was an error', err)
    return
  }
  console.log(data)
}
fs.readFile('/some/file/that/does-not-exist', nodeStyleCallback)
fs.readFile('/some/file/that/does-exist', nodeStyleCallback)
```

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


Node.js - error


## 状态管理概述

状态管理是任何应用程序开发的关键方面，Flutter也不例外。它指的是跟踪和修改应用程序的状态。在本文中，我们将深入探讨Flutter中的状态管理概念，并探索可用于管理状态的不同技术。

## 状态管理的概述

在Flutter中，一切都是小部件，每个小部件都可以有自己的状态。状态是在构建小部件时可以同步读取的信息，并且可能在小部件的生命周期内发生变化。例如，如果我们有一个复选框小部件，它是否被选中就是它的状态。

管理应用程序的状态可能是一项复杂的任务，特别是当应用程序规模扩大时。选择适合您的应用程序需求并能够随着应用程序的增长而扩展的状态管理技术非常重要。

## 选择合适的状态管理技术

Flutter提供了几种状态管理技术。让我们来探索其中一些：

1. Provider：Provider是一个使用小部件构建的依赖注入系统。它结合了控制反转（IoC）和上下文（context），因此您可以在小部件树的任何位置获取一个类的实例。
2. Riverpod：Riverpod是一种更高级的状态管理解决方案，旨在克服Provider的限制。它允许您从任何地方访问提供程序，而无需使用上下文，并且它也具备类型安全性。
3. Bloc：Bloc代表业务逻辑组件（Business Logic Component）。它是一个使用流（streams）处理应用程序状态的状态管理系统。它将表示层与业务逻辑层分离，从而使测试变得更容易。
4. Redux：Redux是一个可预测的状态容器，可帮助您编写行为一致的应用程序。它非常适用于需要跟踪大量状态的大型应用程序。

每种技术都有其优缺点，选择合适的技术取决于您的应用程序的具体需求。对于小型应用程序，使用Provider或Riverpod可能已经足够了。然而，对于具有复杂状态管理需求的大型应用程序，Bloc或Redux可能更合适。

总之，状态管理是Flutter开发的重要组成部分。了解不同的技术并选择适合您的应用程序的技术可以极大地提高代码质量和应用程序的性能。


State Management in Flutter


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

## 向浏览器扩展添加可选项

打开`manifest.json`，添加 options 选项，注册选项页面。

```json
{
  "options_ui": {
    "page": "options.html",
    "open_in_tab": false
  }
}
```

创建`options.html`

```html
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta http-equiv="X-UA-Compatible" content="ie=edge" />
    <title>DDT Pop-up</title>
    <link rel="stylesheet" type="text/css" href="./css/style.css" />
  </head>
  <body>
    <div id="options"></div>
    <script type="module" src="src/options/index.jsx"></script>
  </body>
</html>
```

修改`src/index.jsx`

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

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

修改`src/App.jsx`

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

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

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

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

  return (
    <div className="m-4">
      <select
        onChange={(event) => pickColor(event.target.value)}
        value={color}
        className="block w-full p-4 text-sm text-gray-900 border border-gray-300 rounded-lg bg-gray-50 focus:ring-indigo-500 focus:border-indigo-500 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>
        <option value="red">Red</option>
      </select>
    </div>
  )
}
```

修改`vite.config.js`，多页面打包配置

```js
import {defineConfig} from 'vite'
const {resolve} = require('path')
import react from '@vitejs/plugin-react'

export default defineConfig({
  plugins: [react()],
  build: {
    rollupOptions: {
      input: {
        main: resolve(__dirname, 'index.html'),
        options: resolve(__dirname, 'options.html')
      }
    }
  }
})
```

最终效果如下：

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

## Source Code

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


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

Chrome插件开发 - Custom options page


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 代码非常重要。


理解函数的执行过程


LIMIT 语句经常在许多关系型数据库中使用，比如 MySQL，H2，HSQLDB。

但是 LIMIT 语句不属于 SQL 标准。

Postgresql 提供了 SQL 标准的语句来替代 LIMIT，它就是 FETCH 语句，它是在 SQL：2008 标准被提出来的。

## 语法

```sql
OFFSET start { ROW | ROWS }
FETCH { FIRST | NEXT } [ row_count ] { ROW | ROWS } ONLY
```

FIRST 和 NEXT 是同义词，ROW 和 ROWS 是同义词，同义词可以相互替换

start 必须为 0 或正整数，如果没有 OFFSET 字句，则 start 默认为 0，如果 start 比结果集中的行数大，则查询语句不返回结果。

row_count 是大于等于 1 的整数，如果你不指定它，它默认为 1

因为表中存储的行顺序是未指定的，所以应该始终使用 FETCH 子句和 order BY 子句，以使返回结果集中的行顺序一致。

## FETCH vs LIMIT

使用 FETCH 查询并选择第一条记录

```sql
SELECT
    film_id,
    title
FROM
    film
ORDER BY
    title
FETCH FIRST ROW ONLY;
```

![bQ3nfm](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/bQ3nfm.jpg)
等同于以下代码：

```sql
SELECT
    film_id,
    title
FROM
    film
ORDER BY
    title
FETCH FIRST 1 ROW ONLY;
```

## 总结

尽量使用 FETCH 语句，而不是 LIMIT 语句。


如何使用 PostgreSQL FETCH 检索查询返回的部分行