import-local执行流程与node模块路径解析流程
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);
}