recursal/MDN huggingface dataset:
String.prototype.trim()
=======================

La méthode **`trim()`** permet de retirer les blancs en début et fin de chaîne. Les blancs considérés sont les caractères d'espacement (espace, tabulation, espace insécable, etc.) ainsi que les caractères de fin de ligne (LF, CR, etc.).

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

Syntaxe
-------


```js
str.trim();
```

### Valeur de retour

Une nouvelle chaîne de caractères dérivant de la chaîne appelante pour laquelle les blancs ont été retirés aux deux extrémités de la chaîne.

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

La méthode `trim()` renvoie la chaîne sans blanc au début et à la fin. La méthode `trim()` n'affecte pas la valeur de la chaîne courante.

Exemples
--------

L'exemple qui suit affiche la chaîne `'toto'` :


```js
var chaîneOriginale = " toto ";
console.log(chaîneOriginale.trim()); // 'toto'

// Un autre exemple de .trim() qui enlève les espaces juste d'un côté

var chaîneOriginale = "toto ";
console.log(chaîneOriginale.trim()); // 'toto'
```

Prothèse d'émulation (*polyfill*)
---------------------------------

Si l'environnement utilisé ne possède pas cette méthode, il est possible de l'émuler avec le fragment de code suivant :


```js
if (!String.prototype.trim) {
  String.prototype.trim = function () {
    return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
  };
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.trim |

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

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

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

* `String.prototype.trimStart()`
* `String.prototype.trimEnd()`
String.prototype.padStart()
===========================

La méthode **`padStart()`** permet de compléter la chaîne courante avec une chaîne de caractères donnée afin d'obtenir une chaîne de longueur fixée. Pour atteindre cette longueur, la chaîne complémentaire peut être répétée. La chaîne courante est complétée depuis le début.

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

Syntaxe
-------


```js
str.padStart(longueurCible [, chaîneComplémentaire])
```

### Paramètres

`longueurCible`

La longueur de la chaîne qu'on souhaite obtenir. Si la longueur indiquée est inférieure à celle de la chaîne courante, cette dernière est renvoyée telle quelle.

`chaîneComplémentaire` Facultatif

La chaîne de caractères avec laquelle on veut compléter la chaîne courante. Si cette chaîne est trop longue, on prendra uniquement le début (la partie la plus à gauche quand la langue s'écrit de gauche à droite). La valeur par défaut de ce paramètre est l'espace " " (U+0020). Si cette chaîne est trop courte, elle sera répétée.

### Valeur de retour

Une chaîne de caractères (`String`) dont la longueur est celle indiquée, complétée avec la chaîne fournie au début de la chaîne courante.

Exemples
--------


```js
"abc".padStart(10); // " abc"
"abc".padStart(10, "toto"); // "totototabc"
"abc".padStart(6, "123465"); // "123abc"
"abc".padStart(8, "0"); // "00000abc"
"abc".padStart(1); // "abc"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.padstart |

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

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

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

* `String.prototype.padEnd()`
String.prototype.search()
=========================

La méthode **`search()`** éxecute une recherche dans une chaine de caractères grâce à une expression rationnelle appliquée sur la chaîne courante.

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

Syntaxe
-------


```js
str.search(regexp);
```

### Paramètres

`regexp`

Un objet représentant une expression rationnelle. Si l'objet passé n'est pas un objet d'expression régulière, il est directement converti en une instance de `RegExp` en utilisant `new RegExp(obj)`.

### Valeur de retour

Si la recherche aboutit, `search()` renvoie un entier qui correspond à l'indice de la première correspondance trouvée dans la chaîne. Si rien n'est trouvé, la méthode renvoie `-1`.

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

Si la recherche est positive, `search()` renvoie l'indice de la première correspondance pour l'expression rationnelle au sein de la chaine de caractères. Sinon, la méthode renvoie -1.

Si on souhaite savoir si un motif est trouvé dans une chaine de caractères, on utilisera cette méthode (semblable à la méthode `test()`) du prototype de `RegExp` ; pour plus d'informations (mais une éxecution plus lente), on utilisera `match()` (semblable à la méthode `exec()` pour les expressions rationnelles). La méthode `test` est semblable mais renvoie uniquement un booléen indiquant si une correspondance a été trouvée.

Exemples
--------

Dans l'exemple suivant, on utilise une chaîne de caractères pour laquelle on applique deux expressions rationnelles (la première permet d'obtenir une correspondance et la seconde n'en trouve aucune).


```js
var maChaine = "CoucOu";
var regex1 = /[A-Z]/g;
var regex2 = /[.]/g;

console.log(maChaine.search(regex1)); // Renvoie 0, la position de la première majuscule
console.log(maChaine.search(regex2)); // Renvoie -1 car il n'y a aucun point dans la chaîne
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.search |

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

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

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

* `String.prototype.match()`
* `RegExp.prototype.exec()`
String.length
=============

La propriété **`length`** représente la longueur d'une chaine de caractères, exprimée en nombre de points de code UTF-16. C'est une propriété accessible en lecture seule.

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

Syntaxe
-------


```js
str.length;
```

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

Cette propriété renvoie le nombre de « codets » (ou unités de code ou bien *code units* en anglais) d'une chaîne de caractères UTF-16. Le format utilisé pour représenter les chaînes de caractères en JavaScript utilise un seul codet sur 16 bits pour représenter la plupart des caractères communs. En revanche, pour représenter les caractères plus rares, deux codets seront utilisés : la valeur renvoyée par `length` ne correspondra alors pas au nombre de caractères dans la chaîne.

ECMAScript 2016 (la septième édition) établit une longueur maximale de `2^53 - 1` éléments. Auparavant, aucune longueur maximale n'était spécifiée. Pour Firefox, les chaînes ont une longueur maximale de `2^30-2` caractères (environ 1 Go). Pour les versions de Firefox antérieures à Firefox 65, la taille maximale était de de `2^28-1` (environ 256 Mo).

Pour une chaine vide, on aura `length` égal à 0.

La propriété statique `String.length` renvoie la valeur 1.

Exemples
--------

### Utiliser `String.length`


```js
const x = "Mozilla";
const vide = "";

console.log(x + " mesure " + x.length + " codets");
/\* "Mozilla mesure 7 codets" \*/

console.log("La chaîne vide a une longueur de " + vide.length);
/\* "La chaîne vide a une longueur de 0" \*/
```

### Affecter une valeur à `length`


```js
const maChaine = "Sloubi";
// Lorsqu'on tente d'affecter une valeur à la propriété length
// rien d'observable ne se produit

maChaine.length = 3;
console.log(maChaine); /\* Sloubi \*/
console.log(maChaine.length); // 6
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-properties-of-string-instances-length |

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

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

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

* La propriété JavaScript `String.length` et l'internationalisation des applications web (en anglais)
String.prototype.sup()
======================

**Obsolète:** Cette fonctionnalité a été supprimée des standards du Web. Bien que quelques navigateurs puissent encore la supporter, elle est en cours d'éradication. Ne l'utilisez ni dans d'anciens projets, ni dans de nouveaux. Les pages et applications Web l'utilisant peuvent cesser de fonctionner à tout moment.

La méthode **`sup()`** crée un élément HTML `<sup>` qui entraîne l'affichage de la chaîne en exposant.

Syntaxe
-------


```js
str.sup();
```

### Valeur de retour

Une chaîne de caractères représentant un élément HTML `<sup>`.

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

 La méthode `sup` encapsule une chaîne dans une balise `<sup>` :
 `"<sup>str</sup>`".

Exemples
--------

L'exemple suivant utilise les méthodes `sub()` et `sup` pour mettre en forme une chaîne :


```js
var superText = "exposant";
var subText = "indice";

console.log("Ceci illustre l'affichage d'un texte en " + superText.sup() + ".");
// Ceci illustre l'affichage d'un texte en <sup>exposant</sup>.
console.log("Ceci illustre l'affichage d'un texte en " + subText.sub() + ".");
Ceci illustre l'affichage d'un texte en <sub>indice</sub>.
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.sup |

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

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

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

* `String.prototype.sub()`
String.prototype.big()
======================

**Obsolète:** Cette fonctionnalité a été supprimée des standards du Web. Bien que quelques navigateurs puissent encore la supporter, elle est en cours d'éradication. Ne l'utilisez ni dans d'anciens projets, ni dans de nouveaux. Les pages et applications Web l'utilisant peuvent cesser de fonctionner à tout moment.

La méthode **`big()`** crée un élément HTML `<big>` qui affichera la chaine de caractères avec une taille de police importante.

**Note :** L'élément `<big>` a été retiré de HTML5 et ne doit pas être utilisé. À la place, les développeurs web doivent utiliser les propriétés CSS.

Syntaxe
-------


```js
str.big();
```

### Valeur de retour

Une chaîne de caractères qui représente un élément HTML `<big>`.

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

 La méthode `big()` place la chaine de caractères dans une balise `<big>` :
 `"<big>str</big>`"

Exemples
--------

L'exemple suivant montre les méthodes de `String` pour changer la taille d'une chaine de caractères :


```js
var chaîneMonde = "Coucou monde";

console.log(chaîneMonde.small()); // <small>Coucou monde</small>
console.log(chaîneMonde.big()); // <big>Coucou monde</big>
console.log(chaîneMonde.fontsize(7)); // <fontsize=7>Coucou monde</fontsize>
```


Avec l'objet `element.style`, il est possible d'accéder à l'attribut `style` de l'élément et de le manipuler. Par exemple :


```js
document.getElementById("idÉlément").style.fontSize = "2em";
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.big |

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

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

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

* `String.prototype.fontsize()`
* `String.prototype.small()`
String.prototype.toUpperCase()
==============================

La méthode **`toUpperCase()`** retourne la valeur de la chaîne courante, convertie en majuscules.

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

Syntaxe
-------


```js
str.toUpperCase();
```

### Valeur de retour

Une nouvelle chaîne de caractères obtenue à partir de la chaîne appelante, passée en majuscules.

### Exceptions levées

`TypeError`

Une telle exception sera levée si on appelle cette méthode sur `null` ou `undefined` (en utilisant `Function.prototype.call()` par exemple).

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

La méthode `toUpperCase()` retourne la valeur de la chaîne convertie en majuscules. `toUpperCase` n'affecte pas la valeur de la chaîne elle-même.

Exemples
--------

### Utiliser `toUpperCase()`


```js
console.log("alphabet".toUpperCase()); // "ALPHABET"
```

### Convertir une valeur `this` en chaîne de caractères

Cette peut être utilisée pour convertir une valeur qui n'est pas une chaîne de caractères lorsque celle-ci est fournie comme valeur `this` :


```js
var obj = {
  toString: function toString() {
    return "abcdef";
  },
};
var a = String.prototype.toUpperCase.call(obj);
var b = String.prototype.toUpperCase.call(true);

console.log(a); // Affiche 'ABCDEF' dans la console
console.log(b); // Affiche 'TRUE' dans la console
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.touppercase |

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

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

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

* `String.prototype.toLocaleLowerCase()`
* `String.prototype.toLocaleUpperCase()`
* `String.prototype.toLowerCase()`
String.prototype.trimEnd()
==========================

La méthode **`trimEnd()`** permet de retirer les blancs situés à la fin d'une chaîne de caractères. `trimRight()` est un synonyme pour cette méthode.

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

Syntaxe
-------


```js
str.trimEnd();
str.trimRight();
```

### Valeur de retour

Une nouvelle chaîne de caractères basée sur la chaîne appelante et dont les blancs en fin de chaîne ont été supprimés.

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

La méthode `trimEnd()` renvoie la chaîne de caractères sans les blancs présents à partir de la droite de la chaîne. `trimEnd()` ne modifie pas la chaîne elle-même.

### Synonyme

Pour des raisons de cohérence avec les méthodes existantes comme `String.prototype.padEnd`, le nom standard de cette méthode est `trimEnd`. Toutefois, à des fins de compatibilité web, `trimRight` est un synonyme de `trimEnd`. Pour certains moteurs JavaScript, on pourra donc avoir :


```js
String.prototype.trimRight.name === "trimEnd";
```

Exemples
--------

L'exemple qui suit illustre comment afficher la chaîne " toto":


```js
var str = " toto ";

console.log(str.length); // 9

str = str.trimEnd();
console.log(str.length); // 7
console.log(str); // " toto"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.trimend |

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

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

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

* `String.prototype.trim()`
* `String.prototype.trimStart()`
String.prototype.anchor()
=========================

La méthode **`anchor()`** permet de créer une ancre HTML `<a>` qui est utilisé comme cible hypertexte.

Syntaxe
-------


```js
str.anchor(name);
```

### Paramètres

`name`

Une chaîne de caractères représentant l'attribut `name` de la balise à créér.

### Valeur de retour

Une chaîne de caractères qui représente un élément HTML `<a>`.

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

On utilise la méthode `anchor()` pour créer et afficher des ancres dans un document HTML à l'aide de JavaScript.

Ici la chaîne représente le texte que verra l'utilisateur. Le paramètre `name` représente l'attribut `name` de l'élément `<a>`.

Les ancres créées avec la méthode `anchor` deviennent des éléments accessibles à travers le tableau `document.anchors`.

Exemples
--------


```js
var maChaîne = "Table des matières";

document.body.innerHTML = maChaîne.anchor("ancre\_contenu");
```


produira le code HTML suivant :


```html
<a name="ancre\_contenu">Table des matières</a>
```

Prothèse d'émulation (*polyfill*)
---------------------------------


```js
if (!String.prototype.anchor) {
  String.prototype.anchor = function (x) {
    return '<a name="' + x + '">' + this + "</a>";
  };
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.anchor |

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

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

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

* `String.prototype.link()`
String.prototype.fontcolor()
============================

**Obsolète:** Cette fonctionnalité a été supprimée des standards du Web. Bien que quelques navigateurs puissent encore la supporter, elle est en cours d'éradication. Ne l'utilisez ni dans d'anciens projets, ni dans de nouveaux. Les pages et applications Web l'utilisant peuvent cesser de fonctionner à tout moment.

La méthode **`fontcolor()`** permet de créer un élément `<font>` qui permet d'afficher la chaine de caractères dans une fonte utilisant la couleur donnée.

**Note :** L'élément <font> a été retiré dans HTML5 et ne devrait plus être utilisé. Les propriétés CSS permettent de modifier les aspects de mise en forme et doivent donc être utilisées à la place.

Syntaxe
-------


```js
str.fontcolor(couleur);
```

### Paramètres

`couleur`

Une chaîne de caractères représentant la couleur en une valeur hexadécimale RGB ou comme un littéral. Les différents littéraux utilisables pour les noms de couleurs sont listés dans la référence des couleurs CSS.

### Valeur de retour

Une chaîne de caractères représentant un élément HTML `<font>`.

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

Si la couleur est représentée sous forme d'un triplet RVB, le format attendu est `rrvvbb`. Ainsi, pour représenter un rose saumon, les différentes composantes seront rouge = FA, vert = 80, et bleu = 72, le triplet s'écrit donc "`FA8072`".

Exemples
--------

L'exemple qui suit illustre comment utiliser la méthode `fontcolor()` pour modifier la couleur d'une chaîne de caractères en créant une balise `<font>` qui encadre la chaîne.


```js
var worldString = "Coucou monde";

console.log(
  worldString.fontcolor("red") + " avec le littéral red sur cette ligne",
);
// '<font color="red">Coucou monde</font> avec le littéral red sur cette ligne'

console.log(
  worldString.fontcolor("FF00") +
    " avec la valeur hexadécimale sur cette ligne",
);
// '<font color="FF00">Coucou monde</font> avec la valeur hexadécimale sur cette ligne'
```


L'objet `element.style` permet d'utiliser l'attribut `style` de l'élément et de le manipuler de façon générique. Par exemple :


```js
document.getElementById("IDdeVotreElement").style.color = "red";
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.fontcolor |

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

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

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

* `String.prototype.fontsize()`
String.prototype.repeat()
=========================

La méthode **`repeat()`** construit et renvoie une nouvelle chaine de caractères qui contient le nombre de copie demandée de la chaine de caractères sur laquelle la méthode a été appelée, concaténées les unes aux autres.

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

Syntaxe
-------


```js
str.repeat(compte);
```

### Paramètres

`compte`

Un nombre entier entre 0 and +∞ : [ 0, +∞[, indiquant le nombre de fois que la chaine de caractères doit être repétée dans la nouvelle chaine de caractères.

### Valeur de retour

Une nouvelle chaîne de caractères composée du nombre indiqué de copies de la chaîne appelante.

### Exceptions

* `RangeError` : le nombre de répétition doit être positif.
* `RangeError` : le nombre de répétition ne doit pas être infini et la taille de la chaîne résultante ne doit pas dépasser la taille maximale pour une chaîne de caractères.

`RangeError`

La compteur doit être positif et inférieur à l'infini.

Exemples
--------


```js
"abc".repeat(-1); // RangeError
"abc".repeat(0); // ""
"abc".repeat(1); // "abc"
"abc".repeat(2); // "abcabc"
"abc".repeat(3.5); // "abcabcabc" (le compteur est converti en un nombre entier)
"abc".repeat(1 / 0); // RangeError

({ toString: () => "abc", repeat: String.prototype.repeat }).repeat(2);
// "abcabc" (repeat() est une méthode générique)
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.repeat |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
String.raw()
============

La méthode statique **`String.raw()`** est une fonction d'étiquetage (*tag function*) pour les gabarits de chaînes de caractères (elle est semblable au préfixe `r` en Python ou au préfixe `@` en C#). Cette fonction permet d'obtenir la chaîne brute pour un gabarit (les caractères spéciaux ne sont pas pris en compte mais retranscrits tels quels, les séquences d'échappement ne sont pas interprétées et les emplacements (ex. `${toto}`) sont traités).

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

Syntaxe
-------


```js
String.raw(callSite, ...substitutions);

String.raw`gabaritChaîne`;
```

### Paramètres

`callSite`

Un site d'appel bien formé pour un gabarit (*call site object*) tel que `{raw: "string"}`.

...substitutions

Paramètre contenant les valeurs à substituer.

gabaritChaîne

Un gabarit de chaîne de caractères, éventuellement avec des substitutions (`${...}`).

### Valeur de retour

La chaîne de caractères brute correspondant à un gabarit donné.

### Exceptions

`TypeError`

Une exception `TypeError` est renvoyée si le premier argument n'est pas un objet bien formé.

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

Dans la plupart des cas, `String.raw()` est utilisé avec des gabarits de chaînes de caractères. La première syntaxe, présentée ci-avant est rarement utilisée. En effet, le moteur JavaScript appellera cette forme avec les arguments appropriés, comme pour les fonctions d'étiquetage (*tag*).

La méthode `String.raw()` est la seule méthode d'étiquetage native pour les chaînes de caractères. Elle fonctionne comme la fonction par défaut pour les gabarits et permet d'effectuer des concaténations. Il est également possible d'implémenter cette méthode avec du code JavaScript.

Exemples
--------


```js
String.raw`Hi\n${2 + 3}!`;
// "Hi\n5!", le caractère après "Hi" n'est pas
// le caractère de nouvelle ligne
// "\" et "n" sont bien deux caractères distincts
// ici.

String.raw`Hi\u000A!`;
// "Hi\u000A!", de même ici. Les caractères
// \, u, 0, 0, 0, A et 6 sont distincts.
// Tous les caractères d'échappement seront
// inefficaces. Des backslashes peuvent donc être
// présents dans la chaîne produite. Cela peut
// être vérifié avec la propriété .length de la
// chaîne.

let nom = "Bob";
String.raw`Hi\n${nom}!`;
// "Hi\nBob!", les remplacements sont effectués.

// Généralement, on n'appelle pas String.raw
// comme une fonction, mais c'est possible :
String.raw({ raw: "test" }, 0, 1, 2);
// "t0e1s2t"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.raw |

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

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

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

* Gabarits de chaînes de caractères
* `String`
* Grammaire lexicale JavaScript