当前位置：首页 > 文章列表 > 文章 > php教程 > PHP调用外部命令的几种方式

PHP调用外部命令的几种方式

2025-09-29 12:20:30 0浏览收藏

怎么入门文章编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《PHP执行外部命令方法详解》，涉及到，有需要的可以收藏一下

答案是proc_open()最适合处理长时间运行的外部命令并实时获取输出，因其支持非阻塞I/O、精细控制进程的输入输出流，并可通过stream_select()实现多管道监听，实时读取stdout和stderr，同时避免PHP进程完全阻塞，适用于需要持续反馈和交互的复杂场景。

php如何执行外部命令？php执行系统外部命令详解

PHP执行外部命令，说白了，就是让你的PHP脚本能去调用操作系统里那些命令行程序，比如ls、grep、ffmpeg甚至是你自己写的脚本。核心思路无非是PHP作为“指挥官”，把命令发给操作系统，然后接收执行结果。这背后有几个内置函数在支撑，它们各有特点，选择哪个得看你具体需要什么：是只关心命令是否执行成功，还是需要完整的输出，或者需要实时交互、更精细的进程控制。

解决方案

PHP提供了多种函数来执行外部命令，每种都有其适用场景和局限性。理解它们的工作方式是高效且安全地利用系统资源的基石。

1. exec() 函数：exec(string $command, array &$output = null, int &$return_var = null): string|false 这个函数执行命令，并只返回命令输出的最后一行。如果你想获取所有输出，需要传入第二个参数$output，它会是一个数组，每行输出作为数组的一个元素。第三个参数$return_var则会存储命令的退出状态码（通常0表示成功，非0表示失败）。

特点： 非实时输出，获取所有输出需通过数组，能获取退出码。
适用场景： 当你只需要命令的最终结果，或者一次性获取所有输出进行后续处理时。

<?php
$command = 'ls -l';
$output = [];
$return_var = 0;

$last_line = exec($command, $output, $return_var);

echo "最后一行输出: " . $last_line . PHP_EOL;
echo "所有输出:\n";
foreach ($output as $line) {
    echo $line . PHP_EOL;
}
echo "退出状态码: " . $return_var . PHP_EOL;
?>

2. shell_exec() 函数：shell_exec(string $command): string|nullshell_exec() 会执行命令，并把命令的所有输出作为一个字符串返回。如果命令执行失败或没有输出，它会返回NULL。

特点： 简单直接，一次性返回所有输出字符串，但无法获取退出码。
适用场景： 当你只关心命令的完整输出，且不那么在意命令的退出状态时。

<?php
$command = 'cat /etc/os-release'; // 假设这是一个会输出内容的命令
$output = shell_exec($command);

if ($output === null) {
    echo "命令执行失败或无输出。" . PHP_EOL;
} else {
    echo "命令输出:\n" . $output . PHP_EOL;
}
?>

3. system() 函数：system(string $command, int &$return_var = null): string|falsesystem() 函数会直接将命令的输出发送到PHP的输出缓冲（通常是浏览器或终端），并返回命令输出的最后一行。与exec()类似，它也可以通过第二个参数获取退出状态码。

特点： 实时输出到标准输出，返回最后一行，能获取退出码。
适用场景： 当你需要用户实时看到命令的输出，比如执行一个进度条命令，或者一些简单的交互式脚本。

<?php
echo "开始执行命令...\n";
$command = 'ping -c 3 127.0.0.1'; // ping 3次，输出会实时显示
$return_var = 0;

$last_line = system($command, $return_var);

echo "命令执行完毕。\n";
echo "最后一行输出: " . $last_line . PHP_EOL;
echo "退出状态码: " . $return_var . PHP_EOL;
?>

4. passthru() 函数：passthru(string $command, int &$return_var = null): voidpassthru() 函数直接将命令的原始输出（包括二进制数据）传递给浏览器或终端，不进行任何处理或缓冲。它没有返回值，但可以获取退出状态码。

特点： 实时原始输出，尤其适合处理二进制数据（如图片生成、视频转换），能获取退出码。
适用场景： 当你需要执行一个生成二进制文件（如图像、PDF）的命令，并直接将结果发送给用户浏览器时，或者需要处理大文件流。

<?php
// 假设你有一个脚本可以生成图片，例如 convert image.jpg -resize 50% output.jpg
// 为了演示，这里用一个简单的命令，实际场景会更复杂
header('Content-Type: text/plain'); // 假设我们输出的是纯文本
echo "开始执行passthru...\n";
$command = 'echo "Hello from passthru!" && sleep 1 && echo "Done."';
$return_var = 0;

passthru($command, $return_var);

echo "passthru执行完毕。\n";
echo "退出状态码: " . $return_var . PHP_EOL;
?>

5. proc_open() 函数：proc_open(array|string $command, array $descriptorspec, array &$pipes, string $cwd = null, array $env = null, array $other_options = null): resource|false 这是最强大、最灵活的函数，它允许你打开一个进程，并对其标准输入（stdin）、标准输出（stdout）和标准错误（stderr）进行精细控制。你可以像操作文件一样读写这些管道，甚至是非阻塞地进行。

特点： 完整的进程控制，可读写stdin/stdout/stderr，非阻塞I/O，获取详细进程信息。
适用场景： 复杂交互、长时间运行的命令、需要实时监控和控制I/O流、需要处理并发进程的场景。

<?php
$command = 'php -r "for($i=0;$i<5;$i++){ echo \"Stdout line $i\\n\"; usleep(200000); } file_put_contents(\'php://stderr\', \'Stderr message\\n\');"';
$descriptorspec = [
    0 => ['pipe', 'r'],  // stdin 是一个管道，可写
    1 => ['pipe', 'w'],  // stdout 是一个管道，可读
    2 => ['pipe', 'w']   // stderr 是一个管道，可读
];
$pipes = [];
$process = proc_open($command, $descriptorspec, $pipes);

if (is_resource($process)) {
    // 写入stdin (如果需要的话)
    // fwrite($pipes[0], 'input data');
    fclose($pipes[0]);

    // 非阻塞读取stdout和stderr
    stream_set_blocking($pipes[1], false);
    stream_set_blocking($pipes[2], false);

    while (!feof($pipes[1]) || !feof($pipes[2])) {
        $read = [$pipes[1], $pipes[2]];
        $write = null;
        $except = null;
        $timeout = 1; // 秒

        if (stream_select($read, $write, $except, $timeout) > 0) {
            foreach ($read as $stream) {
                $output = fread($stream, 8192);
                if ($output) {
                    if ($stream === $pipes[1]) {
                        echo "STDOUT: " . $output;
                    } elseif ($stream === $pipes[2]) {
                        echo "STDERR: " . $output;
                    }
                }
            }
        }
        usleep(100000); // 短暂暂停，避免CPU空转
    }

    fclose($pipes[1]);
    fclose($pipes[2]);

    $return_code = proc_close($process);
    echo "进程退出码: " . $return_code . PHP_EOL;
} else {
    echo "无法启动进程。" . PHP_EOL;
}
?>

PHP执行外部命令时，如何确保安全性，避免命令注入？

这是我每次写到外部命令执行时，第一个在脑子里敲响警钟的问题。坦白说，命令注入的风险太高了，一个不小心就可能让整个系统门户大开。所以，确保安全性，避免命令注入，是比实现功能本身更重要的事。

首先，最核心的原则就是：永远不要直接将用户输入拼接进你将要执行的命令字符串中。这就像把钥匙直接交给陌生人，然后指望他只开你允许的门。

1. 使用 escapeshellarg() 和 escapeshellcmd() 进行转义： PHP提供了这两个函数来帮助你安全地处理命令行参数。

escapeshellarg(string $arg): string：这个函数会确保你传入的字符串作为一个单独的参数被shell正确处理。它会用单引号将参数包裹起来，并转义其中的单引号。这是处理用户提供的单个参数的首选方法。
escapeshellcmd(string $command): string：这个函数会转义整个命令字符串中的任何可能被shell解释为特殊字符的字符。它主要用于确保你执行的命令本身是安全的，而不是命令的参数。但通常，我更倾向于将命令本身固定，只对可变的参数使用 escapeshellarg()。因为escapeshellcmd()可能比你想象的更复杂，甚至可能在某些情况下引入新的安全问题。

<?php
// 错误示例：直接拼接用户输入，极易被注入
// $user_input = "file.txt; rm -rf /"; // 恶意输入
// $command = "cat " . $user_input;
// shell_exec($command); // 灾难！

// 正确示例：使用 escapeshellarg() 处理参数
$user_input = "file.txt; rm -rf /"; // 恶意输入
$safe_arg = escapeshellarg($user_input); // 会变成 "'file.txt; rm -rf /'"
$command = "cat " . $safe_arg;
echo "安全命令: " . $command . PHP_EOL;
// shell_exec($command); // 此时 shell 会尝试 cat 一个名为 "'file.txt; rm -rf /'" 的文件，而不是执行 rm -rf /
?>

2. 最小权限原则： 运行PHP的Web服务器用户（例如www-data或apache）应该只拥有执行必要命令的最小权限。例如，如果你的PHP脚本只需要执行ffmpeg，那就确保www-data用户只能执行ffmpeg，并且只能在特定的目录操作。限制其对系统关键文件的读写权限。

3. 白名单机制： 如果你的应用需要执行的外部命令种类是有限且固定的，那么建立一个“白名单”是极其有效的策略。只允许执行预定义、安全验证过的命令，而不是根据用户输入动态构造命令。例如：

<?php
$allowed_commands = [
    'ls' => '/bin/ls',
    'grep' => '/bin/grep',
    // ... 其他允许的命令
];

$requested_command_alias = 'ls'; // 假设这是用户请求的命令别名
$user_param = '-l /tmp'; // 假设这是用户提供的参数

if (isset($allowed_commands[$requested_command_alias])) {
    $full_command_path = $allowed_commands[$requested_command_alias];
    $safe_param = escapeshellarg($user_param); // 再次强调，参数必须转义
    $command_to_execute = $full_command_path . ' ' . $safe_param;
    echo "执行: " . $command_to_execute . PHP_EOL;
    // shell_exec($command_to_execute);
} else {
    echo "不允许执行此命令。" . PHP_EOL;
}
?>

4. proc_open() 的优势：proc_open() 在安全性方面有一个天然的优势：你可以将命令和参数分开传递，而不是拼接成一个大字符串。这使得命令注入的难度大大增加，因为它不会让shell有机会在参数中解析出新的命令。

<?php
$command_parts = [
    '/bin/cat',
    'file.txt; rm -rf /' // 恶意参数
];

$descriptorspec = [ /* ... */ ];
$pipes = [];
// proc_open 会将 'file.txt; rm -rf /' 作为一个整体参数传递给 cat，而不是执行 rm
$process = proc_open($command_parts, $descriptorspec, $pipes);
// ...
?>

在我看来，如果你真的需要高安全性且复杂的外部命令交互，proc_open() 配合参数数组的传递方式，是目前最稳妥的选择。

哪种PHP函数最适合处理长时间运行的外部命令，并实时获取输出？

处理长时间运行的外部命令，并且需要实时获取输出，这在很多场景下都非常常见，比如视频转码、数据处理脚本、大型文件压缩等等。这时候，exec()、shell_exec()、system() 就不太合适了，它们要么会阻塞PHP进程直到命令完成（exec()和shell_exec()），要么虽然能实时输出但缺乏细粒度控制（system()和passthru()）。

毫无疑问，proc_open() 是处理这类需求的最佳选择。

为什么呢？ proc_open() 允许你打开一个进程，并建立与该进程的多个通信管道：标准输入（stdin）、标准输出（stdout）和标准错误（stderr）。你可以像操作文件一样，对这些管道进行读写。更关键的是，你可以设置这些管道为非阻塞模式。这意味着你的PHP脚本在等待外部命令输出时，不会被完全“卡死”，它可以做其他事情，或者在等待输出的同时，检查是否有错误信息，或者向命令发送进一步的输入。

实时获取输出的机制： 通过 proc_open() 建立管道后，你可以使用 stream_select() 函数来监听这些管道。stream_select() 可以监视多个文件描述符（包括管道），看它们是否准备好进行读写操作，或者是否发生了异常。这样，你就可以在一个循环中，非阻塞地读取 stdout 和 stderr 的数据，并将其实时显示给用户或进行处理。

示例代码的核心逻辑：

<?php
// 假设有一个长时间运行的命令，会持续输出
$command = 'for i in $(seq 1 10); do echo "Processing item $i..."; sleep 0.5; done; echo "Finished."; exit 0;';

$descriptorspec = [
    0 => ['pipe', 'r'], // stdin
    1 => ['pipe', 'w'], // stdout
    2 => ['pipe', 'w']  // stderr
];

$pipes = [];
$process = proc_open($command, $descriptorspec, $pipes);

if (is_resource($process)) {
    // 设置管道为非阻塞模式
    stream_set_blocking($pipes[1], false);
    stream_set_blocking($pipes[2], false);

    echo "开始执行长时间命令...\n";
    ob_implicit_flush(true); // 确保输出实时发送到浏览器/终端
    ob_end_flush();

    while (true) {
        $read_streams = [$pipes[1], $pipes[2]];
        $write_streams = null;
        $except_streams = null;
        $timeout = 1; // 1秒超时，避免无限等待

        // 监听管道，看是否有数据可读
        $num_changed_streams = stream_select($read_streams, $write_streams, $except_streams, $timeout);

        if ($num_changed_streams === false) {
            // 错误发生
            echo "stream_select 发生错误。\n";
            break;
        } elseif ($num_changed_streams > 0) {
            foreach ($read_streams as $stream) {
                $output = fread($stream, 8192); // 读取数据块
                if ($output) {
                    if ($stream === $pipes[1]) {
                        echo "STDOUT: " . $output; // 实时输出标准输出
                    } elseif ($stream === $pipes[2]) {
                        echo "STDERR: " . $output; // 实时输出标准错误
                    }
                }
            }
        }

        // 检查进程是否已结束
        $status = proc_get_status($process);
        if (!$status['running']) {
            // 确保读取完所有剩余输出
            while (!feof($pipes[1])) { echo "STDOUT: " . fread($pipes[1], 8192); }
            while (!feof($pipes[2])) { echo "STDERR: " . fread($pipes[2], 8192); }
            break; // 进程已结束，退出循环
        }
        // usleep(100000); // 可以加一个短暂暂停，降低CPU占用，但 stream_select 已经有超时机制了
    }

    // 关闭所有管道
    fclose($pipes[0]);
    fclose($pipes[1]);
    fclose($pipes[2]);

    $return_code = proc_close($process);
    echo "命令执行完毕，退出码: " . $return_code . PHP_EOL;
} else {
    echo "无法启动进程。\n";
}
?>

这个模式下，PHP脚本不会被外部命令完全阻塞，它能持续检查并处理输出，这对于需要长时间运行且用户需要实时反馈的场景来说，简直是救星。相比之下，passthru() 虽然也能实时输出，但它无法让你在PHP脚本内部捕获和处理这些输出，也无法区分标准输出和标准错误，更不用说控制输入了。所以，对于复杂的实时交互和长时间任务，proc_open() 才是王道。