Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Utilizzo dei risultati impaginati nella versione 3 AWS SDK per PHP
<a name="guide_paginators"></a>

Alcune operazioni AWS di servizio sono suddivise in pagine e rispondono con risultati troncati. Ad esempio, l'`ListObjects`operazione Amazon S3 restituisce solo fino a 1.000 oggetti alla volta. Operazioni come queste (in genere contraddistinte dal prefisso "list" o "describe") necessitano di richieste successive con parametri di token (o contrassegno) per recuperare l'intero set di risultati.

 I **paginatori** sono una funzionalità di The AWS SDK per PHP che funge da astrazione rispetto a questo processo per semplificare l'utilizzo di paginated da parte degli sviluppatori. APIs Un impaginatore è essenzialmente un'iterazione dei risultati, creati mediante il metodo `getPaginator()` del client. Quando richiami `getPaginator()`, devi fornire il nome e gli argomenti dell'operazione (come avviene per l'esecuzione di un'operazione). È possibile eseguire iterazioni sull'oggetto di un impaginatore utilizzando `foreach` per ottenere singoli oggetti `Aws\Result`.

```
$results = $s3Client->getPaginator('ListObjects', [
    'Bucket' => 'amzn-s3-demo-bucket'
]);

foreach ($results as $result) {
    foreach ($result['Contents'] as $object) {
        echo $object['Key'] . "\n";
    }
}
```

## Oggetti Paginator
<a name="paginator-objects"></a>

L'oggetto restituito dal metodo `getPaginator()` è un'istanza della classe `Aws\ResultPaginator`, che implementa l'interfaccia nativa PHP `iterator`, motivo per cui funziona con `foreach`. Può anche essere usato con funzioni di iterazione, come `iterator_to_array`, e si integra perfettamente con le [iterazioni SPL](http://www.php.net/manual/en/spl.iterators.php) come l'oggetto `LimitIterator`.

Gli oggetti dell'impaginatore contengono solo una "pagina" di risultati alla volta e vengono eseguiti lentamente: ciò significa che effettuano solo il numero di richieste necessarie a ottenere la pagina corrente dei risultati. Ad esempio, l'`ListObjects`operazione Amazon S3 restituisce solo fino a 1.000 oggetti alla volta, quindi se il bucket contiene circa 10.000 oggetti, l'impaginatore dovrebbe eseguire un totale di 10 richieste. Quando effettui l'iterazione dei risultati, la prima richiesta viene eseguita all'avvio dell'iterazione, la seconda alla seconda iterazione del loop e così via.

## Enumerazione dei dati dai risultati
<a name="enumerating-data-from-results"></a>

Gli oggetti dell'impaginatore dispongono di un metodo denominato `search()`, che consente di creare iterazioni per i dati all'interno di un set di risultati. Quando chiami`search()`, fornisci un'[JMESPath espressione](guide_jmespath.md) per specificare quali dati estrarre. La chiamata di `search()` restituisce un'iterazione che consente di ottenere i risultati dell'espressione in ogni pagina di risultati. La valutazione avviene in modo pigro durante lo scorrimento nell'iterazione restituita.

L'esempio che segue è equivalente al codice di esempio precedente, ma con l'utilizzo del metodo `ResultPaginator::search()` per brevità

```
$results = $s3Client->getPaginator('ListObjects', [
    'Bucket' => 'amzn-s3-demo-bucket'
]);

foreach ($results->search('Contents[].Key') as $key) {
    echo $key . "\n";
}
```

JMESPath le espressioni consentono di eseguire operazioni piuttosto complesse. Se ad esempio vuoi stampare tutte le chiavi e i prefissi comuni dell'oggetto (ad esempio eseguire `ls` di un bucket), puoi procedere come segue.

```
// List all prefixes ("directories") and objects ("files") in the bucket
$results = $s3Client->getPaginator('ListObjects', [
    'Bucket'    => 'amzn-s3-demo-bucket',
    'Delimiter' => '/'
]);

$expression = '[CommonPrefixes[].Prefix, Contents[].Key][]';
foreach ($results->search($expression) as $item) {
    echo $item . "\n";
}
```

## Impaginazione asincrona
<a name="async-paginators"></a>

Puoi eseguire iterazioni dei risultati di un impaginatore in modo asincrono fornendo un callback per il metodo `each()` di un `Aws\ResultPaginator`. Il callback viene richiamato per ogni valore ottenuto dall'impaginatore.

```
$results = $s3Client->getPaginator('ListObjects', [
    'Bucket' => 'amzn-s3-demo-bucket'
]);

$promise = $results->each(function ($result) {
    echo 'Got ' . var_export($result, true) . "\n";
});
```

**Nota**  
L'utilizzo del metodo `each()` consente di impaginare i risultati di un'operazione API mentre vengono contestualmente inviate altre richieste in modo asincrono.

Un valore non nullo restituito dal callback verrà prodotto dalla coroutine sottostante basata sulla promessa: ciò significa dal callback possono essere restituite promesse che devono essere risolte prima di continuare l'iterazione sui restanti elementi, essenzialmente unendo altre promesse all'iterazione. L'ultimo valore non nullo restituito dal callback è il risultato che soddisfa la promessa per qualsiasi promessa di tipo downstream. Se l'ultimo valore restituito è una promessa, la risoluzione di quest'ultima è il risultato che comporta il soddisfacimento o il rifiuto delle promesse di downstream.

```
// Delete all keys that end with "Foo"
$promise = $results->each(function ($result) use ($s3Client) {
    if (substr($result['Key'], -3) === 'Foo') {
        // Merge this promise into the iterator
        return $s3Client->deleteAsync([
            'Bucket' => 'amzn-s3-demo-bucket',
            'Key'    => 'Foo'
        ]);
    }
});

$promise
    ->then(function ($result) {
        // Result would be the last result to the deleteAsync operation
    })
    ->otherwise(function ($reason) {
        // Reason would be an exception that was encountered either in the
        // call to deleteAsync or calls performed while iterating
    });

// Forcing a synchronous wait will also wait on all of the deleteAsync calls
$promise->wait();
```