如何查找Node.js项目中所有被调用的同步方法（含深层调用）？

当然有办法搞定这个问题！要找出Node.js项目里所有被调用的同步方法——包括自定义方法嵌套调用npm模块、再到核心同步方法的深层调用，我们可以从静态分析和动态追踪两个方向入手，下面给你详细拆解几种实用方案：

这类方法通过解析代码的抽象语法树（AST）来扫描调用关系，适合快速覆盖整个项目的潜在同步调用。

• 使用ESLint自定义规则或现成插件
  如果你平时用ESLint做代码检查，那可以直接利用它的AST遍历能力。你可以自定义规则，让它扫描所有代码中的调用表达式，标记出Node.js核心的同步API（比如fs.readFileSync、child_process.execSync这类名字带Sync的），甚至能追踪到自定义函数内部调用的npm模块里的同步方法。嫌自己写规则麻烦？也可以用现成的插件，比如eslint-plugin-node里的部分规则就能帮你标记同步API的使用，但要覆盖深层嵌套的调用链，可能得自己扩展下规则的逻辑。

• 基于AST的自定义分析脚本
  如果需要更灵活的控制，你可以用@babel/parser或acorn这类工具手动解析代码生成AST，然后递归遍历所有调用节点，记录调用链。比如下面这个基础脚本，能扫描项目文件并标记核心同步方法的调用，还能递归分析自定义函数内部的嵌套调用：

const fs = require('fs');
const parser = require('@babel/parser');
const traverse = require('@babel/traverse').default;

// 分析单个文件的AST
function analyzeFile(filePath) {
  const code = fs.readFileSync(filePath, 'utf8');
  const ast = parser.parse(code, { 
    sourceType: 'module', 
    plugins: ['jsx', 'typescript'] 
  });
  
  traverse(ast, {
    CallExpression(path) {
      const callee = path.node.callee;
      let funcName = '';

      // 处理类似fs.readFileSync的成员调用
      if (callee.type === 'MemberExpression') {
        funcName = `${callee.object.name}.${callee.property.name}`;
        // 检测Node.js核心模块的同步方法
        if (['fs', 'child_process', 'crypto'].includes(callee.object.name) && callee.property.name.endsWith('Sync')) {
          console.log(`找到同步方法调用：${funcName} 在 ${filePath}:${path.node.loc.start.line}`);
        }
      } 
      // 处理自定义函数调用，递归分析内部逻辑
      else if (callee.type === 'Identifier') {
        funcName = callee.name;
        const funcDef = path.scope.getBinding(funcName);
        if (funcDef && funcDef.path.type === 'FunctionDeclaration') {
          traverse(funcDef.path.node.body, {
            CallExpression(innerPath) {
              // 复用上面的逻辑检测自定义函数内部的同步调用
              const innerCallee = innerPath.node.callee;
              if (innerCallee.type === 'MemberExpression' && innerCallee.property.name.endsWith('Sync')) {
                console.log(`自定义函数${funcName}内部调用同步方法：${innerCallee.object.name}.${innerCallee.property.name} 在 ${filePath}:${innerPath.node.loc.start.line}`);
              }
            }
          });
        }
      }
    }
  });
}

// 遍历整个项目目录
function traverseProject(dir) {
  const files = fs.readdirSync(dir);
  files.forEach(file => {
    const fullPath = `${dir}/${file}`;
    const stat = fs.statSync(fullPath);
    if (stat.isDirectory()) {
      traverseProject(fullPath);
    } else if (fullPath.endsWith('.js') || fullPath.endsWith('.ts')) {
      analyzeFile(fullPath);
    }
  });
}

// 启动分析，替换成你的项目源码目录
traverseProject('./src');

如果要覆盖node_modules里的依赖，只需把遍历范围扩展到node_modules目录，同时处理CommonJS和ES模块的不同导入逻辑即可。

静态分析可能会漏掉动态生成的函数调用，而动态追踪能捕获运行时实际执行的同步方法，适合验证静态分析的结果，或覆盖特定代码路径。

• 替换核心同步方法并记录调用栈
  你可以手动替换Node.js核心模块的同步方法，在调用时打印完整调用链，这样就能看到从自定义方法到npm模块再到核心同步方法的完整路径：

const fs = require('fs');
const originalReadFileSync = fs.readFileSync;

// 替换fs.readFileSync，添加调用栈日志
fs.readFileSync = function(...args) {
  console.log('\n=== 调用了fs.readFileSync ===');
  console.log('调用链：');
  console.log(new Error().stack.replace('Error', '')); // 去掉Error字样，只保留栈信息
  return originalReadFileSync.apply(this, args);
};

// 同理替换其他同步方法，比如child_process.execSync
const cp = require('child_process');
const originalExecSync = cp.execSync;
cp.execSync = function(...args) {
  console.log('\n=== 调用了child_process.execSync ===');
  console.log('调用链：');
  console.log(new Error().stack.replace('Error', ''));
  return originalExecSync.apply(this, args);
};

// 运行你的项目入口文件
require('./src/index.js');

这种方式简单直接，但需要手动覆盖所有核心同步方法，适合小范围验证。

• 使用perf_hooks进行性能级追踪
  Node.js内置的perf_hooks模块可以记录函数调用的详细信息，包括调用栈和耗时，能帮你批量捕获所有同步方法的调用：

const { PerformanceObserver, performance } = require('perf_hooks');

// 监听函数调用事件
const obs = new PerformanceObserver((list) => {
  const entries = list.getEntriesByType('function');
  entries.forEach(entry => {
    // 筛选名字带Sync的同步方法
    if (entry.name.endsWith('Sync')) {
      console.log(`\n同步方法：${entry.name}`);
      console.log(`耗时：${entry.duration.toFixed(2)}ms`);
      console.log(`调用栈：\n${entry.stack}`);
    }
  });
});

// 开启函数调用追踪
obs.observe({ entryTypes: ['function'], buffered: true });

// 运行项目代码
require('./src/index.js');

注意这个功能需要Node.js 8.5+版本支持，且会带来一定性能开销，适合在测试环境中使用。

静态分析能快速扫描整个项目，找出大部分潜在的同步调用；动态追踪则能补全静态分析遗漏的动态调用或分支代码。建议先用静态分析工具做全量扫描，再在测试环境中用动态追踪验证，确保覆盖所有代码路径。

内容的提问来源于stack exchange，提问作者gpilotino