recursal/MDN huggingface dataset:
Opérateur de groupement
=======================

L'opérateur de groupement `( )` contrôle la précédence de l'évaluation dans les expressions.

Exemple interactif
------------------

Syntaxe
-------


```js
( )
```

Description
-----------

L'opérateur de groupement consiste en une paire de parenthèses encadrant une expression et permettant de surcharger la précédence normale des opérateurs afin que les expressions dont la précédence est plus basse soient évaluées avant.

Exemples
--------

Normalement, la multiplication et la division sont prises en compte avant l'addition et la soustraction. On peut changer ce comportement avec l'opérateur de groupement.


```js
var a = 1;
var b = 2;
var c = 3;

// précédence normale
a + b \* c; // 7
// l'évaluation est effectuée de cette façon
a + (b \* c); // 7

// précédence surchargée avec le groupement
// on additionne avant de multiplier
(a + b) \* c; // 9

// mathématiquement, cela est équivalent à
a \* c + b \* c; // 9
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-grouping-operator |

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* Précédence des opérators
* `delete`
* `typeof`
Affectation après ET binaire (&=)
=================================

L'opérateur d'affectation après ET binaire (`&=`) utilise la représentation binaire des deux opérandes, applique un ET logique entre chaque puis affecte le résultat de l'opération à la variable représentée par l'opérande gauche.

Exemple interactif
------------------

Syntaxe
-------


```js
Opérateur: x &= y;
Signification: x = x & y;
```

Exemples
--------

### Utiliser l'affectation après ET binaire


```js
let a = 5;
// 5: 00000000000000000000000000000101
// 2: 00000000000000000000000000000010
a &= 2; // 0
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-assignment-operators |

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* Les opérateurs d'affectation dans le guide JavaScript
* L'opérateur ET binaire
OU exclusif binaire (^)
=======================

L'opérateur binaire OU exclusif (XOR) (`^`) renvoie un nombre dont la représentation binaire est une séquence de bits où il y a un `1` pour chaque position où exactement un des bits des deux opérandes vaut `1`.

Exemple interactif
------------------

Syntaxe
-------


```js
a ^ b;
```

Description
-----------

Les opérandes sont convertis en entiers sur 32 bits et exprimés comme une séquence de bits. Les nombres sur plus de 32 bits ont leurs bits en excès écartés. Par exemple, l'entier suivant nécessite plus de 32 bits pour être représenté et il sera converti en un entier sur 32 bits :
```

Avant:  11100110111110100000000000000110000000000001
Après:              10100000000000000110000000000001
```


Chaque bit du premier opérande est associé avec le bit correspondant du second opérande. Lorsqu'exactement un de ces bit vaut 1, le bit correspondant du résultat sera placé à 1. Le résultat est donc construit binairement.

La table de vérité pour l'opérateur OU exclusif (XOR) est :

| a | b | a XOR b |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
```

.    9 (base 10) = 00000000000000000000000000001001 (base 2)
    14 (base 10) = 00000000000000000000000000001110 (base 2)
                   --------------------------------

14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)
```


Utiliser le OU exclusif binaire avec n'importe quel nombre `x` d'une part et `0` d'autre part renverra `x`.

Exemples
--------

### Utiliser le OU exclusif binaire


```js
// 9 (00000000000000000000000000001001)
// 14 (00000000000000000000000000001110)

14 ^ 9;
// 7 (00000000000000000000000000000111)
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # prod-BitwiseXORExpression |

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* Les opérateurs binaires dans le guide javascript
* L'opérateur ET binaire et d'affectation
Affectation après ET logique (&&=)
==================================

L'opérateur d'affectation après ET logique (`x &&= y`) n'affecte la valeur de l'opérande droit uniquement si l'opérande gauche est équivalent à vrai (*truthy*).

Exemple interactif
------------------

Syntaxe
-------


```js
expr1 &&= expr2;
```

Description
-----------

### Évaluation en court-circuit

L'opérateur ET logique est évalué de gauche à droite et le moteur vérifie s'il peut utiliser un court-circuit avec la régle suivante :

`(une expression équivalente à faux) && expr` sera court-circuitée pour fournir directement l'expression équivalente à faux.

Ce « court-circuit » indique que `expr` **n'est pas évaluée**. Tout effet de bord lié à cette évaluation n'aura pas lieu (par exemple si `expr` est un appel de fonction, la fonction n'est pas exécutée).

L'opérateur d'affectation après ET logique utilise également ce court-circuit et `x &&= y` est donc équivalent à :


```js
x && (x = y);
```


En revanche, **il n'est pas équivalent** à ce qui suit, et qui effectue quoi qu'il arrive une affectation :


```js
x = x && y;
```

Exemples
--------

### Utiliser l'affectation après ET logique


```js
let x = 0;
let y = 1;

x &&= 0; // 0
x &&= 1; // 0
y &&= 1; // 1
y &&= 0; // 0
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-assignment-operators |

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* L'opérateur ET logique (&&)
* L'opérateur de coalescence des nuls (`??`)
* L'opérateur d'affectation après ET binaire (`&=`)
* Le type `Boolean`
* *Truthy*
* *Falsy*
Affectation après OU binaire (|=)
=================================

L'opérateur d'affectation après OU binaire (`|=`) utilise la représentation binaire des deux opérandes et effectue un OU logique entre chaque puis affecte le résultat à la variable représentée par l'opérande gauche.

Exemple interactif
------------------

Syntaxe
-------


```js
Opérateur: x |= y;
Signification: x = x | y;
```

Exemples
--------

### Utiliser l'affectation après OU binaire


```js
let a = 5;
a |= 2; // 7
// 5: 00000000000000000000000000000101
// 2: 00000000000000000000000000000010
// -----------------------------------

// 7: 00000000000000000000000000000111
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-assignment-operators |

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* Les opérateurs d'affectation dans le guide JavaScript
* L'opérateur OU binaire
* L'opérateur d'affectation après OU logique (`||=`)
yield\*
=======

Une **expression `yield*`** est utilisée afin de déléguer le mécanisme d'itération/génération à un autre `générateur` ou à un autre objet itérable.

Exemple interactif
------------------

Syntaxe
-------


```js
yield \* expression;
```


`expression`

L'expression qui renvoie un objet itérable.

Description
-----------

L'expression `yield*` itère sur l'opérande et génère chaque valeur générée par l'opérande.

La valeur de l'expression `yield*` est la valeur renvoyée par l'itérateur lorsque celui est terminé (la propriété `done` vaut `true`).

Exemples
--------

### Délégation de la génération

Dans le code suivant, les valeurs générées par `g1()` sont renvoyées grâce aux appels à la fonction `next()`, comme pour celles renvoyées par `g2()`.


```js
function\* g1() {
  yield 2;
  yield 3;
  yield 4;
}
function\* g2() {
  yield 1;
  yield\* g1();
  yield 5;
}

var iterator = g2();

console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 3, done: false }
console.log(iterator.next()); // { value: 4, done: false }
console.log(iterator.next()); // { value: 5, done: false }
console.log(iterator.next()); // { value: undefined, done: true }
```

### Les autres objets itérables

`yield*` peut également être utilisé avec d'autres sortes d'itérables (chaînes, tableaux ou arguments) :


```js
function\* g3() {
  yield\* [1, 2];
  yield\* "34";
  yield\* Array.from(arguments);
}

var iterator = g3(5, 6);

console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: "3", done: false }
console.log(iterator.next()); // { value: "4", done: false }
console.log(iterator.next()); // { value: 5, done: false }
console.log(iterator.next()); // { value: 6, done: false }
console.log(iterator.next()); // { value: undefined, done: true }
```

### La valeur de l'expression yield\*

`yield*` est une expression et non une instruction, elle est donc évaluée et fournit une valeur :


```js
function\* g4() {
  yield\* [1, 2, 3];
  return "toto";
}

var résultat;

function\* g5() {
  résultat = yield\* g4();
}

var iterator = g5();

console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 3, done: false }
console.log(iterator.next()); // { value: undefined, done: true }, g4() renvoie{ value: "toto", done: true } at this point

console.log(résultat); // "toto"
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator-function-definitions-runtime-semantics-evaluation |

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* Le protocole itérateur
* L'instruction `function*`
* L'expression `function*`
* `yield`
Affectation après addition (+=)
===============================

L'opérateur d'addition et d'affectation (`+=`) calcule la somme ou la concaténation de ses deux opérandes puis affecte le résultat à la variable représentée par l'opérande gauche. C'est le type des opérandes qui détermine s'il y a somme ou concaténation.

Exemple interactif
------------------

Syntaxe
-------


```js
Opérateur: x += y;
Signification: x = x + y;
```

Exemples
--------

### Utiliser l'opérateur d'addition et d'affectation


```js
let toto = "toto";
let truc = 5;
let machin = true;

// nombre + nombre -> addition
truc += 2; // 7

// booléen + nombre -> addition
machin += 1; // 2

// booléen + booléen -> addition
machin += false; // 1

// nombre + chaîne de caractères -> concaténation
truc += "toto"; // "5toto"

// chaîne de caractères + booléen -> concaténation
toto += false; // "totofalse"

// chaîne de caractères + chaîne de caractères -> concaténation
toto += "truc"; // "tototruc"
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-assignment-operators |

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* Les opérateurs d'affectation dans le guide JavaScript
* L'opérateur d'addition/concaténation
NON binaire (~)
===============

L'opérateur binaire NON (`~`) prend l'opposé de chaque bit de son opérande et fournit la valeur ainsi obtenue. À l'instar des autres opérateurs binaires, il convertit son opérande en un entier signé sur 32 bits.

Exemple interactif
------------------

Syntaxe
-------


```js
~a;
```

Description
-----------

L'opérande est converti en un entier signé sur 32 bits. Les nombres avec plus de 32 bits voient leurs bits les plus significatifs être tronqués. Voici un exemple où l'entier qui suit est supérieur à une valeur pouvant être exprimée sur 32 bits : la conversion écrête la valeur pour obtenir un entier signé sur 32 bits :
```

Avant : 11100110111110100000000000000110000000000001
Après :             10100000000000000110000000000001
```


Pour former le résultat, chaque bit qui compose l'opérande est inversé.

La table de vérité pour l'opération `NON` est :

| a | NON a |
| --- | --- |
| 0 | 1 |
| 1 | 0 |


```js
 9 (base 10) = 00000000000000000000000000001001 (base 2)
               --------------------------------

~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10)
```


L'entier signé sur 32 bits est inversé selon le complément à deux. Autrement dit, la présence du bit le plus significatif est utilisée pour exprimer des entiers négatifs.

Appliquer un NON binaire sur n'importe quel nombre `x` fournira la valeur `-(x + 1)`. Ainsi, `~-5` renverra `4`.

Étant donné l'utilisation d'une représentation sur 32 bits, `~-1` et `~4294967295` (2^32 - 1) donneront tous les deux `0`.

Exemples
--------

### Utiliser le NON binaire


```js
~0; // -1
~-1; // 0
~1; // -2
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-bitwise-not-operator |

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* Les opérateurs binaires dans le guide JavaScript
Indications du client (client hints)
====================================

Les **indications du client** (*client hints* en anglais) sont un ensemble d'en-têtes de requêtes HTTP qu'un serveur peut demander de façon proactive à un client afin de connaître les caractéristiques spécifiques à l'appareil du client et aux préférences utilisées dans l'agent utilisateur. L'ensemble des en-têtes pour ces « indications » sont listées dans En-têtes HTTP > Indications du client.

Un serveur doit annoncer sa prise en charge de telles indications via l'en-tête `Accept-CH` (en-US) qui contiendra les indications du client qui l'intéressent. Lorsqu'un client qui prend en charge cette fonctionnalité reçoit cet en-tête `Accept-CH`, il ajoute les en-têtes d'indication correspondantes aux requêtes suivantes.

Ainsi, après avoir reçu l'en-tête `Accept-CH` suivant dans une réponse. Le client pourrait ajouter les en-têtes `Width` (en-US), `Viewport-Width` (en-US), et `Downlink` (en-US) aux requêtes suivantes.
```

Accept-CH: Width, Viewport-Width, Downlink
```


Le serveur peut alors utiliser ces informations du client pour déterminer les ressources à lui envoyer.

**Note :** Les indications du client peuvent aussi être formulées en HTML à l'aide de l'élément `<meta>` avec l'attribut `http-equiv` :


```html
<meta http-equiv="Accept-CH" content="Width, Viewport-Width, Downlink" />
```


Client Hints Infrastructures variables
--------------------------------------

Afin d'indiquer à la gestion du cache que les indications du client peuvent modifier la teneur de la réponse, il faudra utiliser l'en-tête HTTP `Vary`.

Exemple de réponse variable :
```

Vary: Accept, Width, Viewport-Width, Downlink
```

Voir aussi
----------

* En-têtes HTTP pour ces indications
* En-tête HTTP `Vary`
* Infrastructure générale pour les indications du client
Méthodes de requête HTTP
========================

HTTP définit un ensemble de **méthodes de requête** qui indiquent l'action que l'on souhaite réaliser sur la ressource indiquée. Bien qu'on rencontre également des noms (en anglais), ces méthodes sont souvent appelées *verbes HTTP*. Chacun d'eux implémente une sémantique différente mais certaines fonctionnalités courantes peuvent être partagées par différentes méthodes (e.g. une méthode de requête peut être sûre (*safe*), idempotente ou être mise en cache (*cacheable*)).

`GET`

La méthode `GET` demande une représentation de la ressource spécifiée. Les requêtes GET doivent uniquement être utilisées afin de récupérer des données.

`HEAD`

La méthode `HEAD` demande une réponse identique à une requête GET pour laquelle on aura omis le corps de la réponse (on a uniquement l'en-tête).

`POST`

La méthode `POST` est utilisée pour envoyer une entité vers la ressource indiquée. Cela entraîne généralement un changement d'état ou des effets de bord sur le serveur.

`PUT`

La méthode `PUT` remplace toutes les représentations actuelles de la ressource visée par le contenu de la requête.

`DELETE`

La méthode `DELETE` supprime la ressource indiquée.

`CONNECT`

La méthode `CONNECT` établit un tunnel vers le serveur identifié par la ressource cible.

`OPTIONS`

La méthode `OPTIONS` est utilisée pour décrire les options de communications avec la ressource visée.

`TRACE`

La méthode `TRACE` réalise un message de test aller/retour en suivant le chemin de la ressource visée.

`PATCH`

La méthode `PATCH` est utilisée pour appliquer des modifications partielles à une ressource.

Spécifications
--------------

| Specification |
| --- |
| HTTP Semantics # CONNECT |
| HTTP Semantics # DELETE |
| HTTP Semantics # GET |
| HTTP Semantics # HEAD |
| HTTP Semantics # OPTIONS |
| HTTP Semantics # POST |
| HTTP Semantics # PUT |
| HTTP Semantics # TRACE |

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* Les en-têtes (*headers*) HTTP
GET
===

La **méthode HTTP GET** demande une représentation de la ressource spécifiée. Les requêtes GET doivent uniquement être utilisées afin de récupérer des données.

|  |  |
| --- | --- |
| La requête a un corps | Non |
| Une réponse de succès a un corps | Oui |
| Sûre | Oui |
| Idempotente | Oui |
| Peut être mise en cache | Oui |
| Autorisée dans les formulaires HTML | Oui |

Syntaxe
-------
```

GET /index.html
```

Spécifications
--------------

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

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* `Range` (en-US)
DELETE
======

La **méthode HTTP DELETE** supprime la ressource indiquée.

|  |  |
| --- | --- |
| La requête a un corps | Non |
| Une réponse de succès a un corps | Non |
| Sûre | Non |
| Idempotente | Oui |
| Peut être mise en cache | Non |
| 
 Autorisée dans les
 formulaires HTML | Non |

Syntaxe
-------
```

DELETE /file.html HTTP/1.1
```

Exemple
-------

### Requête
```

DELETE /file.html HTTP/1.1
```

### Réponses

Si une méthode `DELETE` est appliquée avec succès, il y a plusieurs codes de statut de réponse possibles :

* Un code de statut `202` (`Accepted`) si l'action est en passe de réussir mais n'a pas encore été confirmée.
* Un code de statut `204` (`No Content`) si l'action a été confirmée et qu'aucune information supplémentaire n'est à fournir.
* Un code de statut `200` (`OK`) si l'action a été confirmée et que le message de réponse inclut une représentation décrivant le statut.
```

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

<html>
  <body>
    <h1>File deleted.</h1>
  </body>
</html>
```

Spécifications
--------------

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

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* HTTP status: `200`, `202`, `204`
PATCH
=====

La **méthode `PATCH` d'une requête HTTP** applique des modifications partielles à une ressource.

La méthode HTTP `PUT` est déjà définie pour écraser une ressource avec un nouveau corps complet de message, et pour la méthode HTTP `POST`, il n'existe aucun moyen standard pour découvrir le support de format de patch. Tout comme `POST`, la méthode HTTP `PATCH` n'est pas listée comme étant idempotent, contrairement à `PUT`. Cela signifie que les requêtes patch identiques et successives auront des effets différents sur l'objet manipulé.

Pour découvrir si un serveur supporte la méthode PATCH, un serveur peut annoncer son support en l'ajoutant à la liste des méthodes autorisées dans les headers de la réponse `Allow` ou encore `Access-Control-Allow-Methods` (pour CORS).

Une autre indication (implicite) que la méthode PATCH est autorisée est la présence du header `Accept-Patch` (en-US).

|  |  |
| --- | --- |
| La requête possède un corps de message (body) | Oui |
| 
 Une requête traitée avec succès retourne une réponse avec un corps de
 message (body)
  | Non |
| Safe | Non |
| Idempotent | Non |
| Cacheable | Non |
| 
 Utilisation au sein des
 formulaires HTML | Non |

Syntaxe
-------
```

PATCH /file.txt HTTP/1.1
```

Exemple
-------

### Requête
```

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

[description des changements]
```

### Réponse

Une requête traitée avec succès retourne une réponse accompagnée d'un code de réponse `204`. Dans ce cas-ci, la réponse ne contient un corps de message.
```

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

Spécifications
--------------

| Specification |
| --- |
| RFC 5789  |

Compatibilité des navigateurs
-----------------------------

{{Compat}}Voir aussi
----------

* `204`
* `Allow`, `Access-Control-Allow-Methods`
* `Accept-Patch` (en-US) – spécifie les formats de document de patch acceptés par le serveur.
TRACE
=====

La **méthode HTTP `TRACE`** effectue un test de rebouclage des messages le long du chemin vers la ressource cible, fournissant ainsi un mécanisme de débogage utile.

Le destinataire final de la demande doit renvoyer au client le message reçu, à l'exclusion de certains champs décrits ci-dessous, en tant que corps de message d'une réponse `200`. (OK) avec un `Content-Type` de `message/http`. Le destinataire final est soit le serveur d'origine, soit le premier serveur à recevoir une valeur `Max-Forwards` (en-US) de 0 dans la requête.

|  |  |
| --- | --- |
| La demande a un corps | Non |
| Une réponse réussie a un corps | Non |
| Safe | Oui |
| Idempotent | Oui |
| Cacheable | Non |
| Autorisé dans les formulaires HTML | Non |

Syntaxe
-------
```

TRACE /index.html
```

Spécifications
--------------

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

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* Méthodes HTTP
HEAD
====

La **méthode HTTP `HEAD`** demande les en-têtes qui seraient retournés si la ressource spécifiée était demandée avec une méthode HTTP `GET`. Une telle requête peut être envoyée avant de procéder au téléchargement d'une ressource volumineuse, par exemple pour économiser de la bande passante.

Une réponse issue d'une requête `HEAD` ne doit pas avoir de corps. Si tel est le cas, elle doit être ignorée. Toutefois, les en-têtes d'entité décrivant le contenu du corps, comme `Content-Length`, peuvent être inclus dans la réponse. Ils ne sont pas liés au corps de la réponse `HEAD` , qui doit être vide, mais au corps d'une réponse issue d'une requête similaire utilisant la méthode `GET`.

Si le résultat d'une requête `HEAD` montre qu'une ressource mise en cache après une requête `GET` est désormais dépassée, le cache est invalidé, même si aucune requête GET n'a été émise.

|  |  |
| --- | --- |
| La requête a un corps | Non |
| Une réponse de succès a un corps | Non |
| Sûre | Oui |
| Idempotente | Oui |
| Peut être mise en cache | Oui |
| 
 Autorisée dans les
 formulaires HTML | Non |

Syntaxe
-------
```

HEAD /index.html
```

Spécifications
--------------

| Specification |
| --- |
| HTTP Semantics # HEAD |

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* `GET`