Node-回眸[一]

npm -v # 查看版本
npm help # 列出所有命令
npm -l # 列出所有命令及简单用法
npm init # 初始化项目，创建package.json
npm install / i <包名@版本号> # 安装
npm i --save / -S # 生产依赖，默认
npm i --save-dev / -D # 开发依赖
npm i -g  # 全局安装
npm i <package-name> --registry=https://registry.npmmirror.com # 指定安装源
npm update # 更新依赖
npm uninstall / r # 移除依赖
npm prune # 清除未使用的模块
npm run <script-name> # 执行脚本命令
npm start # 执行start脚本命令
npm search <keyword> # 关键字搜索包
npm info <package-name> # 查看指定包的详细信息
npm list # 列出项目所有依赖包
npm ls -g # 查看全局安装的包
npm outdated # 列出需要更新的包
npm audit # 检查依赖项是否存在安全漏洞
npm adduser # 注册npm账户
npm login # 登录npm账户
npm logout # 登出
npm publish # 发布包
npm link # 将本地模块链接到全局的node_modules目录下
# npm config
npm config list # 列出npm配置信息
npm config set <key> <value> [-g]  # 给配置参数key设置值为value，-g配置全局.npmrc
npm config get <key> # 获取配置参数key的值
npm set <key> <value> [-g] # 给配置参数key设置值为value
npm get <key> # 获取配置参数key的值
npm get registry # 查看安装源
npm get userconfig # 获取用户配置文件路径
npm get prefix # 获取全局node_modules路径
npm config delete <key> # 删除置参数key及其值
npm config list [-l] # 显示npm的所有配置参数的信息
npm config edit # 编辑配置文件
# npm version
npm version patch # 2.0.0 -> 2.0.1
npm version minor # 2.0.1 -> 2.1.0
npm version major # 3.1.0 -> 4.0.0
npm version prerelease # 1.0.0 -> 1.0.1-0, 1.0.1-0 -> 1.0.1-1
npm version prepatch # 1.0.1-1 -> 1.0.2-0
npm version preminor # 1.0.2-0 -> 1.1.0-0
npm version premajor # 4.0.0 --> 5.0.0-0

node_modules
└─ foo
   ├─ index.js
   ├─ package.json
   └─ node_modules
      └─ bar
         ├─ index.js
         └─ package.json

├── package-A @1.0
|── package-B @1.0
├── package-C @1.0
│   └── package-A @2.0
│   └── package-B @2.0
├── package-D @1.0
│   └── package-A @2.0
│   └── package-B @2.0

├── .modules.yaml
├── .pnpm
│   ├── lock.yaml
│   ├── picocolors@1.0.0
│   │   └── node_modules
│   ├── node_modules
│   │   ├── .bin
│   │   └── picocolors -> ../picocolors@1.0.0/node_modules/picocolors
│   └── react@18.2.0
│       └── node_modules
└── vue -> .pnpm/vue@3.4.5/node_modules/vue

registry=http://registry.npmjs.org/
# 定义npm的registry，即npm的包下载源

proxy=http://proxy.example.com:8080/
# 定义npm的代理服务器，用于访问网络

https-proxy=http://proxy.example.com:8080/
# 定义npm的https代理服务器，用于访问网络

strict-ssl=true
# 是否在SSL证书验证错误时退出

cafile=/path/to/cafile.pem
# 定义自定义CA证书文件的路径

user-agent=npm/{npm-version} node/{node-version} {platform}
# 自定义请求头中的User-Agent

save=true
# 安装包时是否自动保存到package.json的dependencies中

save-dev=true
# 安装包时是否自动保存到package.json的devDependencies中

save-exact=true
# 安装包时是否精确保存版本号

engine-strict=true
# 是否在安装时检查依赖的node和npm版本是否符合要求

scripts-prepend-node-path=true
# 是否在运行脚本时自动将node的路径添加到PATH环境变量中

{
  "dependencies": {
    "express": "^4.18.0"
  }
}

version 当前包的版本号
resolved 当前包的下载地址
integrity 用于验证包的完整性
dev 是否为开发依赖包
bin 当前包中可执行文件的路径和名称
engines 当前包所依赖的Node.js版本范围

"scripts": {
  "dev": "vite"
},

"bin": {
  "vite": "bin/vite.js"
},

"scripts": {
  "dev": "node index.js",
  "predev": "node pre.js",
  "postdev": "node post.js"
},

# 调用vite命令
npm run dev # "dev": "vite"
npx vite

npm init <initializer> # npm create 是其别名

"bin": {
  "create-vite": "index.js",
  "cva": "index.js"
},

verdaccio --listen 9999 # 指定端口
npm adduser --registry http://localhost:4873/ # 创建账户
npm publish --registry http://localhost:4873/ # 发布包
npm i --registry http://localhost:4873 # 安装时指定源

const fs = require('node:fs');  // 导入核心模块
const express = require('express');  // 导入 node_modules 目录下的模块
const myModule = require('./myModule.js');  // 导入相对路径下的模块
const nodeModule = require('./myModule.node');  // 导入扩展模块
module.exports = {
  name: chuckle
}
exports.a = 1

import('./data.json', {
  assert: { type: 'json' }
}).then(data => {
  console.log(data.default) // { name: 'data' }
})

import { stat, exists, readFile } from 'fs';
const name = '张三';
export const age = 18;
export default name;
import { age } from './index.js';
import name from './index.js';

import data from './data.json' assert { type: "json" };
console.log(data)

import { createRequire } from 'module';
const require = createRequire(import.meta.url);
const addon = require('./addon.node');

function Module(id = '', parent) {
  // 模块 id,通常为模块的绝对路径
  this.id = id;
  this.path = path.dirname(id);
  // exports
  setOwnProperty(this, 'exports', {});
  // 当前模块调用者
  moduleParentCache.set(this, parent);
  updateChildren(parent, this, false);
  this.filename = null;
   // 模块是否加载完成
  this.loaded = false;
  // 当前模块所引用的模块
  this.children = [];
  // ......
}

Module.prototype.require = function(id) {
  // 验证 id 是否为字符串类型且非空
  validateString(id, 'id');
  // 如果 id 为空字符串，抛出一个错误，要求 id 为非空字符串
  if (id === '') {
    throw new ERR_INVALID_ARG_VALUE('id', id,
                                    'must be a non-empty string');
  }
  // requireDepth记载模块加载的深度，在达到一定深度时进行一些特殊处理
  // 自增表示当前模块的加载深度增加了一个层次
  requireDepth++;
  try {
    // 调用 Module._load 方法加载指定的模块，isMain 参数设为 false
    // isMain用于在模块加载过程中区分出主模块和其他模块
    return Module._load(id, this, /* isMain */ false);
  } finally {
    // 自减表示当前模块的加载深度减少了一个层次
    requireDepth--;
  }
};

Module._load = function(request, parent, isMain) {
  let relResolveCacheIdentifier;
  // 优化相同目录下懒加载的模块的加载过程
  if (parent) {
    // .....
  }

  // 内建模块处理
  // 如果模块请求以 'node:' 开头，表示模块为内建模块
  if (StringPrototypeStartsWith(request, 'node:')) {
    // Slice 'node:' prefix
    const id = StringPrototypeSlice(request, 5);

    const module = loadBuiltinModule(id, request);
    if (!module?.canBeRequiredByUsers) {
      throw new ERR_UNKNOWN_BUILTIN_MODULE(request);
    }
    // 加载内建模块并返回其 exports
    return module.exports;
  }

  // 解析出模块的全路径
  const filename = Module._resolveFilename(request, parent, isMain);

  // 如果找到缓存的模块，如果已被加载，则直接返回该模块缓存的exports
  // 否则将其标记为已加载，后续再去处理缓存的加载
  const cachedModule = Module._cache[filename];
  if (cachedModule !== undefined) {
    // 更新父模块的子模块列表
    updateChildren(parent, cachedModule, true);
    // 检查模块是否已经加载
    if (!cachedModule.loaded) {
      // 如果模块尚未加载
      // 获取缓存的 CommonJS 模块的解析结果对象
      const parseCachedModule = cjsParseCache.get(cachedModule);
      // 如果解析结果对象不存在，或者解析结果对象已经加载过
      if (!parseCachedModule || parseCachedModule.loaded)
        // 返回处理循环 require 的情况的导出对象
        return getExportsForCircularRequire(cachedModule);
      // 将解析结果对象标记为已加载
      parseCachedModule.loaded = true;
    } else {
      return cachedModule.exports;
    }
  }

  // 尝试加载没有以 'node:' 开头导入的内建模块
  const mod = loadBuiltinModule(filename, request);
  if (mod?.canBeRequiredByUsers &&
      BuiltinModule.canBeRequiredWithoutScheme(filename)) {
    return mod.exports;
  }

  // 获取模块的缓存，或创建一个新的 Module 实例
  const module = cachedModule || new Module(filename, parent);

  // 如果是主模块，则标记主模块
  if (isMain) {
    setOwnProperty(process, 'mainModule', module);
    setOwnProperty(module.require, 'main', process.mainModule);
    module.id = '.';
  }

  // 通知监视模式有关模块状态的变化
  reportModuleToWatchMode(filename);

  // 模块实例缓存
  Module._cache[filename] = module;
  if (parent !== undefined) {
    relativeResolveCache[relResolveCacheIdentifier] = filename;
  }

  let threw = true;
  try {
    // 调用module.load加载模块
    module.load(filename);
    threw = false;
  } finally {
    // 进行一些清理工作
    // ......
  }

  // 返回导出对象
  return module.exports;
};

Module.prototype.load = function(filename) {
  // 调试信息，输出加载模块的文件名和模块的标识符
  debug('load %j for module %j', filename, this.id);

  // 确保模块是未被加载过的
  assert(!this.loaded);
  // 设置模块的文件名和路径列表
  this.filename = filename;
  this.paths = Module._nodeModulePaths(path.dirname(filename));

  // 寻找并确定文件名的扩展名
  const extension = findLongestRegisteredExtension(filename);
  // allow .mjs to be overridden
  // 如果文件名以 '.mjs' 结尾，并且没有针对 '.mjs' 的扩展处理函数，抛出错误
  if (StringPrototypeEndsWith(filename, '.mjs') && !Module._extensions['.mjs'])
    throw new ERR_REQUIRE_ESM(filename, true);

  // 执行特定文件后缀名解析函数 如 js / json / node
  Module._extensions[extension](this, filename);
  // 表示该模块加载成功
  this.loaded = true;

  // ... esm 模块的支持
};

Module._extensions['.json'] = function(module, filename) {
  // 读取文件内容，返回utf8字符串
  const content = fs.readFileSync(filename, 'utf8');

  // 存在安全策略时，进行内容完整性验证
  if (policy?.manifest) {
    // 获取文件的模块 URL
    const moduleURL = pathToFileURL(filename);
    // 进行内容完整性验证
    policy.manifest.assertIntegrity(moduleURL, content);
  }

  try {
    // stripBOM移除字符串中的BOM（字节顺序标记）
    // JSONParse解析JSON字符串为JS对象
    // setOwnProperty设置module的exports属性为该JS对象
    // 以前的代码是这么做的module.exports = JSONParse(stripBOM(content));
    setOwnProperty(module, 'exports', JSONParse(stripBOM(content)));
  } catch (err) {
    // 如果解析失败，将文件名和错误信息拼接后抛出错误
    err.message = filename + ': ' + err.message;
    throw err;
  }
};

Module._extensions['.node'] = function(module, filename) {
  // 存在安全策略时，进行内容完整性验证
  if (policy?.manifest) {
    const content = fs.readFileSync(filename);
    const moduleURL = pathToFileURL(filename);
    policy.manifest.assertIntegrity(moduleURL, content);
  }
  // 使用 process.dlopen 方法加载模块
  return process.dlopen(module, path.toNamespacedPath(filename));
};

SetMethod(context, target, "dlopen", binding::DLOpen);

bool DLib::Open() {
  int ret = uv_dlopen(filename_.c_str(), &lib_);
  // ......
}
void DLOpen(const FunctionCallbackInfo<Value>& args) {
  // ......
  env->TryLoadAddon(*filename, flags, [&](DLib* dlib) {
    // ......
    const bool is_opened = dlib->Open();
    // ......
    if (!is_opened) {
      std::string errmsg = dlib->errmsg_.c_str();
      dlib->Close();
    }
  }
  // ......
}

Module._extensions['.js'] = function(module, filename) {
  // If already analyzed the source, then it will be cached.
  // 从cjsParseCache中获取已经解析过的模块源码
  // const cjsParseCache = new SafeWeakMap();
  const cached = cjsParseCache.get(module);
  let content; // 保存源码内容的变量
  // 如果已缓存，则直接使用缓存的源码。
  if (cached?.source) {
    content = cached.source;
    cached.source = undefined;
  } else {
    // 否则，fs读取文件内容
    content = fs.readFileSync(filename, 'utf8');
  }
  // 如果是.js文件，还需进行type检查，cjs或mjs就直接交给_compile处理
  if (StringPrototypeEndsWith(filename, '.js')) {
    const pkg = readPackageScope(filename);
    // Function require shouldn't be used in ES modules.
    // 如果package.json中type为module，则抛出错误，因为ESM不应该使用require
    if (pkg?.data?.type === 'module') {
      const parent = moduleParentCache.get(module);
      const parentPath = parent?.filename;
      const packageJsonPath = path.resolve(pkg.path, 'package.json');
      const usesEsm = hasEsmSyntax(content);
      const err = new ERR_REQUIRE_ESM(filename, usesEsm, parentPath,
                                      packageJsonPath);
      // Attempt to reconstruct the parent require frame.
      // 如果抛出了错误，它还会尝试重构父模块的 require 调用堆栈，
      // 以提供更详细的错误信息。它会读取父模块的源代码，并根据错误的行号和列号，
      // 在源代码中找到相应位置的代码行，并将其作为错误信息的一部分展示出来。
      if (Module._cache[parentPath]) {
        let parentSource;
        try {
          parentSource = fs.readFileSync(parentPath, 'utf8');
        } catch {
          // Continue regardless of error.
        }
        if (parentSource) {
          const errLine = StringPrototypeSplit(
            StringPrototypeSlice(err.stack, StringPrototypeIndexOf(
              err.stack, '    at ')), '\n', 1)[0];
          const { 1: line, 2: col } =
              RegExpPrototypeExec(/(\d+):(\d+)\)/, errLine) || [];
          if (line && col) {
            const srcLine = StringPrototypeSplit(parentSource, '\n')[line - 1];
            const frame = `${parentPath}:${line}\n${srcLine}\n${
              StringPrototypeRepeat(' ', col - 1)}^\n`;
            setArrowMessage(err, frame);
          }
        }
      }
      // 抛出错误
      throw err;
    }
  }
  // 调用_compile继续处理js模块的加载
  module._compile(content, filename);
};

Module.prototype._compile = function(content, filename) {
  // 如果启用了策略，则获取模块的 URL 和相关信息
  let moduleURL;
  let redirects;
  const manifest = policy?.manifest;
  if (manifest) {
    // 将模块文件名转换为URL格式
    moduleURL = pathToFileURL(filename);
    // redirects是一个URL映射表，用于处理模块依赖关系
    redirects = manifest.getDependencyMapper(moduleURL);
    // manifest则是一个安全策略对象，用于检测模块的完整性和安全性
    manifest.assertIntegrity(moduleURL, content);
  }
  // 向模块内部注入公共变量 __dirname / __filename / module / exports / require
  // 并将模块内容包装为一个安全的可执行函数
  // compiledWrapper得到一个可执行的全局上下文函数
  const compiledWrapper = wrapSafe(filename, content, this);

  let inspectorWrapper = null;
  // ... 对于 Inspector 调试模式的支持

  const dirname = path.dirname(filename);
  const require = makeRequireFunction(this, redirects);
  let result;
  const exports = this.exports;
  const thisValue = exports;
  const module = this;
  if (requireDepth === 0) statCache = new SafeMap();
  if (inspectorWrapper) {
    // 调用compiledWrapper，将需要的5个参数传入，最后返回执行完的结果
    result = inspectorWrapper(compiledWrapper, thisValue, exports,
                              require, module, filename, dirname);
  } else {
    // Reflect.apply调用compiledWrapper，将需要的5个参数传入，最后返回执行完的结果
    result = ReflectApply(compiledWrapper, thisValue,
                          [exports, require, module, filename, dirname]);
  }
  hasLoadedAnyUserCJSModule = true;
  if (requireDepth === 0) statCache = null;
  return result;
};

function wrapSafe(filename, content, cjsModuleInstance) {
  // 如果已经打过补丁（重要的也是这部分)
  if (patched) {
    // wrap函数：将模块内容包装为一个安全的可执行函数
    const wrapper = Module.wrap(content);
    // 创建 vm.Script 对象，表示可执行JS代码的node虚拟机
    const script = new Script(wrapper, {
      filename,
      lineOffset: 0,
      // 在CJS中支持ESM的import()，用来动态加载模块
      importModuleDynamically: async (specifier, _, importAssertions) => {
        const loader = asyncESM.esmLoader;
        return loader.import(specifier, normalizeReferrerURL(filename),
                             importAssertions);
      },
    });

    // Cache the source map for the module if present.
    // 如果模块包含源映射，缓存源映射信息
    if (script.sourceMapURL) {
      maybeCacheSourceMap(filename, content, this, false, undefined, script.sourceMapURL);
    }

    // vm.runInThisContext此方法用于创建一个独立的沙箱运行空间
    // code 内的代码可以访问外部的 global 对象，但是不能访问其他变量
    // 返回一个可执行的全局上下文函数
    return script.runInThisContext({
      displayErrors: true,
    });
  }

  // 没有打过补丁
  try {
    // 调用 internalCompileFunction 函数将模块内容编译为一个函数
    const result = internalCompileFunction(content,
      // 传递给编译的函数的参数列表
      [
      'exports',
      'require',
      'module',
      '__filename',
      '__dirname',
    ], {
      filename,
      // 在CJS中支持ESM的import()，用来动态加载模块
      importModuleDynamically(specifier, _, importAssertions) {
        const loader = asyncESM.esmLoader;
        return loader.import(specifier, normalizeReferrerURL(filename),
                             importAssertions);
      },
    });

    // Cache the source map for the module if present.
    // 如果模块包含源映射，缓存源映射信息
    if (result.sourceMapURL) {
      maybeCacheSourceMap(filename, content, this, false, undefined, result.sourceMapURL);
    }

    // 返回一个可执行的全局上下文函数
    return result.function;
  } catch (err) {
    if (process.mainModule === cjsModuleInstance)
      enrichCJSError(err, content);
    throw err;
  }
}

let wrap = function(script) {
  return Module.wrapper[0] + script + Module.wrapper[1];
};
const wrapper = [
  '(function (exports, require, module, __filename, __dirname) { ',
  '\n});',
];

global.a = 1;
globalThis.b = 2;
console.log(a, b) // 1 2

// 当前模块的所在目录的绝对路径
console.log(__dirname) // c:\***\***
// 当前模块文件的绝对路径，包括文件名和文件扩展名
console.log(__filename) // c:\***\***\index.js

const fs = require('fs')
const path = require('path')
const { JSDOM } = require('jsdom')

// 读取html文件的内容
const content = fs.readFileSync(path.join(__dirname, 'index.html'), 'utf-8')
// 构建dom对象
const dom = new JSDOM(content)
// 全局挂载API方便使用
globalThis.window = dom.window
globalThis.document= dom.window.document
// dom操作
document.querySelector('#app').innerHTML = 'hello world'
// 覆写html文件
fs.writeFileSync(path.join(__dirname, 'index.html'), dom.serialize())

const path = require('path')

// 1、sep 获取当前系统的路径分隔符
console.log(path.sep); // \

// 2、basename 获取路径的基础名称
console.log(path.basename(__filename)); // index.js

// 3、dirname 获取路径的目录名
console.log(path.dirname(__filename)); // c:\chuckle\qx\NodeJS-new\path

// 4、extname 获取文件的扩展名
console.log(path.extname(__filename)); // .js
console.log(path.extname("/a/b/index.min.js")); // .js 多个.只会获取最后一个
console.log(path.extname("/a/b/index")); // 没有扩展名返回空字符串

// 5、join 拼接路径，使用当前系统的分隔符
console.log(path.join(__dirname, 'index.js')); // c:\chuckle\qx\NodeJS-new\path\index.js
// 支持路径操作符号
console.log(path.join('a', 'b', '../')); // a\
// 如果连接后的路径字符长度为0，则返回 '.'，表示当前工作目录
console.log(path.join('')) // '.'

// 6、resolve 解析路径，返回绝对路径
// 返回工作目录的绝对路径+相对路径
console.log(path.resolve('a', 'b')); // C:\chuckle\qx\NodeJS-new\a\b
// 多个绝对路径，返回最后一个，并忽略前面的相对路径
console.log(path.resolve('a', '/b', '/c', 'd')); // C:\c\d
// 如果解析后的路径字符长度为0，则返回工作目录的绝对路径
console.log(path.resolve('')); // C:\chuckle\qx\NodeJS-new
// 常用
console.log(path.resolve(__dirname, 'index.js')); // c:\chuckle\qx\NodeJS-new\path\index.js

// 7、parse 解析路径并返回对象
console.log(path.parse(__filename));
// {
//   root: 'c:\\',
//   dir: 'c:\\chuckle\\qx\\NodeJS-new\\path',
//   base: 'index.js',
//   ext: '.js',
//   name: 'index'
// }
// ┌──────────────────┬────────────┐
// │          dir     │    base    │
// ├──────┬           ├──────┬─────┤
// │ root │           │ name │ ext │
// "  /    foo/bar/baz/ index  .js "

// 8、format 从对象中解析出路径，和 parse 相反
console.log(path.format(path.parse(__filename))); // c:\chuckle\qx\NodeJS-new\path\index.js

// 9、isAbsolute 判断是否为绝对路径
console.log(path.isAbsolute('/foo')); // true
console.log(path.isAbsolute('\\foo')); // true
console.log(path.isAbsolute('C:/foo')); // true
console.log(path.isAbsolute('./a')); // false

// 10、relative 获取 from 到 to 的相对路径
console.log(path.relative('/foo/bar/baz', '/foo/bar/dir/file.js')) // ..\dir\file.js
// from 或 to 任何一方为空,则使用当前工作目录代替其空路径
console.log(path.relative('', '/foo/bar/dir/file.js')) // ..\..\..\foo\bar\dir\file.js
console.log(path.relative('/foo/bar/dir/file.js', '')) // ..\..\..\..\chuckle\qx\NodeJS-new

// 11、normalize 规范化路径，将不符合规范的路径经过格式化转换为标准路径
console.log(path.normalize('c:\\a\\b\\c\\index.js')); // c:\a\b\c\index.js
console.log(path.normalize('c:\\\\\a/\\\\b\\\c/\\/index.js')); // c:\a\b\c\index.js
console.log(path.normalize('c:/a/../b/c')); // c:\b\c

// 若需要在POSIX中处理windows路径，使用 win32 进行兼容
console.log(path.win32.basename('c:\\a\\b\\c\\index.js')); // index.js
// 也可以在windows下使用 posix 规范
console.log(path.posix.basename('c:\\a\\b\\c\\index.js')); // c:\a\b\c\index.js，posix无法处理windows路径
console.log(path.posix.basename('c:/a/b/c/index.js')); // index.js

// 1、platform 获取当前系统平台
console.log(os.platform()); // win32
// type Platform = 'aix' | 'android' | 'darwin' | 'freebsd' | 'haiku' | 'linux' | 'openbsd' | 'sunos' | 'win32' | 'cygwin' | 'netbsd';

// 2、type 获取当前系统名称
console.log(os.type()); // Windows_NT
// returns `'Linux'` on Linux, `'Darwin'` on macOS, and `'Windows_NT'` on Windows.

// 3、release 获取当前系统版本号
console.log(os.release()); // 10.0.19044

// 4、version 获取当前系统版本名称
console.log(os.version()); // Windows 10 Pro

// 5、EOL 返回操作系统的换行符，"\n" 或 "\r\n"
console.log(JSON.stringify(os.EOL)); // "\r\n"

// 6、arch 获取当前系统的 CPU 架构
console.log(os.arch()); // x64
//  ‘arm’, ‘arm64’, ‘ia32’, ‘mips’, ‘mipsel’, ‘ppc’, ‘ppc64’, ‘riscv64’, ‘s390’, ‘s390x’, ‘x64’ 等。

// 7、constants 返回操作系统的常量，如错误码、信号码等
console.log(os.constants); // { UV_UDP_REUSEADDR: 4, ... }

// 8、homedir 获取当前用户的主目录
console.log(os.homedir()); // C:\Users\64507
// 底层原理是通过环境变量获取，USERPROFILE 或 HOME
// > printenv USERPROFILE

// 9、cpus 获取CPU的线程以及详细信息，返回数组，元素个数为线程数(逻辑处理器个数)
console.log(os.cpus()); // [ { model: 'AMD Ryzen 7 5800U with Radeon Graphics ... } ]
console.log(os.cpus().length); // 16 线程数
// {
//   model: 'AMD Ryzen 7 5800U with Radeon Graphics', // CPU型号
//   speed: 1896, // CPU速度，以MHz或GHz为单位
//   times: { // CPU时间（毫秒）
//     user: 3473453, // 用户态时间
//     nice: 0, // 低优先级用户态时间
//     sys: 5935453, // 系统态时间
//     idle: 437847828, // 空闲时间
//     irq: 704953 // 硬中断时间
//   }
// },

// 10、networkInterfaces 获取网络接口列表
console.log(os.networkInterfaces()); // { '本地连接* 1': [ { address: '127.0.0.1', ... } ] }
// {
//   address: '127.0.0.1', // IP地址
//   netmask: '255.0.0.0', // 子网掩码
//   family: 'IPv4', // IP协议版本
//   mac: '00:00:00:00:00:00', // MAC地址
//   internal: true, // 是否为内部地址
//   cidr: '127.0.0.1/8' // CIDR表示法
// }

// 11、freemem 获取系统空闲内存，单位字节
console.log(os.freemem()); // 4641640448

// 12、totalmem 获取系统总内存，单位字节
console.log(os.totalmem()); // 16442781696

// 13、hostname 获取主机名
console.log(os.hostname()); // DESKTOP-3JQKQ0O

// 14、uptime 获取系统正常运行时间，单位秒
console.log(os.uptime()); // 1017.283

// 15、userInfo 获取当前用户信息
console.log(os.userInfo()); // { uid: -1, gid: -1, username: '64507', homedir: 'C:\\Users\\64507', shell: null }

// 16、loadavg 获取系统平均负载，数组包含 1、5、15 分钟的平均负载
console.log(os.loadavg()); // [ 0, 0, 0 ]
// 它只在Linux和macOS上返回有意义的值。

// 17、tmpdir 获取系统临时目录
console.log(os.tmpdir()); // C:\Users\64507\AppData\Local\Temp

// 18、endianness 获取系统字节序
console.log(os.endianness()); // LE
// 取决于Node是用Big Endian还是Little Endian编译的。

// 19、getPriority(pid) 获取进程优先级
console.log(os.getPriority(0)); // 0

// 20、setPriority(pid, priority) 设置进程优先级
console.log(os.setPriority(0, 10)); // undefined

const childProcess = require('child_process')
const os = require('os')

// 兼容不同系统的打开浏览器命令
const open = (url) => {
  const cmd = {
    darwin: 'open',
    win32: 'start',
    linux: 'xdg-open'
  }
  childProcess.exec(`${cmd[os.platform()]} ${url}`)
}

open('https://www.baidu.com')

console.log("task开始")
setTimeout(() => {
  console.log("setTimeout")
}, 1000)
while (true) { }
console.log("task结束")

create(server) // 创建一个web服务
parse(query) // 解析请求获取参数
read(data) // I/O操作，从系统磁盘读取文件内容
send(result) // 将结果返回给用户

setTimeout(() => {
  console.log("setTimeout1")
}, 2000)

Promise.resolve().then(()=>{
  console.log('promise')
})

process.nextTick(()=>{
  console.log('nextTick')
})

setTimeout(() => {
  console.log("setTimeout2")
}, 1000)

setImmediate(()=>{
  console.log('setImmediate')
})

setTimeout(() => {
  console.log("setTimeout3")
}, 0)

fs.writeFile('./test.txt', 'test', () => {
  console.log('writeFile')
})

// nextTick
// promise
// setTimeout3
// setImmediate
// writeFile
// setTimeout2
// setTimeout1

console.log('1');
process.nextTick(function(){
    console.log('2');
});
console.log('3');
// 1 3 2

console.log(process.argv)
// 第一个元素是 node.exe 的路径，第二个元素是当前执行的 js 文件的路径，其余的元素是命令行参数
// [
//   'C:\\Program Files\\nodejs\\node.exe', // node.exe 的路径
//   'c:\\chuckle\\qx\\NodeJS-new\\process\\index.js', // 当前执行的 js 文件的路径
//   '--version' // 命令行参数
// ]
console.log(process.argv.includes('--version') ? '1.0.0' : null) // node index.js --version

// node --harmony .\execArgv.js -a -b -c
console.log(process.execArgv);
// [ '--harmony' ]
console.log('------------------');
console.log(process.argv);
// [
//   'C:\\Program Files\\nodejs\\node.exe',
//   'C:\\chuckle\\qx\\NodeJS-new\\process\\execArgv.js',
//   '-a',
//   '-b',
//   '-c'
// ]

// 取当前工作目录
console.log(process.cwd()) // C:\chuckle\qx\NodeJS-new 获取当前工作目录
console.log(path.resolve()) // C:\chuckle\qx\NodeJS-new 获取当前工作目录
console.log(__dirname) // c:\chuckle\qx\NodeJS-new\process 获取当前文件所在的目录
// 切换工作目录
console.log(process.chdir('..')) // 修改当前工作目录
console.log(process.cwd()) // C:\chuckle\qx

console.log(process.pid) // 45736
console.log(process.ppid) // 37716

console.log(process.title) // 管理员: C:\windows\System32\WindowsPowerShell\v1.0\powershell.exe
process.title = 'node'
console.log(process.title) // node

console.log(process.uptime()) // 0.0367208

console.log(process.memoryUsage())
// {
//   rss: 36507648, // 常驻内存，物理内存存量
//   heapTotal: 6369280, // V8给分配的堆内存总量
//   heapUsed: 5690504, // 已使用的堆内存
//   external: 429451, // 外部内存使用量 c、c++ 使用的
//   arrayBuffers: 17378 // ArrayBuffer 的总内存
// }
console.log(os.freemem()); // 获取系统空闲内存
console.log(os.totalmem()); // 获取系统总内存

const startUsage = process.cpuUsage();
const now = Date.now();
while (Date.now() - now < 500);
console.log(process.cpuUsage(startUsage)); // { user: 500000, system: 0 }
// user表示用户程序代码运行占用的时间，system表示系统占用时间
// 如果当前进程占用多个内核来执行任务，那么数值会比实际感知的要大

console.log(process.execPath) // C:\Program Files\nodejs\node.exe
console.log(process.version) // v18.12.1
console.log(process.versions)
// {
//   node: '18.12.1',
//   v8: '10.2.154.15-node.12',
//   ......
// }
console.log(process.release)
// {
//   name: 'node',
//   lts: 'Hydrogen',
//   ......
// }
console.log(process.config) // [......]

console.log(process.arch) // x64
console.log(os.arch()) // x64

console.log(process.platform) // win32
console.log(os.platform()) // win32

process.emitWarning('warning!');
// 可以给警告信息加个名字，便于分类
process.emitWarning('warning!', 'CustomWarning');
// 也可以传入Error对象
const myWarning = new Error('Warning!');
myWarning.name = 'CustomWarning';
process.emitWarning(myWarning);
// 监听warning
process.on('warning', (warning) => {
  console.warn(warning.name); // 'CustomWarning'
  console.warn(warning.message); // 'warning!'
  console.warn(warning.stack); // CustomWarning: Warning! at Object.<anonymous> ......
});

process.exit(1) // 退出当前进程，退出码为1
process.exitCode = 1 // 退出码为1

process.kill(process.pid); // 默认是 SIGTERM 信号，杀死进程，退出之前重置终端模式
process.kill(process.pid, 'SIGINT') // Ctrl+C 退出进程
process.kill(process.pid, 0)

// 例子
// 从标准输入开始读取，因此进程不会退出。
process.stdin.resume();

process.on('SIGINT', () => {
  console.log('不能使用 Ctrl + C 退出了');
});

// 使用单个函数处理多个信号
function handle(signal) {
  console.log(`Received ${signal}`);
}

process.on('SIGINT', handle);
process.on('SIGTERM', handle);

setTimeout(() => {
  console.log("setTimeout1")
}, 2000)
process.exitCode = 1
// 两秒后，事件循环清空，触发beforeExit事件
process.on('beforeExit', (code) => {
  console.log(code) // 1
})

process.on('beforeExit', (code) => {
  setTimeout(() => {
    console.log("setTimeout")
  }, 2000)
})
// setTimeout
// setTimeout
// ......

setTimeout(() => {
  console.log("setTimeout1")
}, 2000)
process.exitCode = 1

process.on('exit', (code) => {
  console.log('exit', code)
  setTimeout(() => {
    console.log("setTimeout2")
  }, 2000)
})

process.on('beforeExit', (code) => {
  console.log('beforeExit', code)
})

// setTimeout1
// beforeExit 1
// exit 1

setTimeout(() => {
  const err = new Error('错误信息')
  err.name = 'CustomError'
  process.emitWarning(err)
}, 2000)
process.on('warning', (warning) => {
  console.log(warning.name)
  console.log(warning.message)
  console.log(warning.stack)
})
// (node:40184) CustomError: 错误信息
// (Use `node --trace-warnings ...` to show where the warning was created)
// CustomError
// 错误信息
// CustomError: 错误信息
//     at Timeout._onTimeout (c:\chuckle\qx\NodeJS-new\process\进程事件.js:21:15)
//     at listOnTimeout (node:internal/timers:564:17)
//     at process.processTimers (node:internal/timers:507:7)

setTimeout(() => {
  process.kill(process.pid) // 默认信号为SIGTERM
  console.log('kill') // 在win上不会执行
}, 2000)
// 在windows上会直接退出进程，而不会监听到SIGTERM信号
process.on('SIGTERM', (signal) => {
  console.log(`Received ${signal}`)
})

process.stdin.setEncoding('utf8'); // 设置编码格式
process.stdin.resume() // 开启输入流
// 通过监听data事件来处理输入。每当用户输入一些数据时，就会触发data事件
process.stdin.on("data", data => { // 监听输入
  process.stdout.write(`data: ${data.toString()}`) // 输出输入
  // process.stdin.pause() // 暂停输入流
})
// 当有可从流中读取的数据或已到达流的末尾时，则将触发 readable 事件。
// 表明流有新的信息。如果数据可用，则 stream.read() 将返回该数据。
process.stdin.on('readable', () => {
  let chunk;
  while ((chunk = process.stdin.read()) !== null) {
    process.stdout.write(`readable: ${chunk}`);
  }
});
// 当标准输入流结束时触发，即输入流中没有更多数据可供读取时，win上不一定会触发
process.stdin.on('end', () => {
  console.log('输入结束');
});

process.stdout.write(`hello `) // 需要手动添加空格
process.stdout.write(`world${os.EOL}`) // 需要手动添加换行符
// hello world
console.log("hello")
console.log("world") // console.log会自动在输出末尾添加换行符
// hello
// world
// console.log会自动在不同的输出之间添加空格
console.log("hello", "world")
// hello world
const obj = { name: 'obj' }
process.stdout.write(JSON.stringify(obj) + os.EOL) // 需要手动将对象转换为字符串
console.log(obj) // console.log可以直接输出对象
// {"name":"obj"}

1. input <stream.Readable> 要监听的可读流
2. output <stream.Writable> 要写入 readline 数据的可写流
3. completer <Function> 可选的用于Tab制表符自动补全的函数
4. terminal <boolean> 如果 input 和 output 流应该被视为终端，并且写入了 ANSI/VT100 转义码，则为 true。默认值：在实例化时检查 output 流上的 isTTY。
5. history <string[]> 历史行的初始列表。仅当 terminal 由用户或内部的 output 检查设置为 true 时，此选项才有意义，否则历史缓存机制根本不会初始化。默认值：[]。
6. historySize <number> 保留的最大历史行数。要禁用历史记录，则将此值设置为 0。仅当 terminal 由用户或内部的 output 检查设置为 true 时，此选项才有意义，否则历史缓存机制根本不会初始化。默认值：30。
7. removeHistoryDuplicates <boolean> 如果为 true，则不会将重复的历史记录添加到历史记录中。默认值：false。
8. prompt <string> 要使用的提示字符串。默认值：'> '。
9. crlfDelay <number> 读取行时要使用的延迟毫秒数，用于确定输入行何时结束。默认值：100。
10. escapeCodeTimeout <number> 读取转义序列时要使用的超时毫秒数
11. tabSize <number> 一个制表符等于的空格数（最小为 1）。默认值：8。
12. signal <AbortSignal> 允许使用中止信号关闭接口。中止信号将在内部调用接口上的 close。

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin, // 设置输入流
  output: process.stdout, // 设置输出流
});
rl.question('今天星期几：', (answer) => {
  // 对答案进行处理
  console.log(`答：${answer}`);
  rl.close();
});

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  prompt: '> ',
});
rl.prompt();
rl.on('line', (line) => {
  console.log(`你输入了：${line}`);
  rl.prompt();
}).on('close', () => {
  rl.clearLine(0);
  console.log('再见');
  process.exit(0);
});

const readline = require('readline/promises')
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
})
rl.question('今天星期几：').then(answer => {
  console.log(`答：${answer}`)
  rl.close()
})

"scripts": {
  "dev": "cross-env NODE_ENV=dev node env.js",
  "build": "cross-env NODE_ENV=prod node env.js"
},

if (process.env.NODE_ENV === 'dev') {
  console.log('开发环境')
} else if (process.env.NODE_ENV === 'prod') {
  console.log('生产环境')
} else {
  console.log('未知环境')
}

set NODE_ENV=prod  #windows
export NODE_ENV=prod #posix

child_process.exec(command, [options], callback)
exec(
  command: string,
  options?: Object | undefined
  callback?: ((
      error: ExecException | null,
      stdout: string,
      stderr: string
    ) => void
  ) | undefined
): ChildProcess

cwd <string> 子进程的当前工作目录。
env <Object> 环境变量键值对。
encoding <string> 默认为 'utf8'。
shell <string> 用于执行命令的 shell。 在 UNIX 上默认为 '/bin/sh'，在 Windows 上默认为 process.env.ComSpec。
timeout <number> 超时，默认为 0。
maxBuffer <number> stdout 或 stderr 允许的最大字节数。默认为 1024 * 1024。如果超过限制，则子进程会被终止。查看警告：maxBuffer and Unicode。
killSignal <string> | <integer> 默认为 'SIGTERM'。
uid <number> 设置该进程的用户标识。
gid <number> 设置该进程的组标识。
windowsHide <boolean> 隐藏通常在 Windows 系统上创建的子进程控制台窗口。默认值：false。

exec('node -v && mkdir test',{
  cwd: __dirname, // 设置工作目录为当前目录
}, (err, stdout, stderr) => {
  console.log(stdout) // v18.12.1
})

const nodeVersion  = execSync('node -v && mkdir test',{
  cwd: __dirname, // 设置工作目录为当前目录
})
console.log(nodeVersion.toString())

child_process.spawn(command, [args], [options])
spawn(
  command: string,
  args?: readonly string[] | undefined,
  options?: SpawnOptionsWithoutStdio | undefined
): ChildProcessWithoutNullStreams

cwd <string> | <URL> 子进程的当前工作目录。
env <Object> 环境变量键值对。默认值：process.env。
argv0 <string> 显式设置发送给子进程的 argv[0] 的值。如果未指定，这将设置为 command。
stdio <Array> | <string> 子进程的标准输入输出配置。
detached <boolean> 准备子进程独立于其父进程运行。具体行为取决于平台。
uid <number> 设置进程的用户标识。
gid <number> 设置进程的群组标识。
serialization <string> 指定用于在进程之间发送消息的序列化类型。可能的值为 'json' 和 'advanced'。默认值：'json'。
shell <boolean> | <string> 如果是 true，则在 shell 内运行 command。在 Unix 上使用 '/bin/sh'，在 Windows 上使用 process.env.ComSpec。 可以将不同的 shell 指定为字符串。默认值： false（无外壳）。
windowsVerbatimArguments <boolean> 在 Windows 上不为参数加上引号或转义。 在 Unix 上被忽略。当指定了 shell 并且是 CMD 时，则自动设置为 true。 默认值：false。
windowsHide <boolean> 隐藏通常在 Windows 系统上创建的子进程控制台窗口。默认值：false。
signal <AbortSignal> 允许使用中止信号中止子进程。
timeout <number> 允许进程运行的最长时间（以毫秒为单位）。默认值：undefined。
killSignal <string> | <integer> 当衍生的进程将被超时或中止信号杀死时要使用的信号值。默认值：'SIGTERM'。

const subprocess = spawn('ping', ['127.0.0.1'], {
  shell: true,
})

// 读取输出流
subprocess.stdout.on('data', (data) => {
  console.log(iconv.decode(data, 'cp936'))
})
// 输出流结束
subprocess.stdout.on('end', () => {
  console.log('end')
})
// 输出流关闭
subprocess.stdout.on('close', () => {
  console.log('close')
})
// 正在 Ping 127.0.0.1 具有 32 字节的数据:
// 来自 127.0.0.1 的回复: 字节=32 时间<1ms TTL=128
// 来自 127.0.0.1 的回复: 字节=32 时间<1ms TTL=128
// 来自 127.0.0.1 的回复: 字节=32 时间<1ms TTL=128
// 来自 127.0.0.1 的回复: 字节=32 时间<1ms TTL=128
// 127.0.0.1 的 Ping 统计信息:
//     数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，
// 往返行程的估计时间(以毫秒为单位):
//     最短 = 0ms，最长 = 0ms，平均 = 0ms
// end
// close

// 子进程创建成功
subprocess.on('spawn', () => {
  console.log('subprocess spawn', subprocess.pid) // spawn 39036
})
setTimeout(() => {
  // 关闭子进程的标准输出流
  subprocess.stdout.end();
  // 退出子进程
  subprocess.kill();
}, 2000)
// 子进程结束并退出
subprocess.on('exit', (code, signal) => {
  console.log('subprocess exit', code, signal) // subprocess exit null SIGTERM
})
// 子进程结束并且其的标准输入输出流已关闭
subprocess.on('close', (code, signal) => {
  console.log('subprocess close', code, signal) // subprocess close null SIGTERM
})
// 子进程错误
subprocess.on('error', (err) => {
  console.log('subprocess error', err)
})
// 断开连接
subprocess.on('disconnect', () => {
  console.log('subprocess disconnect')
})
// 子进程消息
subprocess.on('subprocess message', (msg) => {
  console.log(msg)
})

child_process.execFile(file[, args][, options][, callback])
execFile(
  file: string,
  args: readonly string[] | null | undefined,
  options: Object | undefined
  callback: (
    error: ExecFileException | null,
    stdout: string, stderr: string
  ) => void
): ChildProcess

cwd <string> | <URL> 子进程的当前工作目录。
env <Object> 环境变量键值对。默认值：process.env。
encoding <string> 默认值：'utf8'
timeout <number> 默认值：0
maxBuffer <number> 标准输出或标准错误上允许的最大数据量（以字节为单位）。如果超过，则子进程将终止并截断任何输出。默认值：1024 * 1024。
killSignal <string> | <integer> 默认值：'SIGTERM'
uid <number> 设置进程的用户标识。
gid <number> 设置进程的群组标识。
windowsHide <boolean> 隐藏通常在 Windows 系统上创建的子进程控制台窗口。默认值： false。
windowsVerbatimArguments <boolean> 在 Windows 上不为参数加上引号或转义。在 Unix 上被忽略。默认值：false。
shell <boolean> | <string> 如果是 true，则在 shell 内运行 command。在 Unix 上使用 '/bin/sh'，在 Windows 上使用 process.env.ComSpec。 可以将不同的 shell 指定为字符串。默认值：false（无外壳）。
signal <AbortSignal> 允许使用中止信号中止子进程。

execFile('node', ['-v'], (err, stdout, stderr) => {
  console.log(stdout) // v21.2.0
});

echo '开始'
mkdir test
cd ./test
echo console.log("test") >test.js
echo '结束'
node test.js

execFile(path.resolve(__dirname, './test.cmd'),{
  cwd: __dirname, // 设置工作目录为当前目录
}, (err, stdout, stderr) => {
  console.log(stdout)
});

c:\chuckle\qx\NodeJS-new\child_process>echo '开始'
'开始'
c:\chuckle\qx\NodeJS-new\child_process>mkdir test
c:\chuckle\qx\NodeJS-new\child_process>cd ./test
c:\chuckle\qx\NodeJS-new\child_process\test>echo console.log("test")  1>test.js
c:\chuckle\qx\NodeJS-new\child_process\test>echo '结束'
'结束'
c:\chuckle\qx\NodeJS-new\child_process\test>node test.js
test

child_process.fork(modulePath[, args][, options])
fork(
  modulePath: string,
  options?: ForkOptions | undefined
): ChildProcess

cwd <string> | <URL> 子进程的当前工作目录。
detached <boolean> 准备子进程独立于其父进程运行。具体行为取决于平台。
env <Object> 环境变量键值对。默认值：process.env。
execPath <string> 用于创建子进程的可执行文件。
execArgv <string[]> 传给可执行文件的字符串参数列表。默认值：process.execArgv。
gid <number> 设置进程的群组标识。
serialization <string> 指定用于在进程之间发送消息的序列化类型。可能的值为 'json' 和 'advanced'。默认值：'json'。
signal <AbortSignal> 允许使用中止信号关闭子进程。
killSignal <string> | <integer> 当衍生的进程将被超时或中止信号杀死时要使用的信号值。 默认值：'SIGTERM'。
silent <boolean> 如果为 true，则子进程的标准输入、标准输出和标准错误将通过管道传输到父进程，否则它们将从父进程继承。参阅 child_process.spawn() 的 stdio 的 'pipe' 和 'inherit' 选项，默认值：false。
stdio <Array> | <string> 参见 child_process.spawn() 的 stdio。提供此选项时，它会覆盖 silent。如果使用数组变体，则它必须恰好包含一个值为 'ipc' 的条目，否则将抛出错误。例如 [0, 1, 2, 'ipc']。
uid <number> 设置进程的用户标识。
windowsVerbatimArguments <boolean> 在 Windows 上不为参数加上引号或转义。在 Unix 上被忽略。默认值：false。
timeout <number> 允许进程运行的最长时间（以毫秒为单位）。默认值：undefined。

// 使用child.js创建Node子进程
const forked = fork(path.resolve(__dirname, './child.js'));

// 监听子进程的消息
forked.on("message", msg => {
  console.log("Message from child", msg);
});

// 向子进程发送消息
forked.send({ hello: "world" });

// 监听父进程发送的消息
process.on("message", msg => {
  console.log("Message from parent:", msg);
});

let counter = 0;

setInterval(() => {
  // 向父进程发送消息
  process.send({ counter: counter++ });
}, 1000);

Message from parent: { hello: 'world' }
Message from child { counter: 0 }
Message from child { counter: 1 }
Message from child { counter: 2 }
# ......

const server = (data) => {
  // 开启一个子进程，完成计算任务
  const compute = fork(path.resolve(__dirname, './compute.js'));
  // 向子进程发送数据
  compute.send(data);
  // 监听子进程的消息，获取计算结果
  compute.on('message', (msg) => {
    console.log('计算结果：', msg);
  })
}
// 模拟多个请求同时到来
server([1,2,3,4,5,6,7,8,9,10]);
server([100,200,300,400,500,600,700,800,900,1000]);
server([10,200,3000,4000,5000,6000,7000,8000,9000,10000]);

const longComputation = async (data) => {
  return await new Promise((resolve, reject) => {
    setTimeout(() => {
      const sum = data.reduce((a, b) => {
        return a + b;
      }, 0);
      resolve(sum);
    }, 3000); // 模拟3s的计算任务
  });
};
// 监听父进程发送的消息，开启计算任务
process.on("message", async msg => {
  try {
    const result = await longComputation(msg);
    // 等待计算任务完成后，向父进程发送结果
    process.send(result);
  } catch (error) {
    process.send({ error: error.message });
  } finally {
    process.disconnect();
    process.exit();
  }
});

计算结果： 55
计算结果： 5500
计算结果： 52210

const ffmpeg = (str) => {
  const ffmpegProcess = childProcess.execFile('ffmpeg', str.split(" "), {
    cwd: __dirname,
  }, (err, stdout, stderr) => {
    if (err) {
      console.error(err)
      return
    }
    console.log("ffmpeg执行成功")
  })
  ffmpegProcess.stdin.write('y'); // 输入y，覆盖输出文件
  ffmpegProcess.stdin.end();  // 结束输入流
}

// 格式转换
ffmpeg('-i ./test.mp4 ./test.avi')

// 音频提取，直接转为音频格式即可，-vn表示去掉视频
ffmpeg('-i ./test.mp4 -vn ./test.mp3')

// 裁剪视频，内部的编码格式不变，所以使用-c copy指定直接拷贝，不经过转码，这样比较快
ffmpeg('-i ./test.mp4 -ss 00:00:00 -to 00:00:05 -c copy ./test2.mp4')

// 加水印
ffmpeg('-i ./test.mp4 -vf drawtext=text=Chuckle:fontsize=30:fontcolor=white:x=10:y=10 ./test3.mp4')

// 删除水印，指定水印宽高和起始点
ffmpeg('-i ./test3.mp4 -vf delogo=w=120:h=30:x=10:y=10 ./test4.mp4')