背景

某年某月的某一天，同事A提交新功能，同时包含新功能所用到的依赖修改一并提交到仓库中。这时，同事b在不知情的情况下，同步了更新，并直接快乐的敲下了启动命令yarn dev，之后当然就是构建失败。

在上述背景下，同事b决定作出一个工具来解决这时候的尴尬

需求分析

• 在每次运行某个脚本之前，先行检查库是否更新，通过后再运行后面的脚本
  实现思路：

在每个脚本前，放置检查脚本，例如：

{
 "scripts": {
   "dev": "node util/checkDependency.js && webpack-dev-server --open --config xxx"
 }
}

• 用户在没有初始化的时候运行了脚本，需要帮助用户初始化
  实现思路：

1. 先检查项目node_modules是否存在，不存在，则直接运行初始化脚本，并缓存当前package.json
2. 再检查是否存在缓存的package.json文件，不存在也视为版本有差异，初始化后缓存
3. 如果缓存的package.json存在，则检查其中的devDependencies和dependencies每项是否一致，并且keys都能对应得上。否则初始化，并更新缓存

实现代码

由于是ts实现，写完后需要先用tsc编译成js方可

import * as fs from 'fs'
import * as path from 'path'
import { spawn } from 'child_process';

function updateLib() {
  const cmd_yarn = 'yarn -i';//优先运行yarn -i
  const cmd_npm = 'npm install'// 如果上面的运行失败了，再降级运行这行
  spawn(cmd_yarn, {
    stdio: 'inherit',
    shell: true
  }).addListener('exit', (code) => {
    if (code !== 0) {
      spawn(cmd_npm, {
        stdio: 'inherit',
        shell: true
      })
    }
  })
}

(function () {
  const packagePath = path.resolve(__dirname, '../../package.json');//原始package.json路径
  const catchPath = path.resolve(__dirname, '../../.catch');//缓存的package.json路径
  const node_modulesPath = path.resolve(__dirname, '../../node_modules');
  const packageCatchPath = catchPath + '/package.json.catch';
  let packageJson: PackageJson;

//缓存功能实现函数
  function writeCatch() {
    try {
      fs.writeFileSync(packageCatchPath, JSON.stringify(packageJson, null, ""))
    } catch (error) {
      console.error('package.json缓存文件写入失败')
    }
  }

  try {
    packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
  } catch (error) {
    throw '包文件读取错误!'
  }

  if (!fs.existsSync(catchPath) || !fs.existsSync(node_modulesPath)) {
    if (!fs.existsSync(catchPath)) fs.mkdirSync(catchPath);
    updateLib();
    writeCatch();
  }
  else if (!fs.existsSync(packageCatchPath)) {
    updateLib();
    writeCatch();
  }
  else {
    try {
      const packageCatchJson: PackageJson = JSON.parse(fs.readFileSync(packageCatchPath, 'utf-8'));
      const packageCatchLibs = { ...packageCatchJson.dependencies, ...packageCatchJson.devDependencies };
      const packageLibs = { ...packageJson.devDependencies, ...packageJson.dependencies };
      const pcjks = Object.keys(packageCatchLibs);
      const pjksStack = Object.keys(packageLibs);
      let check = true;
//对比对应key的value（也就是版本）是否相同，一旦不相同，就更新它
      while (pjksStack.length) {
        const lib = pjksStack.pop();
        if (!packageCatchLibs[lib] || packageCatchLibs[lib] !== packageLibs[lib]) {
          console.log(`update lib[${lib}] => { package: ${packageLibs[lib]}, packageCatch: ${packageCatchLibs[lib]}}`)
          check = false;
          break;
        }

        pcjks.splice(pcjks.indexOf(lib), 1);
      }

      if (!check || pcjks.length) {
        console.log('检查到package依赖库有更新，正在执行更新操作......')
        updateLib();
        writeCatch();
      }
    } catch (error) {
      throw `缓存文件格式错误，请删除[${packageCatchPath}]后再试`
    }
  }

  console.log('依赖检查完毕')
})()


export interface PackageJson {
  name: string,
  version: string,
  license: string,
  scripts: {
    [shell: string]: string;
  },
  devDependencies: {
    [lib: string]: string;
  },
  dependencies: {
    [lib: string]: string;
  }
}