在开发脚手架之前，我们先了解下脚手架开发的流程图。

脚手架架构图

Canvas 1.png

脚手架拆包策略

  • 核心流程:core
  • 命令:commands
    • 初始化
    • 发布
    • 清除缓存
  • 模型层:models
    • Command命令
    • Project项目
    • Component组件
    • Npm模块
    • Git仓库
  • 支持模块:utils
    • Git操作
    • 云构建
    • 工具方法
    • API请求
    • Git API

1632656091942.jpg

命令执行流程

  • 准备阶段

core准备阶段.png

  • 命令注册

    core命令阶段.png

  • 命令执行

5fe4a3a408c7620016001303.jpeg

准备阶段

  • 检查版本号
  1. // 检查版本
  2. function checkPkgVersion() {
  3.     log.info('cli', pkg.version);
  4. }
  • 检查node版本
  1. // 检查node版本
  2. checkNodeVersion() {
  3.     //第一步，获取当前Node版本号
  4.     const currentVersion = process.version;
  5.     const lastVersion = LOWEST_NODE_VERSION;
  6.     //第二步，对比最低版本号
  7.     if (!semver.gte(currentVersion, lastVersion)) {
  8.         throw new Error(colors.red(`code-robot-cli 需要安装v${lastVersion}以上版本的Node.js`));
  9.     }
  10. }
  • 检查root权限
  1. // 检查root启动
  2. function checkRoot() {
  3.     //使用后，检查到root账户启动，会进行降级为用户账户
  4.     const rootCheck = require('root-check');
  5.     rootCheck();
  6. }
  • 检查用户主目录
  1. // 检查用户主目录
  2. function checkUserHome() {
  3.     if (!userHome || !pathExists(userHome)) {
  4.         throw new Error(colors.red('当前登录用户主目录不存在!!!'));
  5.     }
  6. }
  • 检查入参
  1. // 检查入参
  2. function checkInputArgs() {
  3.     const minimist = require('minimist');
  4.     args = minimist(process.argv.slice(2));
  5.     checkArgs();
  6. }
  8. function checkArgs() {
  9.     if (args.debug) {
  10.         process.env.LOG_LEVEL = 'verbose';
  11.     } else {
  12.         process.env.LOG_LEVEL = 'info';
  13.     }
  14.     log.level = process.env.LOG_LEVEL;
  15. }
  • 检查环境变量
  1. // 检查环境变量
  2. function checkEnv() {
  3.     const dotenv = require('dotenv');
  4.     const dotenvPath = path.resolve(userHome, '.env');
  5.     if (pathExists(dotenvPath)) {
  6.         config = dotenv.config({
  7.             path: dotenvPath
  8.         });
  9.     }
  10.     createDefaultConfig();
  11.     log.verbose('环境变量', process.env.CLI_HOME_PATH);
  12. }
  14. function createDefaultConfig() {
  15.     const cliConfig = {
  16.         home: userHome
  17.     }
  18.     if (process.env.CLI_HOME) {
  19.         cliConfig['cliHome'] = path.join(userHome, process.env.CLI_HOME);
  20.     } else {
  21.         cliConfig['cliHome'] = path.join(userHome, constants.DEFAULT_CLI_HOME);
  22.     }
  23.     process.env.CLI_HOME_PATH = cliConfig.cliHome;
  24. }
  • 检查是否是最新版本
  1. // 检查是否是最新版本，是否需要更新
  2. async function checkGlobalUpdate() {
  3.     //1.获取当前版本号和模块名
  4.     const currentVersion = pkg.version;
  5.     const npmName = pkg.name;
  6.     //2.调用npm API,获取所有版本号
  7.     const { getNpmSemverVersion } = require('@code-robot-cli/get-cli-info');
  8.     //3.提取所有版本号，比对哪些版本号是大于当前版本号
  9.     const lastVersion = await getNpmSemverVersion(currentVersion, npmName);
  10.     if (lastVersion && semver.gt(lastVersion, currentVersion)) {
  11.         //4.获取最新的版本号，提示用户更新到该版本
  12.         log.warn(colors.yellow(`请手动更新${npmName},当前版本:${currentVersion},最新版本:${lastVersion} 
  13.                     更新命令:npm install -g ${npmName}`))
  14.     }
  15. }

命令注册

注册init阶段

  1. //命名的注册
  2. function registerCommand() {
  3.     program
  4.         .name(Object.keys(pkg.bin)[0])
  5.         .usage('<command> [options]')
  6.         .version(pkg.version)
  7.         .option('-d, --debug', '是否开启调试模式', false)
  8.         .option('-tp, --targetPath <targetPath>', '是否指定本地调试文件路径', '');
  10.     program
  11.         .command('init [projectName]')
  12.         .option('-f, --force', '是否强制初始化项目')
  13.         .action(init); //init 单独解析一个命令 exec动态加载模块
  16.     //开启debug模式
  17.     program.on('option:debug', function () {
  18.         if (program.debug) {
  19.             process.env.LOG_LEVEL = 'verbose';
  20.         } else {
  21.             process.env.LOG_LEVEL = 'info';
  22.         }
  23.         log.level = process.env.LOG_LEVEL;
  24.         log.verbose('test');
  25.     });
  27.     //指定targetPath
  28.     program.on('option:targetPath', function () {
  29.         process.env.CLI_TARGET_PATH = program.targetPath;
  30.     });
  32.     //对未知命令的监听
  33.     program.on('command:*', function (obj) {
  34.         const availabelCommands = program.commands.map(cmd => cmd.name());
  35.         log.verbose(colors.red('未知命令:' + obj[0]));
  36.         if (availabelCommands.length > 0) {
  37.             log.verbose(colors.blue('可用命令:' + availabelCommands.join(',')));
  38.         }
  39.     })
  41.     program.parse(process.argv);
  42.     //用户没有输入命令的时候
  43.     if (program.args && program.args.length < 1) {
  44.         program.outputHelp();
  45.         console.log();
  46.     }
  47. }

当前架构图

通过准备阶段和命令初始化init阶段，我们创建了如下一些package:
5fe4a37908dd3d1b13720561.jpeg

这样的架构设计已经可以满足一般脚手架需求，但是有以下两个问题:

1.cli安装速度慢:所有的package都集成在cli里，因此当命令较多时，会减慢cli的安装速度

2.灵活性差:init命令只能使用@code-robot-cli/init包，对于集团公司而言，每个团队init命令可能都各不相同，可能需要实现init命令动态化，如:

  • 团队A使用@code-robot-cli/init作为初始化模板
  • 团队B使用自己开发的@code-robot-cli/my-init作为初始化模板
  • 团队C使用自己开发的@code-robot-cli/your-init作为初始化模板

这时对我们的架构设计就提出了挑战，要求我们能够动态加载init模块，这将增加架构的复杂度，但大大提升脚手架的可扩展性，将脚手架框架和业务逻辑解耦

脚手架架构优化

jiaoshoujiayouhua.png

命令执行阶段

  1. const SETTINGS = {
  2.     init: "@code-robot-cli/init",
  3. }
  5. const CACHE_DIR = 'dependencies/';
  7. async function exec() {
  8.     let targetPath = process.env.CLI_TARGET_PATH;
  9.     const homePath = process.env.CLI_HOME_PATH;
  10.     let storeDir = '';
  11.     let pkg;
  12.     log.verbose('targetPath', targetPath);
  13.     log.verbose('homePath', homePath);
  14.     const cmdObj = arguments[arguments.length - 1];
  15.     const cmdName = cmdObj.name();
  16.     const packageName = SETTINGS[cmdName];
  17.     const packageVersion = 'latest';
  19.     if (!targetPath) {//是否执行本地代码
  20.         //生成缓存路径
  21.         targetPath = path.resolve(homePath, CACHE_DIR);
  22.         storeDir = path.resolve(targetPath, 'node_modules');
  23.         log.verbose(targetPath, storeDir);
  24.         //初始化Package对象
  25.         pkg = new Package({
  26.             targetPath,
  27.             storeDir,
  28.             packageName,
  29.             packageVersion
  30.         });
  31.         //判断Package是否存在
  32.         if (await pkg.exists()) {
  33.             //更新package
  34.             await pkg.update()
  35.         } else {
  36.             //安装package
  37.             await pkg.install();
  38.         }
  39.     } else {
  40.         pkg = new Package({
  41.             targetPath,
  42.             packageName,
  43.             packageVersion
  44.         });
  45.     }
  46.     //获取入口文件
  47.     const rootFile = pkg.getRootFile();
  48.     if (rootFile) {//判断入口文件是否存在
  49.         try {
  50.             //在当前进程中调用
  51.             // require(rootFile).call(null, Array.from(arguments));
  52.             //在node子进程中调用
  53.             const args = Array.from(arguments);
  54.             const cmd = args[args.length - 1];
  55.             const o = Object.create(null);
  56.             Object.keys(cmd).forEach(key=>{
  57.                 if (cmd.hasOwnProperty(key) && !key.startsWith('_') && key !== 'parent') {
  58.                     o[key] = cmd[key];
  59.                 }
  60.             })
  61.             args[args.length - 1] = o;
  62.             const code = `require('${rootFile}').call(null, ${JSON.stringify(args)})`;
  63.             const child = spawn('node',['-e',code],{
  64.                 cwd:process.cwd(),
  65.                 stdio:'inherit'
  66.             });
  67.             //执行产生异常
  68.             child.on('error',e=>{
  69.                 log.error(e.message);
  70.                 process.exit(1);
  71.             });
  72.             //执行完毕 正常退出
  73.             child.on('exit',e=>{
  74.                 log.verbose('命令执行成功:'+e);
  75.                 process.exit(e);
  76.             })
  77.         } catch (e) {
  78.             log.error(e.message);
  79.         }
  81.     }
  84.     //1.targetPath -> modulePath
  85.     //2.modulePath -> Package(npm模块)
  86.     //3.Package.getRootFile(获取入口文件)
  87.     //4.Package.update/Package.install
  88. }

脚手架项目创建功能设计

首先我们要思考下脚手架项目创建为了什么:

  • 可扩展性:能够快速复用到不同团队，适应不同团队之间的差异
  • 低成本:在不改动脚手架源码的情况下，能够新增模板，且新增模板的成本很低
  • 高性能:控制存储空间，安装时充分利用Node多进程提升安装性能

创建项目功能架构设计图

整体过程分为三个阶段：

  • 准备阶段

prepare.png

  • 下载模块

downloadTemplate.png

  • 安装模块

installTemplate.png

准备阶段

准备阶段的核心工作就是:

  • 确保项目的安装环境
  • 确认项目的基本信息

下载模块

下载模块是利用已经封装Package类快速实现相关功能

安装模块

安装模块分为标准模式和自定义模式:

  • 标准模式下，将通过ejs实现模块渲染，并自动安装依赖并启动项目
  • 自定义模式下，将允许用户主动去实现模块的安装过程和后续启动过程

核心代码如下:

  1. class InitCommand extends Command {
  2.     init() {
  3.         this.projectName = this._argv[0] || '';
  4.         this.force = this._cmd.force;
  5.         log.verbose(this._argv);
  6.         log.verbose('projectName', this.projectName);
  7.         log.verbose('force', this.force);
  8.     }
  9.     async exec() {
  10.         try {
  11.             //1.准备阶段
  12.             const projectInfo = await this.prepare();
  13.             if (projectInfo) {
  14.                 //2.下载模板
  15.                 log.verbose('projectInfo', projectInfo);
  16.                 this.projectInfo = projectInfo
  17.                 await this.downloadTemplate();
  18.                 //3.安装模板
  19.                 await this.installTemplate();
  20.             }
  21.         } catch (e) {
  22.             log.error(e.message);
  23.             if (process.env.LOG_LEVEL === 'verbose') {
  24.                 console.log(e);
  25.             }
  26.         }
  27.     }
  29.     async installTemplate() {
  30.         log.verbose('templateInfo', this.templateInfo);
  31.         if (this.templateInfo) {
  32.             if (!this.templateInfo.type) {
  33.                 this.templateInfo.type = TEMPLATE_TYPE_NORMAL
  34.             }
  35.             if (this.templateInfo.type === TEMPLATE_TYPE_NORMAL) {
  36.                 //标准安装   
  37.                 await this.installNormalTemplate();
  38.             } else if (this.templateInfo.type === TEMPLATE_TYPE_CUSTOM) {
  39.                 //自定义安装
  40.                 await this.installCustomTemplate();
  41.             } else {
  42.                 throw new Error('无法失败项目模板类');
  43.             }
  45.         } else {
  46.             throw new Error('项目模板信息不存在');
  47.         }
  48.     }
  49.     checkCommand(cmd) {
  50.         if (WHITE_COMMAND.includes(cmd)) {
  51.             return cmd;
  52.         }
  53.         return null;
  54.     }
  56.     async execCommand(command, errMsg) {
  57.         let ret;
  58.         if (command) {
  59.             const cmdArray = command.split(' ');
  60.             const cmd = this.checkCommand(cmdArray[0]);
  61.             if (!cmd) {
  62.                 throw new Error('命令不存在!命令:' + command);
  63.             }
  64.             const args = cmdArray.slice(1);
  65.             ret = await execAsync(cmd, args, {
  66.                 stdio: 'inherit',
  67.                 cwd: process.cwd(),
  68.             })
  69.         }
  70.         if (ret !== 0) {
  71.             throw new Error(errMsg)
  72.         }
  73.     }
  75.     async ejsRender(options) {
  76.         const dir = process.cwd();
  77.         const projectInfo = this.projectInfo;
  78.         return new Promise((resolve, reject) => {
  79.             glob('**', {
  80.                 cwd: dir,
  81.                 ignore: options.ignore || '',
  82.                 nodir: true,
  83.             }, (err, files) => {
  84.                 if (err) {
  85.                     reject(err);
  86.                 }
  87.                 Promise.all(files.map(file => {
  88.                     const filePath = path.join(dir, file);
  89.                     return new Promise((resolve1, reject1) => {
  90.                         ejs.renderFile(filePath, projectInfo, {}, (err, result) => {
  91.                             console.log(result);
  92.                             if (err) {
  93.                                 reject1(err);
  94.                             } else {
  95.                                 fse.writeFileSync(filePath, result);
  96.                                 resolve1(result);
  97.                             }
  98.                         })
  99.                     });
  100.                 })).then(() => {
  101.                     resolve();
  102.                 }).catch(err => {
  103.                     reject(err);
  104.                 });
  105.             })
  106.         })
  107.     }
  109.     async installNormalTemplate() {
  110.         //拷贝模板代码直当前目录
  111.         let spinner = spinnerStart('正在安装模板');
  112.         log.verbose('templateNpm', this.templateNpm)
  113.         try {
  114.             const templatePath = path.resolve(this.templateNpm.cachFilePath, 'template');
  115.             const targetPath = process.cwd();
  116.             fse.ensureDirSync(templatePath);//确保当前文件存不存在，不存在会创建
  117.             fse.ensureDirSync(targetPath);
  118.             fse.copySync(templatePath, targetPath);//把缓存目录下的模板拷贝到当前目录
  119.         } catch (e) {
  120.             throw e;
  121.         } finally {
  122.             spinner.stop(true);
  123.             log.success('模板安装成功');
  124.         }
  125.         const templateIgnore = this.templateInfo.ignore || [];
  126.         const ignore = ['**/node_modules/**', ...templateIgnore];
  127.         await this.ejsRender({ ignore });
  128.         //依赖安装
  129.         const { installCommand, startCommand } = this.templateInfo
  130.         await this.execCommand(installCommand, '依赖安装过程中失败');
  131.         //启动命令执行
  132.         await this.execCommand(startCommand, '启动执行命令失败');
  133.     }
  134.     async installCustomTemplate() {
  135.         //查询自定义模板的入口文件
  136.         if (await this.templateNpm.exists()) {
  137.             const rootFile = this.templateNpm.getRootFile();
  138.             if (fs.existsSync(rootFile)) {
  139.                 log.notice('开始执行自定义模板');
  140.                 const options = {
  141.                     ...this.options,
  142.                     cwd:process.cwd(),
  143.                 }
  144.                 const code = `require('${rootFile}')(${JSON.stringify(options)})`;
  145.                 log.verbose('code',code);
  146.                 await execAsync('node',['-e', code], { stdio: 'inherit', cwd: process.cwd()});
  147.                 log.success('自定义模板安装成功');
  148.             } else {
  149.                 throw new Error('自定义模板入口文件不存在');
  150.             }
  151.         }
  152.     }
  154.     async downloadTemplate() {
  155.         //1. 通过项目模板API获取项目模板信息
  156.         //1.1 通过egg.js搭建一套后端系统
  157.         //1.2 通过npm存储项目模板
  158.         //1.3 将项目模板信息存储到mongodb数据库中
  159.         //1.4 通过egg.js获取mongodb中的数据并且通过API返回
  160.         const { projectTemplate } = this.projectInfo;
  161.         const templateInfo = this.template.find(item => item.npmName === projectTemplate);
  162.         const targetPath = path.resolve(userHome, '.code-robot-cli', 'template');
  163.         const storeDir = path.resolve(userHome, '.code-robot-cli', 'template', 'node_modules');
  164.         const { npmName, version } = templateInfo;
  165.         this.templateInfo = templateInfo;
  166.         const templateNpm = new Package({
  167.             targetPath,
  168.             storeDir,
  169.             packageName: npmName,
  170.             packageVersion: version
  171.         })
  172.         if (! await templateNpm.exists()) {
  173.             const spinner = spinnerStart('正在下载模板...');
  174.             await sleep();
  175.             try {
  176.                 await templateNpm.install();
  177.             } catch (e) {
  178.                 throw e;
  179.             } finally {
  180.                 spinner.stop(true);
  181.                 if (templateNpm.exists()) {
  182.                     log.success('下载模板成功');
  183.                     this.templateNpm = templateNpm;
  184.                 }
  185.             }
  186.         } else {
  187.             const spinner = spinnerStart('正在更新模板...');
  188.             await sleep();
  189.             try {
  190.                 await templateNpm.update();
  191.             } catch (e) {
  192.                 throw e;
  193.             } finally {
  194.                 spinner.stop(true);
  195.                 if (templateNpm.exists()) {
  196.                     log.success('更新模板成功');
  197.                     this.templateNpm = templateNpm;
  198.                 }
  199.             }
  200.         }
  201.     }
  204.     async prepare() {
  205.         // 判断项目模板是否存在
  206.         const template = await getProjectTemplate();
  207.         if (!template || template.length === 0) {
  208.             throw new Error('项目模板不存在');
  209.         }
  210.         this.template = template;
  211.         //1.判断当前目录是否为空
  212.         const localPath = process.cwd();
  213.         if (!this.isDirEmpty(localPath)) {
  214.             let ifContinue = false;
  215.             if (!this.force) {
  216.                 //询问是否继续创建
  217.                 ifContinue = (await inquirer.prompt({
  218.                     type: 'confirm',
  219.                     name: 'ifContinue',
  220.                     default: false,
  221.                     message: '当前文件夹不为空，是否继续创建项目?'
  222.                 })).ifContinue;
  223.                 if (!ifContinue) {
  224.                     return;
  225.                 }
  226.             }
  227.             //2.是否启动强制更新
  228.             if (ifContinue || this.force) {
  229.                 //给用户二次确认
  230.                 const { confirmDelete } = await inquirer.prompt({
  231.                     type: 'confirm',
  232.                     name: 'confirmDelete',
  233.                     default: false,
  234.                     message: '是否确认清空当前目录下的文件?',
  235.                 })
  236.                 if (confirmDelete) {
  237.                     //清空当前目录
  238.                     fse.emptyDirSync(localPath)
  239.                 }
  240.             }
  241.         }
  242.         return this.getProjectInfo();
  244.         //3.选择创建项目或组件
  245.         //4.获取项目得基本信息
  247.     }
  248.     async getProjectInfo() {
  250.         function isValidName(v) {
  251.             return /^[a-zA-Z]+([-][a-zA-Z][a-zA-Z0-9]*|[_][a-zA-Z][a-zA-Z0-9]*|[a-zA-Z0-9])*$/.test(v);
  252.         }
  254.         let projectInfo = {};
  255.         let isProjectInfoValid = false;
  256.         if (isValidName(this.projectName)) {
  257.             isProjectInfoValid = true;
  258.             projectInfo.projectName = this.projectName;
  259.         }
  261.         //1.选择创建项目或组件
  262.         const { type } = await inquirer.prompt({
  263.             type: 'list',
  264.             name: 'type',
  265.             message: '请选择初始化类型',
  266.             default: TYPE_PROJECT,
  267.             choices: [{
  268.                 name: '项目',
  269.                 value: TYPE_PROJECT
  270.             }, {
  271.                 name: '组件',
  272.                 value: TYPE_COMPONENT
  273.             }]
  274.         });
  275.         log.verbose('type', type);
  276.         this.template = this.template.filter(template => {
  277.             return template.tag.includes(type);
  278.         })
  279.         const title = type === TYPE_PROJECT ? '项目' : '组件';
  280.         //2.获取项目的基本信息
  281.         const projectNamePrompt = {
  282.             type: 'input',
  283.             name: 'projectName',
  284.             message: `请输入${title}的名称`,
  285.             default: '',
  286.             validate: function (v) {
  287.                 const done = this.async();
  288.                 setTimeout(function () {
  289.                     //1.输入的首字符必须为英文字符
  290.                     //2.尾字符必须为英文或数字，不能为字符
  291.                     //3.字符仅运行"-_"
  292.                     //\w = a-zA-Z0-9  *表示0个或多个
  293.                     if (!isValidName(v)) {
  294.                         done(`请输入合法的${title}名称`);
  295.                         return;
  296.                     }
  297.                     done(null, true);
  298.                 }, 0);
  299.             },
  300.             filter: function (v) {
  301.                 return v;
  302.             }
  303.         }
  304.         let projectPrompt = [];
  305.         if (!isProjectInfoValid) {
  306.             projectPrompt.push(projectNamePrompt);
  307.         }
  308.         projectPrompt.push({
  309.             input: 'input',
  310.             name: 'projectVersion',
  311.             message: `请输入${title}版本号`,
  312.             default: '1.0.0',
  313.             validate: function (v) {
  314.                 const done = this.async();
  315.                 setTimeout(function () {
  316.                     //1.输入的首字符必须为英文字符
  317.                     //2.尾字符必须为英文或数字，不能为字符
  318.                     //3.字符仅运行"-_"
  319.                     //\w = a-zA-Z0-9  *表示0个或多个
  320.                     if (!(!!semver.valid(v))) {
  321.                         done('请输入合法的版本号');
  322.                         return;
  323.                     }
  324.                     done(null, true);
  325.                 }, 0);
  326.             },
  327.             filter: function (v) {
  328.                 if (!!semver.valid(v)) {
  329.                     return semver.valid(v);
  330.                 } else {
  331.                     return v;
  332.                 }
  333.             }
  334.         }, {
  335.             type: 'list',
  336.             name: 'projectTemplate',
  337.             message: `请选择${title}模板`,
  338.             choices: this.createTemplateChoices()
  339.         });
  340.         if (type === TYPE_PROJECT) {
  341.             const project = await inquirer.prompt(projectPrompt);
  342.             projectInfo = {
  343.                 ...projectInfo,
  344.                 type,
  345.                 ...project
  346.             }
  347.         } else if (type === TYPE_COMPONENT) {
  348.             const descriptionPrompt = {
  349.                 input: 'input',
  350.                 name: 'componentDescription',
  351.                 message: '请输入组件描述信息',
  352.                 default: '',
  353.                 validate: function (v) {
  354.                     const done = this.async();
  355.                     setTimeout(function () {
  356.                         //1.输入的首字符必须为英文字符
  357.                         //2.尾字符必须为英文或数字，不能为字符
  358.                         //3.字符仅运行"-_"
  359.                         //\w = a-zA-Z0-9  *表示0个或多个
  360.                         if (!v) {
  361.                             done('请输入组件描述信息');
  362.                             return;
  363.                         }
  364.                         done(null, true);
  365.                     }, 0);
  366.                 }
  367.             }
  368.             projectPrompt.push(descriptionPrompt);
  369.             const component = await inquirer.prompt(projectPrompt);
  370.             projectInfo = {
  371.                 ...projectInfo,
  372.                 type,
  373.                 ...component
  374.             }
  375.         }
  376.         //return 项目的基本信息(object)
  377.         if (projectInfo.projectName) {
  378.             projectInfo.className = require('kebab-case')(projectInfo.projectName).replace(/^-/, '');
  379.         }
  380.         if (projectInfo.projectVersion) {
  381.             projectInfo.version = projectInfo.projectVersion;
  382.         }
  383.         if (projectInfo.componentDescription) {
  384.             projectInfo.description = projectInfo.componentDescription;
  385.         }
  386.         return projectInfo;
  387.     }
  389.     isDirEmpty(localPath) {
  390.         let fileList = fs.readdirSync(localPath);
  391.         //文件过滤的逻辑
  392.         fileList = fileList.filter(file => (
  393.             !file.startsWith('.') && ['node_modules'].indexOf(file) < 0
  394.         ));
  396.         return !fileList || fileList.length <= 0;
  397.     }
  398.     createTemplateChoices() {
  399.         return this.template.map(item => ({
  400.             value: item.npmName,
  401.             name: item.name
  402.         }))
  403.     }
  404. }
  406. function init(argv) {
  407.     // console.log('init',projectName,cmdObj.force,process.env.CLI_TARGET_PATH);
  408.     return new InitCommand(argv);
  409. }
  412. module.exports = init;
  413. module.exports.InitCommand = InitCommand;

至此我们完成了脚手架开发以及通过脚手架创建项目。

如何通过Yargs来开发脚手架?

  • 脚手架分为三部分构成(vue create vuex)
    • bin:主命令在package.json中配置bin属性，npm link本地安装
    • command:命令
    • options:参数(boolean/string/number)
    • 文件顶部增加#!/usr/bin/env node,这行命令的用途时告诉操作系统要在环境变量当中查询到node命令,通过node命令来执行文件
  • 脚手架初始化流程
    • 构造函数:Yargs() (通过Yargs构造函数的调用去生成一个脚手架)
    • 常用方法:
      • Yargs.options (注册脚手架的属性)
      • Yargs.option
      • Yargs.group (将脚手架属性进行分组)
      • Yargs.demandCommand (规定最少传几个command)
      • Yargs.recommendCommands (在输入错误command以后可以给你推荐最接近的正确的command)
      • Yargs.strict (开启以后可以报错提示)
      • Yargs.fail (监听脚手架的异常)
      • Yargs.alias (起别名)
      • Yargs.wrapper (命令行工具的宽度)
      • Yargs.epilogus (命令行工具底部的提示)
  • 脚手架参数解析方法
    • hideBin(process.argv)
    • Yargs.parse(argv, options)
  • 命令注册方法
    • Yargs.command(command,describe, builder, handler)
    • Yargs.command({command,describe, builder, handler})

Node.js模块路径解析流程

  • Node.js项目模块路径解析是通过require.resolve方法来实现的
  • require.resolve就是通过Module._resolveFileName方法实现的
  • require.resolve实现原理:
    • Module._resolveFileName方法核心流程有3点:
      • 判断是否为内置模块
      • 通过Module._resolveLookupPaths方法生成node_modules可能存在的路径
      • 通过Module._findPath查询模块的真实路径
    • Module._findPath核心流程有4点:
      • 查询缓存(将request和paths通过\x00(空格)合并成cacheKey)
      • 遍历paths,将path与request组成文件路径basePath
      • 如果basePath存在则调用fs.realPathSync获取文件真实路径
      • 将文件真实路径缓存到Module._pathCache(key就是前面生成的cacheKey)
    • fs.realPathSync核心流程有3点:
      • 查询缓存(缓存的key为p，即Module._findPath中生成的文件路径)
      • 从左往右遍历路径字符串，查询到/时，拆分路径，判断该路径是否为软连接，如果是软连接则查询真实链接，并生成新路径p，然后继续往后遍历，这里有1个细节需要注意:
        • 遍历过程中生成的子路径base会缓存在knownHard和cache中，避免重复查询
      • 遍历完成得到模块对应的真实路径，此时会将原路径original作为key，真实路径作为value，保存到缓存中
  • require.resolve.paths等价于Module._resolveLoopupPaths,该方法用于获取所有的node_modules可能存在的路径
  • require.resolve.paths实现原理: