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

iterators generators


小部件（Widgets）是Flutter应用程序的基本构建块。它们描述了界面在任何给定时刻的外观。换句话说，您在屏幕上看到的每个元素（以及一些看不见的元素）都是一个小部件。这包括按钮、文本、滑块、图像，甚至应用程序本身。

在本单元中，我们将深入探讨Flutter小部件的世界。我们将首先了解无状态（stateless）小部件和有状态（stateful）小部件之间的区别，然后指导您创建自己的自定义小部件的过程。

## 理解无状态和有状态小部件

在Flutter中，小部件可以是无状态的或有状态的。

无状态小部件是不可变的，这意味着它们的配置在创建时设置，并且无法更改。它们描述的是用户界面的一部分，可以依赖构造函数中的配置信息，并且仅在该信息发生变化时才会改变。例如，Text小部件是无状态的，因为在创建时我们给它一个文本字符串，除非销毁并重新创建带有新文本的小部件，否则文本不会更改。

另一方面，有状态小部件可以随时间变化。它们可以在小部件本身或外部保存可变状态，并且可以通过调用setState在屏幕上重新绘制。例如，复选框是一个有状态小部件，因为它可以随时间被选中或取消选中。

## 构建自定义小部件

在Flutter中构建自定义小部件是每个Flutter开发者都应该具备的基本技能。它涉及将较小的小部件组合成更大、更复杂的小部件。

要创建一个自定义小部件，您需要创建一个新的类，该类扩展自StatelessWidget或StatefulWidget，然后覆盖build方法。build方法描述了小部件在任何给定时刻的外观。它返回一个新的小部件树，其中可以包括您创建的自定义小部件和标准Flutter小部件。

以下是一个自定义无状态小部件的示例：

```dart
class CustomButton extends StatelessWidget {
  final String label;

  CustomButton({this.label});

  @override
  Widget build(BuildContext context) {
    return RaisedButton(
      child: Text(label),
      onPressed: () {
        print('Button pressed');
      },
    );
  }
}
```

在这个例子中，CustomButton是一个无状态小部件，它接受一个标签作为参数，并创建一个带有该标签的RaisedButton。当按钮被按下时，它会在控制台打印一条消息。

通过本单元的学习，您应该对Flutter中的小部件如何工作有了扎实的理解，并且能够创建自己的自定义小部件。随着我们继续前进并开始构建更复杂的Flutter应用程序，这将是一项关键的技能。


Introduction to Flutter Widgets


> `useRef` 返回一个可变的 `ref` 对象，其 `.current` 属性被初始化为传入的参数（initialValue），返回的 `ref` 对象在组件的整个生命周期内保持不变。

例如：创建`VideoPlayer`组件

```tsx
import {useRef} from 'react'
import VideoPlayer from 'videoplayer'

function VideoPlayerComponent() {
  const playerRef = useRef(new VideoPlayer())
  //
}
```

对于上面的代码，在初始化组件时，调用`new VideoPlayer()`的结果将存储在`ref`中，在下一次渲染时，仍将调用`new VideoPlayer()`，但是`useef`不会再接收到其调用结果，这意味着`playerRef`可能为空。

同样的，`useState`也是存在这种情况，区别在于，`useState`可以接受初始化函数，比如

```tsx
import {useState} from 'react'
import VideoPlayer from 'videoplayer'
function VideoPlayerComponent() {
  const [player] = useState(() => new VideoPlayer())
  //
}
```

所以，在使用`playerRef`的时候，需要对它做个判断：

```tsx
import {useRef} from 'react'
import VideoPlayer from 'videoplayer'

function VideoPlayerComponent() {
  const playerRef = useRef<VideoPlayer | null>(null)

  if (playerRef.current === null) {
    playerRef.current = new VideoPlayer()
  }

  const onClick = () => {
    // Error: Object is possibly 'null'.
    playerRef.current.play()
  }
}
```

组件只会调用一次`new VideoPlayer()`并存储在`playerRef`中，但是 typescript 会检查并提示`Error: Object is possibly 'null'`

解决方法：

operation chaining - 可选链

`playerRef.current.play()` => `playerRef.current？.play()`

useImmutableRefValue

```tsx
import {useMemo, useRef} from 'react'

const useImmutableRefValue = <R,>(createRef: () => R) => {
  const ref = useRef<R>()

  const value = useMemo(() => {
    if (!ref.current) {
      ref.current = createRef()
    }

    return ref.current
    // Only one instance, no deps required.
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [])

  return value
}

export default useImmutableRefValue
```

```tsx
import VideoPlayer from 'videoplayer'
import useImmutableRefValue from 'useImmutableRefValue'

function Component() {
  const player = useImmutableRefValue(() => new VideoPlayer())

  const onClick = () => {
    player.play()
  }
}
```


useRef 返回一个可变的 ref 对象，其 .current 属性被初始化为传入的参数（initialValue），返回的 ref 对象在组件的整个生命周期内保持不变。

useImmutableRefValue - 帮助你更好的使用Typescript开发React应用


```bash
npm install @next/bundle-analyzer -D
```

修改`next.config.js`

```js
const withBundleAnalyzer = require('@next/bundle-analyzer')({
  enabled: process.env.ANALYZE === 'true'
})

module.exports = withBundleAnalyzer({
  //...other config
})
```

```bash
ANALYZE=true npm run build
```

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

修改`package.json`

```json
{
  "scripts": {
    "analyze": "ANALYZE=true next build"
  }
}
```

`npm run analyze`


Next.js - Integrate Bundle Analyzer


## 屏幕

### 屏幕大小

> 屏幕尺寸是屏幕的宽度和高度: 显示器、手机等设备屏幕。

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

`window.screen` 属性可以获取屏幕尺寸，其中包含屏幕的宽度和高度，以像素为单位。

```js
const screenWidth = window.screen.width
const screenHeight = window.screen.height
```

### 可用屏幕大小

> 可用屏幕尺寸是屏幕的宽度和高度，不包含任何系统窗口，以像素为单位。

![Available Screen Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/nYbW0L.jpg)

```js
const availableScreenWidth = window.screen.availWidth
const availableScreenHeight = window.screen.availHeight
```

## 视窗

### 视窗外部宽高

> 窗口的外部大小由整个浏览器窗口的宽度和高度组成，包括地址栏、标签栏和其他浏览器面板。

![Window Outer Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/8muma1.jpg)

使用`outerWidth`和`outerHeight`可以获取窗口的外部宽高，以像素为单位。

```js
const windowOuterWidth = window.outerWidth
const windowOuterHeight = window.outerHeight
```

### 视窗内部大小

> 视窗的内部大小由整个浏览器窗口的宽度和高度组成，不包括地址栏、标签栏和其他浏览器面板。

![Window Inner Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/YHT2o8.jpg)

使用`innerWidth`和`innerHeight`可以获取窗口的内部宽高，以像素为单位。

```js
const windowInnerWidth = window.innerWidth
const windowInnerHeight = window.innerHeight

/*不包含滚动条*/
const windowInnerWidth = document.documentElement.clientWidth
const windowInnerHeight = document.documentElement.clientHeight
```

## 页面大小

> 页面大小是页面内容的宽度和高度(不包含边框、边距和滚动条)。

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

```js
const pageWidth = document.documentElement.scrollWidth
const pageHeight = document.documentElement.scrollHeight
// 如果 pageHeight 大于 window.innerHeight，则页面会出现横向滚动条
```


如何获取 Screen、Window、Page 等组件的宽高？


在计算机科学中，并发性是指系统中同时执行多个独立任务的能力。在 Swift 中，我们可以使用 Grand Central Dispatch (GCD) 和 Operation Queues 来实现并发性。

## Grand Central Dispatch (GCD)

GCD 是苹果提供的一种轻量级的并发性机制，它使用队列（queue）来管理任务。队列分为两种类型：串行队列（serial queue）和并发队列（concurrent queue）。

串行队列是指按照队列中任务的顺序，依次执行每个任务，只有当一个任务执行完成之后，才会执行下一个任务。而并发队列是指同时执行多个任务，任务执行的顺序不确定。

在 GCD 中，使用 dispatch_queue_t 类型来表示队列。我们可以使用 dispatch_queue_create 函数来创建队列：

```swift
let serialQueue = DispatchQueue(label: "com.example.serialQueue")
let concurrentQueue = DispatchQueue(label: "com.example.concurrentQueue", attributes: .concurrent)
```

在上面的代码中，我们创建了一个串行队列和一个并发队列。

为了将任务提交到队列中，我们可以使用 async 或 sync 函数。async 函数会将任务提交到队列中，并立即返回，不会等待任务执行完成。而 sync 函数会将任务提交到队列中，并等待任务执行完成之后再返回。如果我们在当前队列中调用 sync 函数，则会导致死锁。

```swift
serialQueue.async {
    print("Task 1")
}
concurrentQueue.async {
    print("Task 2")
}
concurrentQueue.sync {
    print("Task 3")
}
print("Task 4")
```

在上面的代码中，我们将 Task 1 和 Task 2 提交到了并发队列中，它们会同时执行，而 Task 3 会在当前队列中同步执行，因此会等待 Task 2 执行完成之后才会执行。Task 4 则在主线程中执行。

## Operation Queues

除了 GCD，Swift 还提供了一种更高级别的并发性机制，称为 Operation Queues。它使用 Operation 和 Operation Queue 来管理任务。

Operation 是一个抽象类，表示一个要执行的任务。我们可以继承 Operation 类来创建自己的任务。例如，下面是一个简单的 Operation 子类：

```swift
class MyOperation: Operation {
  override func main() {
    print("Task 1")
  }
}
```

在上面的代码中，我们创建了一个 MyOperation 类，它会打印一条消息。

我们可以将 Operation 提交到 Operation Queue 中，就像提交任务到 GCD 队列中一样：

```swift
let operationQueue = OperationQueue()

let op1 = MyOperation()
let op2 = BlockOperation {
    print("Task 2")
}
let op3 = BlockOperation {
    print("Task 3")
}
let op4 = BlockOperation {
    print("Task 4")
}

op2.addDependency(op1)
op3.addDependency(op2)
op4.addDependency(op3
```

Swift 提供了几种处理并发性的方式，包括：

- Grand Central Dispatch (GCD)：是一个轻量级的库，用于并发性编程。它提供了一个简单的 API 来调度任务并发执行，包括串行、并行、同步和异步等方式。
- Operation Queues：提供了一个面向对象的 API，允许你创建一个队列，并将任务添加到队列中。每个任务都可以封装为一个 Operation 对象，并且可以设置依赖关系和优先级等属性。
- Futures 和 Promises：它们是一种在异步编程中管理异步计算的方法。Futures 表示一个异步操作的结果，Promises 则是一个异步操作的产生者。
- Actors：是一种并发性编程模型，它将内存安全性和高性能相结合。Actor 是一个可扩展的、高效的并发性构造，它可以避免常见的竞态条件和死锁问题。

这些并发性的方式都可以帮助开发者在 Swift 中实现并发性编程，提高程序的性能和响应能力。


并发性是指系统中同时执行多个独立任务的能力。

Swift - 并发性


## Tutorials

- [Install](/blog/nodejs/01-install)
- [First Program](/blog/nodejs/02-first-program)
- [NPM & CLI](/blog/nodejs/03-npm&cli)
- [Globals](/blog/nodejs/04-globals)
- [OS](/blog/nodejs/05-os)
- [Error](/blog/nodejs/06-error)
- [DNS & NET](/blog/nodejs/07-dns&net)
- [Crypto](/blog/nodejs/08-crypto)
- [TSL & SSL & DEBUGGER](/blog/nodejs/09-tsl&ssl&debugger)
- [Process](/blog/nodejs/10-process)
- [Child Process](/blog/nodejs/11-child_process)
- [Buffers](/blog/nodejs/12-buffers)
- [Streams](/blog/nodejs/13-Streams)
- [File System](/blog/nodejs/14-File%20System)
- [Path](/blog/nodejs/15-Path)
- [StringDecoder](/blog/nodejs/16-StringDecoder)
- [Query String](/blog/nodejs/17-Query%20String)
- [zlib](/blog/nodejs/18-zlib)
- [Assertion](/blog/nodejs/19-Assertion)
- [V8](/blog/nodejs/20-V8)
- [Callbacks](/blog/nodejs/21-Callbacks)
- [Events](/blog/nodejs/22-Events)

## Node.js 技术栈学习指南路线图

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