**Git 命令收藏，防止找不到**




## 批量删除标签
```bash
git tag -l | xargs -n 1 git push --delete origin # 删除远程标签，需要本地和远程同步
git tag -l | xargs git tag -d # 清理本地标签
```

## 批量删除分支
```bash
git branch -a | grep 'lyn_' | xargs git branch -D # 批量删除本地分支
git branch -r | grep  'feature/LBSM-31' | sed 's/origin\///g' | xargs -I {} git push origin :{} #批量删除远程分支
```

## 统计每个人代码增删行数
```bash
git log --format='%aN' | sort -u | while read name; do echo -en "$name\t"; git log --author="$name" --pretty=tformat: --numstat | awk '{ add += $1; subs += $2; loc += $1 - $2 } END { printf "added lines: %s, removed lines: %s, total lines: %s\n", add, subs, loc }' -; done
```
## 打标签
```bash
git tag  # 查看所有标签
git tag -a v1.4 -m 'my version 1.4'   # 创建附注标签（当前commit记录）
git tag v1.4   # 创建轻量标签（当前commit记录）    
git show v1.4 # 查看标签
git tag -a v1.4 -m 'my version 1.4'  bdc31e0   # 创建历史记录提交的标签

git push origin v1.5   # 共享单个标签
git push origin --tags # 共享所有标签
git checkout -b version2 v2.0.0  # 检出标签
```

## 储藏
```bash
git stash  # 暂存列表，暂时会保存当前commit的信息和hash，方便分清
git stash list # 查看暂存列表，最新暂存的在最前面
git stash apply # 应用第一个暂存
git stash apply stash@{1}  # 当然你也可以指定应用哪个暂存
git stash drop  # 删除第一个暂存
git stash drop  stash@{1}  # 当然你也可以指定删除哪个暂存
git stash pop # 应用暂存并且删除暂存

git stash --keep-index  # 它告诉 Git 不要储藏任何你通过 git add 命令已暂存的东西。
git stash -u      # 储藏任何创建的未跟踪文件
git stash --patch # 择性地存储你的工作区更改
```

Git 命令收藏

**本篇对Node child_process进行深入了解，child_process开启子进程的方法有exec、execFile、spawn、fork。**

**注意事项**
- 子进程会在执行完命令以后，自动被关闭，除非进程里面的代码一直在运行
- 如果在fork进程中出现父子进程相互发消息的情况，则不会自动关闭，需要手动进行关闭。



## exec
1. 运行完所有内容以后，才会进入callback
2. 超出maxBuffer以后，进程会被自动终止
3. options的shell默认值为true，会衍生一个 shell，然后在 shell 中执行 command，且缓冲任何产生的输出
```js
exec('cat read.txt',(error, stdout, stderr)=>{
  if (error) {
    console.error(`执行的错误: ${error}`);
    return;
  }
  console.log(`stdout: ${stdout}`);
  console.error(`stderr: ${stderr}`);
})
```

## execFile
1. 和exec第一点相同
2. 和exec第二点相同
3. options的shell默认值为false。不会衍生 shell。 相反，指定的可执行文件 file 会作为新进程直接地衍生，使其比 child_process.exec() 稍微更高效,但是无法执行 I/O 重定向和文件通配等行为
```js
execFile('cat',['read.txt','>','a.txt'],(error, stdout, stderr)=>{
  if (error) {
    throw error;
  }
  console.log('stdout',stdout);
  console.log('stderr',stderr);
})
```

## spawn
1. 采用流的形式接收数据和导出数据
2. 可以解除maxBuffer限制
3. 和execFile第三点相同
```js
const { spawn } = require('child_process');
const ps = spawn('ps', ['ax']);
const grep = spawn('grep', ['ssh']);

ps.stdout.on('data', (data) => {
  grep.stdin.write(data);
});

ps.stderr.on('data', (data) => {
  console.error(`ps stderr: ${data}`);
});

ps.on('close', (code) => {
  console.log('ps close')
  if (code !== 0) {
    console.log(`ps 进程退出，退出码 ${code}`);
  }
  grep.stdin.end();
});

grep.stdout.on('data', (data) => {
  console.log(data.toString());
});

grep.stderr.on('data', (data) => {
  console.error(`grep stderr: ${data}`);
});

grep.on('close', (code) => {
  console.log('grep close')
  if (code !== 0) {
    console.log(`grep 进程退出，退出码 ${code}`);
  }
});
```
## fork
1. 采用流的形式接收数据和导出数据
2. 无法执行命令
3. 与父进程共享一个 IPC 通道，用于父子通信
```js
// parent.js
const { fork } = require('child_process');

const child = fork('./child.js');

child.on('message', (message) => {
  console.log(`Received message from child: ${message}`);
});

child.send('Hello from parent');

// child.js
process.on('message', (message) => {
  console.log(`Received message from parent: ${message}`);
  process.send('Hello from child');
});

```

## 创建和父模块分离的子进程
1. 通过 `detached:true` 使子进程脱离父进程。
2. 将子进程与父进程的IO分离，需要配置 stdio
3. 移除父进程对子进程的引用，使用 child_process.unref()
```js
setInterval(() => {
console.log('父进程')
},2000)

const subprocess = spawn('node', ['detached.js'], {
  detached: true,
  stdio: 'ignore'
});
subprocess.unref();

// detached.js
setInterval(()=>{
  console.log('子进程')
},1000)
```


## 总结
1. spawn 用于直接使用的命令，交互通过child.stdout进行
2. exec和execFile也直接用于命令，交互通过回调进行
3. fork用户执行文件，可以进行父子通信

Node 之 child_process

**本篇对Node process 进行深入了解**




## process

### process.stdin、process.stdout
输入、输出流

创建文件夹例子
```js
const fs=require('fs')
process.stdout.write('请输入项目名称：')
process.stdin.setEncoding('utf-8')
process.stdin.on('data',function(e){
  fs.mkdirSync(e.toString().replace(/(\r\n)|(\n)/g,''))
  process.stdout.write('项目创建成功\n')
  process.nextTick(()=>{
    process.exit()
  })
})
```


### 基础事件

#### beforeExit

对于导致显式终止的条件，不会触发 'beforeExit' 事件，例如调用 process.exit() 或未捕获的异常。在回调里面异步调用函数，进程会被维持

#### exit

- 显式调用 process.exit() 方法；
- Node.js 事件循环不再需要执行任何其他工作。
- 监听器函数必须只执行同步操作。 在调用 'exit' 事件监听器之后，Node.js 进程将立即退出，从而导致在事件循环中仍排队的任何其他工作被放弃。

```js
process.on('beforeExit', (code) => {
  console.log('进程 beforeExit 事件的代码: ', code);
});

process.on('exit', (code) => {
  console.log('进程 exit 事件的代码: ', code);
});
console.log('此消息最新显示');
```

#### disconnect
#### message
#### warning
#### 信号事件

### 处理异常的事件

#### multipleResolves

只要 Promise 有以下情况，就会触发 'multipleResolves' 事件
- resolve不止一次
- reject不止一次
- resolve后reject
- reject后resolve
```js
process.on('multipleResolves', (type, promise, reason) => {
  console.error(type, promise, reason);
  setImmediate(() => process.exit(1));
});

async function main() {
  try {
    return await new Promise((resolve, reject) => {
      resolve('第一次调用');
      resolve('吞没解决');
      reject(new Error('吞没解决'));
    });
  } catch {
    throw new Error('失败');
  }
}
main();
```

#### unhandledRejection
如果在事件循环的一次轮询中，一个 Promise 被拒绝，并且此 Promise 没有绑定错误处理器， 'unhandledRejection 事件会被触发
```js
process.on('unhandledRejection', (reason, promise) => {
  console.log('未处理的拒绝：', promise, '原因：', reason);
  // 记录日志、抛出错误、或其他逻辑。
});
new Promise((resolve,reject)=>{
  reject('失败')
})
```

#### rejectionHandled
每当 Promise 被拒绝并且错误处理函数附加到它（例如，使用 promise.catch()）晚于一个 Node.js 事件循环时，就会触发 'rejectionHandled' 事件
```js
const unhandledRejections = new Map();
process.on('unhandledRejection', (reason, promise) => {
  console.log('unhandledRejection')
  unhandledRejections.set(promise, reason);
});
process.on('rejectionHandled', (promise) => {
  console.log('rejectionHandled')
  unhandledRejections.delete(promise);
});

let p=new Promise((resolve,reject)=>{
   reject(10)
})

setImmediate(()=>{
  p.catch(()=>{
  })
})
```

#### uncaughtException
当未捕获的 JavaScript 异常一直冒泡回到事件循环时，会触发 'uncaughtException' 事件。出现异常，没有错误，默认是以错误码1直接退出，设定此函数进程将会依然被保持
```js
let fs=require('fs')
process.on('uncaughtException', (err, origin) => {
  fs.writeSync(
    process.stderr.fd,
    `捕获的异常: ${err}\n` +
    `异常的来源: ${origin}\n`
  );
})

setTimeout(() => {
  console.log('这里仍然会运行')
  process.exit(20)
}, 1500)

setInterval(()=>{
  console.log('进程依然在继续')
},500)
process.on('exit',(code)=>{
  console.log('错误代码',code)
})


// 故意引起异常，但不要捕获它。
nonexistentFunc()
console.log('这里不会运行')
```

### 常用方法
#### process.chdir() 
修改工作目录
```js
process.chdir(directory)
```

#### process.cwd()
返回当前工作目录
```js
console.log(`Starting directory: ${process.cwd()}`);
try {
  process.chdir('/usr');
  console.log(`New directory: ${process.cwd()}`);
} catch (err) {
  console.error(`chdir: ${err}`);
}
```
#### process.cpuUsage() 
返回Node.js 进程的内存使用情况，上一次调用 process.cpuUsage() 方法的结果，可以作为参数值传递给此方法，得到的结果是与上一次的差值
```js
process.cpuUsage([previousValue])

const startUsage = process.cpuUsage();
// { user: 38579, system: 6986 }

// 将 CPU 旋转 500 毫秒。
const now = Date.now();
while (Date.now() - now < 500);

console.log(process.cpuUsage(startUsage));
// { user: 514883, system: 11226 }
```
#### process.memoryUsage()
返回 Node.js 进程的内存使用情况
```js
process.memoryUsage()
console.log(process.memoryUsage());
```
#### process.exit()
退出进程
```js
process.exit([code])
```
#### process.kill()
根据进程id，杀死进程
```js
process.kill(pid[, signal])
console.log(process.pid)
setInterval(()=>{

},100)
process.kill(process.pid, 'SIGKILL');
```
#### process.nextTick
将一个函数推迟到当前执行栈执行完毕之后立即执行，而不是在异步任务队列中排队等待执行
```js
process.nextTick(callback[, ...args])
```

### 常用属性
#### process.argv
第一个元素是 process.execPath。  第二个元素将是正在执行的 JavaScript 文件的路径。 其余元素将是任何其他命令行参数

#### process.argv0
process.execPath

#### process.execArgv
属性返回当 Node.js 进程被启动时，Node.js 特定的命令行选项
```js
console.log(process.argv) //[
  '/Users/ccz/.nvm/versions/node/v12.14.0/bin/node',
  '/Users/ccz/Public/student-project/cs/vue-cs-3.0/a2.js',
  '-a',
  '-b=100'
]

console.log(process.argv0) ///Users/ccz/.nvm/versions/node/v12.14.0/bin/node
console.log(process.execArgv) //[ '--harmony' ]
```

#### process.connected
一旦 process.connected 为 false，则不能通过 IPC 通道使用 process.send() 发送信息

#### process.exitCode
当进程正常退出，或通过 process.exit() 退出且未指定退出码时，此数值将作为进程的退出码。指定 process.exit(code) 的退出码将覆盖 process.exitCode 的原有设置

#### process.platform
标识 Node.js 进程运行其上的操作系统平台
#### process.pid
返回进程的 PID
#### process.ppid
返回当前父进程的 PID

Node 之 process

**本篇对Node stream 进行深入了解，stream分为可写流和可读流。**



## stream
### 可写流事件

写入操作是异步的

#### 1.可写流的基本例子
```js
const fs=require('fs')
const file=fs.createWriteStream('a1.txt')
file.write('一些数据\n');
file.write('更多数据\n');
file.end('完成写入数据');
```

#### 2.drain事件，监听当超出缓冲区后,何时缓冲区被释放

短时间内写入大量数据，超出缓冲区时（默认16kb），此时运行write会暂时无法写入。

使用drain可以监听当前写入是否超出缓冲区，作出相应处理
```js
const fs=require('fs')
const file=fs.createWriteStream('a1.txt')

let i=100000
let ok=true
function write(){
  while(i>0&&ok){
    i--
    if(i===0){
      file.write('一些数据\n','utf-8',()=>{
        console.error('写入已完成');
      })
    }
    else{
      ok=file.write('一些数据\n','utf-8');
    }
  }
  if(i>0){
    ok=true
    console.log(`还剩下${i}`)
    file.once('drain', write);
  }
}
write()
// file.end('完成写入数据'); //不能在这里加入end，因为end会强制结束
```
该例子，所有数据都会全部显示。证明超出缓存区以后，数据依然会被写入（后面的800多条数据都会在缓冲区）
```js
const file=fs.createWriteStream('a1.txt')
let i=0
let ok=true
function write(){
  for(;i<2000;i++){
    ok=file.write(`一些数据${i}\n`,'utf-8');
    if(!ok){
      file.once('drain', ()=>{
        console.log('缓冲区被占满')
      });
      console.log(i)
    }
  }
}
write()
// file.end('一些数据\n','utf-8'); 
// 添加该行，结果不会有任何改变，但是将无法看到 console.log('缓冲区被占满')，猜测是因为end强制输出。
```

#### 3.finish事件，只有当触发end方法或者pipe方法完成传输时，才会触发finish事件
```js
const fs=require('fs')
const file=fs.createWriteStream('a1.txt')
file.write('一些数据\n')
file.write('一些数据\n')
file.end('完成写入数据');
file.on('finish',()=>{
  console.error('写入已完成');
})
```

#### 4.error事件，当发生报错时，会触发该事件。如果定义该事件，报错则不会退出进程，否则将退出进程
```js
file.write('一些数据\n','utf-8');
file.destroy(new Error('12345'))

setInterval(()=>{
  console.log('进程正在进行') //维持进程
},500)

file.on('error',()=>{
  console.log('出现错误')
})
```

#### 5.close事件，当关闭可读流时，会触发该事件。比如destory（不进行error报错），end等
```js
file.write('一些数据\n','utf-8');
//file.destroy() //也会触发close事件

file.end('一些数据\n','utf-8');
file.on('close',()=>{
  console.log('进行已结束')
})
```

#### 6.pipe事件，监听可写流是否通过pipe传输
```js
const fs=require('fs')
const writer=fs.createWriteStream('write.txt')
const reader=fs.createReadStream('read.txt')

writer.on('pipe', (src) => {
  console.log('有数据正通过管道流入写入器');});
writer.on('drain',()=>{
  console.log('缓冲区已被释放')
})
reader.pipe(writer);
```

7.unpipe，监听可写流pipe传输是否被移除

### 可写流方法和属性
#### 方法
**writable.cork()**

强制把所有写入的数据都缓冲到内存中。drain事件将会在最后被写入的时候触发一次。当调用 stream.uncork() 或 stream.end() 方法时，缓冲的数据才会被输出。

**writable.uncork()**

释放缓冲数据，输出到目标

建议使用 process.nextTick() 来延迟调用 writable.uncork()。 通过这种方式，可以对单个 Node.js 事件循环中调用的所有 writable.write() 进行批处理。
```js
stream.cork();
stream.write('一些 ');
stream.write('数据 ');
process.nextTick(() => stream.uncork());
```

**writable.destroy([error])**

销毁流。 填写error则触发 'error'事件，不填写则触发 'close' 事件

**writable.end([chunk[, encoding]][, callback])**

触发finish事件和close事件。先触发finish事件，在触发close事件

**writable.write(chunk[, encoding][, callback])**

写入数据到流

**writable.setDefaultEncoding(encoding)**

方法为可写流设置默认的 encoding


#### 属性
- writable.destroyed：在调用了 writable.destroy() 之后为 true
- writable.writable：如果调用 writable.write() 是安全的，则为 true
- writable.writableEnded：在调用了 writable.end() 之后为 true。 此属性不表明数据是否已刷新，对此请使用 writable.writableFinished
- writable.writableFinished：在触发 'finish' 事件之立即设置为 true
- writable.writableHighWaterMark：返回构造可写流时传入的 highWaterMark 的值
- writable.writableLength：此属性包含准备写入的队列中的字节数（或对象）。 该值提供有关 highWaterMark 状态的内省数据
- writable.writableObjectMode：获取用于给定 Writable 流的 objectMode 属性

### 可读流介绍
流动模式（flowing）或暂停模式（paused）
- 在流动模式中，数据自动从底层系统读取，并通过 EventEmitter 接口的事件尽可能快地被提供给应用程序。
- 在暂停模式中，必须显式调用 stream.read() 读取数据块。

所有可读流都开始于暂停模式，可以通过以下方式切换到流动模式：
- 添加 'data' 事件句柄。
- 调用 stream.resume() 方法。
- 调用 stream.pipe() 方法将数据发送到可写流。

可读流可以通过以下方式切换回暂停模式：

- 如果没有管道目标，则调用 stream.pause()。
- 如果有管道目标，则移除所有管道目标。调用 stream.unpipe() 可以移除多个管道目标。

只有提供了消费或忽略数据的机制后，可读流才会产生数据。 如果消费的机制被禁用或移除，则可读流会停止产生数据。

为了向后兼容，移除 'data' 事件句柄不会自动地暂停流。 如果有管道目标，一旦目标变为 drain 状态并请求接收数据时，则调用 stream.pause() 也不能保证流会保持暂停模式。

如果可读流切换到流动模式，且没有可用的消费者来处理数据，则数据将会丢失。 例如，当调用 readable.resume() 时，没有监听 'data' 事件或 'data' 事件句柄已移除。

添加 'readable' 事件句柄会使流自动停止流动，并通过 readable.read() 消费数据。 如果 'readable' 事件句柄被移除，且存在 'data' 事件句柄，则流会再次开始流动。

### 可读流事件
#### data事件
使用该事件，流将会被转换到流动模式

data事件的优先级比readable优先级低，使用readable将被转换为暂停模式

当调用 readable.read() 且有数据块返回时，也会触发 'data' 事件

使用data事件，会自动读取文件
```js
const fs = require('fs')
const reader = fs.createReadStream('read.txt')
reader.setEncoding('utf8')
reader.on('data', function (chunk) {
  console.log(chunk)
})
```

#### end事件
事件只有在数据被完全消费掉后才会触发（pipe，data，readable都可以触发）

#### close事件
pipe，data，readable都可以触发,destroy不包含error也可以触发

#### readable事件
监听数据变化，如果有新的数据，或者数据到达流的尽头,才会触发readable事件
```js
const fs = require('fs')
const reader = fs.createReadStream('read.txt')

reader.setEncoding('utf8')
reader.on('readable', function (chunk) {
  let result=reader.read()
  console.log('chunk',result)
})
reader.on('end',function(){
  console.log('end')
})
```

#### error事件
监听报错，如果出现报错，则进入该事件

#### pause事件
监听pause方法调用，调用后执行该事件（流动模式下才可以暂停）
```js
const fs = require('fs')
const reader = fs.createReadStream('read.txt')

reader.setEncoding('utf8')
let i=0
reader.on('data', function (chunk) {
  i++
  console.log('chunk')
  if(i>2){
    reader.pause()
  }
})
reader.on('pause',function(){
  console.log('pause')
})
reader.on('end',function(){
  console.log('end')
})
```

#### resume事件
监听resume方法调用

### 可读流方法和属性
#### 方法
**readable.destroy([error])**

销毁流。 填写error则触发 'error'事件，不填写则触发 'close' 事件

**readable.isPaused()**

方法返回可读流当前的操作状态。

**readable.pause()**

方法使流动模式的流停止触发 'data' 事件，并切换出流动模式。 任何可用的数据都会保留在内部缓存中，readable事件下无法使用

**readable.resume()**

readable.resume() 方法将被暂停的可读流恢复触发 'data' 事件，并将流切换到流动模式，readable事件下无法使用

**readable.pipe(destination[, options])**

方法绑定可写流到可读流，将可读流自动切换到流动模式，并将可读流的所有数据推送到绑定的可写流。 数据流会被自动管理，所以即使可读流更快，目标可写流也不会超负荷。
```js
const fs = require('fs')
const reader = fs.createReadStream('read.txt')
const writer=fs.createWriteStream('write.txt')
reader.pipe(writer,{
  end:false //为false 的话，pipe write不会使用end写入
})
reader.on('end', () => {
  writer.end('结束');
});
```

**readable.read([size])**

可选的 size 参数指定要读取的特定字节数。 如果无法读取 size 个字节，则除非流已结束，否则将会返回 null，在这种情况下，将会返回内部 buffer 中剩余的所有数据。

**readable.setEncoding(encoding)**

设置编码格式

**readable.unpipe([destination])**

移除管道流


#### 属性
- readable.destroyed：在调用了 readable.destroy() 之后为 true
- readable.readable:如果可以安全地调用 readable.read()，则为 true
- readable.readableEncoding:获取用于给定可读流的 encoding 属性。 可以使用 readable.setEncoding() 方法设置 encoding 属性
- readable.readableEnded:当 'end' 事件被触发时变为 true
- readable.readableHighWaterMark:返回构造可读流时传入的 highWaterMark 的值

Node 之 stream

**随着现代Web应用程序的发展，服务器端JavaScript平台Node.js越来越受欢迎。Node.js提供了一种快速、高效的方式来构建服务器端应用程序，并通过其强大的API来支持许多关键功能。无论您是初学者还是有经验的开发人员，了解Node.js API的基本概念和用法都是非常重要的。**

**本篇学习 event、buffer、dgram、net。**




## event
```js
const EventEmitter = require('events');
const myEmitter = new EventEmitter();
myEmitter.on('event', () => {
  console.log('触发事件');
});
myEmitter.emit('event');
```

内置事件：
- error:当 EventEmitter 实例出错时，应该触发 'error' 事件。
- newListener：EventEmitter 实例在新的监听器被添加到其内部监听器数组之前，会触发自身的 'newListener' 事件。
- removeListener: 'removeListener' 事件在 listener 被移除后触发。
```js
const MyEmitter=require('events');
const myEmitter = new MyEmitter();
// 只处理一次，避免无限循环。
myEmitter.once('newListener', (event, listener) => {
  if (event === 'event') {
    // 在前面插入一个新的监听器。
    myEmitter.on('event', () => {
      console.log('B');
    });
  }
});
myEmitter.on('event', () => {
  console.log('A');
});
myEmitter.emit('event');
```

**内置方法：**
- on(eventName, listener):注册事件监听器
- once(eventName, listener):注册只被执行一次的事件监听器
- off(eventName, listener):移除事件监听器
- emit(eventName,...args)：执行事件
- addListener(eventName, listener):同on方法
- removeListener(eventName, listener)：同off方法
- prependListener(eventName, listener)：添加 listener 函数到名为 eventName 的事件的监听器数组的开头。 不会检查 listener 是否已被添加。 多次调用并传入相同的 eventName 和 listener 会导致 listener 被添加多次。
- prependOnceListener(eventName, listener):同上
- removeAllListeners：移除事件
- eventNames()：返回当前已注册的事件名
- getMaxListeners():获取当前监听器的最大限制个数
- setMaxListeners(n)：默认情况下，如果为特定事件添加了超过 10 个监听器，则 EventEmitter 会打印一个警告。 这有助于发现内存泄露。 但是，并不是所有的事件都要限制 10 个监听器。 emitter.setMaxListeners() 方法可以为指定的 EventEmitter 实例修改限制。
- listenerCount(eventName):返回正在监听的名为 eventName 的事件的监听器的数量。
- listeners(eventName):返回名为 eventName 的事件的监听器数组的副本。
- rawListeners(eventName)：返回名为 eventName 的事件的监听器数组的拷贝。和listeners没啥区别，都无法都直接改变函数或者直接添加方法。唯一区别，是once调用方法


## buffer
在了解buffer之前，先来了解下ASCII码、Unicode、UTF-8

ASCII码一个字符只占一个字节，一个字节最多可以展示256个符号（只能用来展示字母和符号）。不能用来展示中文

Unicode一个字符占两个字节，用十六进制编码而成（ASCII码编译成16进制），可以展示256*256个符号。英文，中文占2个字节

UTF-8：目前互联网最常见的Unicode编码方式，它是一种变长的编码方式。它可以使用1~4个字节表示一个符号，根据不同的符号而变化字节长度。英文占1个字节，中文3个字节

JS下unicode转换：
```js
'a'.charCodeAt().toString(16) // charCodeAt转成10进制，unicode默认16进制，需要通过toString进行转换进制
// 61
let a='61'
parseInt(a,16) // 将16进制的参数a，转换为10进制
// 97
```

Buffer.from：将数据转换为buffer
```js
const buf = Buffer.from('abc','ascii'); // buffer格式=><Buffer 61 62 63>
console.log(buf.toString('base64')) // 转换为base64编码格式，输出=>YWJj
```

Buffer.alloc：生成指定长度的buffer
```js
const buf1 = Buffer.alloc(5); // 默认以0填充 
console.log(buf1); // <Buffer 00 00 00 00 00>
const buf2 = Buffer.alloc(5,'a'); // 默认以'a'的编码填充
console.log(buf2);// <Buffer 61 61 61 61 61>
const buf3 = Buffer.alloc(5,'YWJj','base64'); // 将'YWJj'采用base64的编码形式
console.log(buf3);
```

Buffer.concat：将数组内的buffer整合成一个buffer对象
```js
let arr=[Buffer.alloc(1),Buffer.alloc(2)]
let bufArr=Buffer.concat(arr)
console.log(bufArr)
```

## dgram
**server.js**
```js
const dgram = require('dgram');
const server = dgram.createSocket('udp4');

server.on('error', (err) => {
  console.log(`服务器异常：\n${err.stack}`);
  server.close();
});

server.on('message', (msg, rinfo) => {
  console.log(`服务器接收到来自 ${rinfo.address}:${rinfo.port} 的 ${msg}`);
});

server.on('listening', () => {
  const address = server.address();
  console.log(`服务器监听 ${address.address}:${address.port}`);
});

server.bind(41234);
```

**client.js**
```js
const dgram=require('dgram')
const clientSocket=dgram.createSocket('udp4')

clientSocket.send('hello',41234,'127.0.0.1',()=>{ // 向服务端发送请求
  console.log('发送成功',clientSocket.address())
  clientSocket.close()
})
```

## net
**server.js**
```js
const net=require('net')
const fs=require('fs')

const server=net.createServer(()=>{
  //这个函数其实就是connection事件绑定的函数
})

server.on('connection',(socket)=>{
  console.log('有人连接了',socket.remoteAddress,socket.remotePort)
  let image=fs.readFileSync('./logo.png')
  socket.write(image)
  socket.end()
  socket.on('data',data=>{
    socket.write('show me the money')
  })
})

server.listen(12345)
```

**client.js**
```js
const net=require('net')
const clientSocket=net.createConnection(12345)

clientSocket.on('data',data=>{
  console.log('服务器返回',data)
//  clientSocket.write('get money')
})

clientSocket.on('end',()=>{
  console.log('数据接收完成')
})
```

## http
**开启服务**
```js
const http=require('http')
const server = http.createServer()

server.on('request',(req,res)=>{
  console.log('接收到了请求',req.socket.address(),req.url)
  res.writeHead(200, { 'Content-Type': 'text/plain;charset=utf-8' })
  res.end('响应内容')
})
server.listen(6688)
```
**发送请求**
```js
const http=require('http')
const fs=require('fs')

let client=http.request({
  host:'www.baidu.com',
  port:80,
  protocol:'http:',
  method:'get',
  path:'/'
},(res)=>{
  let content=''
  
  res.on('data',data=>{
    content+=data.toString()
  })

  res.on('end',()=>{
    fs.writeFileSync('./baidu.html',content)
  })
})

client.end()
```
**静态资源服务**
```js
const fs=require('fs')
const http=require('http')

const server = http.createServer()

function staticSend(res,fileName,headers={
  'Content-Type': 'text/html;charset=utf-8',
},statusCode=200){
  const ext=fileName.substr(fileName.lastIndexOf('.')+1)
  if(ext==='css'){
    headers={
      'Content-Type': 'text/css;charset=utf-8',
    }
  }
  res.writeHead(statusCode, http.STATUS_CODES[statusCode],headers)
  res.end(fs.readFileSync(fileName))
}


server.on('request',(req,res)=>{
  console.log(req.url)
  if(req.url.indexOf('/static/')===0){ // url以/static/开头
    if(fs.existsSync(__dirname+req.url)){ // 文件存在
      staticSend(res,__dirname+req.url)
    }
    else{ // 文件不存在
      res.writeHead(401, http.STATUS_CODES[404])
      res.end()
    }
    return
  }
  res.writeHead(200, http.STATUS_CODES[200],{
    'Content-Type': 'text/html;charset=utf-8'
  })
  switch (req.url) {
    case '/404':
      res.writeHead(404, http.STATUS_CODES[404])
      res.end('<h1 style="color: red;">404</h1>');
      break;
    default:
       res.end('<h1>响应内容</h1>')
  }
})


server.listen(6688)

```