如何解决PHP异步操作的“回调地狱”与阻塞问题，使用GuzzlePromises让你的代码更优雅高效

<pre class="brush:php;toolbar:false;">// 伪代码：同步阻塞的困境
$user = fetchUserData($userId); // 等待，可能耗时200ms
$orders = fetchUserOrders($user->id); // 等待，可能耗时300ms
$products = [];
foreach ($orders as $order) {
    $products[] = fetchProductDetails($order->productId); // 循环等待，每个可能耗时250ms
}
// 总耗时 = 200 + 300 + N * 250ms，效率低下！

<pre class="brush:php;toolbar:false;">// 伪代码：可怕的回调地狱
fetchUserData($userId, function ($user) use ($userId) {
    fetchUserOrders($user->id, function ($orders) use ($user) {
        $productPromises = [];
        foreach ($orders as $order) {
            fetchProductDetails($order->productId, function ($product) use (&$productPromises) {
                $productPromises[] = $product;
                // 当所有产品都获取到后，再进行下一步操作...
            }, function ($error) { /* 处理产品错误 */ });
        }
        // 如何知道所有产品都完成了？如何处理所有产品的错误？
    }, function ($error) { /* 处理订单错误 */ });
}, function ($error) { /* 处理用户错误 */ });

<code class="bash">composer require guzzlehttp/promises</code>

<pre class="brush:php;toolbar:false;">use GuzzleHttp\Promise\Promise;

$promise = new Promise();

// 注册成功和失败的回调
$promise->then(
    function ($value) {
        echo '操作成功，得到值: ' . $value;
    },
    function ($reason) {
        echo '操作失败，原因: ' . $reason;
    }
);

// 模拟异步操作完成，并解析 Promise
// $promise->resolve('这是最终的结果！'); // 触发成功回调
// $promise->reject('出错了！'); // 触发失败回调

<pre class="brush:php;toolbar:false;">use GuzzleHttp\Promise\Promise;

// 模拟异步函数
function asyncFetchUserData($userId) {
    $promise = new Promise();
    // 假设这里是真正的异步网络请求，一段时间后返回结果
    // 为简化示例，我们立即解析
    if ($userId === 123) {
        $promise->resolve(['id' => 123, 'name' => 'Alice']);
    } else {
        $promise->reject('用户未找到');
    }
    return $promise;
}

function asyncFetchUserOrders($userId) {
    $promise = new Promise();
    if ($userId === 123) {
        $promise->resolve(['order_a', 'order_b']);
    } else {
        $promise->reject('订单获取失败');
    }
    return $promise;
}

// 使用 Promise 链式调用
asyncFetchUserData(123)
    ->then(function ($user) {
        echo "获取到用户: " . $user['name'] . "\n";
        return asyncFetchUserOrders($user['id']); // 返回新的 Promise，继续链式调用
    })
    ->then(function ($orders) {
        echo "获取到订单: " . implode(', ', $orders) . "\n";
        return "所有数据获取完毕！"; // 最终返回一个普通值，也会被包装成 Promise
    })
    ->then(function ($finalMessage) {
        echo $finalMessage . "\n";
    })
    ->otherwise(function ($reason) { // 集中处理链中任何环节的错误
        echo "操作失败: " . $reason . "\n";
    });

// 运行队列以确保 Promise 被解析（在事件循环中异步运行的场景下需要）
// GuzzleHttp\Promise\Utils::queue()->run();

<pre class="brush:php;toolbar:false;">use GuzzleHttp\Promise\Promise;

$promise = new Promise(function () use (&$promise) {
    // 模拟一个耗时操作，然后解析 Promise
    sleep(1); // 暂停1秒
    $promise->resolve('等待1秒后得到的结果');
});

echo "开始等待...\n";
$result = $promise->wait(); // 会阻塞当前进程，直到 Promise 被解析
echo "等待结束，结果: " . $result . "\n"; // 输出 "等待1秒后得到的结果"

<pre class="brush:php;toolbar:false;">use GuzzleHttp\Promise\Coroutine;
use GuzzleHttp\Promise\Promise;

function asyncOperation($value) {
    return new Promise(function () use (&$promise, $value) {
        // 模拟异步
        sleep(0.1);
        $promise->resolve($value * 2);
    });
}

$coroutine = Coroutine::of(function () {
    $result1 = yield asyncOperation(10); // 暂停，等待 asyncOperation(10) 完成
    echo "第一步结果: " . $result1 . "\n"; // 20

    $result2 = yield asyncOperation($result1); // 暂停，等待 asyncOperation(20) 完成
    echo "第二步结果: " . $result2 . "\n"; // 40

    return $result2 + 5;
});

// 运行协程，并等待最终结果
$finalResult = $coroutine->wait();
echo "最终结果: " . $finalResult . "\n"; // 45