## OS

**操作系统**

> const os = require("os")

| Api               | 说明                                         | 用法                                |
| ----------------- | -------------------------------------------- | ----------------------------------- |
| arch              | 操作系统的 CPU 架构                          | `os.arch()`                       |
| cpus              |                                              | `os.cpus()`                       |
| freemem           | 返回空闲的系统内存量                         | `os.freemem()`                    |
| totalmem          | 返回系统的内存总量                           | `os.totalmem()`                   |
| getPriority       | 返回由 `pid` 指定的进程的调度优先级        | `os.getPriority([pid])`           |
| setPriority       | 尝试为 `pid` 指定的进程设置调度优先级      | `os.setPriority([pid, ]priority)` |
| homedir           | 返回当前用户的主目录的字符串路径。           | `os.homedir()`                    |
| tmpdir            | 以字符串的形式返回操作系统的默认临时文件目录 | `os.tmpdir()`                     |
| hostname          | 返回操作系统的主机名返回操作系统的主机名     | `os.hostname()`                   |
| userInfo          | 返回关于当前有效用户的信息                   | `os.userInfo([options])`          |
| platform          | 返回标识操作系统平台                         | `os.platform()`                   |
| release           | 以字符串的形式返回操作系统                   | `os.release()`                    |
| version           |                                              | `os.version()`                    |
| networkInterfaces | 返回已分配了网络地址的网络接口               | `os.networkInterfaces()`          |
| uptime            | 返回系统的正常运行时间（以秒为单位）         | `os.uptime()`                     |

> networkInterfaces

![image-20201013192753285](http://api.portal.levenx.com/5c22355f243b413e98b637fecb552136.jpg)


OS操作系统constos=require('os')Api说明用法arch操作系统的CPU架构os.arch()cpusos.cpus()freemem返回空闲的系统内存量os.freemem()totalmem返回系统的内存总量os.totalmem()getPriority返回由pid指定的进程的调度优先级os.getPriority([pid])setPriority尝试为pid指定的进程

Node方法汇总os篇

## 前言

在Node.js中，可以使用几种方法来实现 `replaceAll`功能，也就是在一个字符串中替换所有出现的子串。以下是一些常用方法：

### 使用String.prototype.replace()与正则表达式

在 JavaScript（因此也包括Node.js）中，你可以使用 `String.prototype.replace()`方法结合全局（global）正则表达式来替换所有匹配的字符串。例如：

```javascript
let str = "hello world, hello everyone";
str = str.replace(/hello/g, "hi");
console.log(str); // 输出: "hi world, hi everyone"
```

在正则表达式后面加上 `g`标志代表全局搜索，这样就会替换字符串中的所有匹配项。

### 使用String.prototype.replaceAll()（Node.js v15+）

从Node.js版本15开始，`String`对象提供了一个 `replaceAll()`方法，它可以直接替换字符串中的所有匹配的子串，而不需要使用正则表达式。例如：

```javascript
let str = "hello world, hello everyone";
str = str.replaceAll("hello", "hi");
console.log(str); // 输出: "hi world, hi everyone"
```

### 使用循环和String.prototype.replace()

如果你需要在较老的版本的Node.js中实现 `replaceAll`功能，或者有其他原因导致不能使用正则或 `replaceAll`方法，你可以在循环中使用 `replace()`方法直到不再发现匹配项。这不是最高效的方法，但它可以工作：

```javascript
let str = "hello world, hello everyone";
let substr = "hello";
let newSubstr = "hi";

while (str.includes(substr)) {
    str = str.replace(substr, newSubstr);
}

console.log(str); // 输出: "hi world, hi everyone"
```

### 使用String.prototype.split()和Array.prototype.join()

还有一种替换所有匹配项的技巧是使用 `split()`和 `join()`方法：

```javascript
let str = "hello world, hello everyone";
let substr = "hello";
let newSubstr = "hi";

str = str.split(substr).join(newSubstr);
console.log(str); // 输出: "hi world, hi everyone"
```

通过 `split()`方法将原字符串按指定子串分割成数组，然后用 `join()`方法将数组元素与新子串结合成一个新字符串，从而实现将所有匹配的子串替换掉。


在Node.js中，可以使用几种方法来实现replaceAll功能，也就是在一个字符串中替换所有出现的子串。以下是一些常用方法：使用String.prototype.replace()与正则表达式在JavaScript（因此也包括Node.js）中，你可以使用String.prototype.replace()方法结合全局（global）正则表达式来替换所有匹配的字符串。例如：letstr="he

Nodejs 使用 replaceAll 方法的四种方式

## 概念

如果A与B存在相互依赖、相互引用关系，不就形成了一个闭环或者说死循环？那程序怎么会继续解析呢？很显然，运行结果告诉我们，nodejs引擎有自己的一套处理循环引用的机制。下面我们根据上述运行结果，来推演了两个module模块的执行顺序，以了解nodejs打破闭环的机制。

![img](https://tva1.sinaimg.cn/large/008eGmZEgy1gpocn55edqj30vv0akdg7.jpg)

## 过程分解

1. 执行modA第一行，输出一个test接口
2. 执行modA第二行，要引入modB此时断点产生了,即开始执行modB里的代码, 程序开始走"breakpoint-out"路线
3. 执行modB第一行
4. 执行modB第二行，要因为modA,此步骤为打破闭环的关键，此时将A里断点之前的执行结果输出给modB，如图里的蓝色虚线框标识的部分，此时在modB中打印modA.test,打印'A'
5. 继续执行modB第三行
6. 继续执行modB第四行，对外输出test接口('BB')，此后，modB执行完毕，主程序返回至断点处（modA中在②步骤产生的断点），将modB的执行结果保存在'modB' const变量中。
7. 执行modA的第三行
8. 执行modA的第四行，打印'modB'对象里的test接口，根据中指向结果可知，'modB'返回的test接口为'BB'，因此，打印'BB'，程序结束。


如果main.js调用的是'modB.js'，分析过程完全一致，打印的结果将是'B, AA'。

根据上述分析可知，nodejs中的模块互相引用形成的“闭环”其实是用“断点”这一方式打开的，以断点为出口去执行其他模块，也以断点为入口进行返回，之后继续执行断点之后的代码。


如果A与B存在相互依赖、相互引用关系，不就形成了一个闭环或者说死循环？那程序怎么会继续解析呢？很显然，运行结果告诉我们，nodejs引擎有自己的一套处理循环引用的机制。下面我们根据上述运行结果，来推演了两个module模块的执行顺序，以了解nodejs打破闭环的机制。过程分解：①执行modA第一行，输出一个test接口②执行modA第二行，要引入modB此时断点产生了,即开始执行modB里的代码,

Node模块循环引用的具体过程

## 前言

> 对于工程化的 Node 项目，如果设置配置系统参数，可以改变项目的参数耦合性。
>
> 本文记录三种参数配置的方法。

## 一、env 变量

> `process.env` 参数变量配置

1. 添加 npm 依赖

   > npm install cross-env -D
   >
2. 命令行参数设置

   ```javascript
   "scripts": {
      "start":"cross-env NODE_ENV=dev API=localost node app.js"
    }

   ```
3. 读取 `process.env` 参数

   ```javascript
   console.log('process.env.NODE_ENV:', process.env.NODE_ENV);

   ```

   ![image-20210126163518950](https://tva1.sinaimg.cn/large/008eGmZEgy1gn16ovm3j5j30ma03uq39.jpg)

---

## 二、argv 变量

1. 命令行尾部添加参数 (npm 脚本命令)

   ```javascript
   "scripts": {
       "argv": "node app.js --app name=levenx"
     }


   ```
2. 或者直接控制台输入执行

   ```javascript
   node app.js --app name=levenx
   ```
3. 自定义参数读取 `process.argv

   > console.log(process.argv.splice(2))
   >

   ![image-20210126164009598](https://tva1.sinaimg.cn/large/008eGmZEgy1gn16txg1uuj30ls03i3ys.jpg)

   从上图可以可以看出，process.argv 参数只是把命令行后自定义的参数进行空格分割，并没有把参数进行加工，需要开发者自己按照一定的规则处理参数。

### **推荐一个 npm 工具库：minimist**

1. 安装依赖

   ```javascript
   npm install minimist
   ```
2. 使用方法

   ```javascript
   node app.js -x 3 -y 4 -n5 -abc --beep=boop foo bar baz
   ```
3. 读取参数

   ```javascript
   const argv = require('minimist')(process.argv.slice(2));
   console.log(argv);

   ```

   ![image-20210126165142580](https://tva1.sinaimg.cn/large/008eGmZEgy1gn175xv0pzj30nu09cmxs.jpg)

---

## 三、.env 文件 + dotenv

需要配置的参数变量单独放在一个配置文件.env

![image-20210126171114574](https://tva1.sinaimg.cn/large/008eGmZEgy1gn17q9n884j31020b8gml.jpg)

读取参数方法

```javascript
npm install dotenv
```

```javascript
let env = require('dotenv').config();
console.log(env);
```

![image-20210126171547161](https://tva1.sinaimg.cn/large/008eGmZEgy1gn17v01rvxj30je02st8y.jpg)

或者

```javascript
let dotenv = require('dotenv');
dotenv.config();
console.log(process.env);
```

![image-20210126172020500](https://tva1.sinaimg.cn/large/008eGmZEgy1gn17zqge2fj30gy056jry.jpg)


前言:对于工程化的Node项目，如果设置配置系统参数，可以改变项目的参数耦合性。本文记录三种参数配置的方法。一、env变量process.env参数变量配置添加npm依赖npminstallcross-env-D命令行参数设置'scripts':{'start':'cross-envNODE_ENV=devAPI=localostnodeapp.js'}读取process.env参数console

Node 项目参数配置化，命令行参数

## 前言

> web端上传图片、文件等流化数据，一般使用form表单方式，或者通过 Ajax 方式上传时就使用 FormData 来承载流化数据。具体可以参考[AJAX 图片上传功能实现（点击，拖拽，粘贴）Koa 服务端](https://blog.csdn.net/m0_37890289/article/details/105011124)

同时也存在需要使用 Node 操作方式上传文件到 http 服务器上,下文详细记载。

## 一、request

1. node 端添加 `request` 依赖库

   ```javascript
   npm install request

   ```
2. 文件上传操作

   ```javascript
   const path = require('path');
   const fs = require('fs');
   const request = require('request');

   let files = fs.readdirSync(path.join(__dirname, 'dist'));
   let needUploads = [];
   //收集需要上传的文件
   files.forEach(async name => {
     needUploads.push(fs.createReadStream(path.join(__dirname, `dist/${name}`)));
   });
   //上传操作
   request.post(
     { url: 'https://localhost:3000/upload', formData: needUploads },
     (err, httpResponse, body) => {
       console.log('Upload successful!  Server responded with:', body);
     },
   );



   ```
3. 服务器代码

   ```javascript
   ...
   const koaBody = require('koa-body');
   ...
   app.use(
     koaBody({
       multipart: true,
     }),
   );


   ```
4. 服务器业务代码

   ```javascript
   const router = require('koa-router')();
   const fs = require('fs');
   const path = require('path');

   //接受上传文件接口
   router.post('/upload', async (ctx, next) => {
     const files = ctx.request.files;
     for (let key in files) {
       let file = files[key];
       const reader = fs.createReadStream(file.path); // 创建可读流
       const upStream = fs.createWriteStream(
         path.resolve(__dirname, `../public/${file.name}`),
       );
       reader.pipe(upStream);
     }
     ctx.response.status = 200;
     ctx.body = {
       code: 200,
     };
   });

   module.exports = router;

   ```
   5. 实例案例图片

   ![image-20210126181817283](https://tva1.sinaimg.cn/large/008eGmZEgy1gn19o2exe4j31c50u0wrt.jpg)


前言：web端上传图片、文件等流化数据，一般使用form表单方式，或者通过Ajax方式上传时就使用FormData来承载流化数据。具体可以参考AJAX图片上传功能实现（点击，拖拽，粘贴）Koa服务端同时也存在需要使用Node操作方式上传文件到http服务器上,下文详细记载。一、requestnode端添加request依赖库npminstallrequest文件上传操作constpath=requ

Node 通过 http 协议上传文件到服务器

## fs文件系统模块

**文件系统**

> const fs = require("fs");
>
> const fs = require("fs/promises");

| 方法名                | 说明                                                     | 使用方法                                                                          |
| --------------------- | -------------------------------------------------------- | --------------------------------------------------------------------------------- |
| mkdir                 | 创建目录                                                 | fs.mkdir(path[, options])                                                         |
| mkdirSync             |                                                          |                                                                                   |
| mkdtemp               | 创建一个唯一的临时目录                                   | mkdtemp(prefix[, options]).例：fsPromises.mkdtemp(path.join(os.tmpdir(), 'foo-')) |
| mkdtempSync           |                                                          |                                                                                   |
| writeFile             | 异步地将数据写入到一个文件                               | fs.writeFile(file, data[, options])                                               |
| writeFileSync         |                                                          |                                                                                   |
| write                 | 将 `string` 写入到文件                                 | fs.write(string[, position[, encoding]])                                          |
| writeSync             |                                                          |                                                                                   |
| appendFile            | 追加数据到文件                                           | fs.appendFile(path, data[, options])                                              |
| appendFileSync        | 同步地将数据追加到文件                                   |                                                                                   |
| copyFile              | 将 `src` 拷贝到 `dest`                               | fs.copyFile(src, dest[, mode])                                                    |
| copyFileSync          |                                                          |                                                                                   |
| readdir               | 读取目录的内容                                           |                                                                                   |
| readdirSync           | 读取目录的内容(同步)                                     |                                                                                   |
| lstat                 | 遍历目录                                                 | fs.lstat(path[, options]                                                          |
| lstatSync             |                                                          |                                                                                   |
| readFile              | 异步地读取文件的全部内容                                 | fs.readFile(path[, options]                                                       |
| readFileSync          |                                                          |                                                                                   |
|                       |                                                          |                                                                                   |
| exists                | 判断文件是否存在                                         | fs.exists(path, callback)                                                         |
| existsSync            | 判断文件是否存在（同步）                                 | fs.existsSync(path)                                                               |
|                       |                                                          |                                                                                   |
| open                  | 异步地打开文件                                           | fs.open(path, flags[, mode])                                                      |
| opendir               | 异步地打开目录                                           | fs.opendir(path[, options])                                                       |
|                       |                                                          |                                                                                   |
| realpath              |                                                          | fs.realpath(path[, options], callback)                                            |
| realpathSync          | 获取真实路径。                                           |                                                                                   |
| **watch**       | 监视 `filename` 的更改，其中 `filename` 是文件或目录 | **fs.watch(filename[, options][, listener])**                               |
| **watchFile**   | 监视 `filename` 的更改                                 | **watchFile(filename[, options], listener)**                                |
| **unwatchFile** | 停止监视 `filename` 的变化                             | **fs.unwatchFile(filename[, listener])**                                    |
| stat                  | 文件属性                                                 | fs.stat(path,callback)                                                            |
| statSync              |                                                          |                                                                                   |
| access                | 测试用户对 `path` 指定的文件或目录的权限               | fs.access(path[, mode])                                                           |
| accessSync            |                                                          |                                                                                   |
|                       |                                                          |                                                                                   |
| rename                | 重命名                                                   | fs.rename(oldName, newName, callback)                                             |
| renameSync            |                                                          |                                                                                   |
| truncate              | 截断 `path`                                            | fs.truncate(path[, len])                                                          |
| truncateSync          |                                                          |                                                                                   |
|                       |                                                          |                                                                                   |
| unlink                | 删除文件                                                 | fs.unlink(path,callback)                                                          |
| unlinkSync            | 删除文件（同步）                                         | fs.unlinkSync(path)                                                               |
| rmdir                 | 删除 `path` 指定的目录                                 |                                                                                   |
| rmdirSync             |                                                          |                                                                                   |

> open flag属性

![image-20201013172349889](http://api.portal.levenx.com/bbcc35cd8cae4e94a1b3009ddd9fa1a6.jpg)


fs文件系统模块文件系统constfs=require('fs');constfs=require('fs/promises');方法名说明使用方法mkdir创建目录fs.mkdir(path[,options])mkdirSyncmkdtemp创建一个唯一的临时目录mkdtemp(prefix[,options]).例：fsPromises.mkdtemp(path.join(os.tmpdir

Api	说明	用法
arch	操作系统的 CPU 架构	`os.arch()`
cpus		`os.cpus()`
freemem	返回空闲的系统内存量	`os.freemem()`
totalmem	返回系统的内存总量	`os.totalmem()`
getPriority	返回由 `pid` 指定的进程的调度优先级	`os.getPriority([pid])`
setPriority	尝试为 `pid` 指定的进程设置调度优先级	`os.setPriority([pid, ]priority)`
homedir	返回当前用户的主目录的字符串路径。	`os.homedir()`
tmpdir	以字符串的形式返回操作系统的默认临时文件目录	`os.tmpdir()`
hostname	返回操作系统的主机名返回操作系统的主机名	`os.hostname()`
userInfo	返回关于当前有效用户的信息	`os.userInfo([options])`
platform	返回标识操作系统平台	`os.platform()`
release	以字符串的形式返回操作系统	`os.release()`
version		`os.version()`
networkInterfaces	返回已分配了网络地址的网络接口	`os.networkInterfaces()`
uptime	返回系统的正常运行时间（以秒为单位）	`os.uptime()`