buffer是Node.js提供用来存放二进制数据的缓存区

Node.js - Events


在 ECMAScript 中，变量可以存在两种类型的值，即原始值和引用值。

1. 原始值占用的内存空间是固定的，而引用值占用的内存空间是动态的。
2. 原始值的值存储在栈中，而引用值的值存储在堆中。
3. 原始值的保存与复制是直接的，而引用值的保存与复制是通过值的拷贝来实现的。
4. 原始值使用`typeof`运算符来检测其类型，而引用值使用`instanceof`运算符来检测其类型。
5. 原始值的值可以通过`==`运算符来比较，而引用值的值可以通过`===`运算符来比较。
6. 使用`new()`构造出的对象是引用值，而不是原始值。

> 除了`null`和`undefined`之外，所有的基本类型都是原始值，而所有的引用类型都是引用值。

## 基本类型

- number
- boolean
- bigint
- string
- symbol
- null
- undefined

## 引用类型

- object
- array
- function

```js
const number = 10

const bool = false

const str = 'Hello!'

const missingObject = null

const nothing = undefined
```

基本类型的值是存储在栈中的，所以在 JavaScript 中，基本类型的值可替换但不可被改变。

```js
var bar = 'baz'
console.log(bar) // baz
bar.toUpperCase()
console.log(bar) // baz

// 使用数组方法可以改变一个数组
var foo = []
console.log(foo) // []
foo.push('plugh')
console.log(foo) // ["plugh"]

// 赋值行为可以给基本类型一个新值，而不是改变它
bar = bar.toUpperCase() // BAZ
```

```js
// 基本类型
let foo = 5

// 定义一个貌似可以改变基本类型值的函数
function addTwo(num) {
  num += 2
}
// 和前面的函数一样
function addTwo_v2(foo) {
  foo += 2
}

// 调用第一个函数，并传入基本类型值作为参数
addTwo(foo)
// Getting the current Primitive value
console.log(foo) // 5

// 尝试调用第二个函数...
addTwo_v2(foo)
console.log(foo) // 5
```

**在执行函数体内语句之前，JavaScript 会将传递进来的参数（基本类型的值）复制一份，创建一个本地副本。这个副本只存在于该函数的作用域中，我们能够通过指定在函数中的标识符访问到它（addTwo 中的 num，addTwo_v2 中的 foo）。**


基本类型与引用类型


在计算机科学中，并发性是指系统中同时执行多个独立任务的能力。在 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 - 并发性


React components 由一组元素构成。

基本函数组件的编写方式与常规 `JavaScript` 函数类似，但有几个不同之处。

- 组件名称必须以大写字母开头（即 MyComponent，而不是 myComponent）。
- 与 `JavaScript` 函数不同，组件必须返回 JSX。

以下是 `React` 函数组件的基本语法：

```jsx
function App() {
  return <div>Hello world!</div>
}
```


React是一个JavaScript库，致力于使UI开发变得简单

React Components


在 JavaScript 中，undefined 是一个原始值，表示没有值。它是未初始化变量的默认值，也是没有返回值的函数返回的值。

你可以使用 undefined 值来检查变量是否已初始化或函数是否已返回值：

```js
let x
console.log(x === undefined) // true

function f() {}
console.log(f() === undefined) // true
```

请注意，undefined 与 null 不同，null 表示没有对象值。在 JavaScript 中，null 是可以赋值给变量的值，而 undefined 是未初始化变量的默认值。

你还可以使用 typeof 运算符来检查一个值是否为 undefined。typeof 运算符对于 undefined 值会返回字符串 "undefined"：

```js
console.log(typeof undefined) // "undefined"
```

此外，你还可以使用 undefined 值将变量重置为其默认值：

```js
let x = 1
x = undefined // x 现在为 undefined
```

通常认为使用 undefined 值重置变量是不好的做法，因为它会导致混淆，使代码难以理解。相反，最好是明确将变量设置为 null 或其他在代码上下文中有意义的值。

总之，undefined 是 JavaScript 中的原始值，表示没有值。它是未初始化变量的默认值，也是没有返回值的函数返回的值。您可以使用“未定义”值来检查变量是否已初始化，或者函数是否已返回值，您还可以使用`typeof`操作符来检查值是否为 undefined。然而，使用 typeof 来检查值是否为 undefined 来重置变量通常被认为是一种不好的做法。


Undefined


`child_process` 模块使我们在一个运行良好的子进程内运行一些能够进入操作系统的命令

## spawn

`spawn`创建一个子进程

语法：`spawn(command, [args], [options])`

```js
const {spawn} = require('child_process')
const fs = require('fs')

for (var i = 0; i < 3; i++) {
  var workerProcess = spawn('node', ['support.js', i])
  workerProcess.stdout.on('data', function (data) {
    console.log('stdout: ' + data)
  })
  workerProcess.stderr.on('data', function (data) {
    console.log('stderr: ' + data)
  })
  workerProcess.on('close', function (code) {
    console.log('child process exited with code ' + code)
  })
}
```

## exec

`exec`使用子进程执行命令，不缓存子进程的输出，并将子进程的输出以回调函数参数的形式返回

语法：`exec(command, [options], callback)`

```js support.js
console.log('进程 ' + process.argv[2] + ' 执行。')
```

```js master.js
const fs = require('fs')
const child_process = require('child_process')

for (var i = 0; i < 3; i++) {
  var workerProcess = child_process.exec(
    'node support.js ' + i,
    function (error, stdout, stderr) {
      if (error) {
        console.log(error.stack)
        console.log('Error code: ' + error.code)
        console.log('Signal received: ' + error.signal)
      }
      console.log('stdout: ' + stdout)
      console.log('stderr: ' + stderr)
    }
  )

  workerProcess.on('exit', function (code) {
    console.log('子进程已退出，退出码 ' + code)
  })
}
```

## fork

`fork`创建一个子进程，并在父进程中继续执行

语法：`fork(modulePath, [args], [options])`

```js support.js
console.log('进程 ' + process.argv[2] + ' 执行。')
```

```js master.js
const fs = require('fs')
const child_process = require('child_process')

for (var i = 0; i < 3; i++) {
  var worker_process = child_process.fork('support.js', [i])

  worker_process.on('close', function (code) {
    console.log('子进程已退出，退出码 ' + code)
  })
}
```

[Node.js 文档](http://nodejs.cn/api/child_process.html)


child_process 模块使我们在一个运行良好的子进程内运行一些能够进入操作系统的命令

Node.js - Child Process


JavaScript 中的 null 值表示没有值或空引用。它是语言中的基本值之一，其他基本值还有 undefined、true 和 false。

你可以这样将 null 值赋给变量：

```js
let x = null
```

null 经常用来表示对象值的缺失。例如，你可以使用 null 来表示函数的结果缺失：

```js
function getUser(id) {
  let user = database.get(id)
  if (!user) {
    return null
  }
  return user
}

let user = getUser(123)
if (user === null) {
  console.log('用户未找到')
} else {
  console.log(user.name)
}
```

在上面的例子中，如果在数据库中未找到用户，函数 getUser() 将返回 null。

请注意，null 与 undefined 不同，undefined 表示没有值。在 JavaScript 中，未初始化的变量的默认值是 undefined，而 null 是可以赋值给变量的值。

你还可以使用 null 值将对象重置为初始状态：

```js
let obj = {a: 1, b: 2}
obj = null // obj 现在为 null
```

最后，你可以使用 typeof 运算符来检查一个值是否为 null。typeof 运算符对于 null 值会返回字符串 "object"：

```js
console.log(typeof null) // "object"
```

但是，这种行为被视为语言中的 bug，不会改变。建议只在对象值的上下文中使用 null
