Vue CLI 是如何實現的 -- 終端命令行工具篇

1npm install -g @vue/cli
2vue create vue-cli-test
3
4

 1用法：create [options] <app-name>
 2
 3選項：
 4  -p, --preset <presetName>       忽略提示符並使用已保存的或遠程的預設選項
 5  -d, --default                   忽略提示符並使用默認預設選項
 6  -i, --inlinePreset <json>       忽略提示符並使用內聯的 JSON 字符串預設選項
 7  -m, --packageManager <command>  在安裝依賴時使用指定的 npm 客戶端
 8  -r, --registry <url>            在安裝依賴時使用指定的 npm registry
 9  -g, --git [message]             強制 / 跳過 git 初始化，並可選的指定初始化提交信息
10  -n, --no-git                    跳過 git 初始化
11  -f, --force                     覆寫目標目錄可能存在的配置
12  -c, --clone                     使用 git clone 獲取遠程預設選項
13  -x, --proxy                     使用指定的代理創建項目
14  -b, --bare                      創建項目時省略默認組件中的新手指導信息
15  -h, --help                      輸出使用幫助信息
16

1{
2  "bin": {
3    "vue": "bin/vue.js"
4  }
5}
6
7

 1// 檢查 node 版本
 2checkNodeVersion(requiredVersion, '@vue/cli');
 3
 4// 掛載 create 命令
 5program.command('create <app-name>').action((name, cmd) => {
 6  // 獲取額外參數
 7  const options = cleanArgs(cmd);
 8  // 執行 create 方法
 9  require('../lib/create')(name, options);
10});
11

 1const leven = require('leven');
 2
 3// 如果不是當前已掛載的命令，會猜測用戶意圖
 4program.arguments('<command>').action(cmd => {
 5  suggestCommands(cmd);
 6});
 7
 8// 猜測用戶意圖
 9function suggestCommands(unknownCommand) {
10  const availableCommands = program.commands.map(cmd => cmd._name);
11
12  let suggestion;
13
14  availableCommands.forEach(cmd => {
15    const isBestMatch =
16      leven(cmd, unknownCommand) < leven(suggestion || '', unknownCommand);
17    if (leven(cmd, unknownCommand) < 3 && isBestMatch) {
18      suggestion = cmd;
19    }
20  });
21
22  if (suggestion) {
23    console.log(`  ` + chalk.red(`Did you mean ${chalk.yellow(suggestion)}?`));
24  }
25}
26

 1const EOL_NODE_MAJORS = ['8.x', '9.x', '11.x', '13.x'];
 2for (const major of EOL_NODE_MAJORS) {
 3  if (semver.satisfies(process.version, major)) {
 4    console.log(
 5      chalk.red(
 6        `You are using Node ${process.version}.\n` +
 7          `Node.js ${major} has already reached end-of-life and will not be supported in future major releases.\n` +
 8          `It's strongly recommended to use an active LTS version instead.`
 9      )
10    );
11  }
12}
13
14

 1async function create(projectName, options) {
 2  // 判斷傳入的 projectName 是否是 .
 3  const inCurrent = projectName === '.';
 4  // path.relative 會返回第一個參數到第二個參數的相對路徑
 5  // 這裏就是用來獲取當前目錄的目錄名
 6  const name = inCurrent ? path.relative('../', cwd) : projectName;
 7  // 最終初始化項目的路徑
 8  const targetDir = path.resolve(cwd, projectName || '.');
 9}
10
11

1const result = validateProjectName(name);
2if (!result.validForNewPackages) {
3  console.error(chalk.red(`Invalid project name: "${name}"`));
4  exit(1);
5}
6
7

 1// 是否 vue create -m
 2if (fs.existsSync(targetDir) && !options.merge) {
 3  // 是否 vue create -f
 4  if (options.force) {
 5    await fs.remove(targetDir);
 6  } else {
 7    await clearConsole();
 8    // 如果是初始化在當前路徑，就只是確認一下是否在當前目錄創建
 9    if (inCurrent) {
10      const { ok } = await inquirer.prompt([
11        {
12          name: 'ok',
13          type: 'confirm',
14          message: `Generate project in current directory?`,
15        },
16      ]);
17      if (!ok) {
18        return;
19      }
20    } else {
21      // 如果有目標目錄，則詢問如何處理：Overwrite / Merge / Cancel
22      const { action } = await inquirer.prompt([
23        {
24          name: 'action',
25          type: 'list',
26          message: `Target directory ${chalk.cyan(
27            targetDir
28          )} already exists. Pick an action:`,
29          choices: [
30            { name: 'Overwrite', value: 'overwrite' },
31            { name: 'Merge', value: 'merge' },
32            { name: 'Cancel', value: false },
33          ],
34        },
35      ]);
36      // 如果選擇 Cancel，則直接中止
37      // 如果選擇 Overwrite，則先刪除原目錄
38      // 如果選擇 Merge，不用預處理啥
39      if (!action) {
40        return;
41      } else if (action === 'overwrite') {
42        console.log(`\nRemoving ${chalk.cyan(targetDir)}...`);
43        await fs.remove(targetDir);
44      }
45    }
46  }
47}
48
49

 1module.exports = (...args) => {
 2  return create(...args).catch(err => {
 3    stopSpinner(false); // do not persist
 4    error(err);
 5    if (!process.env.VUE_CLI_TEST) {
 6      process.exit(1);
 7    }
 8  });
 9};
10
11

1const creator = new Creator(name, targetDir, getPromptModules());
2await creator.create(options);
3
4

 1module.exports = class Creator extends EventEmitter {
 2  constructor(name, context, promptModules) {
 3    super();
 4
 5    this.name = name;
 6    this.context = process.env.VUE_CLI_CONTEXT = context;
 7    // 獲取了 preset 和 feature 的 交互選擇列表，在 vue create 的時候提供選擇
 8    const { presetPrompt, featurePrompt } = this.resolveIntroPrompts();
 9    this.presetPrompt = presetPrompt;
10    this.featurePrompt = featurePrompt;
11
12    // 交互選擇列表：是否輸出一些文件
13    this.outroPrompts = this.resolveOutroPrompts();
14
15    this.injectedPrompts = [];
16    this.promptCompleteCbs = [];
17    this.afterInvokeCbs = [];
18    this.afterAnyInvokeCbs = [];
19
20    this.run = this.run.bind(this);
21
22    const promptAPI = new PromptModuleAPI(this);
23    // 將默認的一些配置注入到交互列表中
24    promptModules.forEach(m => m(promptAPI));
25  }
26};
27

 1module.exports = class PromptModuleAPI {
 2  constructor(creator) {
 3    this.creator = creator;
 4  }
 5  // 在 promptModules 裏用
 6  injectFeature(feature) {
 7    this.creator.featurePrompt.choices.push(feature);
 8  }
 9  // 在 promptModules 裏用
10  injectPrompt(prompt) {
11    this.creator.injectedPrompts.push(prompt);
12  }
13  // 在 promptModules 裏用
14  injectOptionForPrompt(name, option) {
15    this.creator.injectedPrompts
16      .find(f => {
17        return f.name === name;
18      })
19      .choices.push(option);
20  }
21  // 在 promptModules 裏用
22  onPromptComplete(cb) {
23    this.creator.promptCompleteCbs.push(cb);
24  }
25};
26
27

1this.promptCompleteCbs.forEach(cb => cb(answers, preset));
2
3

1module.exports = class Creator extends EventEmitter {
2  constructor(name, context, promptModules) {
3    const promptAPI = new PromptModuleAPI(this);
4    promptModules.forEach(m => m(promptAPI));
5  }
6};
7
8

 1this.emit('creation', { event: 'creating' }); // 創建
 2this.emit('creation', { event: 'git-init' }); // 初始化 git
 3this.emit('creation', { event: 'plugins-install' }); // 安裝插件
 4this.emit('creation', { event: 'invoking-generators' }); // 調用 generator
 5this.emit('creation', { event: 'deps-install' }); // 安裝額外的依賴
 6this.emit('creation', { event: 'completion-hooks' }); // 完成之後的回調
 7this.emit('creation', { event: 'done' }); // create 流程結束
 8this.emit('creation', { event: 'fetch-remote-preset' }); // 拉取遠程 preset
 9
10

1const creator = new Creator('', cwd.get(), getPromptModules());
2onCreationEvent = ({ event }) => {
3  progress.set({ id: PROGRESS_ID, status: event, info: null }, context);
4};
5creator.on('creation', onCreationEvent);
6
7

 1{
 2  "useConfigFiles": true,
 3  "cssPreprocessor": "sass",
 4  "plugins": {
 5    "@vue/cli-plugin-babel": {},
 6    "@vue/cli-plugin-eslint": {
 7      "config": "airbnb",
 8      "lintOn": ["save", "commit"]
 9    }
10  },
11  "configs": {
12    "vue": {...},
13    "postcss": {...},
14    "eslintConfig": {...},
15    "jest": {...}
16  }
17}
18
19

 1exports.getPromptModules = () => {
 2  return [
 3    'vueVersion',
 4    'babel',
 5    'typescript',
 6    'pwa',
 7    'router',
 8    'vuex',
 9    'cssPreprocessors',
10    'linter',
11    'unit',
12    'e2e',
13  ].map(file => require(`../promptModules/${file}`));
14};
15
16

 1module.exports = cli => {
 2  cli.injectFeature({
 3    name: '',
 4    value: '',
 5    short: '',
 6    description: '',
 7    link: '',
 8    checked: true,
 9  });
10
11  cli.injectPrompt({
12    name: '',
13    when: answers => answers.features.includes(''),
14    message: '',
15    type: 'list',
16    choices: [],
17    default: '2',
18  });
19
20  cli.onPromptComplete((answers, options) => {});
21};
22

 1// Creator.js
 2module.exports = class Creator extends EventEmitter {
 3  async create(cliOptions = {}, preset = null) {
 4    const isTestOrDebug = process.env.VUE_CLI_TEST || process.env.VUE_CLI_DEBUG;
 5    const { run, name, context, afterInvokeCbs, afterAnyInvokeCbs } = this;
 6
 7    if (!preset) {
 8      if (cliOptions.preset) {
 9        // vue create foo --preset bar
10        preset = await this.resolvePreset(cliOptions.preset, cliOptions.clone);
11      } else if (cliOptions.default) {
12        // vue create foo --default
13        preset = defaults.presets.default;
14      } else if (cliOptions.inlinePreset) {
15        // vue create foo --inlinePreset {...}
16        try {
17          preset = JSON.parse(cliOptions.inlinePreset);
18        } catch (e) {
19          error(
20            `CLI inline preset is not valid JSON: ${cliOptions.inlinePreset}`
21          );
22          exit(1);
23        }
24      } else {
25        preset = await this.promptAndResolvePreset();
26      }
27    }
28  }
29};
30

 1 async promptAndResolvePreset(answers = null) {
 2    // prompt
 3    if (!answers) {
 4      await clearConsole(true);
 5      answers = await inquirer.prompt(this.resolveFinalPrompts());
 6    }
 7    debug("vue-cli:answers")(answers);
 8 }
 9
10 resolveFinalPrompts() {
11    this.injectedPrompts.forEach((prompt) => {
12      const originalWhen = prompt.when || (() => true);
13      prompt.when = (answers) => {
14        return isManualMode(answers) && originalWhen(answers);
15      };
16    });
17
18    const prompts = [
19      this.presetPrompt,
20      this.featurePrompt,
21      ...this.injectedPrompts,
22      ...this.outroPrompts,
23    ];
24    debug("vue-cli:prompts")(prompts);
25    return prompts;
26 }
27

 1async promptAndResolvePreset(answers = null)  {
 2  if (
 3    answers.save &&
 4    answers.saveName &&
 5    savePreset(answers.saveName, preset)
 6  ) {
 7    log();
 8    log(
 9      `🎉  Preset ${chalk.yellow(answers.saveName)} saved in ${chalk.yellow(
10        rcPath
11      )}`
12    );
13  }
14}
15
16

 1exports.saveOptions = toSave => {
 2  const options = Object.assign(cloneDeep(exports.loadOptions()), toSave);
 3  for (const key in options) {
 4    if (!(key in exports.defaults)) {
 5      delete options[key];
 6    }
 7  }
 8  cachedOptions = options;
 9  try {
10    fs.writeFileSync(rcPath, JSON.stringify(options, null, 2));
11    return true;
12  } catch (e) {
13    error(
14      `Error saving preferences: ` +
15        `make sure you have write access to ${rcPath}.\n` +
16        `(${e.message})`
17    );
18  }
19};
20
21exports.savePreset = (name, preset) => {
22  const presets = cloneDeep(exports.loadOptions().presets || {});
23  presets[name] = preset;
24  return exports.saveOptions({ presets });
25};
26

 1const isManualMode = answers => answers.preset === '__manual__';
 2
 3const featurePrompt = {
 4  name: 'features',
 5  when: isManualMode,
 6  type: 'checkbox',
 7  message: 'Check the features needed for your project:',
 8  choices: [],
 9  pageSize: 10,
10};
11

 1cli.injectPrompt({
 2  name: 'vueVersion',
 3  when: answers => answers.features.includes('vueVersion'),
 4  message: 'Choose a version of Vue.js that you want to start the project with',
 5  type: 'list',
 6  choices: [
 7    {
 8      name: '2.x',
 9      value: '2',
10    },
11    {
12      name: '3.x (Preview)',
13      value: '3',
14    },
15  ],
16  default: '2',
17});
18
19

 1{
 2  "name": "a",
 3  "version": "0.1.0",
 4  "private": true,
 5  "devDependencies": {
 6    "@vue/cli-plugin-babel": "~4.5.0",
 7    "@vue/cli-plugin-eslint": "~4.5.0",
 8    "@vue/cli-service": "~4.5.0"
 9  }
10}
11
12

1await run('git init');
2
3

 1shouldInitGit(cliOptions) {
 2  // 如果全局沒安裝 Git，則不初始化
 3  if (!hasGit()) {
 4    return false;
 5  }
 6  // 如果 CLI 有傳入 --git 參數，則初始化
 7  if (cliOptions.forceGit) {
 8    return true;
 9  }
10  // 如果 CLI 有傳入 --no-git，則不初始化
11  if (cliOptions.git === false || cliOptions.git === "false") {
12    return false;
13  }
14  // 如果當前目錄下已經有 Git 環境，就不初始化
15  return !hasProjectGit(this.context);
16}
17
18

 1function generateReadme(pkg, packageManager) {
 2  return [
 3    `# ${pkg.name}\n`,
 4    '## Project setup',
 5    '```',
 6    `${packageManager} install`,
 7    '```',
 8    printScripts(pkg, packageManager),
 9    '### Customize configuration',
10    'See [Configuration Reference](https://cli.vuejs.org/config/).',
11    '',
12  ].join('\n');
13}
14
15

 1const descriptions = {
 2  build: 'Compiles and minifies for production',
 3  serve: 'Compiles and hot-reloads for development',
 4  lint: 'Lints and fixes files',
 5  'test:e2e': 'Run your end-to-end tests',
 6  'test:unit': 'Run your unit tests',
 7};
 8
 9function printScripts(pkg, packageManager) {
10  return Object.keys(pkg.scripts || {})
11    .map(key => {
12      if (!descriptions[key]) return '';
13      return [
14        `\n### ${descriptions[key]}`,
15        '```',
16        `${packageManager} ${packageManager !== 'yarn' ? 'run ' : ''}${key}`,
17        '```',
18        '',
19      ].join('\n');
20    })
21    .join('');
22}
23

 1 async install () {
 2   if (this.needsNpmInstallFix) {
 3     // 讀取 package.json
 4     const pkg = resolvePkg(this.context)
 5     // 安裝 dependencies
 6     if (pkg.dependencies) {
 7       const deps = Object.entries(pkg.dependencies).map(([dep, range]) => `${dep}@${range}`)
 8       await this.runCommand('install', deps)
 9     }
10     // 安裝 devDependencies
11     if (pkg.devDependencies) {
12       const devDeps = Object.entries(pkg.devDependencies).map(([dep, range]) => `${dep}@${range}`)
13       await this.runCommand('install', [...devDeps, '--save-dev'])
14     }
15     // 安裝 optionalDependencies
16     if (pkg.optionalDependencies) {
17       const devDeps = Object.entries(pkg.devDependencies).map(([dep, range]) => `${dep}@${range}`)
18       await this.runCommand('install', [...devDeps, '--save-optional'])
19     }
20     return
21   }
22   return await this.runCommand('install', this.needsPeerDepsFix ? ['--legacy-peer-deps'] : [])
23 }
24
25

 1function shouldUseTaobao() {
 2  let faster
 3  try {
 4    faster = await Promise.race([
 5      ping(defaultRegistry),
 6      ping(registries.taobao)
 7    ])
 8  } catch (e) {
 9    return save(false)
10  }
11
12  if (faster !== registries.taobao) {
13    // default is already faster
14    return save(false)
15  }
16
17  const { useTaobaoRegistry } = await inquirer.prompt([
18    {
19      name: 'useTaobaoRegistry',
20      type: 'confirm',
21      message: chalk.yellow(
22        ` Your connection to the default ${command} registry seems to be slow.\n` +
23          `   Use ${chalk.cyan(registries.taobao)} for faster installation?`
24      )
25    }
26  ])
27  return save(useTaobaoRegistry);
28}
29

 1async initPlugins () {
 2  for (const id of this.allPluginIds) {
 3    const api = new GeneratorAPI(id, this, {}, rootOptions)
 4    const pluginGenerator = loadModule(`${id}/generator`, this.context)
 5
 6    if (pluginGenerator && pluginGenerator.hooks) {
 7      await pluginGenerator.hooks(api, {}, rootOptions, pluginIds)
 8    }
 9  }
10}
11

 1module.exports = api => {
 2  delete api.generator.files['babel.config.js'];
 3
 4  api.extendPackage({
 5    babel: {
 6      presets: ['@vue/cli-plugin-babel/preset'],
 7    },
 8    dependencies: {
 9      'core-js': '^3.6.5',
10    },
11  });
12};
13

 1// GeneratorAPI.js
 2// 刪減部分代碼，只針對 @vue/cli-plugin-babel 分析
 3extendPackage (fields, options = {}) {
 4  const pkg = this.generator.pkg
 5  const toMerge = isFunction(fields) ? fields(pkg) : fields
 6  // 遍歷傳入的參數，這裏是 babel 和 dependencies 兩個對象
 7  for (const key in toMerge) {
 8    const value = toMerge[key]
 9    const existing = pkg[key]
10    // 如果 key 的名稱是 dependencies 和 devDependencies
11    // 就通過 mergeDeps 方法往 package.json 合併依賴
12    if (isObject(value) && (key === 'dependencies' || key === 'devDependencies')) {
13      pkg[key] = mergeDeps(
14        this.id,
15        existing || {},
16        value,
17        this.generator.depSources,
18        extendOptions
19      )
20    } else if (!extendOptions.merge || !(key in pkg)) {
21      pkg[key] = value
22    }
23  }
24}
25
26

 1{
 2  "babel": {
 3    "presets": ["@vue/cli-plugin-babel/preset"]
 4  },
 5  "dependencies": {
 6    "core-js": "^3.6.5"
 7  },
 8  "devDependencies": {},
 9  "name": "test",
10  "private": true,
11  "version": "0.1.0"
12}
13
14

1api.render('./template', {
2  doesCompile: api.hasPlugin('babel') || api.hasPlugin('typescript'),
3});
4
5

 1if (options.vueVersion === '3') {
 2  api.extendPackage({
 3    dependencies: {
 4      vue: '^3.0.0',
 5    },
 6    devDependencies: {
 7      '@vue/compiler-sfc': '^3.0.0',
 8    },
 9  });
10} else {
11  api.extendPackage({
12    dependencies: {
13      vue: '^2.6.11',
14    },
15    devDependencies: {
16      'vue-template-compiler': '^2.6.11',
17    },
18  });
19}
20
21

1api.extendPackage({
2  scripts: {
3    serve: 'vue-cli-service serve',
4    build: 'vue-cli-service build',
5  },
6  browserslist: ['> 1%', 'last 2 versions', 'not dead'],
7});
8
9

 1if (options.cssPreprocessor) {
 2  const deps = {
 3    sass: {
 4      sass: '^1.26.5',
 5      'sass-loader': '^8.0.2',
 6    },
 7    'node-sass': {
 8      'node-sass': '^4.12.0',
 9      'sass-loader': '^8.0.2',
10    },
11    'dart-sass': {
12      sass: '^1.26.5',
13      'sass-loader': '^8.0.2',
14    },
15    less: {
16      less: '^3.0.4',
17      'less-loader': '^5.0.0',
18    },
19    stylus: {
20      stylus: '^0.54.7',
21      'stylus-loader': '^3.0.2',
22    },
23  };
24
25  api.extendPackage({
26    devDependencies: deps[options.cssPreprocessor],
27  });
28}
29

 1// for v3 compatibility
 2if (options.router && !api.hasPlugin('router')) {
 3  require('./router')(api, options, options);
 4}
 5
 6// for v3 compatibility
 7if (options.vuex && !api.hasPlugin('vuex')) {
 8  require('./vuex')(api, options, options);
 9}
10

 1extractConfigFiles(extractAll, checkExisting) {
 2  const configTransforms = Object.assign(
 3    {},
 4    defaultConfigTransforms,
 5    this.configTransforms,
 6    reservedConfigTransforms
 7  );
 8  const extract = (key) => {
 9    if (
10      configTransforms[key] &&
11      this.pkg[key] &&
12      !this.originalPkg[key]
13    ) {
14      const value = this.pkg[key];
15      const configTransform = configTransforms[key];
16      const res = configTransform.transform(
17        value,
18        checkExisting,
19        this.files,
20        this.context
21      );
22      const { content, filename } = res;
23      this.files[filename] = ensureEOL(content);
24      delete this.pkg[key];
25    }
26  };
27  if (extractAll) {
28    for (const key in this.pkg) {
29      extract(key);
30    }
31  } else {
32    extract("babel");
33  }
34}
35
36

 1const program = require('commander');
 2
 3function camelize(str) {
 4  return str.replace(/-(\w)/g, (_, c) => (c ? c.toUpperCase() : ''));
 5}
 6
 7function cleanArgs(cmd) {
 8  const args = {};
 9  cmd.options.forEach(o => {
10    const key = camelize(o.long.replace(/^--/, ''));
11    // if an option is not present and Command has a method with the same name
12    // it should not be copied
13    if (typeof cmd[key] !== 'function' && typeof cmd[key] !== 'undefined') {
14      args[key] = cmd[key];
15    }
16  });
17  return args;
18}
19

 1const requiredVersion = require('../package.json').engines.node;
 2
 3function checkNodeVersion(wanted, id) {
 4  if (!semver.satisfies(process.version, wanted, { includePrerelease: true })) {
 5    console.log(
 6      chalk.red(
 7        'You are using Node ' +
 8          process.version +
 9          ', but this version of ' +
10          id +
11          ' requires Node ' +
12          wanted +
13          '.\nPlease upgrade your Node version.'
14      )
15    );
16    process.exit(1);
17  }
18}
19
20checkNodeVersion(requiredVersion, '@vue/cli');
21

 1const fs = require('fs');
 2const path = require('path');
 3
 4function getPackageJson(cwd) {
 5  const packagePath = path.join(cwd, 'package.json');
 6
 7  let packageJson;
 8  try {
 9    packageJson = fs.readFileSync(packagePath, 'utf-8');
10  } catch (err) {
11    throw new Error(`The package.json file at '${packagePath}' does not exist`);
12  }
13
14  try {
15    packageJson = JSON.parse(packageJson);
16  } catch (err) {
17    throw new Error('The package.json is malformed');
18  }
19
20  return packageJson;
21}
22

 1module.exports = function sortObject(obj, keyOrder, dontSortByUnicode) {
 2  if (!obj) return;
 3  const res = {};
 4
 5  if (keyOrder) {
 6    keyOrder.forEach(key => {
 7      if (obj.hasOwnProperty(key)) {
 8        res[key] = obj[key];
 9        delete obj[key];
10      }
11    });
12  }
13
14  const keys = Object.keys(obj);
15
16  !dontSortByUnicode && keys.sort();
17  keys.forEach(key => {
18    res[key] = obj[key];
19  });
20
21  return res;
22};
23

 1const fs = require('fs-extra');
 2const path = require('path');
 3
 4// 刪除已經存在的文件
 5function deleteRemovedFiles(directory, newFiles, previousFiles) {
 6  // get all files that are not in the new filesystem and are still existing
 7  const filesToDelete = Object.keys(previousFiles).filter(
 8    filename => !newFiles[filename]
 9  );
10
11  // delete each of these files
12  return Promise.all(
13    filesToDelete.map(filename => {
14      return fs.unlink(path.join(directory, filename));
15    })
16  );
17}
18
19// 輸出文件到硬盤
20module.exports = async function writeFileTree(dir, files, previousFiles) {
21  if (previousFiles) {
22    await deleteRemovedFiles(dir, files, previousFiles);
23  }
24  // 主要就是這裏
25  Object.keys(files).forEach(name => {
26    const filePath = path.join(dir, name);
27    fs.ensureDirSync(path.dirname(filePath));
28    fs.writeFileSync(filePath, files[name]);
29  });
30};
31

 1const hasProjectGit = cwd => {
 2  let result;
 3  try {
 4    execSync('git status', { stdio: 'ignore', cwd });
 5    result = true;
 6  } catch (e) {
 7    result = false;
 8  }
 9  return result;
10};
11
12

 1function get(target, path) {
 2  const fields = path.split('.');
 3  let obj = target;
 4  const l = fields.length;
 5  for (let i = 0; i < l - 1; i++) {
 6    const key = fields[i];
 7    if (!obj[key]) {
 8      return undefined;
 9    }
10    obj = obj[key];
11  }
12  return obj[fields[l - 1]];
13}
14