# z-tools-node

**Repository Path**: zhangkb/z-tools-node

## Basic Information

- **Project Name**: z-tools-node
- **Description**: node端工具方法
- **Primary Language**: JavaScript
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2022-09-08
- **Last Updated**: 2023-04-27

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# z-tools-node

`node` 端工具方法。

## 方法

带 `sync` 后缀的为同步方法，否则为异步方法。

### checkdir

> 判断路径是否为存在，返回布尔值。

- 函数：`checkdir(dir:string): Promise<boolean>`
- 参数：`dir` 要检测的路径。
- 返回值：值为 `boolean` 的 `promise` 对象。

```js
const { checkdir } = require("z-tools-node");
checkdir("D:/test/1.jpg").then((res) => {
  console.log(res);
});
```

### isFile

> 判断路径是否为文件，路径不存在返回 `false`。

- 函数：`isFile(dir:string): Promise<boolean>`
- 参数：`dir` 要检测的路径。
- 返回值：值为 `boolean` 的 `promise` 对象。

```js
const { isFile } = require("z-tools-node");
isFile("D:/test/1.jpg").then((res) => {
  console.log(res);
});
```

### isDirectory

> 判断路径是否为文件夹，路径不存在返回 `false`。

- 函数：`isDirectory(dir:string): Promise<boolean>`
- 参数：`dir` 要检测的路径。
- 返回值：值为 `boolean` 的 `promise` 对象。

```js
const { isDirectory } = require("z-tools-node");
isDirectory("D:/test/1.jpg")
  .then((res) => {
    console.log(res);
  })
  .catch((error) => {
    console.log("err", error);
  });
```

### mkdir

> 创建目录，支持深层创建。
> `fs.mkdir(dir)` 方法无法创建深层目录，如果目标目录的上层无法访问就会报错，`mkdir()` 方法则会逐层创建目录，避免报错。

- 函数：`mkdir(dir:string): Promise<void>`
- 参数：`dir` 要检测的路径。
- 返回值：值为 `boolean` 的 `promise` 对象。

```js
const { mkdir } = require("z-tools-node");
mkdir("D:/a/b/c")
  .then(() => {
    console.log("finish");
  })
  .catch((error) => {
    console.log(error);
  });
```

### rmdirSync

> 删除文件夹及其下所有内容，同步任务，返回 `error`，无返回值时表示成功

- 函数：`rmdirSync(dir:string): Error|void`
- 参数：`dir` 要检测的路径。
- 返回值：可能返回 `error`。

```js
const { rmdirSync } = require("z-tools-node");
const err = rmdirSync("D:/a/b/c");
console.log(err);
```

### renameFolder

> 修改指定目录下的所有文件夹名称，自定义修改规则。

- 函数：`renameFolder(dir:string, getRename(oriname:string):string, deep:boolean): Promise<void>`
- 参数：
  - `dir` 目标根目录（此目录不会被重命名）。
  - `getRename(oriname: string): string` 获取新名称的方法，接收参数为当前目录名称，返回值将作为新文件夹名称。
  - `deep` 是否深度处理。
- 返回值：`promise` 对象，无值。

```js
const { renameFolder } = require("z-tools-node");

const dir = "D:/test";

renameFolder(
  "D:/test",
  function (name) {
    const newName = name.replace(/\s/g, "");
    return newName;
  },
  true
).then(() => {
  console.log("finish");
});
```

### renameFile

> 修改指定目录下的所有文件名称，自定义修改规则。

用法参数同 `renameFolder()` 方法。

### copy

> 复制文件。

- 函数：`copy(fromFileName:string, toFileName:string): Promise<void>`
- 参数：
  - `fromFileName` 源文件路径。
  - `toFileName` 目标路径
- 返回值：`promise` 对象，无值。

```js
const { copy } = require("z-tools-node");
copy("D:/test/1.jpg", "D:/test/2.jpg")
  .then(() => {
    console.log("copy success");
  })
  .catch((error) => {
    console.log("copy fail", error);
  });
```

### getIPAddressSync

> 获取本机 `ipV4` 地址。

- 函数：`getIPAddressSync():string`
- 返回值：本机 `ipV4` 地址字符串。

```js
const { getIPAddressSync } = require("z-tools-node");
const ip = getIPAddressSync();
```

## 工具方法

### clone

> 克隆。

- 函数：`clone(value: any, deep: boolean): any`
- 参数：
  - `value` 要克隆的属性值。
  - `deep` 是否为深克隆。
- 返回值：新的属性值。

```js
const { clone } = require("z-tools-node");
const data = {
  name: "z",
};
const newData = clone(data, true);
```

### parallelTaskLimiter

> 并发任务限制器。
> `parallelTaskLimiter()` 方法返回 `promise` 对象，在所有任务执行完毕后执行 `resolve`并将任务的返回值传递给 `then()` 方法。
> 用法与 `Promise.all()` 相似，不同之处在于：
>
> 1. `Promise.all()` 会同时执行传入的方法，`parallelTaskLimiter()` 可以限制同时执行的数量。
> 2. `Promise.all()` 只会返回第一个 `reject()` 抛出的异常信息，`parallelTaskLimiter()` 会返回一个数组，记录所有任务的执行情况。

- 函数：`parallelTaskLimiter(taskList: Array<Promise<T>>, maxThreadAmount: number): Array<T>`
- 参数：
  - `taskList` 任务列表，必填。
  - `maxThreadAmount` 最大并行任务数量，默认值 `5`。
- 返回值：所有任务的执行结果数组，结果顺序与任务顺序一致。

```js
const { parallelTaskLimiter } = require("z-tools-node");

async function task() {
  return new Promise((resolve, reject) => {
    const time = Math.floor(Math.random() * 1000) + 1000;
    setTimeout(() => {
      if (time > 1500) {
        reject(time);
      } else {
        resolve(time);
      }
    }, 1000);
  })
    .then((time) => {
      console.log("rs", time);
      return true;
    })
    .catch((time) => {
      console.log("rj", time);
      return false;
    });
}

async function example() {
  const list = [];

  let count = 10;
  while (count--) {
    list.push(task);
  }

  console.time("finished");
  parallelTask(list, 2).then((result) => {
    console.log(result);
    console.timeEnd("finished");
  });
}

example();
```

## 类

### DatabaseGenerator

> 本地数据库生成器。
> 使用本地 `json` 文件作为数据库进行操作，只提供基础功能：文件初始化、操作缓存、整体读取、整体写入。

#### 构造函数

- 构造函数：`DatabaseGenerator(filePath:string, defaultData:any)`
- 参数：
  - `context` 文件路径，必填。
  - `maxThreadAmount` 创建文件时需要填入文件的值，对象或者数组，默认值为 `{}`。
- 返回值：`database` 实例对象。

#### database 实例对象

- 成员方法
  - `getData()` 获取数据。
  - `setData(data: any)` 写入数据。

#### 示例

```js
const { DatabaseGenerator } = require("z-tools-node");
const path = require("path");
const database = new DatabaseGenerator(path.join(__dirname, "test.json"));
const data = database.getData();

data["name"] = "test";
database.setData(data);
```

- 可以通过继承 `DatabaseGenerator` 自己实现更精细的操作。

```js
const { DatabaseGenerator } = require("z-tools-node");
const DATABASE_RESOURCE_ERROR_PATH = "./resource.error.json";

class ResourceErrorDatabaseGenerator extends DatabaseGenerator {
  has(dir) {
    const list = this.getData();
    return list.includes(dir);
  }

  add(dir) {
    const list = this.getData();
    list.push(dir);
    this.setData(list);
  }

  clear() {
    this.setData([]);
  }
}

const ResourceErrorDatabase = new ResourceErrorDatabaseGenerator(
  DATABASE_RESOURCE_ERROR_PATH,
  []
);

exports.ResourceErrorDatabase = ResourceErrorDatabase;
```