La [AWS SDK per JavaScript V3 API Reference Guide](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) descrive in dettaglio tutte le operazioni API per la AWS SDK per JavaScript versione 3 (V3). 

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à.

# Crea e richiama oggetti di servizio
<a name="creating-and-calling-service-objects"></a>

L' JavaScript API supporta la maggior parte dei AWS servizi disponibili. Ogni servizio dell' JavaScriptAPI fornisce a una classe client un `send` metodo da utilizzare per richiamare tutte le API supportate dal servizio. Per ulteriori informazioni sulle classi di servizio, le operazioni e i parametri nell' JavaScript API, consulta l'[API Reference](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/).

Quando si utilizza l'SDK in Node.js, si aggiunge il pacchetto SDK per ogni servizio necessario all'utilizzo dell'applicazione`import`, che fornisce supporto per tutti i servizi correnti. L'esempio seguente crea un oggetto di servizio Amazon S3 nella `us-west-1` regione.

```
// Import the Amazon S3 service client
import { S3Client } from "@aws-sdk/client-s3"; 
// Create an S3 client in the us-west-1 Region
const s3Client = new S3Client({
    region: "us-west-1"
});
```

## Specificare i parametri dell'oggetto di servizio
<a name="specifying-service-object-parameters"></a>

Quando chiami un metodo di un oggetto di servizio, trasferisci i parametri in JSON come richiesto dall'API. Ad esempio, in Amazon S3, per ottenere un oggetto per un bucket e una chiave specificati, passa i seguenti parametri al `GetObjectCommand` metodo da. `S3Client` Per ulteriori informazioni sul trasferimento di parametri JSON, consulta [Lavora con JSON](working-with-json.md).

```
s3Client.send(new GetObjectCommand({Bucket: 'bucketName', Key: 'keyName'}));
```

Per ulteriori informazioni sui parametri di Amazon S3, consulta [@aws -sdk/client-s3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-s3/) nell'API Reference.

## Usa @smithy /types per i client generati in TypeScript
<a name="smithy-types"></a>

Se lo stai utilizzando TypeScript, il `@smithy/types` pacchetto ti consente di manipolare le forme di input e output di un client.

### Scenario: rimozione `undefined` dalle strutture di input e output
<a name="remove-undefined-from-input"></a>

I membri delle forme generate vengono uniti alle forme `undefined` di input e `?` (facoltativo) alle forme di output. Per gli input, ciò rinvia la convalida al servizio. Per quanto riguarda gli output, ciò suggerisce vivamente di controllare in fase di esecuzione i dati di output.

Se desideri saltare questi passaggi, usa gli helper o digita`AssertiveClient`. `UncheckedClient` L'esempio seguente utilizza i type helper con il servizio Amazon S3.

```
import { S3 } from "@aws-sdk/client-s3";
import type { AssertiveClient, UncheckedClient } from "@smithy/types";

const s3a = new S3({}) as AssertiveClient<S3>;
const s3b = new S3({}) as UncheckedClient<S3>;

// AssertiveClient enforces required inputs are not undefined
// and required outputs are not undefined.
const get = await s3a.getObject({
  Bucket: "",
  // @ts-expect-error (undefined not assignable to string)
  Key: undefined,
});

// UncheckedClient makes output fields non-nullable.
// You should still perform type checks as you deem
// necessary, but the SDK will no longer prompt you
// with nullability errors.
const body = await (
  await s3b.getObject({
    Bucket: "",
    Key: "",
  })
).Body.transformToString();
```

Quando si utilizza la trasformazione su un client non aggregato con la `Command` sintassi, l'input non può essere convalidato perché passa attraverso un'altra classe, come mostrato nell'esempio seguente.

```
import { S3Client, ListBucketsCommand, GetObjectCommand, GetObjectCommandInput } from "@aws-sdk/client-s3";
import type { AssertiveClient, UncheckedClient, NoUndefined } from "@smithy/types";

const s3 = new S3Client({}) as UncheckedClient<S3Client>;

const list = await s3.send(
  new ListBucketsCommand({
    // command inputs are not validated by the type transform.
    // because this is a separate class.
  })
);

/**
 * Although less ergonomic, you can use the NoUndefined<T>
 * transform on the input type.
 */
const getObjectInput: NoUndefined<GetObjectCommandInput> = {
  Bucket: "undefined",
  // @ts-expect-error (undefined not assignable to string)
  Key: undefined,
  // optional params can still be undefined.
  SSECustomerAlgorithm: undefined,
};

const get = s3.send(new GetObjectCommand(getObjectInput));

// outputs are still transformed.
await get.Body.TransformToString();
```

### Scenario: restringimento dei tipi di blob del payload di output di un client generato da Smithy TypeScript
<a name="remove-undefined-from-input"></a>

Questo scenario è principalmente rilevante per le operazioni con sistemi di streaming, ad esempio all'interno di in v3. `S3Client` AWS SDK per JavaScript 

Poiché i tipi di payload blob dipendono dalla piattaforma, potresti voler indicare nell'applicazione che un client è in esecuzione in un ambiente specifico. Questo restringe i tipi di payload blob, come illustrato nell'esempio seguente.

```
import { GetObjectCommand, S3Client } from "@aws-sdk/client-s3";
import type { NodeJsClient, SdkStream, StreamingBlobPayloadOutputTypes } from "@smithy/types";
import type { IncomingMessage } from "node:http";

// default client init.
const s3Default = new S3Client({});

// client init with type narrowing.
const s3NarrowType = new S3Client({}) as NodeJsClient<S3Client>;

// The default type of blob payloads is a wide union type including multiple possible
// request handlers.
const body1: StreamingBlobPayloadOutputTypes = (await s3Default.send(new GetObjectCommand({ Key: "", Bucket: "" })))
  .Body!;

// This is of the narrower type SdkStream<IncomingMessage> representing
// blob payload responses using specifically the node:http request handler.
const body2: SdkStream<IncomingMessage> = (await s3NarrowType.send(new GetObjectCommand({ Key: "", Bucket: "" })))
  .Body!;
```