Opaque types（不透明类型）是一种声明方式，它可以隐藏类型的实现细节，同时提供一个公共接口供外部使用，这样可以使代码更加模块化和安全。

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)


Learning Node.js


Hook 是 React 16.8 的新增特性。它可以让你在不编写 class 的情况下使用 state 以及其他的 React 特性。

- useState
- useEffect
- useRef
- useContext
- useCallback
- useMemo

## 使用 useState

`useState` 可以让你在不编写 class 的情况下使用 state。

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

function Counter() {
  const [count, setCount] = useState(0)

  function updateCount() {
    setCount(count + 1)
  }

  return <button onClick={updateCount}>Count is: {count}</button>
}
```

`useState`第一个参数是初始值，第二个参数是一个函数，这个函数可以更新初始值。

如果更新函数返回值与初始值相同，那么组件不会更新。否则将组件的重新渲染加入队列。

## 使用 useEffect

`useEffect(callback[, dependencies]);`

- `callback`是包含副作用逻辑的函数
- `dependencies`是一个数组，表示依赖的数据发生变化时，`callback`函数才会执行。

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

当`dependecies`未提供时，每次渲染都会执行`callback`函数。

当`dependencies`提供的是一个空数组时，`callback`函数只会执行一次。

当`dependencies`提供的是一个不为空的数组时，`callback`函数会在依赖的数据发生变化时执行。

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

function MyComponent() {
  useEffect(() => {
    // perform side effect here
  }, [])
}
```

[A Simple Explanation of React.useEffect()](https://dmitripavlutin.com/react-useeffect-explanation/)

## 使用 useRef

`useRef`允许直接访问 JSX 元素的 DOM 元素。

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

function MyComponent() {
  const ref = useRef()

  return <div ref={ref} />
}
```

此时，可以使用`ref.current`访问到 DOM 元素。比如：

```jsx
import {useWindowEvent} from '@mantine/hooks'
import {useRef} from 'react'

function Header() {
  const inputRef = useRef()

  useWindowEvent('keydown', (event) => {
    if (event.code === 'KeyK' && event.ctrlKey) {
      event.preventDefault()
      inputRef.current.focus()
    }
  })

  return <input ref={inputRef} />
}
```

## 使用 useContext

`useContext`提供比`Context.Consumer`更简单的方式来访问 Context。比如：

```jsx
import { createContext, useContext } from 'react';

const NameContext = createContext('');

function App() {
  return (
    <NameContext.Provider value="John Doe">
      <Body />
    <NameContext.Provider>
  );
}

function Body() {
  return <Greeting />;
}

function Greeting() {
	const name = useContext(NameContext);

  return (
    <h1>Welcome, {name}</h1>
  );
}
```

## 使用 useCallback

`useCallback`返回一个 memoized 函数，这个函数会在组件的每次渲染时被调用。

`useCallback(fn,deps)`，类似于 vue 中的 computed

```jsx
function App() {
  const [player, setPlayer] = React.useState('')
  const [players, setPlayers] = React.useState(['Messi', 'Ronaldo', 'Laspada'])

  function handleChangeInput(event) {
    setPlayer(event.target.value)
  }
  function handleAddPlayer() {
    setPlayers(players.concat(player))
  }
  const handleRemovePlayer = useCallback(
    (player) => {
      setPlayers(players.filter((p) => p !== player))
    },
    [players]
  )

  return (
    <>
      <input onChange={handleChangeInput} />
      <button onClick={handleAddPlayer}>Add Player</button>
      <PlayerList players={players} handleRemovePlayer={handleRemovePlayer} />
    </>
  )
}

function PlayerList({players, handleRemovePlayer}) {
  return (
    <ul>
      {players.map((player) => (
        <li key={player} onClick={() => handleRemovePlayer(player)}>
          {player}
        </li>
      ))}
    </ul>
  )
}
```

## 使用 useMemo

`useMemo`返回一个 memoized 值，与`useEffect`、`useCallback`类似，接收函数和依赖项作为参数。

```jsx
import * as React from 'react'
import {getMDXComponent} from 'mdx-bundler/client'

function Post({code, frontmatter}) {
  const Component = React.useMemo(() => getMDXComponent(code), [code])

  return (
    <>
      <header>
        <h1>{frontmatter.title}</h1>
        <p>{frontmatter.description}</p>
      </header>
      <main>
        <Component />
      </main>
    </>
  )
}
```


Hook 是 React 16.8 的新增特性。它可以让你在不编写 class 的情况下使用 state 以及其他的 React 特性。

React Hooks


在 Swift 中，类型转换(Type Casting)指的是检查一个实例的类型，或将该实例视为其超类或子类之一的过程。

Swift 提供了两种类型转换方式：

- 通过类型检查来检查实例的类型是否与特定的类型相同（或是子类或父类）：使用 is 和 as 操作符来完成类型检查。

  - is 操作符用于检查一个实例是否属于某个特定类型或其子类。返回值为布尔类型。
  - as? 操作符用于尝试将实例转换为特定类型。如果转换成功，返回一个可选类型的实例，否则返回 nil。
  - as! 操作符强制将实例转换为特定类型。如果转换失败，会抛出一个运行时错误。

- 通过向下转换来将父类实例转换为其子类实例：使用 as? 或 as! 操作符完成向下转换。
  - as? 操作符尝试将父类实例转换为子类实例。如果转换成功，返回一个可选类型的子类实例，否则返回 nil。
  - as! 操作符强制将父类实例转换为子类实例。如果转换失败，会抛出一个运行时错误。

下面是一个示例代码：

```swift
class Animal {
  func makeSound() {
    print("I am an animal")
  }
}

class Dog: Animal {
  override func makeSound() {
    print("Woof!")
  }
}

let animal = Animal()
let dog = Dog()

// Type check
if dog is Animal {
  print("dog is an Animal")
}

// Downcasting
let maybeDog = animal as? Dog
if let dog = maybeDog {
  dog.makeSound()
} else {
  print("Not a dog")
}

// Forced downcasting
let definitelyDog = animal as! Dog // Runtime error!
```

在上面的代码中，我们创建了一个 Animal 类和一个继承自 Animal 的 Dog 类。使用 is 操作符检查 dog 实例是否是 Animal 类的子类，并使用 as? 操作符尝试将 Animal 实例转换为 Dog 实例。最后，使用 as! 操作符强制将 Animal 实例转换为 Dog 实例（如果尝试转换一个非 Dog 实例，则会引发运行时错误）


在Swift中，类型转换(Type Casting)指的是检查一个实例的类型，或将该实例视为其超类或子类之一的过程。。

Swift - 类型转换


Swift 支持多种控制流语句，包括条件语句、循环语句和控制转移语句。这些语句可以控制代码的执行流程，使程序能够根据不同的条件执行不同的代码路径。

以下是 Swift 中常用的控制流语句：

条件语句（if、else、else if）

```swift
let age = 20
if age < 18 {
  print("未成年人")
} else if age < 30 {
  print("年轻人")
} else {
  print("中年人")
}
```

循环语句（for、while、repeat-while）

```swift
// for 循环
for i in 1...5 {
  print(i)
}

// while 循环
var i = 0
while i < 5 {
  print(i)
  i += 1
}

// repeat-while 循环
i = 0
repeat {
  print(i)
  i += 1
} while i < 5
```

控制转移语句（break、continue、fallthrough、return、throw）

```swift
// break 语句
for i in 1...10 {
if i == 5 {
  break
}
print(i)
}

// continue 语句
for i in 1...10 {
if i % 2 == 0 {
  continue
}
print(i)
}

// fallthrough 语句
let score = 80
var grade = ""
switch score {
  case 0..<60:
  grade = "不及格"
  case 60..<70:
  grade = "及格"
  case 70..<80:
  grade = "中等"
  case 80..<90:
  grade = "良好"
  case 90...100:
  grade = "优秀"
  fallthrough
  default:
  print("你的成绩是 \(score)，评级是 \(grade)")
}

// return 语句
func sum(_ a: Int, _ b: Int) -> Int {
  return a + b
}

// throw 语句
enum MyError: Error {
  case error1
  case error2
}

func test() throws {
  throw MyError.error1
}
```

Swift 的控制流语句功能强大，使用灵活，可以编写出各种复杂的逻辑结构，从而满足不同的编程需求。需要根据具体的需求选择不同的控制流语句。


Swift 支持多种控制流语句，包括条件语句、循环语句和控制转移语句

Swift - 控制流


## Promise

> 用于一个异步操作的最终完成或失败及其结果

## 状态

1. pending，初识状态
2. fulfilled，操作成功
3. rejected，操作失败

## 流程

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

## 语法

```js
new Promise((resolve, reject) => {
  /*executor*/
})
```

> Promise 执行时立即调用 executor 函数（通常是一些异步操作），resovle 将 Promise 的状态改为 fulfilled，reject 将 Promise 的状态改为 rejected，如果 catch 到了错误，将忽略 executor 内的返回值，Promise 的状态被改成 rejected

## 属性

1. Promise.length //1
2. Promise.prototype //Promise 的构造器的原型

## 方法

1. Promise.all //Promise.all 方法常被用于处理多个 promise 对象的状态集合
2. Promise.race //当 iterable 参数里的任意一个子 promise 被成功或失败后，父 promise 马上也会用子 promise 的成功返回值或失败详情作为参数调用父 promise 绑定的相应句柄，并返回该 promise 对象。
3. Promise.reject //返回一个状态为失败的 Promise 对象，并将给定的失败信息传递给对应的处理方法
4. Promise.resolve //返回的 Promise 对象状态为 fulfilled

## 原型

1. Promise.prototype.constructor //返回被创建的实例函数. 默认为 Promise 函数.
2. Promise.prototype.catch //添加一个拒绝(rejection) 回调到当前 promise, 返回一个新的 promise
3. Promise.prototype.then //添加解决(fulfillment)和拒绝(rejection)回调到当前 promise, 返回一个新的 promise, 将以回调的返回值来 resolve.
4. Promise.prototype.finally //添加一个事件处理回调于当前 promise 对象，并且在原 promise 对象解析完毕后，返回一个新的 promise 对象。回调会在当前 promise 运行完毕后被调用，无论当前 promise 的状态是完成(fulfilled)还是失败(rejected)

## 使用

```js
const P=new Promise((resolve,reject)=>{
    if(/*success*/){
        resolve()
    }else{
        reject()
    }
})
```


Promise


> `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 对象在组件的整个生命周期内保持不变。