Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Janji dalam AWS SDK untuk PHP Versi 3
<a name="guide_promises"></a>

 AWS SDK untuk PHP Penggunaan **menjanjikan** untuk memungkinkan alur kerja asinkron, dan asinkron ini memungkinkan permintaan HTTP dikirim secara bersamaan. Spesifikasi janji yang digunakan oleh SDK adalah [Promises/A](https://promisesaplus.com/) \$1.

## Apa itu janji?
<a name="what-is-a-promise"></a>

*Janji* merupakan hasil akhir dari operasi asinkron. Cara utama berinteraksi dengan janji adalah melalui `then` metodenya. Metode ini mendaftarkan callback untuk menerima nilai akhir janji atau alasan mengapa janji tidak dapat dipenuhi.

 AWS SDK untuk PHP Bergantung pada paket [Guzzlehttp/promises Composer untuk implementasi janjinya](https://github.com/guzzle/promises). Guzzle menjanjikan mendukung alur kerja pemblokiran dan non-pemblokiran dan dapat digunakan dengan loop peristiwa non-pemblokiran apa pun.

**catatan**  
Permintaan HTTP dikirim secara bersamaan dalam AWS SDK untuk PHP menggunakan satu utas, di mana panggilan non-pemblokiran digunakan untuk mentransfer satu atau beberapa permintaan HTTP saat bereaksi terhadap perubahan status (misalnya, memenuhi atau menolak janji).

## Janji di SDK
<a name="promises-in-the-sdk"></a>

Janji digunakan di seluruh SDK. [Misalnya, janji digunakan di sebagian besar abstraksi tingkat tinggi yang disediakan oleh SDK: [paginator](guide_paginators.md#async-paginators), [pelayan](guide_waiters.md#async-waiters), [kumpulan perintah, [unggahan multipart](s3-multipart-upload.md), transfer](guide_commands.md#command-pool) S3, dan sebagainya. directory/bucket ](s3-transfer.md)

Semua klien yang SDK memberikan janji pengembalian saat Anda memanggil salah satu metode `Async` akhiran. Misalnya, kode berikut menunjukkan cara membuat janji untuk mendapatkan hasil operasi Amazon `DescribeTable` DynamoDB.

```
$client = new Aws\DynamoDb\DynamoDbClient([
    'region'  => 'us-west-2',
    'version' => 'latest',
]);

// This will create a promise that will eventually contain a result
$promise = $client->describeTableAsync(['TableName' => 'mytable']);
```

Perhatikan bahwa Anda dapat menelepon salah satu `describeTable` atau`describeTableAsync`. Metode ini adalah `__call` metode ajaib pada klien yang didukung oleh model API dan `version` nomor yang terkait dengan klien. Dengan memanggil metode seperti `describeTable` tanpa `Async` akhiran, klien akan memblokir saat mengirim permintaan HTTP dan mengembalikan `Aws\ResultInterface` objek atau melempar file. `Aws\Exception\AwsException` Dengan akhiran nama operasi dengan `Async` (yaitu,`describeTableAsync`) klien akan membuat janji yang akhirnya dipenuhi dengan `Aws\ResultInterface` objek atau ditolak dengan. `Aws\Exception\AwsException`

**penting**  
Ketika janji dikembalikan, hasilnya mungkin sudah tiba (misalnya, saat menggunakan penangan tiruan), atau permintaan HTTP mungkin belum dimulai.

Anda dapat mendaftarkan callback dengan janji dengan menggunakan `then` metode ini. Metode ini menerima dua callback`$onRejected`, `$onFulfilled` dan keduanya bersifat opsional. `$onFulfilled`Panggilan balik dipanggil jika janji terpenuhi, dan `$onRejected` panggilan balik dipanggil jika janji ditolak (artinya gagal).

```
$promise->then(
    function ($value) {
        echo "The promise was fulfilled with {$value}";
    },
    function ($reason) {
        echo "The promise was rejected with {$reason}";
    }
);
```

### Menjalankan perintah secara bersamaan
<a name="executing-commands-concurrently"></a>

Beberapa janji dapat disusun bersama sedemikian rupa sehingga dieksekusi secara bersamaan. Ini dapat dicapai dengan mengintegrasikan SDK dengan loop peristiwa non-pemblokiran, atau dengan membangun beberapa janji dan menunggu mereka selesai secara bersamaan.

```
use GuzzleHttp\Promise\Utils;

$sdk = new Aws\Sdk([
    'version' => 'latest',
    'region'  => 'us-east-1'
]);

$s3 = $sdk->createS3();
$ddb = $sdk->createDynamoDb();

$promises = [
    'buckets' => $s3->listBucketsAsync(),
    'tables'  => $ddb->listTablesAsync(),
];

// Wait for both promises to complete.
$results = Utils::unwrap($promises);

// Notice that this method will maintain the input array keys.
var_dump($results['buckets']->toArray());
var_dump($results['tables']->toArray());
```

**catatan**  
[CommandPool](guide_commands.md#command-pool)Ini menyediakan mekanisme yang lebih kuat untuk mengeksekusi beberapa operasi API secara bersamaan.

## Janji rantai
<a name="chaining-promises"></a>

Salah satu aspek terbaik dari janji adalah bahwa mereka dapat dikomposisi, memungkinkan Anda untuk membuat pipeline transformasi. Janji disusun dengan merantai `then` callback dengan callback berikutnya`then`. Nilai pengembalian `then` metode adalah janji yang dipenuhi atau ditolak berdasarkan hasil callback yang diberikan.

```
$promise = $client->describeTableAsync(['TableName' => 'mytable']);

$promise
    ->then(
        function ($value) {
            $value['AddedAttribute'] = 'foo';
            return $value;
        },
        function ($reason) use ($client) {
            // The call failed. You can recover from the error here and
            // return a value that will be provided to the next successful
            // then() callback. Let's retry the call.
            return $client->describeTableAsync(['TableName' => 'mytable']);
        }
    )->then(
        function ($value) {
            // This is only invoked when the previous then callback is
            // fulfilled. If the previous callback returned a promise, then
            // this callback is invoked only after that promise is
            // fulfilled.
            echo $value['AddedAttribute']; // outputs "foo"
        },
        function ($reason) {
            // The previous callback was rejected (failed).
        }
    );
```

**catatan**  
Nilai pengembalian callback janji adalah `$value` argumen yang diberikan ke janji hilir. Jika Anda ingin memberikan nilai ke rantai janji hilir, Anda harus mengembalikan nilai dalam fungsi callback.

### Penerusan penolakan
<a name="rejection-forwarding"></a>

Anda dapat mendaftarkan callback untuk memanggil saat janji ditolak. Jika pengecualian dilemparkan dalam panggilan balik apa pun, janji ditolak dengan pengecualian dan janji berikutnya dalam rantai ditolak dengan pengecualian. Jika Anda berhasil mengembalikan nilai dari `$onRejected` callback, janji berikutnya dalam rantai janji dipenuhi dengan nilai pengembalian dari `$onRejected` callback.

## Menunggu janji
<a name="waiting-on-promises"></a>

Anda dapat secara sinkron memaksa janji untuk diselesaikan dengan menggunakan `wait` metode janji.

```
$promise = $client->listTablesAsync();
$result = $promise->wait();
```

Jika pengecualian ditemukan saat menjalankan `wait` fungsi janji, janji ditolak dengan pengecualian dan pengecualian dilemparkan.

```
use Aws\Exception\AwsException;

$promise = $client->listTablesAsync();

try {
    $result = $promise->wait();
} catch (AwsException $e) {
    // Handle the error
}
```

`wait`Memanggil janji yang telah dipenuhi tidak memicu fungsi tunggu. Ini hanya mengembalikan nilai yang dikirimkan sebelumnya.

```
$promise = $client->listTablesAsync();
$result = $promise->wait();
assert($result ### $promise->wait());
```

`wait`Memanggil janji yang telah ditolak memberikan pengecualian. Jika alasan penolakan adalah contoh dari `\Exception` alasan dilemparkan. Jika tidak, a `GuzzleHttp\Promise\RejectionException` dilemparkan dan alasannya dapat diperoleh dengan memanggil `getReason` metode pengecualian.

**catatan**  
Panggilan operasi API di AWS SDK untuk PHP ditolak dengan subclass `Aws\Exception\AwsException` kelas. Namun, ada kemungkinan alasan yang dikirim ke suatu `then` metode berbeda karena penambahan middleware khusus yang mengubah alasan penolakan.

## Membatalkan janji
<a name="canceling-promises"></a>

Janji dapat dibatalkan menggunakan `cancel()` metode janji. Jika janji telah diselesaikan, panggilan tidak `cancel()` akan berpengaruh. Membatalkan janji membatalkan janji dan janji apa pun yang menunggu pengiriman dari janji. Janji yang dibatalkan ditolak dengan a. `GuzzleHttp\Promise\RejectionException`

## Menggabungkan janji
<a name="combining-promises"></a>

Anda dapat menggabungkan janji menjadi janji agregat untuk membangun alur kerja yang lebih canggih. `guzzlehttp/promise`Paket berisi berbagai fungsi yang dapat Anda gunakan untuk menggabungkan janji.

Anda dapat menemukan dokumentasi API untuk semua fungsi pengumpulan janji di [namespace- GuzzleHttp](https://docs.aws.amazon.com/aws-sdk-php/v3/api/namespace-GuzzleHttp.Promise.html) .Promise.

### masing-masing dan each\$1limit
<a name="each-and-each-limit"></a>

Gunakan [CommandPool](guide_commands.md#command-pool)ketika Anda memiliki antrian tugas `Aws\CommandInterface` perintah untuk melakukan bersamaan dengan ukuran kolam tetap (perintah dapat berada di memori atau dihasilkan oleh iterator malas). `CommandPool`Ini memastikan bahwa sejumlah perintah tetap dikirim secara bersamaan sampai iterator yang disediakan habis.

`CommandPool`Bekerja hanya dengan perintah yang dijalankan oleh klien yang sama. Anda dapat menggunakan `GuzzleHttp\Promise\each_limit` fungsi untuk melakukan perintah kirim dari klien yang berbeda secara bersamaan menggunakan ukuran kolam tetap.

```
use GuzzleHttp\Promise;

$sdk = new Aws\Sdk([
    'version' => 'latest',
    'region'  => 'us-west-2'
]);

$s3 = $sdk->createS3();
$ddb = $sdk->createDynamoDb();

// Create a generator that yields promises
$promiseGenerator = function () use ($s3, $ddb) {
    yield $s3->listBucketsAsync();
    yield $ddb->listTablesAsync();
    // yield other promises as needed...
};

// Execute the tasks yielded by the generator concurrently while limiting the
// maximum number of concurrent promises to 5
$promise = Promise\each_limit($promiseGenerator(), 5);

// Waiting on an EachPromise will wait on the entire task queue to complete
$promise->wait();
```

### Coroutine janji
<a name="promise-coroutines"></a>

Salah satu fitur yang lebih kuat dari pustaka janji Guzzle adalah memungkinkan Anda menggunakan coroutine janji yang membuat penulisan alur kerja asinkron tampak lebih seperti menulis alur kerja sinkron tradisional. Bahkan, AWS SDK untuk PHP penggunaan coroutine menjanjikan di sebagian besar abstraksi tingkat tinggi.

Bayangkan Anda ingin membuat beberapa bucket dan mengunggah file ke bucket saat bucket tersedia, dan Anda ingin melakukan ini semua secara bersamaan sehingga itu terjadi secepat mungkin. Anda dapat melakukan ini dengan mudah dengan menggabungkan beberapa janji coroutine bersama-sama menggunakan fungsi `all()` promise.

```
use GuzzleHttp\Promise;

$uploadFn = function ($bucket) use ($s3Client) {
    return Promise\coroutine(function () use ($bucket, $s3Client) {
        // You can capture the result by yielding inside of parens
        $result = (yield $s3Client->createBucket(['Bucket' => $bucket]));
        // Wait on the bucket to be available
        $waiter = $s3Client->getWaiter('BucketExists', ['Bucket' => $bucket]);
        // Wait until the bucket exists
        yield $waiter->promise();
        // Upload a file to the bucket
        yield $s3Client->putObjectAsync([
            'Bucket' => $bucket,
            'Key'    => '_placeholder',
            'Body'   => 'Hi!'
        ]);
    });
};

// Create the following buckets
$buckets = ['amzn-s3-demo-bucket1', 'amzn-s3-demo-bucket2', 'amzn-s3-demo-bucket3'];
$promises = [];

// Build an array of promises
foreach ($buckets as $bucket) {
    $promises[] = $uploadFn($bucket);
}

// Aggregate the promises into a single "all" promise
$aggregate = Promise\all($promises);

// You can then() off of this promise or synchronously wait
$aggregate->wait();
```