# Excluir pares chave-valor

Para remover um par chave-valor do KV Store, chame o método `delete()` na sua 
instância KV:

```javascript
await kv.delete(key);
```

## Exemplo

Um exemplo de exclusão de um par chave-valor de dentro de uma Function:

```javascript
async function handleRequest(request) {
  const kv = new Azion.KV();

  try {
    await kv.delete("sessao-usuario");

    return new Response("Chave excluída com sucesso", { status: 200 });
  } catch (e) {
    return new Response(e.message, { status: 500 });
  }
}

addEventListener("fetch", (event) => {
  event.respondWith(handleRequest(event.request));
});
```

---

## Referência

### Método `delete()`

Para remover um par chave-valor, chame o método `delete()` na sua instância KV:

```javascript
await kv.delete(key);
```

#### Parâmetros

| Parâmetro | Tipo | Descrição |
|-----------|------|-----------|
| `key` | `string` | A chave do par KV a ser excluído. |

#### Resposta

| Resposta | Tipo | Descrição |
|----------|------|-----------|
| `response` | `Promise<void>` | Uma Promise que resolve quando a exclusão é concluída. |

O método `delete()` retorna uma Promise que você deve usar `await` para 
verificar a exclusão bem-sucedida.

---

## Orientações

### Excluindo chaves inexistentes

Excluir uma chave que não existe não lançará um erro. A operação é concluída 
com sucesso independentemente de a chave existir:

```javascript
async function handleRequest(request) {
  const kv = new Azion.KV();

  // Isso terá sucesso mesmo se a chave não existir
  await kv.delete("chave-inexistente");

  return new Response("Operação de exclusão concluída", { status: 200 });
}

addEventListener("fetch", (event) => {
  event.respondWith(handleRequest(event.request));
});
```

### Consistência eventual

Como todas as operações do KV Store, exclusões são eventualmente consistentes. 
Após excluir uma chave:

- A exclusão é imediatamente visível na mesma localização da rede global.
- Outras localizações ainda podem ver o valor antigo por até 60 segundos (ou a 
  duração de qualquer `cacheTtl` que foi definido ao ler a chave).

### Exclusão condicional

Você pode querer verificar se uma chave existe antes de excluí-la, ou executar 
lógica adicional:

```javascript
async function handleRequest(request) {
  const kv = new Azion.KV();
  const key = "sessao-usuario";

  // Verificar se a chave existe antes de excluir
  const value = await kv.get(key, "text");

  if (value === null) {
    return new Response("Chave não encontrada", { status: 404 });
  }

  // Executar exclusão
  await kv.delete(key);

  return new Response("Chave excluída", { status: 200 });
}

addEventListener("fetch", (event) => {
  event.respondWith(handleRequest(event.request));
});
```

### Excluindo múltiplas chaves

Para excluir múltiplas chaves, você pode usar `Promise.all()`:

```javascript
async function handleRequest(request) {
  const kv = new Azion.KV();

  const chavesParaExcluir = ["chave1", "chave2", "chave3"];

  await Promise.all(chavesParaExcluir.map(key => kv.delete(key)));

  return new Response("Todas as chaves excluídas", { status: 200 });
}

addEventListener("fetch", (event) => {
  event.respondWith(handleRequest(event.request));
});
```

### Excluindo namespaces

Para excluir um namespace inteiro (não apenas uma chave), use o método estático 
`Azion.KV.delete()`:

```javascript
async function handleRequest(request) {
  const namespaceName = "meu-namespace";

  // Excluir o namespace inteiro
  await Azion.KV.delete(namespaceName);

  return new Response("Namespace excluído", { status: 200 });
}

addEventListener("fetch", (event) => {
  event.respondWith(handleRequest(event.request));
});
```

:::caution
Excluir um namespace remove todos os pares chave-valor dentro dele. Esta 
operação não pode ser desfeita.
:::

---

## Relacionados

- [Escrever pares chave-valor](/pt-br/documentacao/runtime/api-reference/kv-store/write/)
- [Ler pares chave-valor](/pt-br/documentacao/runtime/api-reference/kv-store/read/)
- [Visão geral da API KV Store](/pt-br/documentacao/runtime/api-reference/kv-store/)