Deeper into widgets


回调是函数的异步等价物，在每个任务完成时调用它。

在 Node.js 中，回调通常被使用。Node 的所有 api 都是以支持回调的方式编写的。

例如: 当一个函数开始读取文件时，它会立即将控件返回给执行环境，以便执行下一条指令。

在 Node.js 中，一旦文件 i/o 完成，它将调用回调函数。因此没有阻塞或等待文件 i/o。

这使得 Node.js 具有高度的可伸缩性，因为它可以处理大量的请求，而无需等待任何函数返回结果。

## 同步获取文件内容

```js
var fs = require('fs')
var data = fs.readFileSync('input.txt')
console.log(data.toString())
console.log('Program 已经结束')
```

## 异步获取文件内容

```js
var fs = require('fs')

fs.readFile('input.txt', function (err, data) {
  if (err) return console.error(err)
  console.log(data.toString())
})
console.log('Program 已经结束')
```


A "callback" is any function that is called by another function which takes the first function as a parameter. （在一个函数中调用另外一个函数就是callback）

Node.js - Callbacks


Swift 中有三种主要的集合类型：数组、集合和字典。

## 数组（Arrays）

数组是一组有序的值的集合，可以使用下标来访问每个值。Swift 中的数组可以存储相同类型的值，也可以使用泛型来存储不同类型的值。

以下是创建和操作数组的示例：

```swift

// 创建数组
var numbers: [Int] = [1, 2, 3, 4, 5]
var strings = ["Apple", "Banana", "Orange"]

// 访问数组中的值
let firstNum = numbers[0] // 1
let lastStr = strings[strings.count - 1] // "Orange"

// 修改数组中的值
numbers[2] = 10
strings.append("Grape")

// 遍历数组中的所有值
for number in numbers {
print(number)
}
```

## 集合（Sets）

集合是一组无序的唯一值的集合。Swift 中的集合可以存储任何可哈希的值（Hashable），例如数字、字符串和布尔值等。集合中不允许存在重复的值。

以下是创建和操作集合的示例：

```swift

// 创建集合
var set1: Set<Int> = [1, 2, 3, 4, 5]
var set2: Set<String> = ["Apple", "Banana", "Orange"]

// 访问集合中的值
let hasThree = set1.contains(3) // true

// 修改集合中的值
set1.insert(6)
set2.remove("Banana")

// 遍历集合中的所有值
for element in set2 {
print(element)
}
```

## 字典（Dictionaries）

字典是一组无序的键值对的集合，每个键都唯一且与一个值相关联。Swift 中的字典可以存储任何可哈希的键（Hashable）和任何值，例如数字、字符串和布尔值等。

以下是创建和操作字典的示例：

```swift

// 创建字典
var dict1: [String: Int] = ["One": 1, "Two": 2, "Three": 3]
var dict2 = ["Red": "#FF0000", "Green": "#00FF00", "Blue": "#0000FF"]

// 访问字典中的值
let redCode = dict2["Red"] // "#FF0000"

// 修改字典中的值
dict1["One"] = 10
dict2["Yellow"] = "#FFFF00"

// 遍历字典中的所有键值对
for (key, value) in dict1 {
print("\(key): \(value)")
}
```

Swift 中的集合类型还提供了各种方法和属性，以支持常见的集合操作，例如排序、筛选、合并、查找等。如果您需要更深入地了解 Swift 中的集合类型，可以查看 Swift 官方文档中的相关章

## 元组（Tuples）

元组是将多个值组合在一起的一种方式，这些值可以是任何类型，并不要求是相同类型。元组中的每个值都可以通过名称或下标来访问。

以下是创建和操作元组的示例：

```swift

// 创建元组
let person = ("Tom", 25, true)

// 访问元组中的值
let name = person.0 // "Tom"
let age = person.1 // 25
let isMale = person.2 // true

// 创建带有标签的元组
let student = (name: "Alice", age: 20, isMale: false)

// 访问带有标签的元组中的值
let studentName = student.name // "Alice"
let studentAge = student.age // 20
let studentIsMale = student.isMale // false
```

## Range（区间）

区间是表示一定范围内值的类型。Swift 中有两种类型的区间：半开区间和闭区间。半开区间包含起始值，不包含结束值。闭区间包含起始值和结束值。

以下是创建和操作区间的示例：

```swift

// 创建区间
let range1 = 1..<5 // 半开区间，包含1，不包含5
let range2 = 1...5 // 闭区间，包含1和5

// 遍历区间中的所有值
for i in range1 {
print(i)
}

for i in range2.reversed() {
print(i)
}
```

Swift 的集合类型和区间类型提供了丰富的功能和操作，可以满足各种不同的需求。因此，在编写 Swift 代码时，选择正确的集合类型和区间类型非常重要，可以使代码更加简洁和高效。

## 字典（Dictionary）

字典是一种存储键值对的集合类型。在字典中，每个值都与一个唯一的键相关联。字典中的键必须是唯一的，并且必须是可哈希的（即可以用作字典键的类型必须符合 Hashable 协议）。

以下是创建和操作字典的示例：

```swift

// 创建字典
var scores = ["Tom": 80, "Jerry": 90, "Alice": 95]

// 添加和更新字典中的值
scores["Bob"] = 85 // 添加
scores["Tom"] = 85 // 更新

// 删除字典中的值
scores.removeValue(forKey: "Jerry")

// 遍历字典中的键值对
for (name, score) in scores {
print("\(name) scored \(score)")
}

// 获取字典中所有的键和值
let names = Array(scores.keys)
let scoresArray = Array(scores.values)
```

## 集合（Set）

集合是一种无序的、不重复的元素集合类型。集合中的每个元素必须是唯一的，并且必须是可哈希的（即可以用作集合元素的类型必须符合 Hashable 协议）。

以下是创建和操作集合的示例：

```swift

// 创建集合
var set1: Set<Int> = [1, 2, 3, 4, 5]
var set2: Set<Int> = [4, 5, 6, 7, 8]

// 集合运算
let union = set1.union(set2) // 并集
let intersection = set1.intersection(set2) // 交集
let difference = set1.symmetricDifference(set2) // 对称差集

// 添加和删除集合中的元素
set1.insert(6)
set1.remove(5)

// 遍历集合中的所有元素
for element in set1 {
print(element)
}
```

Swift 的集合类型提供了丰富的功能和操作，可以方便地对数据进行处理和操作。选择正确的集合类型可以使代码更加简洁和高效。

## 可选类型（Optional）

Swift 的可选类型是一种用于处理值缺失的类型。可选类型可以表示一个值存在或不存在。如果一个值存在，可选类型就包含这个值；如果一个值不存在，可选类型就是 nil。

以下是创建和操作可选类型的示例：

```swift

// 创建可选类型
var name: String? = "Tom"

// 访问可选类型中的值
if let unwrappedName = name {
print("Name is \(unwrappedName)")
} else {
print("Name is nil")
}

// 强制解包可选类型中的值
let unwrappedName2 = name!
print("Name is \(unwrappedName2)")

// 可选绑定
if let name = name {
print("Name is \(name)")
} else {
print("Name is nil")
}

// nil 合并运算符
let defaultName = "John"
let finalName = name ?? defaultName
print("Name is \(finalName)")
```

可选类型在 Swift 中经常使用，因为它可以很好地处理值缺失的情况。如果不使用可选类型，代码会变得非常冗长和复杂。因此，在 Swift 中，使用可选类型来处理值缺失的情况是一种很好的实践。


Swift中的集合类型（Collection Types）是一组相同类型的值的集合，可以使用这些集合类型来存储和操作数据

Swift - 集合类型


文本和排版（Typography）是网页设计和开发中非常重要的方面。以下是对这两个主题的详细解释：

文本（Text）是指在网页上显示的字母、数字、符号和其他字符的组合。网页设计师和开发人员可以使用 CSS 来控制文本的外观、布局和样式。以下是一些常见的文本属性：

- 字体属性（font）：控制文本的字体、字号、字重和字形。可以使用 Web 安全字体或自定义字体。
- 颜色属性（color）：控制文本的颜色。可以使用命名颜色、RGB 值、十六进制值或 HSL 值来定义颜色。
- 行高属性（line-height）：控制文本行之间的间距。设置行高可以提高文本的可读性。
- 字距属性（letter-spacing）：控制字母之间的距离。
- 文本对齐属性（text-align）：控制文本在其容器中的对齐方式。

排版（Typography）是指使用字体、排版和排版技巧来设计和布局文本。以下是一些常见的排版技巧：

- 字体选择：选择字体可以根据设计要求选择合适的字体，同时，要考虑可读性和可访问性。例如，sans-serif 字体更容易阅读，而 serif 字体通常用于印刷品。
- 行距：设置适当的行距可以提高文本的可读性。
- 段落间距：适当的段落间距可以使文本更易于阅读。
- 列宽：将文本限制在较窄的列宽中，可以使文本更易于阅读和理解。
- 字母大小写：使用适当的字母大小写可以改善文本的可读性和可访问性。


css - Text and Typography


在上一篇文章，当创建新菜单的时候，可以加载当前位置的天气数据，这章将学习创建弹窗插件。

## 创建小工具

新建`src/Weather.jsx`

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

export default function Weather() {
  const [latLng, setLatLng] = useState({})
  const [data, setData] = useState(null)
  useEffect(() => {
    if (!latLng.lat && !latLng.long) {
      navigator.geolocation.getCurrentPosition(function (position) {
        setLatLng({
          lat: position.coords.latitude,
          long: position.coords.longitude
        })
      })
      return
    }
    if (!data) {
      fetch(
        `${import.meta.env.VITE_APP_API_URL}/weather/?lat=${latLng.lat}&lon=${
          latLng.long
        }&units=metric&APPID=${import.meta.env.VITE_APP_API_KEY}`
      )
        .then((res) => res.json())
        .then((result) => setData(result))
    }
  }, [latLng])

  return (
    <div>
      <h2>The weather today ☁️</h2>
      <br />
      {!data ? (
        <p>Loading...</p>
      ) : (
        <>
          <p>Weather for: {data.name}</p>
          <p>
            Temp: {data.main.temp}° ({data.weather[0].main})
          </p>
        </>
      )}
    </div>
  )
}
```

更改`App.jsx`

```jsx
import Weather from './Weather'

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">
      <Weather />
    </div>
  )
}
```

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

在弹窗点击右键，会显示开发者工具，提示未获取`地理位置`权限，在`manifest.json`中添加如下:

```json
{
  "permissions": ["geolocation"]
}
```

重新构建并加载即可。

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

## Source Code

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


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

Chrome插件开发 - Popup weather extension


## Flutter简介

Flutter是由Google创建的开源UI软件开发工具包。它于2017年5月首次发布，并因其能够从单个代码库构建适用于移动、Web和桌面的本机编译应用程序的能力而受到欢迎。

Flutter被全球开发者和组织广泛使用，出于各种原因，它越来越受到青睐：

- 跨平台开发：Flutter允许您使用相同的代码库为Android、iOS、Web和桌面构建应用程序。这可以显著减少开发时间和成本。
- 热重载：这个特性允许开发者几乎即时地看到他们的更改效果，而无需丢失当前应用程序状态。它提高了生产力，使调试更快、更容易。
- 可定制和可扩展：Flutter提供了一套丰富的预设计小部件，这些小部件可定制和扩展。它还允许您创建自己的小部件。

## 安装和设置

要开始使用Flutter进行开发，您需要设置开发环境。以下是一步步的指南：

1. 系统要求：确保您的系统满足以下要求：

- 操作系统：Windows 7 SP1或更高版本（64位）、基于x86-64的Linux发行版或macOS（64位）。
- 磁盘空间：Windows上需要1.64 GB，Linux/Mac上需要600MB。
- 工具：Windows PowerShell 5.0或更新版本，或者Git for Windows 2.16.2或更新版本。

2. 下载Flutter SDK：访问Flutter网站并下载稳定版本的Flutter SDK。

- 解压文件：将压缩文件解压到计算机上的适当位置。
- 更新路径：为了在控制台中运行Flutter命令，更新系统路径以包括Flutter的bin目录。
- 安装IDE：您可以使用任何文本编辑器结合命令行工具，但建议使用Android Studio或Visual Studio Code等IDE，因为它们提供了用于Flutter开发的集成工具。
- 安装Flutter和Dart插件：如果您使用Android Studio或Visual Studio Code，安装Flutter和Dart插件。这些插件提供了一套用于处理Flutter的工具，包括热重载和小部件编辑。
- 设置模拟器：为了测试Flutter应用程序，您需要一个移动设备模拟器。这可以通过您选择的IDE进行设置。

恭喜！您已经设置好了Flutter开发环境。在下一个单元中，我们将深入介绍在Flutter中使用的编程语言Dart。


Introduction to Flutter and Installation Guide


所有的代码都是在执行上下文中执行的，执行上下文是一个抽象的概念，它是一种规范，用来定义变量或函数有权访问的其他数据，决定它们的各自行为。

在深入研究前，需要了解一些概念：

- 编译器：负责语法分析和代码生成
- JavaScript 引擎：负责执行代码
- 函数声明：指的是使用 function 关键字声明的函数
- 函数表达式：指的是使用 var 关键字声明的函数

## JavaScript 是如何被执行的

JavaScript 代码在执行之前，会经历三个阶段：

- 词法分析（Lexical Analysis）
- 语法分析（Syntactic Analysis）
- 代码生成（Code Generation）

词法分析阶段，会将代码分解成一个个词法单元，比如 var、function、if、else、for、while 等等。

语法分析阶段，会将词法单元转换成一个个语法单元，比如 var a = 1，会被转换成一个个词法单元，然后再转换成一个个语法单元，比如 var、a、=、1。

代码生成阶段，会将语法单元转换成可执行的代码，比如 var a = 1，会被转换成一个个语法单元，然后再转换成可执行的代码，比如 var a = 1。

## JavaScript 中的执行上下文

JavaScript 中的执行上下文是一个抽象的概念，它是一种规范，用来定义变量或函数有权访问的其他数据，决定它们的各自行为。

执行上下文分为三种：

- 全局执行上下文
- 函数执行上下文
- eval 函数执行上下文

### 全局执行上下文

全局执行上下文是默认的执行上下文，它会在 JavaScript 代码执行之前被创建，它会被放到执行上下文栈中，当 JavaScript 代码执行完毕后，它会被从执行上下文栈中移除。

全局执行上下文包含三个部分：

- 变量对象（Variable Object，VO）
- 作用域链（Scope Chain）
- this

#### 变量对象

变量对象是与执行上下文相关的数据作用域，存储了在上下文中定义的变量和函数声明。

变量对象包含两个部分：

- 函数的所有形参（如果是函数上下文）
- 函数声明
- 变量声明

变量对象的创建过程：

- 创建一个 VO
- 将所有形参，变量和函数声明添加到 VO 中
- 将 VO 赋值给活动对象（AO）

#### 作用域链

作用域链是一个指向变量对象的指针列表，它只引用但不实际包含变量对象。

作用域链的创建过程：

- 创建一个作用域链
- 将当前执行上下文的变量对象添加到作用域链中
- 将父级执行上下文的变量对象添加到作用域链中
- 将父级的父级执行上下文的变量对象添加到作用域链中
- 依次类推，直到全局执行上下文的变量对象添加到作用域链中

#### this

this 是一个指针，指向函数执行时所在的作用域。

[this 的指向](/blog/javascript/advance/this指向)

### 函数执行上下文

函数执行上下文是在函数被调用时被创建，它会被放到执行上下文栈中，当函数执行完毕后，它会被从执行上下文栈中移除。

## JavaScript 中的提升

JavaScript 中的提升是指变量和函数的声明会被提升到当前作用域的顶部。

### 变量提升

变量提升是指变量的声明会被提升到当前作用域的顶部，但是变量的赋值不会被提升。

```js
console.log(a) // undefined
var a = 1
```

### 函数提升

函数提升是指函数的声明会被提升到当前作用域的顶部，但是函数的赋值不会被提升。

```js
console.log(a) // function a() {}
function a() {}
```

## JavaScript 执行栈

JavaScript 执行栈是一个用于存储函数调用的栈结构，它遵循先进后出的原则。

当浏览器加载脚本，JS 引擎从全局上下文也就是默认上下文开始执行代码，所以全局上下文被放在执行栈的最底部。

然后 JS 引擎再搜索代码中被调用的函数。每一次函数被调用，一个新的 FEC 就会被创建，并被放置在当前执行上下文的上方。

执行栈最顶部的执行上下文会成为活跃执行上下文，并且始终是 JS 引擎优先执行。

一旦活跃执行上下文中的代码被执行完毕，JS 引擎就会从执行栈中弹出这个执行上下文，紧接着执行下一个执行上下文，以此类推。

为了了解执行栈的工作流，请考虑下面的代码：

```js
var name = 'Victor'

function first() {
  var a = 'Hi!'
  second()
  console.log(`${a} ${name}`)
}

function second() {
  var b = 'Hey!'
  third()
  console.log(`${b} ${name}`)
}

function third() {
  var c = 'Hello!'
  console.log(`${c} ${name}`)
}

first()
```

解释以上代码的执行过程：

1. 全局上下文被创建，全局上下文被压入执行栈中。
2. 全局上下文初始化，创建变量对象、作用域链、this。
3. 全局上下文代码被执行，遇到 first() 函数调用，创建 first() 函数执行上下文，first() 函数执行上下文被压入执行栈中。
4. first() 函数执行上下文初始化，创建变量对象、作用域链、this。
5. first() 函数执行上下文代码被执行，遇到 second() 函数调用，创建 second() 函数执行上下文，second() 函数执行上下文被压入执行栈中。
6. second() 函数执行上下文初始化，创建变量对象、作用域链、this。
7. second() 函数执行上下文代码被执行，遇到 third() 函数调用，创建 third() 函数执行上下文，third() 函数执行上下文被压入执行栈中。
8. third() 函数执行上下文初始化，创建变量对象、作用域链、this。
9. third() 函数执行上下文代码被执行，打印 `Hello Victor`。
10. third() 函数执行上下文被弹出执行栈。
11. second() 函数执行上下文代码被执行，打印 `Hey Victor`。
12. second() 函数执行上下文被弹出执行栈。
13. first() 函数执行上下文代码被执行，打印 `Hi Victor`。
14. first() 函数执行上下文被弹出执行栈。
15. 全局上下文代码被执行，打印 `Victor`。
16. 全局上下文被弹出执行栈。

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

## 全局执行上下文对比函数执行上下文

全局执行上下文和函数执行上下文的区别在于：

1. 全局执行上下文只有一个，但是函数执行上下文可以有很多个。
2. 全局执行上下文在浏览器关闭时被销毁，但是函数执行上下文在函数执行完毕后被销毁。

## 参考

1. [https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Function/Call](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Function/Call)
2. [JavaScript 执行上下文——JS 的幕后工作原理](https://www.freecodecamp.org/chinese/news/execution-context-how-javascript-works-behind-the-scenes/)
