recursal/MDN huggingface dataset:
Cellule de grille
=================

Dans une Grille CSS, une **cellule de grille** est la plus petite unité de la grille CSS. Elle est un espace entre 4 intersections lignes de grille et conceptuellement assimilable à une cellule de tableau.

![Diagram showing an individual cell on the grid.](/fr/docs/Glossary/Grid_Cell/1_grid_cell.png)

Si vous ne placez pas d'éléments à l'aide de l'une des méthodes de placement de grille, les enfants directs du conteneur de grille seront placés un dans chaque cellule individuelle par l'algorithme de placement automatique. Les pistes de ligne ou colonne supplémentaire seront créées par la création des cellules nécessaires pour contenir tous les éléments.

Dans l'exemple, nous avons créé une grille de trois colonnes. Les cinq éléments sont placés dans des cellules de la grille le long d'une rangée initiale de trois cellules de la grille, puis par l'ajout d'une nouvelle ligne pour les deux autres.

Exemple
-------
```

\* {
  box-sizing: border-box;
}

.wrapper {
  border: 2px solid #f76707;
  border-radius: 5px;
  background-color: #fff4e6;
}

.wrapper > div {
  border: 2px solid #ffa94d;
  border-radius: 5px;
  background-color: #ffd8a8;
  padding: 1em;
  color: #d9480f;
}
```



```css
.wrapper {
  display: grid;
  grid-template-columns: repeat(3, 1fr);
  grid-auto-rows: 100px;
}
```



```html
<div class="wrapper">
  <div>One</div>
  <div>Two</div>
  <div>Three</div>
  <div>Four</div>
  <div>Five</div>
</div>
```

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

### Références de propriété

* `grid-template-columns`
* `grid-template-rows`
* `grid-auto-rows`
* `grid-auto-columns`
### En lire plus

* Guide des grilles CSS : *Les concepts de base des grilles CSS*
* Définition des cellules de grille dans la spécification CSS (en)
Fermeture
=========

La contrainte qui définit la **portée** d'exécution. En JavaScript, les **fonctions** créent un contexte de fermeture.

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

### Culture générale

* Fermeture sur Wikipédia
### Référence technique

* Fermeture sur MDN
Rectangle à limitation minimum
==============================

Le **rectangle à limitation minimum** d'un élément est le plus petit rectangle possible (aligné avec les axes du système de coordonnées de l'utilisateur de cet élément) qui inclut cet élément et ses descendants.
Idempotente
===========

Une méthode HTTP est **idempotente** si une requête identique peut être faite une ou plusieurs fois de suite avec le même effet, tout en laissant le serveur dans le même état. En d'autres termes, une méthode idempotente ne doit pas avoir d'effets secondaires (sauf dans la tenue de statistiques). Implémentées correctement, les méthodes `GET`, `HEAD`, `PUT` et `DELETE` sont idempotentes, mais pas la méthode `POST`. Toutes les méthodes sécurisées sont également idempotentes.

L'idempotence implique que seul l'état réel du serveur est pris en compte et le code d'état renvoyé par chaque requête peut différer : le premier appel d'un `DELETE` retournera probablement un code `200`, tandis que les lancements successifs retourneront probablement un code `404`. Une autre implication, `DELETE` étant idempotente, les développeurs ne doivent pas implémenter d'API RESTful avec une fonctionnalité de suppression de la dernière entrée utilisant la méthode DELETE.

À noter : l'idempotence d'une méthode n'est pas garantie par le serveur et certaines applications peuvent incorrectement rompre la contrainte d'idempotence.

`GET /pageX HTTP/1.1` est idempotente. Appelée plusieurs fois de suite, le client obtient les mêmes résultats :
```

GET /pageX HTTP/1.1
GET /pageX HTTP/1.1
GET /pageX HTTP/1.1
GET /pageX HTTP/1.1
```


`POST /add_row HTTP/1.1` n'est pas idempotente ; si elle est appelée plusieurs fois, elle ajoute plusieurs lignes :
```

POST /add_row HTTP/1.1
POST /add_row HTTP/1.1   -> ajoute une 2nde ligne
POST /add_row HTTP/1.1   -> ajoute une 3ème ligne
```


`DELETE /idX/delete HTTP/1.1` est idempotente, même si le code d'état renvoyé peut changer entre les demandes :
```

DELETE /idX/delete HTTP/1.1   -> Retourne 200 si idX existe
DELETE /idX/delete HTTP/1.1   -> Retourne 404 comme il vient d'être supprimé
DELETE /idX/delete HTTP/1.1   -> Retourne 404
```

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

### Culture générale

* Définition d'idempotent dans la spécification HTTP (en).
### Savoir technique

* Description de méthodes idempotentes courantes : `GET`, `HEAD`, `PUT`, `DELETE`, `OPTIONS`
* Description d'une méthode non idempotente courante : `POST`
Repo
====

Dans les systèmes de gestion de versions comme Git ou SVN , un dépôt est l'endroit où sont hébergés le code source d'une application ainsi que diverses méta-données.

Pour en savoir plus
-------------------

* Dépôt sur Wikipédia
IIFE
====

**IIFE** (Immediately Invoked Function Expression) *(Expression de fonction invoquée immédiatement)* est une fonction JavaScript qui est exécutée dès qu'elle est définie.

C'est un modèle de conception qui est également connu sous le nom de Fonction anonyme auto-exécutable et contient deux parties principales. La première est la fonction anonyme avec portée lexicale incluse dans l'opérateur de groupement `()`. Cela empêche l'accès aux variables dans l'expression idiomatique IIFE ainsi que la pollution de la portée globale.

La deuxième partie crée la fonction immédiatement exécutable `()`, à travers laquelle le moteur JavaScript interprétera directement la fonction.

Exemples
--------

La fonction devient une expression de fonction qui est immédiatement exécutée. La variable dans l'expression ne peut pas être atteinte de l'extérieur.


```js
(function () {
  var aName = "Barry";
})();
// Le nom de la variable n'est pas accessible depuis le périmètre externe
aName; // lancement "Exception ReferenceError: aName n'est pas défini"
```


Affecter l'IIFE à une variable ne la stocke pas mais reçoit son résultat.


```js
var result = (function () {
  var name = "Barry";
  return name;
})();
// Crée immédiatement la sortie:
result; // "Barry"
```

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

### Apprendre sur ce sujet

* Exemple rapide (à la fin de la section "Les fonctions", juste avant "Les objets personnalisés")
### Culture générale

* Immediately-invoked function expression (IIFE) sur Wikipédia
Intergiciel
===========

Intergiciel (*Middleware*) est un terme (défini vaguement) pour tout logiciel ou service permettant aux parties d'un système de communiquer et de gérer des données. C'est le logiciel qui gère la communication entre les composants et les entrées / sorties, de sorte que les développeurs peuvent se concentrer sur l'objectif spécifique de leur application.

Dans les frameworks d'application web côté serveur, le terme est souvent plus spécifiquement utilisé pour désigner des composants logiciels préconstruits pouvant être ajoutés au pipeline de traitement des requêtes / réponses du framework, pour gérer des tâches telles que l'accès à la base de données.

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

### Culture générale

* *Middleware* sur Wikipédia
Truthy
======

En JavaScript, on dit en anglais qu'une valeur est ***truthy*** lorsqu'elle est considérée comme vraie (`true`) quand elle est évaluée dans un contexte booléen. Toutes les valeurs sont *truthy* sauf si elles sont définies comme *falsy* (c'est-à-dire, sauf pour `false`, `0`, `-0`, `0n`, `""`, `null`, `undefined` et `NaN`).

JavaScript utilise la contrainte de type dans un contexte booléen.

Exemples de valeurs *truthy* en JavaScript (qui seront converties en `true` dans un contexte booléen, ce qui exécutera le bloc `if`) :


```js
if (true)
if ({})
if ([])
if (42)
if ("0")
if ("false")
if (new Date())
if (-42)
if (12n)
if (3.14)
if (-3.14)
if (Infinity)
if (-Infinity)
```

### L'opérateur ET logique, &&

Si la première valeur est *truthy*, l'opérateur ET logique renvoie le deuxième opérande :


```js
true && "chien"
// renvoie "chien"

[] && "chien"
// renvoie "chien"
```

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

* `Falsy`
* Contrainte de type
* Booléen
Clé
===

Une clé est une information utilisée par un chiffre pour l'encryptage et/ou le décryptage. Les messages cryptés doivent rester sécurisés même si tout ce qui concerne le système de cryptage, sauf la clé, est de notoriété publique.

En cryptographie à clé symétrique, la même clé est utilisée pour l'encryptage et le décryptage. En cryptographie à clé publique, il existe une paire de clés connexes connues comme la *clé publique* et la *clé privée* . La clé publique est is disponible gratuitement, alors que la clé privée est gardée secrète. La clé publique est capable de chiffrer des messages que seule la clé privée correspondante est capable de déchiffrer, et vice versa.

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

* Principe de Kerckhoffs sur Wikipédia
Navigateur Opera
================

**Opera** est le cinquième navigateur web le plus utilisé, distribué publiquement en 1996 et ne fonctionnant à l'origine que sur Windows. Opera utilise Blink comme moteur de rendu depuis 2013 (avant cette date, il s'agissait de Presto). Opera existe également en versions tablette et mobile.

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

* Opera sur Wikipédia
* Site web du navigateur Opera
Axe de grille
=============

La grille CSS est une méthode de mise en page bidimensionnelle permettant une présentation du contenu en lignes et colonnes. Par conséquent, dans toute grille, nous avons deux axes. L'axe du "bloc" ou de la colonne et l'axe "en ligne" ou de la ligne.

C'est sur ces axes que les items peuvent être alignés et justifiés en utilisant les propriétés définies dans les spécifications de l'alignement des boîtes.

En CSS l'axe des colonnes (ou des blocs) est l'axe utilisé lors de la disposition des blocs de texte . Si vous avez 2 paragraphes et travaillez de droite à gauche, du haut vers le bas, ils s'alignent les uns au-dessus des autres, sur l'axe du bloc.

![Diagram showing the block axis in CSS Grid Layout.](/fr/docs/Glossary/Grid_Axis/7_block_axis.png)

L'axe de la ligne (ou en ligne) parcourt l'axe des blocs et représente la direction dans laquelle le texte est déployé. Ce sont nos lignes dans la mise en page des grilles CSS.

![Diagram showing the inline axis in CSS Grid Layout.](/fr/docs/Glossary/Grid_Axis/7_inline_axis.png)

La direction physique de ces axes peut changer en fonction du mode d'écriture du document.

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

### En lire plus

* Guide des grilles CSS : *Les concepts de base des grilles CSS*
* Guide des grilles CSS : *L'alignement des boîtes avec les grilles CSS*
* Guide des grilles CSS : *Les grilles CSS, les valeurs logiques et les modes d'écriture*
Quality values
==============

***Quality values*** (*valeurs de qualité*), ou *q-values* et *q-factors*, sont utilisés pour décrire l'ordre de priorité des valeurs séparées par une virgule dans une liste. C'est une syntaxe spéciale autorisée dans quelques en-têtes HTTP et en HTML. L'importance d'une valeur est marquée par le suffixe `';q='` immédiatement suivi par une valeur comprise entre `0` et `1` inclus, avec jusqu'à trois décimales, la valeur la plus élevée indiquant la priorité la plus haute. Quand le paramètre n'est pas déclaré, la valeur par défaut est `1`.

Exemples
--------

La syntaxe suivante :
```

text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
```


indique l'ordre de priorité :

| Valeur | Priorité |
| --- | --- |
| `text/html` et `application/xhtml+xml` | `1.0` |
| `application/xml` | `0.9` |
| `*/*` | `0.8` |

S'il n'y a pas de priorité définie pour les deux premières valeurs, l'ordre dans la liste est sans importance. Néanmoins, avec la même qualité, des valeurs plus spécifiques ont la priorité sur celles qui le sont moins :
```

text/html;q=0.8,text/*;q=0.8,*/*;q=0.8
```


| Valeur | Priorité |
| --- | --- |
| `text/html` | `0.8` (totalement spécifié) |
| `text/*` | `0.8` (partiellement spécifié) |
| `*/*` | `0.8` (non spécifié) |

Quelques syntaxes, comme celle de `Accept`, autorisent des spécificateurs supplémentaires comme `text/html;level=1`. Ceux-ci augmentent la spécificité de la valeur. Leur utilisation est extrêmement rare.

Information propre aux navigateurs
----------------------------------

### Firefox

À partir de Firefox 18, les valeurs du facteur de qualité sont fixées à 2 décimales. Elles étaient limitées à 1 décimale dans les versions antérieures (bug Firefox 672448).

Plus d'informations
-------------------

* En-têtes HTTP utilisant des *q-values* dans leur syntaxe : `Accept`, `Accept-Charset`, `Accept-Language`, `Accept-Encoding`, `TE` (en-US).
XPath
=====

**XPath** est un langage de requêtes permettant d'accéder aux sections et contenus d'un document XML.

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

### Référence technique

* Documentation XPath sur MDN
* Spécification XPath
### Culture générale

* Site web officiel
* XPath sur Wikipédia
RDF
===

**RDF** (Resource Description Framework) est un langage développé par le W3C pour représenter des informations sur le World Wide Web, comme des pages Web. RDF apporte une manière standard de coder des informations afin que celles-ci puissent être échangées de façon totalement automatisée entre applications.

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

### Culture générale

* *Resource Description Framework* sur Wikipédia
SQL
===

**SQL** (Structured Query Language) est un langage normalisé pour mettre à jour, récupérer et calculer des données dans les tables d'une base de données.

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

### Connaissances Générales

* SQL sur Wikipédia
### Apprendre le SQL

* Apprendre le SQL sur sqlzoo.net
* Tutorial Point
Axe principal
=============

L'axe principal d'une flexbox est déterminé par la direction définie dans la propriété `flex-direction`. Il y a 4 valeurs possibles pour `flex-direction`. Ce sont :

* `row` (*ligne*)
* `row-reverse`
* `column` (*colonne*)
* `column-reverse`

Si vous choisissez `row` ou `row-reverse` votre axe principal passera alors le long de la ligne dans le sens de la direction définie.

![In this image the flex-direction is row which forms the main axis](/fr/docs/Glossary/Main_Axis/basics1.png)

Choisissez `column` ou `column-reverse` et votre axe principal parcourt du début au pied de la page dans la direction du bloc.

![](/fr/docs/Glossary/Main_Axis/basics2.png)

Sur l'axe principal, vous pouvez contrôler le dimensionnement des éléments flexibles en ajoutant tout espace disponible aux éléments eux-mêmes, par le biais des propriétés `flex` sur les éléments. Ou, vous pouvez contrôler l'espace entre et autour des éléments en utilisant la propriété `justify-content`.

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

### Références de la propriété

* `flex-basis`
* `flex-direction`
* `flex-grow`
* `flex-shrink`
* `justify-content`
* `flex`
### En lire plus

* Guide Flexbox CSS : *Les concepts de base pour flexbox*
* Guide Flexbox CSS : *Aligner des éléments dans un conteneur flexible*
* Guide Flexbox CSS : *Contrôler les proportions des boîtes flexibles le long de l'axe principal*
TCP
===

**TCP (pour *Transmission Control Protocol* en anglais)** (ou « protocole de contrôle des transmissions ») est un protocole réseau qui permet à deux hôtes de se connecter et d'échanger des données. Le protocole TCP garantit la distribution des données et des paquets dans l'ordre où ils ont été envoyés. Vint Cerf et Bob Kahn, scientifiques du DARPA à l'époque, ont conçu TCP dans les années 70.

Le rôle de TCP est d'assurer la livraison fiable et sans erreur des paquets. TCP dispose d'un contrôle de concurrence, ce qui signifie que les requêtes initiales sont petites puis augmentent en taille en fonction des niveaux de bande passante que peuvent supporter les ordinateurs, les serveurs et le réseau.

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

* La page à propose de TCP sur Wikipédia
* Aperçu de HTTP
* Le fonctionnement des navigateurs
* Glossaire
    + IPv4
    + IPv6
    + Paquet
Attribut booléen (HTML)
=======================

En HTML, un **attribut booléen** est un attribut qui peut valoir `true` ou `false`.

On notera qu'un attribut booléen vaut `true` s'il est présent et `false` s'il est absent.

Voici un exemple pour l'attribut booléen HTML `checked` :


```html
<!-- Les cases à cocher suivantes seront cochées lors de l'affichage initial -->
<input type="checkbox" checked />
<input type="checkbox" checked="" />
<input type="checkbox" checked="true" />
<input type="checkbox" checked="false" />
<input type="checkbox" checked="n'importe quelle valeur" />

<!-- La case à cocher ne sera pas cochée lors de l'affichage initial -->
<input type="checkbox" />
```

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

* Liste énumérée
Booléen (JavaScript)
====================

En JavaScript, un **booléen** est une valeur primitive qui peut être `true` ou `false`.

Un objet `Boolean` est une enveloppe (*wrapper*) pour les valeurs booléennes primitives.

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

* L'objet global JavaScript `Boolean`
* Les types et structures de données en JavaScript
Attribut booléen (ARIA)
=======================

Un **attribut booléen** ARIA est un attribut à valeur contrainte qui inclut `true` ou `false` dans la liste des valeurs qu'il peut prendre.

En ARIA, les attributs booléens sont uniquement des chaînes de caractères `"true"` et `"false"`.

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

* L'entrée du glossaire pour les listes énumérées, qui contient plus de détails et d'exemples, notamment pour les attributs booléens ARIA.
Nœud (DOM)
==========

Dans le contexte du DOM, un **nœud** est un point unique dans l'arbre des nœuds du DOM. Parmi les différentes choses qui sont des nœuds, on trouve le document lui-même, les éléments, le texte et les commentaires.

Pour en savoir plus
-------------------

### Référence technique

* La spécification WHATWG des arbres de nœuds
Nœud (réseau)
=============

Dans un réseau, un **nœud** est un point unique du réseau. Dans les réseaux physiques, un nœud est en général un appareil, comme un ordinateur ou un routeur.

Pour en savoir plus
-------------------

### Culture générale

* Nœud (réseau) sur Wikipédia
Signature (sécurité)
====================

Une **signature**, ou *signature numérique*, est un protocole montrant l'authenticité d'un message.

À partir du hash d'un message donné, le **processus de signature** génère d'abord une signature numérique liée à l'entité qui effectue la signature, en utilisant la clé privée de l'entité.

À la réception du message, le **processus de vérification**

* *authentifie l'émetteur -* utilise la clé publique de l'émetteur pour déchiffrer la signature et récupérer le hash qui ne peut être créer qu'avec la clé privée de l'émetteur, et
* *contrôle l'intégrité du message -* compare le hash avec celui nouvellement calculé à partir du document reçu (les deux hashs seront différents si le document a été falsifié)

Le système échoue si la clé privée est compromise ou si le destinataire donne trompeusement une fausse clé publique.

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

### Culture générale

* Signature numérique sur Wikipédia
* Voir digest, encryption
### Référence technique

* Tutoriel sur la sécurité informatique
Signature (fonctions)
=====================

Une **signature de fonction** (ou signature de *type*, ou signature de *méthode*) définit les entrées et sorties des fonctions et des méthodes.

Une signature peut comporter :

* Des paramètres et leurs types
* une valeur et un type de retour
* des exceptions susceptibles d'être déclenchées ou reçues
* des informations sur la disponibilité de la méthode dans un programme orienté objet (telles que les mots-clés `public`, `static`, ou `prototype`).
En détail
---------

### Signatures en JavaScript

JavaScript est un langage à *typage faible et* *dynamique*. Cela signifie que vous n'avez pas à déclarer le type d'une variable à l'avance. Il sera déterminé automatiquement pendant le traitement du programme. Une signature en JavaScript peut vous apporter certaines informations sur la méthode :


```js
MonObjet.prototype.maFonction(valeur);
```


* La méthode est installée sur un objet appelé `MonObjet`.
* La méthode est installée sur le `prototype` de `MonObjet` (c'est par conséquent une méthode d'instance) par opposition à une méthode statique.
* Le nom de la méthode est `maFonction`.
* La méthode accepte un paramètre appelé `valeur` et n'est pas définie.
### Signatures en Java

En Java, les signatures servent à identifier les méthodes et les classes au niveau du code de la machine virtuelle. Vous devez déclarer les types des variables dans votre code Java afin de pouvoir l'exécuter. Java est à *typage fort* et vérifiera que chaque paramètre est correct au moment de la compilation.


```java
public static void main(String[] args)
```


* Le mot-clé `public` est un modificateur d'accessibilité et indique que cette méthode peut être appelée par n'importe quel objet.
* Le mot-clé `static` indique qu'il s'agit d'une méthode de classe, et pas de son opposé, à savoir une méthode d'instance.
* Le mot-clé `void` indique que cette méthode n'a pas de valeur de retour.
* Le nom de la méthode est `main`.
* La méthode accepte un paramètre de type tableau de chaînes. Il est nommé `args.`
`Pour approfondir`
------------------

### `Culture générale`

* Signature de type sur Wikipédia
Propriété (JavaScript)
======================

Une propriété est une caractéristique d'un objet qui décrit souvent des attributs associés à une structure de données. Il existe deux sortes de propriétés : les *Propriétés d'Instance* qui contiennent des données spécifiques à une instance d'objet donnée, et les *Propriétés Statiques* qui contiennent les données partagées par toutes les instances d'objet.

Une propriété possède un nom (une chaîne de caractères) et une valeur (primitive, méthode, ou référence d'objet). Remarquez que lorsque nous disons « une propriété contient un objet », c'est un raccourci qui signifie « une propriété contient une *référence* d'objet ». Cette distinction a son importance car l'objet d'origine référencé reste inchangé quand vous modifiez la valeur de la propriété.

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

### Culture générale

* Propriété sur Wikipédia
* Introduction à JavaScript orienté objet
Propriété (CSS)
===============

Une **propriété CSS** est une caractéristique (telle que `color`) dont la valeur associée définit un aspect de la manière dont le navigateur doit afficher l'élément.

Exemple de règle CSS:


```css
/\* "div" est un sélecteur qui indique que tous les éléments "div" \*/
/\* auront le style spécifié par cette règle \*/
div {
  /\* La propriété "color" avec la valeur "black" indique \*/
  /\* que le texte sera coloré en noir \*/
  color: black;

  /\* La propriété "background-color" avec la valeur "white" indique \*/
  /\* que l'arrière-plan des éléments sera coloré en blanc \*/
  background-color: white;
}
```

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

### Culture générale

* Apprendre CSS
### Références techniques

* Référence CSS sur MDN
* The CSS Working Group current work (en)
Block (CSS)
===========

Sur une page web, un **block** est un élément HTML qui apparaît sous l'élément précédent et au-dessus du suivant (communément connu comme un *block-level element* ). Par exemple, `<p>` est par défaut un élément de type block, alors que `<a>` est un *inline element -* vous pouvez placer plusieurs liens les uns à côté des autres dans votre source HTML et ils seront placés sur la même ligne dans la sortie rendue.

En utilisant la propriété CSS `display`, il est possible de définir si un objet doit être affiché en bloc ou en ligne (block ou inline) ; les blocs sont également soumis aux effets des schémas de positionnement et de l'utilisation de la propriété `position` .

Pour en savoir plus
-------------------

### Connaissances générales

* Modèle de mise en forme visuelle
Bloc (script)
=============

En JavaScript, un bloc est un ensemble d'instructions entouré d'accolades ("{}"). Par exemple, vous pouvez placer un bloc d'instructions après `if (condition)` pour indiquer à l'interpréteur d'ignorer la totalité du bloc si la condition est fausse.

Pour en savoir plus
-------------------

### Apprendre à ce sujet

* Bloc d'instructions en JavaScript
Ligne de base (typographie)
===========================

La **ligne de base** est une notion utilisée en typographie qui représente la ligne imaginaire sur laquelle repose les différents caractères d'un texte.

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

* La page Wikipédia sur la ligne de base
* Alignement des boîtes CSS