CSDN

import-local执行流程解析

2023-07-12 10:31 由 素心~ 发表于 #前端开发

import-local 概述

当本地和全局同时存在两个脚手架命令时，使用 import-local 可以优先加载本地脚手架命令

const importLocal = require("import-local");

if (importLocal(__filename)) {
  require("npmlog").info("cli", "正在使用 jinhui-cli 本地版本");
} else {
  require(".")(process.argv.slice(2));
}

以上述代码为例：执行 jinhui 命令时实际执行的应该是

node C:\Program Files\nodejs\jinhui-cli\cli.js
所以将调试程序定位到全局下的 cli 文件，进入 import-local 源码

// __filename格式化 normalizedFilename => c:\\nvm\\v14.18.0\\node_modules\\jinhui-cli\\cli.js
const normalizedFilename = filename.startsWith("file://") ? fileURLToPath(filename) : filename;

// 向上依次查找package.json文件 如果目录存在该文件则判定全局主目录 => c:\\nvm\\v14.18.0\\node_modules\\jinhui-cli
const globalDir = pkgDir.sync(path.dirname(normalizedFilename));

// 全局主目录相对于运行文件的相对路径 => cli.js
const relativePath = path.relative(globalDir, normalizedFilename);

// 获取 package.json 内容
const pkg = require(path.join(globalDir, "package.json"));

// 本地目录的node_modules下是否存在运行文件
const localFile = resolveCwd.silent(path.join(pkg.name, relativePath));

// 本地 node_modules 绝对路径
const localNodeModules = path.join(process.cwd(), "node_modules");

// 执行的文件在当前的node_modules下
// 本地目录下node_modules 与 运行文件的相对路径如果以..开头则不是同一目录下
// 下列判定为：运行文件在本地目录下 且 运行文件根目录与本地目录根目录相同
const filenameInLocalNodeModules =
  !path.relative(localNodeModules, normalizedFilename).startsWith("..") &&
  path.parse(localNodeModules).root === path.parse(normalizedFilename).root;

// 运行文件不在当前node_modules下 且 本地目录node_modules下存在该运行文件 直接执行当前node_modules下的JS文件
return (
  !filenameInLocalNodeModules && localFile && path.relative(localFile, normalizedFilename) !== "" && require(localFile)
);

pkgDir.sync 内部调用 findUp 逐级向上查找

findUp.sync("package.json", { cwd: path.dirname(normalizedFilename) });

module.exports.sync = (name, options = {}) => {
  // 相对路径转绝对路径
  let directory = path.resolve(options.cwd || "");
  // 获取目录根路径
  const { root } = path.parse(directory);
  // 所有要查找的文件名
  const filenames = [].concat(name);

  while (true) {
    // locatePath 遍历数组中的文件名在指定目录下是否存在 如果存在则将查找到的第一个文件名返回
    const file = locatePath.sync(filenames, { cwd: directory });
    if (file) {
      return path.join(directory, name);
    }

    if (directory === root) {
      return null;
    }
    // 每次遍历逐级递减目录
    directory = path.dirname(directory);
  }
};

resolveCwd.silent 内部调用 resloveFrom 查找本地目录是否可加载到指定模块 如能则返回本地模块运行文件路径

module.exports.silent = (moduleId) => resolveFrom.silent(process.cwd(), moduleId);

const resolveFrom = (fromDirectory, moduleId, silent) => {
  const fromFile = path.join(fromDirectory, "noop.js");
  const resolveFileName = () =>
    // 调用Module模块内置方法_resolveFilename 加载模块如果存在则返回文件地址
    Module._resolveFilename(moduleId, {
      id: fromFile,
      filename: fromFile,
      // 调用Module模块内置方法_nodeModulePaths 生成所有可能存在node_modules的目录数组
      paths: Module._nodeModulePaths(fromDirectory),
    });

  // silent为静默方式不抛出异常返回undefined
  if (silent) {
    try {
      return resolveFileName();
    } catch (error) {
      return;
    }
  }
  return resolveFileName();
};

_resolveFilename 文件真实路径查找逻辑

内置模块 Module._nodeModulePaths 逐级目录添加 node_modules

const nmChars = [115, 101, 108, 117, 100, 111, 109, 95, 101, 100, 111, 110];
const nmLen = nmChars.length;
Module._nodeModulePaths = function (from) {
  // 生成绝对路径
  from = path.resolve(from);
  // 如果传入路径为根路径直接返回["/node_modules"]
  if (from === "/") return ["/node_modules"];
  // 定义路径数组
  const paths = [];
  // 从最后一位开始遍历路径
  // p变量用来判断最后一项目录长度是否等于node_modules
  // last变量用来存储当前需要截取的路径长度
  for (let i = from.length - 1, p = 0, last = from.length; i >= 0; --i) {
    const code = StringPrototypeCharCodeAt(from, i);
    // 判断当前遍历位置是否为 \/字符
    if (code === "47") {
      // 如果遍历目录不是node_modules则添加node_modules
      if (p !== nmLen) ArrayPrototypePush(paths, StringPrototypeSlice(from, 0, last) + "/node_modules");
      last = i;
      p = 0;
    } else if (p !== -1) {
      // 遍历字符是否跟nmChars每个charCode相等 nmChars存放了node_modules倒序的charCode 如果相等p++
      if (nmChars[p] === code) {
        ++p;
      } else {
        p = -1;
      }
    }
  }
  // 根目录添加node_modules
  ArrayPrototypePush(paths, "/node_modules");
  return paths;
};

内置模块 Module._resolveFilename 读取文件真实路径

// 下列代码对node.js源码进行了部分删减
Module._resolveFilename = function (request, parent, isMain) {
  // 判断是否可以被加载的内置模块
  if (StringPrototypeStartsWith(request, "node:") || NativeModule.canBeRequiredByUsers(request)) {
    return request;
  }
  // 将paths和环境变量node_modules进行合并;
  const paths = Module._resolveLookupPaths(request, parent);
  // 查找路径文件
  const filename = Module._findPath(request, paths, isMain, false);
  if (filename) return filename;
};

内置模块 Module._findPath 读取文件真实路径

Module._findPath = function (request, paths, isMain) {
  // 判断是否为绝对路径
  const absoluteRequest = path.isAbsolute(request);
  // 如果为绝对路径则paths置空 如果paths不存在则返回false
  if (absoluteRequest) {
    paths = [""];
  } else if (!paths || paths.length === 0) {
    return false;
  }
  // 判断是否存在缓存如果存在返回缓存 缓存key为 模块名 + 模块path jinhui-cli/cli.js/C:/Users/xiabin
  const cacheKey = request + "\x00" + ArrayPrototypeJoin(paths, "\x00");
  // 存在缓存直接返回缓存
  const entry = Module._pathCache[cacheKey];
  if (entry) return entry;

  let exts;
  // 判断结尾是否为  \/字符
  let trailingSlash =
    request.length > 0 && StringPrototypeCharCodeAt(request, request.length - 1) === CHAR_FORWARD_SLASH;
  if (!trailingSlash) {
    // 判断结尾是否为相对路径 /.. /. .. .
    trailingSlash = RegExpPrototypeTest(trailingSlashRegex, request);
  }

  //  遍历所有path
  for (let i = 0; i < paths.length; i++) {
    // Don't search further if path doesn't exist
    const curPath = paths[i];
    // 当前path不是目录则直接跳过本次循环
    if (curPath && stat(curPath) < 1) continue;

    // 文件路径
    const basePath = path.resolve(curPath, request);
    let filename;

    const rc = stat(basePath);
    // 结尾是不是 \/ 不是相对路径
    if (!trailingSlash) {
      // basePath是否为文件
      if (rc === 0) {
        if (!isMain) {
          // 是否阻止做超链接
          if (preserveSymlinks) {
            filename = path.resolve(basePath);
          } else {
            // 将软连接转换为真实文件地址
            filename = toRealPath(basePath);
          }
          // 转绝对路径
        } else if (preserveSymlinksMain) {
          filename = path.resolve(basePath);
        } else {
          // 将软连接转换为真实文件地址
          filename = toRealPath(basePath);
        }
      }
    }

    // 文件未找到且查询路径为目录 则尝试生成文件路径
    if (!filename && rc === 1) {
      if (exts === undefined) exts = ObjectKeys(Module._extensions);
      filename = tryPackage(basePath, exts, isMain, request);
    }
    // 查询到文件真实路径将当前路径缓存 并返回真实路径
    if (filename) {
      Module._pathCache[cacheKey] = filename;
      return filename;
    }
  }

  return false;
};

内置模块 fs.realpathSync 将软连接转换为真实路径

//  toRealPath内部调用此方法并将软连 => 真实路径的所有缓存传入
function realpathSync(p, options) {
  // options不存在则置空
  options = getOptions(options, emptyObj);
  // 如果为URL路径则进行转换
  p = toPathIfFileURL(p);
  // 如果不是string字符串则转为string
  if (typeof p !== "string") {
    p += "";
  }
  // 是否为有效路径
  validatePath(p);
  // 将相对路径转为绝对路径
  p = pathModule.resolve(p);
  // 查询缓存如果存在缓存则直接返回缓存中的真实路径
  const cache = options[realpathCacheKey];
  const maybeCachedResult = cache && cache.get(p);
  if (maybeCachedResult) {
    return maybeCachedResult;
  }
  // 所有软连接缓存 通过Object.create(null)创建的对象没有原型链 是一个纯粹的对象
  const seenLinks = ObjectCreate(null);
  const knownHard = ObjectCreate(null);
  // 将软连接路径作为缓存key p表示真实路径
  const original = p;

  let pos;
  let current;
  let base;
  let previous;
  // 找到根目录
  current = base = splitRoot(p);
  pos = current.length;

  while (pos < p.length) {
    // 传入真实路径 与 查找下一级目录开始位置
    const result = nextPart(p, pos);
    previous = current;
    // 判断是否找到下一级目录 并将本级目录与之前目录做拼接
    if (result === -1) {
      const last = p.slice(pos);
      current += last;
      base = previous + last;
      pos = p.length;
    } else {
      current += p.slice(pos, result + 1);
      base = previous + p.slice(pos, result);
      pos = result + 1;
    }

    // 判断缓存中是否存在本级目录 如果存在则跳过本次循环
    if (knownHard[base] || (cache && cache.get(base) === base)) {
      if (isFileType(statValues, S_IFIFO) || isFileType(statValues, S_IFSOCK)) {
        break;
      }
      continue;
    }

    let resolvedLink;
    const maybeCachedResolved = cache && cache.get(base);
    if (maybeCachedResolved) {
      resolvedLink = maybeCachedResolved;
    } else {
      const baseLong = pathModule.toNamespacedPath(base);
      const ctx = { path: base };
      const stats = binding.lstat(baseLong, true, undefined, ctx);
      handleErrorFromBinding(ctx);
      // 通过文件状态判断是否为软连接 如果不是软连接则加入缓存并跳过
      if (!isFileType(stats, S_IFLNK)) {
        knownHard[base] = true;
        if (cache) cache.set(base, base);
        continue;
      }

      let linkTarget = null;
      let id;
      if (!isWindows) {
        // 获取设备ID
        const dev = stats[0].toString(32);
        // 获取文件ID
        const ino = stats[7].toString(32);
        // 生成唯一键 作为软连接缓存的key
        id = `${dev}:${ino}`;
        // 判断缓存是否存在
        if (seenLinks[id]) {
          linkTarget = seenLinks[id];
        }
      }
      // 缓存不存在
      if (linkTarget === null) {
        // 当前路径
        const ctx = { path: base };
        // 获取当前文件状态
        binding.stat(baseLong, false, undefined, ctx);
        handleErrorFromBinding(ctx);
        // 获取软链对应的真实路径
        linkTarget = binding.readlink(baseLong, undefined, undefined, ctx);
        handleErrorFromBinding(ctx);
      }
      // 相对路径转绝对路径
      resolvedLink = pathModule.resolve(previous, linkTarget);
      // 获取到的软链对应的真实路径存入缓存
      if (cache) cache.set(base, resolvedLink);
      if (!isWindows) seenLinks[id] = linkTarget;
    }
    // 重新生成文件真实路径
    p = pathModule.resolve(resolvedLink, p.slice(pos));

    // 继续循环下面路径 确保路径中没有软链
    current = base = splitRoot(p);
    pos = current.length;

    if (isWindows && !knownHard[base]) {
      const ctx = { path: base };
      binding.lstat(pathModule.toNamespacedPath(base), false, undefined, ctx);
      handleErrorFromBinding(ctx);
      knownHard[base] = true;
    }
  }

  if (cache) cache.set(original, p);
  return encodeRealpathResult(p, options);
}

热门相关：恭喜你被逮捕了   神算大小姐   神算大小姐   万古至尊   神算大小姐