recursal/MDN huggingface dataset:
object-type
===========

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

`exsl:object-type()` devuelve una cadena que indica el tipo del objeto especificado.

**Nota:** La mayoría de tipos de objetos XSLT pueden ser convertidos en otros con seguridad; sin embargo, ciertas conversiones pueden aumentar las condiciones de error. En particular, el tratamiento de algo que no sea un conjunto de nodos (node-set) como un conjunto de nodos lo haría así. Esta función permite que los autores de plantillas con nombre y funciones de extensión proporcionen fácilmente flexibilidad en los valores de los parámetros.

### Sintaxis
```

exsl:object-type(objeto)
```

### Argumentos

`objeto`

El objeto cuyo tipo va a ser devuelto.

### Devuelve

El tipo del objeto, que será uno de los siguientes:

* `string`
* `number`
* `boolean`
* `node-set`
* `RTF`
* `external`
### Definido en

EXSLT - EXSL:OBJECT-TYPE

### Implementación de Gecko

Implementado en Gecko 1.9 y posteriores.
node-set
========

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

`exsl:node-set()` devuelve un conjunto de nodos (node-set) de un fragmento de árbol resultante, que es lo que obtienes cuando miras en `xsl:variable` en vez de su atributo select para seleccionar el valor de la variable. Esto te permite procesar XML creado dentro de una variable en vez de procesarlo en múltiples pasos.

Puedes usar también `exsl:node-set()` para transformar cadenas en nodos de texto.

### Sintaxis
```

exsl:node-set(objeto)
```

### Argumentos

`objeto`

El objeto para el que se devuelve el correspondiente conjunto de nodos (node-set).

### Devuelve

El cojunto de nodos (node-set) correspondiente al `objeto` espedificado.

### Definido en

EXSLT - EXSL:NODE-SET

### Implementación de Gecko

Implementado de Gecko 1.9 y posteriores.
leading
=======

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

`set:leading()` devuelve los nodos de un conjunto de nodos que viene antes del primer nodo del otro conjunto de nodos.

### Sintaxis
```

set:leading(conjuntoNodos1,conjuntoNodos2)
```

### Arguments

`conjuntoNodos1`

El conjunto de nodos en el que hallar los nodos que preceden al primer nodo del segundo conjunto de nodos.

`conjuntoNodos2`

El conjunto de nodos contra el que se compara.

### Devuelve

Un conjunto de nodos que contiene los nodos del `conjuntoNodos1` cuyos valores preceden al primer nodo del `conjuntoNodos2`.

**Nota:** Si el primer nodo del `conjuntoNodos2` no está contenido en `conjuntoNodos1`, de devuelve un conjunto de nodos vacío. Si `conjuntoNodos2` está vacío, entonces el resultado es `conjuntoNodos1`.

### Definido en

EXSLT - SET:LEADING

### Implementación de Gecko

Implementado en Gecko 1.9 y posteriores.
intersection
============

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

`set:intersection()` devuelve la intersección de dos conjuntos de nodos. En otras palabras, devuelve un conjunto de nodos que contiene todos los nodos de ambos conjuntos de nodos.

### Sintaxis
```

set:intersection(conjuntoNodos1,conjuntoNodos2)
```

### Argumentos

`conjuntoNodos1`

El primer conjunto de nodos.

`conjuntoNodos2`

El segundo conjunto de nodos.

### Devuelve

Un conjunto de nodos que contiene todos los nodos tanto de*conjuntoNodos1* como de*conjuntoNodos2*.

### Definido en

EXSLT - SET:INTERSECTION

### Implementación de Gecko

Implementado en Gecko 1.9 y posteriores.
has-same-node
=============

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

`set:has-same-node()` determina si dos conjuntos de nodos tienen algún nodo en común.

### Sintaxis
```

set:has-same-node(conjuntoNodos1,conjuntoNodos2)
```

### Argumentos

`conjuntoNodos1`

El primer conjunto de nodos a revisar.

`conjuntoNodos2`

El segundo conjunto de nodos a revisar.

### Devuelve

`true` si los dos conjuntos de nodos tienen algún nodo en común; de otro modo `false`.

### Definido en

EXSLT - SET:HAS-SAME-NODE

### Implementación de Gecko

Implementado en Gecko 1.9 y posteriores.
trailing
========

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

`set:trailing()` devuelve los nodos de un conjunto de nodos que vienen después del primer nodo de otro conjunto de nodos.

### Sintaxis
```

set:trailing(conjuntoNodos1,conjuntoNodos2)
```

### Argumentos

`conjuntoNodos1`

El conjunto de nodos en el que hallar los nodos que siguen al primer nodo del segundo conjunto de nodos.

`conjuntoNodos2`

El conjunto de nodos contra el que se compara.

### Devuelve

Un conjunto de nodos que contiene los nodos del `conjuntoNodos1` cuyos valores siguen al primer nodo del `conjuntoNodos2`.

**Nota:** Si el primer nodo en `conjuntoNodos2` no está contenido en `conjuntoNodos1`, se devuelve un conjunto de nodos vacío. Si `conjuntoNodos2` está vacío, entonces el resultado es el `conjuntoNodos1`.

### Definido en

EXSLT - SET:TRAILING

### Implementación de Gecko

Implementado en Gecko 1.9 y posteriores.
distinct
========

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

`set:distinct()` devuelve un subconjunto de los nodos del conjunto de nods especificado, devolviendo sólo los nodos con valores de texto únicos.

### Sintaxis
```

set:distinct(conjuntoNodos)
```

### Argumentos

`conjuntoNodos`

El conjunto de nodos en el que hallar nodos únicos.

### Devuelve

Un conjunto de nodos que contiene los nodos que tienen valores de texto únicos.

### Definido en

EXSLT - SET:DISTINCT

### Implementación en Gecko

Implementado en Gecko 1.9 y posteriores.
difference
==========

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

`set:difference()` devuelve la diferencia entre dos conjuntos de nodos. En otras palabras, devuelve un cojunto de nodos cuyos nodos están en uno de los conjuntos pero no en el otro.

La versión de plantilla de `set:difference` aplica plantillas a estos nodos en el modo de `set:difference`, copiando los nodos de modo que se devuelva el fragmento de árbol resultante consistente en los nodos.

### Sintaxis
```

set:difference(conjuntoNodos1,conjuntoNodos2)
```

### Argumentos

`conjuntoNodos1`

El conjunto de nodos desde el cual se sustraen los nodos.

`conjuntoNodos2`

El conjunto de nodos a sustraer de*conjuntoNodos1*.

### Devuelve

Un conjunto de nodos que contiene los nodos que están en*conjuntoNodos1* pero no en*conjuntoNodos2*.

### Definido en

EXSLT - SET:DIFFERENCE

### Implementación en Gecko

Implementado en Gecko 1.9 y posteriores.
tokenize
========

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

`str:tokenize()` divide una cadena usando un conjunto de caracteres como delimitadores que determinan donde deberían ocurrir las divisiones, devolviendo un conjunto de nodos que contiene las cadenas resultantes.

### Sintaxis
```

str:tokenize(cadena,delimitadores)
```

### Argumentos

`cadena`

La cadena a dividir.

`delimitadores`

Cada uno de los caracteres de esta cadena usados como separadores de palabras en la división.

### Devuelve

Un conjunto de nodos de elementos `token`, que contiene cada uno un trozo (token) de la `cadena`.

Por ejemplo:
```

str:tokenize('2007-09-14-03T11:40:23', '-T:')
```


Devuelve un conjunto de nodos como este:
```

<token>2007</token>
<token>09</token>
<token>14</token>
<token>11</token>
<token>40</token>
<token>23</token>
```

### Definido en

EXSLT - STR:TOKENIZE

### Implementación en Gecko

Implementado en Gecko 1.9 y posteriores.
split
=====

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

`str:split()` divide una cadena usando una cadena patrón que determina donde deberían ocurrir las divisiones y devuelve un conjunto de nodos que contiene las cadenas resultantes.

### Sintaxis
```

str:split(cadena,patron)
```

### Argumentos

`cadena`

La cadena a dividir.

`patron`

El patrón que indica por donde dividir la cadena.

### Devuelve

Un conjunto de nodos de elementos `token`, donde cada uno contiene un trozo (token) de la `cadena`.

Por ejemplo:
```

str:split('libro, teléfono, ordenador, silla', ', ')
```


Devuelve un conjunto de nodos como este:
```

<token>libro</token>
<token>teléfono</token>
<token>ordenador</token>
<token>silla</token>
```

### Definido en

EXSLT - STR:SPLIT

### Implementación en Gecko

Implementado en Gecko 1.9 y posteriores.
concat
======

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

`str:concat()` devuelve una cadena que contiene todos los valores cadena de un conjunto de nodos (node-set) concatenados juntos.

### Sintaxis
```

str:concat(conjuntoNodos)
```

### Argumentos

`conjuntoNodos`

El conjunto de nodos cuyos valores de cadena de los nodos deberían ser concatenados en una cadena.

### Devuelve

Una cadena cuyo valor es el de todos los valores cadena de los nodos de `conjuntoNodos` concatenados juntos. Si `conjuntoNodos` está vacío, se devuelve una cadena vacía.

### Definido en

EXSLT - STR:CONCAT

### Implementación en Gecko

Implementado en Gecko 1.9 y posteriores.
match
=====

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

`regexp:match()` realiza la búsqueda de coincidencias de una expresión regular en una cadena, devolviendo las subcoincidencias halladas como resultado.

### Sintaxis
```

regexp:match(objetivo,expresionRegular[[,opciones]])
```

### Argumentos

`objetivo`

Cadena sobre la que se realiza la búsqueda de coincidencias con la expresión regular.

`expresionRegular`

Expresión regular a evaluar en estilo JavaScript.

`opciones`

Cadena opcional que contiene los caracteres con opciones.

Los caracteres con opciones son:

`g` - Coincidencia global

Se devuelven las subcoincidencias de cada coincidencia en la cadena. Si esta opción no se especifica, sólo se devolverán las subcoincidencias del primer emparejamiento.

`i` - Coincidencia sin importar las mayúsculas

Si se especifica esta opción, el emparejamiento se realiza de modo que no se tenga encuenta las mayúsculas.

### Devuelve

Un conjunto de nodos de elementos `match`, cada uno de los cuales tiene un valor de tipo cadena igual a la porción del primer parámetro de la cadena capturado por la expresión regular. Si la coincidencia no es de tipo global, el primer elemento match tiene el valor de la porción de cadena que coincide con la expresión regular completa.

Por ejemplo:


```xml
<xsl:for-each select="regExp:match('http://developer.mozilla.org/en/docs/Firefox\_3\_for\_developers',
 '(\w+):\/\/([^/:]+)(:\d\*)?([^# ]\*)')">
    Parte <xsl:value-of select="position()" /> = <xsl:value-of select="." />
</xsl:for-each>
```


Este código genera el siguiente resultado:
```

Parte 1 = http://developer.mozilla.org/en/docs/Firefox_3_for_developers
Parte 2 = http
Parte 3 = developer.mozilla.org
Parte 4 =
Parte 5 = /en/docs/Firefox_3_for_developers
```

### Definido en

EXSLT - REGEXP:MATCH

### Implementación de Gecko

Implementado en Gecko 1.9 y posteriores.
replace
=======

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

`regexp:replace()` reemplaza porciones de una cadena que coincide con la expresión regular dada por el contenido de otra cadena.

### Sintaxis
```

regexp:replace(original,expresionRegular,reemplazo[,opciones])
```

### Arguments

`original`

Cadena sobre la que se realiza la operación de búsqueda y reemplazo.

`expresionRegular`

Expresión regular a evaluar en estilo JavaScript.

`reemplazo`

Cadena con la que las subcadenas coincidentes serán reemplazadas.

`opciones`

Una cadena opcional que contiene caracteres con las opciones.

Los caracteres de opciones son:

`g` - Reemplazo global

Si se especifica esta opción, todas las ocurrencias de la expresión regular dentro de `original` serán reemplazadas. De otro modo sólo se reemplaza la primera ocurrencia.

`i` - Coincidencia sin importar mayúsculas

Si se especifica esta opción, el emparejamiento se realiza de modo que no importen las mayúsculas.

### Devuelve

La versión revisada de la cadena.

### Definido en

EXSLT - REGEXP:REPLACE

### Implementación de Gecko

Implementado en Gecko 1.9 y posteriores.
test
====

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

`regexp:test()` comprueba si una cadena coincide con una expresión regular especificada.

### Sintaxis
```

regexp:test(comprobacion,expresionRegular[,opciones])
```

### Argumentos

`comprobacion`

Cadena a comprobar.

`expresionRegular`

Expresión regular a evaluar en estilo JavaScript.

`opciones`

Cadena opcional que contiene los caracteres con opciones.

Los caracteres con opciones son:

`g` - Coincidencia global

No tiene efecto para esta función; se permite para mantener la consistencia con otras funciones relacionadas con expresiones regulares.

`i` - Coincidencia sin importar mayúsculas

Si se especifica esta opción el emparejamiento se realiza sin tener en cuenta las mayúsculas.

### Devuelve

`true` si la expresión regular especificada coincide on la cadena de comprobación.

### Definido en

EXSLT - REGEXP:TEST

### Implementación en Gecko

Implementado en Gecko 1.9 y posteriores.
Métodos de petición HTTP
========================

HTTP define un conjunto de **métodos de petición** para indicar la acción que se desea realizar para un recurso determinado. Aunque estos también pueden ser sustantivos, estos métodos de solicitud a veces son llamados *HTTP verbs*. Cada uno de ellos implementan una semántica diferente, pero algunas características similares son compartidas por un grupo de ellos: ej. un *request method* puede ser safe, idempotent (en-US), o cacheable.

`GET`

El método `GET` solicita una representación de un recurso específico. Las peticiones que usan el método `GET` sólo deben recuperar datos.

`HEAD` (en-US)

El método `HEAD` pide una respuesta idéntica a la de una petición GET, pero sin el cuerpo de la respuesta.

`POST`

El método `POST` se utiliza para enviar una entidad a un recurso en específico, causando a menudo un cambio en el estado o efectos secundarios en el servidor.

`PUT`

El modo `PUT` reemplaza todas las representaciones actuales del recurso de destino con la carga útil de la petición.

`DELETE`

El método `DELETE` borra un recurso en específico.

`CONNECT`

El método `CONNECT` establece un túnel hacia el servidor identificado por el recurso.

`OPTIONS` (en-US)

El método `OPTIONS` es utilizado para describir las opciones de comunicación para el recurso de destino.

`TRACE`

El método `TRACE` realiza una prueba de bucle de retorno de mensaje a lo largo de la ruta al recurso de destino.

`PATCH`

El método `PATCH` es utilizado para aplicar modificaciones parciales a un recurso.

Especificaciones
----------------

| Especificación | Título | Comentario |
| --- | --- | --- |
| RFC 7231, sección 4: Métodos de petición | Protocolo de Transferencia de HiperTexto (HTTP/1.1): Semánticas y Contenido | Especifica GET, HEAD, POST, PUT, DELETE, CONNECT, OPTIONS, TRACE. |
| RFC 5789, sección 2: Método Patch | Método PATCH para HTTP | Especifica PATCH. |

Compatibilidad del navegador
----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* HTTP headers
GET
===

El método HTTP **`GET`** solicita una representación del recurso especificado. Las solicitudes que usan **`GET`** solo deben usarse para recuperar datos (no deben incluir datos).

| Petición con cuerpo | No |
| --- | --- |
| Respuesta válida con cuerpo | Sí |
| Seguro | Sí |
| idempotente | Sí |
| Cacheable | Sí |
| Permitido en HTML forms | Sí |

Sintaxis
--------
```

GET /index.html
```

Especificaciones
----------------

| Specification |
| --- |
| HTTP Semantics # GET |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `Range`
CONNECT
=======

El método **HTTP `CONNECT`** inicia la comunicación en dos caminos con la fuente del recurso solicitado. Puede ser usado para abrir una comunicación tunel.

Por ejemplo, el método `CONNECT` puede ser usado para acceder a sitios web que usan SSL (en-US) (HTTPS). El cliente realiza la petición al Servidor Proxy HTTP para establecer una conexión tunel hacia un destino deseado. Entonces el servidor Proxy procede a realizar la conexión en nombre del cliente, una vez establecida la conexión con el servidor deseado, el servidor Proxy envía los datos desde y hacia el cliente.

El método `CONNECT` es un método de salto entre servidores.

| Contiene cuerpo la petición | No |
| --- | --- |
| La respuesta exitosa contiene cuerpo | Si |
| Safe | No |
| Idempotent (en-US) | No |
| Cacheable | No |
| Permitido en formas HTML (en-US) | No |

Sintaxis
--------
```

CONNECT www.example.com:443 HTTP/1.1
```

Ejemplo
-------

Algunos servidores proxy pueden necesitar autorización para crear tuneles. Consulta el encabezado `Proxy-Authorization` (en-US) .


```http
CONNECT server.example.com:80 HTTP/1.1
Host: server.example.com:80
Proxy-Authorization: basic aGVsbG86d29ybGQ=
```

Especificaciones
----------------

| Specification |
| --- |
| HTTP Semantics # CONNECT |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* Proxy server (en-US)
* `Proxy-Authorization` (en-US)
PUT
===

La **petición HTTP PUT** crea un nuevo elemento o reemplaza una representación del elemento de destino con los datos de la petición.

La diferencia entre el método `PUT` y el método `POST` es que `PUT` es un método idempotente: llamarlo una o más veces de forma sucesiva tiene el mismo efecto (sin efectos secundarios), mientras que una sucesión de peticiones `POST` idénticas pueden tener efectos adicionales, como envíar una orden varias veces.

|  |  |
| --- | --- |
| Petición con cuerpo | Sí |
| Respuesta (correcta) con cuerpo | No |
| Seguro | No |
| Idempotente | Yes |
| Cacheable | No |
| Permitido en HTML forms (en-US) | No |

Sintaxis
--------
```

PUT /nuevo.html HTTP/1.1
```

Ejemplos
--------

### Petición
```

PUT /nuevo.html HTTP/1.1
Host: ejemplo.com
Content-type: text/html
Content-length: 16

<p>Nuevo Archivo</p>
```

### Respuestas

Si el elemento de destino no existe y la petición `PUT` lo crea de forma satisfactoria, entonces el servidor debe informar al usuario enviando una respuesta `201` (`Created`) .
```

HTTP/1.1 201 Created
Content-Location: /nuevo.html
```


Si el elemento existe actualmente y es modificado de forma satisfactoria, entonces el servidor de origen debe enviar una respuesta `200` (`OK`) o una respuesta `204` (en-US) (`No Content`) para indicar que la modificación del elemento se ha realizado sin problemas.
```

HTTP/1.1 204 No Content
Content-Location: /existente.html
```

Especificaciones
----------------

| Specification |
| --- |
| HTTP Semantics # PUT |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `201`
* `204` (en-US)
TRACE
=====

El **método HTTP `TRACE`** efectúa una prueba de bucle de mensaje por el camino al recurso objetivo proporcionando un útil mecanismo de debugging.

El destino final de la petición debería devolver el mensaje recibido, excluyendo algunos de los campos descritos abajo, de vuelta al cliente como el mensaje body y una respuesta 200 (OK) con un `Content-Type` de `message/http`. El destinatario final es o el servidor de origen o el primer servidor en recibir un `Max-Forwards` (en-US) de valor 0 en la petición.

| Request has body | No |
| --- | --- |
| Successful response has body | No |
| Safe | Yes |
| Idempotent (en-US) | Yes |
| Cacheable | No |
| Allowed in HTML forms | No |

Sintaxis
--------
```

TRACE /index.html
```

Especificaciones
----------------

| Specification |
| --- |
| HTTP Semantics # TRACE |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* HTTP methods
PATCH
=====

El **método HTTP PATCH** aplica modificaciones parciales a un recurso.

El método HTTP PUT únicamente permite reemplazar completamente un documento. A diferencia de `PUT`, el método `PATCH` no es idempotente, esto quiere decir que peticiones identicas sucesivas *pueden* tener efectos diferentes. Sin embargo, es posible emitir peticiones `PATCH` de tal forma que sean idempotentes.

`PATCH` (al igual que `POST`) *puede* provocar efectos secundarios a otros recursos.

Para averiguar si un servidor soporta `PATCH`, el servidor puede notificar su compatibilidad al añadirlo a la lista en el header: `Allow` o `Access-Control-Allow-Methods` (para CORS).

Otra indicación (implícita) de que las peticiones PATCH son permitidas, es la presencia del header: `Accept-Patch` (en-US), el cual especifica los formatos de documento patch aceptados por el servidor.

|  |  |
| --- | --- |
| Petición con cuerpo | Sí |
| Respuesta exitosa con cuerto | Sí |
| Seguro | No |
| Idempotente | No |
| Cacheable | No |
| 
 Permitido en
 formularios HTML (en-US) | No |

Sintaxis
--------
```

PATCH /file.txt HTTP/1.1
```

Ejemplo
-------

### Petición


```http
PATCH /file.txt HTTP/1.1
Host: www.example.com
Content-Type: application/example
If-Match: "e0023aa4e"
Content-Length: 100

[description of changes]
```

### Respuesta

Una respuesta exitosa es indicada con un código de respuesta `204` (en-US), porque la respuesta no tiene mensaje en el body. (el cual tendría una respuesta con el código 200). Tenga en cuenta que también se pueden utilizar otros códigos.
```

HTTP/1.1 204 No Content
Content-Location: /file.txt
ETag: "e0023aa4f"
```

Especificaciones
----------------

| Especificación | Título |
| --- | --- |
| RFC 5789: PATCH | PATCH Method for HTTP |

Ver también
-----------

* `204` (en-US)
* `Allow`, `Access-Control-Allow-Methods`
* `Accept-Patch` (en-US) – specifies the patch document formats accepted by the server.
DELETE
======

El **método de solicitud HTTP `DELETE`** elimina el recurso especificado.

|  |  |
| --- | --- |
| Petición con cuerpo | Puede |
| Respuesta válida con cuerpo | Puede |
| Seguro (en-US) | No |
| Idempotente (en-US) | Si |
| Se puede almacenar en Cache | No |
| Permitido en formularios HTML | No |

Sintaxis
--------


```http
DELETE /file.html HTTP/1.1
```

Ejemplo
-------

### Petición


```http
DELETE /file.html HTTP/1.1
Host: example.com
```

### Respuestas

Si se aplica correctamente el método `DELETE`, hay varios códigos de estado de respuesta posibles:

* Un código de estado `202` (`Accepted`) si la acción ha sido
 exitosa pero aún no se ha ejecutado.
* Un código de estado `204` (en-US) (`No Content`) si la acción se ha
 ejecutado y no se debe proporcionar más información.
* Un código de estado `200` (`OK`) si la acción se ha ejecutado
 y el mensaje de respuesta incluye una representación que describe el estado.


```http
HTTP/1.1 200 OK
Date: Wed, 21 Oct 2015 07:28:00 GMT

<html>
  <body>
    <h1>Archivo eliminado.</h1>
  </body>
</html>
```

Especificaciones
----------------

| Specification |
| --- |
| HTTP Semantics # DELETE |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Véase también
-------------

* Estado HTTP: `200`, `202`, `204` (en-US)