如何将Node.js中exec的stdout值存入外部变量？

问题说明 #

Node.js里exec的常规用法是这样的：

exec('ls', (err, stdout, stderr) => { 
   if (err) { 
     console.error(err);     
     return;   
   }   
   console.log(stdout); 
});

很多人尝试直接把stdout赋值给外部变量，比如：

var newLS = ''
exec('ls', (err, stdout, stderr) => { 
   if (err) { 
     console.error(err);     
     return;   
   }   
   newLS = stdout;
});
console.log(newLS)

但运行后会发现newLS还是空值——这是因为exec是异步操作，console.log会在回调函数执行前就运行，此时变量还没被赋值。

还有人尝试直接把exec的返回值赋值给变量：

newLS = exec('ls', (err, stdout, stderr) => { 
   if (err) { 
     console.error(err);     
     return;   
   }   
   console.log(stdout); 
});
console.log(newLS)

但这时newLS存储的是ChildProcess对象（包含进程相关的服务信息），并不是命令的输出结果。

实际业务需求 #

下面这段代码是实际场景：需要收集两个exec命令的执行结果，存入vmInfo对象后返回给客户端：

app.post('/vmInfo', (req, res) => {
    var string = JSON.stringify(req.body)
    var objectValue = JSON.parse(string);
    var vmInfo = {
        ip: 'no information',
        memoryUsage: 'no information'
    }

    exec('lxc list virtual1 -c "4" --format="csv"', (error, stdout, stderr) => {

    });

    exec('lxc list virtual1 -c "d" --format="csv"', (error, stdout, stderr) => {

    });
    
    res.send(vmInfo)
})

现在需要解决的是如何正确把两个命令的stdout结果填入vmInfo，再返回响应。

解决方案 #

方法1：回调嵌套（简单但易陷入回调地狱） #

把第二个exec放在第一个的回调函数里，确保第一个命令执行完成后再处理第二个，最后在第二个回调里返回结果：

app.post('/vmInfo', (req, res) => {
    // 原代码的JSON.stringify+parse可以简化为直接用req.body（除非有特殊处理需求）
    var vmInfo = {
        ip: 'no information',
        memoryUsage: 'no information'
    }

    exec('lxc list virtual1 -c "4" --format="csv"', (error, stdout, stderr) => {
        if (!error) {
            vmInfo.ip = stdout.trim(); // 去除多余的换行、空格
        }
        // 第一个命令完成后执行第二个命令
        exec('lxc list virtual1 -c "d" --format="csv"', (error, stdout, stderr) => {
            if (!error) {
                vmInfo.memoryUsage = stdout.trim();
            }
            // 两个命令都处理完后返回结果
            res.send(vmInfo);
        });
    });
})

方法2：Promise封装+async/await（推荐，代码更清晰） #

Node.js的util.promisify可以把回调风格的exec转成Promise，配合async/await就能用同步风格的代码处理异步操作：

const { exec } = require('child_process');
const { promisify } = require('util');
// 把exec转成返回Promise的函数
const execPromise = promisify(exec);

app.post('/vmInfo', async (req, res) => {
    var vmInfo = {
        ip: 'no information',
        memoryUsage: 'no information'
    }

    try {
        // 依次执行两个命令
        const ipResult = await execPromise('lxc list virtual1 -c "4" --format="csv"');
        vmInfo.ip = ipResult.stdout.trim();

        const memoryResult = await execPromise('lxc list virtual1 -c "d" --format="csv"');
        vmInfo.memoryUsage = memoryResult.stdout.trim();
    } catch (error) {
        // 统一处理命令执行错误
        console.error('命令执行失败:', error);
    }

    res.send(vmInfo);
})

如果两个命令没有依赖关系，可以用Promise.all并行执行，提高效率：

const { exec } = require('child_process');
const { promisify } = require('util');
const execPromise = promisify(exec);

app.post('/vmInfo', async (req, res) => {
    var vmInfo = {
        ip: 'no information',
        memoryUsage: 'no information'
    }

    try {
        // 并行执行两个命令，等待所有结果返回
        const [ipResult, memoryResult] = await Promise.all([
            execPromise('lxc list virtual1 -c "4" --format="csv"'),
            execPromise('lxc list virtual1 -c "d" --format="csv"')
        ]);
        
        vmInfo.ip = ipResult.stdout.trim();
        vmInfo.memoryUsage = memoryResult.stdout.trim();
    } catch (error) {
        console.error('命令执行失败:', error);
    }

    res.send(vmInfo);
})

核心原因总结 #

exec是异步非阻塞函数，它的回调会在命令执行完成后才触发。如果在回调执行前就去读取外部变量，变量自然还没被赋值。必须等待异步操作完成后，再去使用变量的值——上面的两种方法都是基于这个原理实现的。

内容的提问来源于stack exchange，提问作者L1M80 54N