原文地址 www.zhufengpeixun.com

很多小伙伴一直很纠结什么是脚手架？其实核心功能就是创建项目初始文件,那问题又来了,市面上的脚手架不够用？为什么还要自己写？

只要提到脚手架你就会想到，vue-cli 、 create-react-app 、 dva-cli … 他们的特点不用多说那就是专一！ 但是在公司中你会发现有以下一系列的问题!

  • 业务类型多
  • 多次造轮子，项目升级等问题
  • 公司代码规范,无法统一

很多时候我们开发时需要新建项目，把已有的项目代码复制一遍，保留基础能力。（但是这个过程非常琐碎而又耗时）。那我们可以自己定制化模板，自己实现一个属于自己的脚手架。来解决这些问题。

在自己开发cli前，那肯定先要看些优秀的cli是如何实现的！虽然不是第一个吃螃蟹的，那也要想想怎么吃更好^_^#

1.必备模块

我们先从大家众所周知的 vue-cli 入手，先来看看他都是用了哪些 npm 包来实现的

  • commander ：参数解析 --help 其实就借助了他~
  • inquirer ：交互式命令行工具，有他就可以实现命令行的选择功能
  • download-git-repo ：在 git 中下载模板
  • chalk ：粉笔帮我们在控制台中画出各种各样的颜色
  • metalsmith ：读取所有文件，实现模板渲染
  • consolidate ：统一模板引擎

先幻想一下要实现的功能:
根据模板初始化项目 quick-cli create project-name
初始化配置文件 quick-cli config set repo repo-name

2.工程创建

废话不多说我们开始创建项目，编写自己的脚手架~~~

  1. npm init -y # 初始化package.json
  2. npm install eslint husky --save-dev # eslint是负责代码校验工作，husky提供了git钩子功能
  3. npx eslint --init # 初始化eslint配置文件

2.1 创建文件夹

  1. ├── bin
  2. │   └── www  // 全局命令执行的根文件
  3. ├── package.json
  4. ├── src
  5. │   ├── main.js // 入口文件
  6. │   └── utils   // 存放工具方法
  7. │── .huskyrc    // git hook
  8. │── .eslintrc.json // 代码规范校验

2.2 eslint配置

配置 package.jso n校验 src 文件夹下的代码

  1. "scripts": {
  2.     "lint":"eslint src"
  3. }

2.3 配置husky

使用git提交前，校验代码是否符合规范

  1. {
  2.   "hooks": {
  3.     "pre-commit": "npm run lint"
  4.   }
  5. }

2.4 链接全局包

设置在命令下执行 quick-cli 时，调用 bin 目录下的 www 文件

  1. "bin": {
  2.     "quick-cli": "./bin/www"
  3. }

www 文件中使用 main 作为入口文件，并且以 node 环境执行此文件

  1. #! /usr/bin/env node
  2. require('../src/main.js');
  1. npm link

我们已经可以成功的在命令行中使用quick-cli命令，并且可以执行 main.js 文件！

3.解析命令行参数

commander:The complete solution for node.js command-line interfaces

先吹一波commander，commander可以自动生成help，解析选项参数！
像这样 vue-cli --help!
像这样 vue-cli create <project-namne>

3.1 使用commander

  1. npm install commander

main.js就是我们的入口文件

  1. const program = require('commander');
  2. program.version('0.0.1')
  3.   .parse(process.argv); // process.argv就是用户在命令行中传入的参数

执行quick-cli --help 是不是已经有一个提示了!
这个版本号应该使用的是当前cli项目的版本号，我们需要动态获取，并且为了方便我们将常量全部放到util下的constants文件夹中

  1. const { name, version } = require('../../package.json');
  2. module.exports = {
  3.   name,
  4.   version,
  5. };

这样我们就可以动态获取版本号了

  1. const program = require('commander');
  2. const { version } = require('./utils/constants');
  3. program.version(version)
  4.   .parse(process.argv);

3.2 配置指令命令

根据我们想要实现的功能配置执行动作，遍历产生对应的命令

  1. const actionsMap = {
  2.   create: { // 创建模板
  3.     description: 'create project',
  4.     alias: 'cr',
  5.     examples: [
  6.       'quick-cli create <template-name>',
  7.     ],
  8.   },
  9.   config: { // 配置配置文件
  10.     description: 'config info',
  11.     alias: 'c',
  12.     examples: [
  13.       'quick-cli config get <k>',
  14.       'quick-cli config set <k> <v>',
  15.     ],
  16.   },
  17.   '*': {
  18.     description: 'command not found',
  19.   },
  20. };
  21. // 循环创建命令
  22. Object.keys(actionsMap).forEach((action) => {
  23.   program
  24.     .command(action) // 命令的名称
  25.     .alias(actionsMap[action].alias) // 命令的别名
  26.     .description(actionsMap[action].description) // 命令的描述
  27.     .action(() => { // 动作
  28.       console.log(action);
  29.     });
  30. });
  31. program.version(version)
  32.   .parse(process.argv);

3.3 编写help命令

监听 help 命令打印帮助信息

  1. program.on('--help', () => {
  2.   console.log('Examples');
  3.   Object.keys(actionsMap).forEach((action) => {
  4.     (actionsMap[action].examples || []).forEach((example) => {
  5.       console.log(`${example}`);
  6.     });
  7.   });
  8. });
  9. 复制代码

到现在我们已经把命令行配置的很棒啦，接下来就开始实现对应的功能！

4.create命令

create命令的主要作用就是去git仓库中拉取模板并下载对应的版本到本地，如果有模板则根据用户填写的信息渲染好模板，生成到当前运行命令的目录下~

  1. action(() => { // 动作
  2.   if (action === '*') { // 如果动作没匹配到说明输入有误
  3.     console.log(acitonMap[action].description);
  4.   } else { // 引用对应的动作文件 将参数传入
  5.     require(path.resolve(__dirname, action))(...process.argv.slice(3));
  6.   }
  7. }

根据不同的动作，动态引入对应模块的文件

创建create.js

  1. // 创建项目
  2. module.exports = async (projectName) => {
  3.   console.log(projectName);
  4. };

执行quick-cli create project,可以打印出 project

4.1 拉取项目

我们需要获取仓库中的所有模板信息，我的模板全部放在了git上，这里就以git为例，我通过axios去获取相关的信息～～～

  1. npm i axios

这里借助下github的 api

  1. const axios = require('axios');
  2. // 1).获取仓库列表
  3. const fetchRepoList = async () => {
  4.   // 获取当前组织中的所有仓库信息,这个仓库中存放的都是项目模板
  5.   const { data } = await axios.get('https://api.github.com/orgs/quick-cli/repos');
  6.   return data;
  7. };
  8. module.exports = async (projectName) => {
  9.   let repos = await fetchRepoList();
  10.   repos = repos.map((item) => item.name);
  11.   console.log(repos);
  12. };

发现在安装的时候体验很不好，没有任何提示，而且最终的结果我希望是可以供用户选择的！

4.2 inquirer & ora

我们来解决上面提到的问题

  1. npm i inquirer ora
  1. module.exports = async (projectName) => {
  2.   const spinner = ora('fetching repo list');
  3.   spinner.start(); // 开始loading
  4.   let repos = await fetchRepoList();
  5.   spinner.succeed(); // 结束loading
  6.   // 选择模板
  7.   repos = repos.map((item) => item.name);
  8.   const { repo } = await Inquirer.prompt({
  9.     name: 'repo',
  10.     type: 'list',
  11.     message: 'please choice repo template to create project',
  12.     choices: repos, // 选择模式
  13.   });
  14.   console.log(repo);
  15. };
  16. 复制代码

我们看到的命令行中选择的功能基本都是基于inquirer实现的，可以实现不同的询问方式。

4.3 获取版本信息

和获取模板一样，我们可以故技重施

  1. const fetchTagList = async (repo) => {
  2.   const { data } = await axios.get(`https://api.github.com/repos/quick-cli/${repo}/tags`);
  3.   return data;
  4. };
  5. // 获取版本信息
  6. spinner = ora('fetching repo tags');
  7. spinner.start();
  8. let tags = await fetchTagList(repo);
  9. spinner.succeed(); // 结束loading
  10. // 选择版本
  11. tags = tags.map((item) => item.name);
  12. const { tag } = await Inquirer.prompt({
  13.   name: 'tag',
  14.   type: 'list',
  15.   message: 'please choice repo template to create project',
  16.   choices: tags,
  17. });
  18. 复制代码

我们发现每次都需要去开启 loading、关闭 loading，重复的代码当然不能放过啦！我们来简单的封装下：

  1. const wrapFetchAddLoding = (fn, message) => async (...args) => {
  2.   const spinner = ora(message);
  3.   spinner.start(); // 开始loading
  4.   const r = await fn(...args);
  5.   spinner.succeed(); // 结束loading
  6.   return r;
  7. };
  8. // 这回用起来舒心多了～～～
  9. let repos = await wrapFetchAddLoding(fetchRepoList, 'fetching repo list')();
  10. let tags = await wrapFetchAddLoding(fetchTagList, 'fetching tag list')(repo);

4.4 下载项目

我们已经成功获取到了项目模板名称和对应的版本，那我们就可以直接下载啦！

  1. npm i download-git-repo

很遗憾的是这个方法不是promise方法，没关系我们自己包装一下：

  1. const { promisify } = require('util');
  2. const downLoadGit = require('download-git-repo');
  3. downLoadGit = promisify(downLoadGit);

node 中已经帮你提供了一个现成的方法，将异步的 api 可以快速转化成 promise 的形式～
下载前先找个临时目录来存放下载的文件，来～我们继续配置常量：

  1. const downloadDirectory = `${process.env[process.platform === 'darwin' ? 'HOME' : 'USERPROFILE']}/.template`;

这里我们将文件下载到当前用户下的.template文件中，由于系统的不同目录获取方式不一样，process.platform 在 windows 下获取的是 win32 ，我这里是 mac 所以获取的值是 darwin，再根据对应的环境变量获取到用户目录

  1. const download = async (repo, tag) => {
  2.   let api = `quick-cli/${repo}`; // 下载项目
  3.   if (tag) {
  4.     api += `#${tag}`;
  5.   }
  6.   const dest = `${downloadDirectory}/${repo}`; // 将模板下载到对应的目录中
  7.   await downLoadGit(api, dest);
  8.   return dest; // 返回下载目录
  9. };
  10. // 下载项目
  11. const target = await wrapFetchAddLoding(download, 'download template')(repo, tag);

如果对于简单的项目可以直接把下载好的项目拷贝到当前执行命令的目录下即可。
安装ncp可以实现文件的拷贝功能：

  1. npm i ncp

像这样:

  1. let ncp = require('ncp'); 
  2. ncp = promisify(ncp);
  3. // 将下载的文件拷贝到当前执行命令的目录下
  4. await ncp(target, path.join(path.resolve(), projectName));

当然这里可以做的更严谨一些，判断一下当前目录下是否有重名文件等…，还有很多细节也需要考虑像多次创建项目是否要利用已经下载好的模板，大家可以自由的发挥～

4.5 模板编译

刚才说的是简单文件，那当然直接拷贝就好了，但是有的时候用户可以定制下载模板中的内容，拿package.json文件为例，用户可以根据提示给项目命名、设置描述等。
这里我在项目模板中增加了ask.js

  1. module.exports = [
  2.     {
  3.       type: 'confirm',
  4.       name: 'private',
  5.       message: 'ths resgistery is private?',
  6.     },
  7.     ...
  8. ]

根据对应的询问生成最终的package.json
下载的模板中使用了ejs模板

  1. {
  2.   "name": "vue-template",
  3.   "version": "0.1.2",
  4.   "private": "<%=private%>",
  5.   "scripts": {
  6.     "serve": "vue-cli-service serve",
  7.     "build": "vue-cli-service build"
  8.   },
  9.   "dependencies": {
  10.     "vue": "^2.6.10"
  11.   },
  12.   "autor":"<%=author%>",
  13.   "description": "<%=description%>",
  14.   "devDependencies": {
  15.     "@vue/cli-service": "^3.11.0",
  16.     "vue-template-compiler": "^2.6.10"
  17.   },
  18.   "license": "<%=license%>"
  19. }
  20. 复制代码

写到这里，大家应该想到了！核心原理就是将下载的模板文件，依次遍历根据用户填写的信息渲染模板，将渲染好的结果拷贝到执行命令的目录下

安装需要用到的模块

  1. npm i metalsmith ejs consolidate
  1. const MetalSmith = require('metalsmith'); // 遍历文件夹
  2. let { render } = require('consolidate').ejs;
  3. render = promisify(render); // 包装渲染方法
  4. // 没有ask文件说明不需要编译
  5. if (!fs.existsSync(path.join(target, 'ask.js'))) {
  6.   await ncp(target, path.join(path.resolve(), projectName));
  7. } else {
  8.   await new Promise((resovle, reject) => {
  9.     MetalSmith(__dirname)
  10.       .source(target) // 遍历下载的目录
  11.       .destination(path.join(path.resolve(), projectName)) // 输出渲染后的结果
  12.       .use(async (files, metal, done) => {
  13.         // 弹框询问用户
  14.         const result = await Inquirer.prompt(require(path.join(target, 'ask.js')));
  15.         const data = metal.metadata();
  16.         Object.assign(data, result); // 将询问的结果放到metadata中保证在下一个中间件中可以获取到
  17.         delete files['ask.js'];
  18.         done();
  19.       })
  20.       .use((files, metal, done) => {
  21.         Reflect.ownKeys(files).forEach(async (file) => {
  22.           let content = files[file].contents.toString(); // 获取文件中的内容
  23.           if (file.includes('.js') || file.includes('.json')) { // 如果是js或者json才有可能是模板
  24.             if (content.includes('<%')) { // 文件中用<% 我才需要编译
  25.               content = await render(content, metal.metadata()); // 用数据渲染模板
  26.               files[file].contents = Buffer.from(content); // 渲染好的结果替换即可
  27.             }
  28.           }
  29.         });
  30.         done();
  31.       })
  32.       .build((err) => { // 执行中间件
  33.         if (!err) {
  34.           resovle();
  35.         } else {
  36.           reject();
  37.         }
  38.       });
  39.   });
  40. }
  41. 复制代码

这里的逻辑就是像上面描述的那样，实现了模板替换，到此安装项目的功能就完成了！我们发现这里所有用到的地址路径都写死了，但是我们希望这是一个更通用的脚手架，可以让用户自己随意配置拉取地址～

5.config命令

新建 config.js 的主要作用其实就是配置文件的读写操作，当然如果配置文件不存在，需要提供默认的值，我们先来编写常量：
constants.js的配置

  1. const configFile = `${process.env[process.platform === 'darwin' ? 'HOME' : 'USERPROFILE']}/.quickrc`; // 配置文件的存储位置
  2. const defaultConfig = {
  3.   repo: 'quick-cli', // 默认拉取的仓库名
  4. };

编写config.js

  1. const fs = require('fs');
  2. const { defaultConfig, configFile } = require('./util/constants');
  3. module.exports = (action, k, v) => {
  4.   if (action === 'get') {
  5.     console.log('获取');
  6.   } else if (action === 'set') {
  7.     console.log('设置');
  8.   }
  9.   // ...
  10. };

一般rc类型的配置文件都是ini格式也就是:

  1. repo=quick-cli
  2. register=github

下载 ini 模块解析配置文件

  1. npm i ini

这里的代码很简单，无非就是文件操作了：

  1. const fs = require('fs');
  2. const { encode, decode } = require('ini');
  3. const { defaultConfig, configFile } = require('./util/constants');
  4. const fs = require('fs');
  5. const { encode, decode } = require('ini');
  6. const { defaultConfig, configFile } = require('./util/constants');
  7. module.exports = (action, k, v) => {
  8.   const flag = fs.existsSync(configFile);
  9.   const obj = {};
  10.   if (flag) { // 配置文件存在
  11.     const content = fs.readFileSync(configFile, 'utf8');
  12.     const c = decode(content); // 将文件解析成对象
  13.     Object.assign(obj, c);
  14.   }
  15.   if (action === 'get') {
  16.     console.log(obj[k] || defaultConfig[k]);
  17.   } else if (action === 'set') {
  18.     obj[k] = v;
  19.     fs.writeFileSync(configFile, encode(obj)); // 将内容转化ini格式写入到字符串中
  20.     console.log(`${k}=${v}`);
  21.   } else if (action === 'getVal') { 
  22.     return obj[k];
  23.   }
  24. };
  25. 复制代码

getVal这个方法是为了在执行 create 命令时可以获取到配置变量

  1. const config = require('./config');
  2. const repoUrl = config('getVal', 'repo');

这样我们可以将 create 方法中所有的quick-cli全部用获取到的值替换掉啦！
到此基本核心的方法已经 ok！剩下的大家可以自行扩展啦！

6.项目发布

终于走到最后一步，我们将项目推送到npm上,流程不再赘述啦！

  1. nrm use npm
  2. npm publish # 已经发布成功～～

可以通过npm install quick-cli -g 进行安装！