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

La méthode **`trimStart()`** permet de retirer les blancs au début de la chaîne de caractères. `trimLeft()` est un synonyme pour cette méthode.

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

Syntaxe
-------


```js
str.trimStart();
str.trimLeft();
```

### Valeur de retour

Une nouvelle chaîne de caractères dérivant de la chaîne appelante pour laquelle les blancs en début de chaîne ont été retirés.

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

La méthode `trimStart()` renvoie la chaîne de caractères dont les blancs à gauche ont été retirés. `trimStart` ne modifie pas la chaîne elle-même.

### Synonyme

Pour des raisons de cohérences avec les méthodes préexistantes (telles que `String.prototype.padStart`), le nom standard de cette méthode est `trimStart`. Toutefois, à des fins de compatibilité web, le nom `trimLeft` sera gardé comme un synonyme. Pour certains moteurs JavaScript, on pourra donc avoir :


```js
String.prototype.trimLeft.name === "trimStart";
```

Exemple
-------

L'exemple qui suit illustre comment afficher la chaîne de caractères `"toto "` en minuscules :


```js
var str = " toto ";

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

str = str.trimStart();
console.log(str.length); // 5
console.log(str); // "toto "
```

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

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

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.trimEnd()`
String.prototype.strike()
=========================

**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 **`strike()`** permet de créer un élément HTML `<strike>` qui permet d'afficher la chaîne comme un texte barré.

Syntaxe
-------


```js
str.strike();
```

### Valeur de retour

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

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

 Cette méthode encadre la chaîne de caractères dans une balise `<strike>` :
 `"<strike>str</strike>`"

Exemples
--------

Les méthodes suivantes peuvent être utilisées pour modifier le formatage d'une chaîne de caractères :


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

console.log(worldString.blink());
console.log(worldString.bold());
console.log(worldString.italics());
console.log(worldString.strike());
```


Cela produira le code HTML suivant dans la console :


```html
<blink>Coucou monde</blink>
<b>Coucou monde</b>
<i>Coucou monde</i>
<strike>Coucou monde</strike>
```

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

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

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

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

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

* `String.prototype.blink()`
* `String.prototype.bold()`
* `String.prototype.italics()`
String.prototype.sub()
======================

**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 **`sub()`** crée un élément HTML `<sub>` qui entraîne l'affichage de la chaîne en indice.

Syntaxe
-------


```js
str.sub();
```

### Valeur de retour

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

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

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

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>expostant</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.sub |

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

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

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

* `String.prototype.sup()`
String.prototype.at()
=====================

La méthode **`at()`** prend un entier en argument et renvoie une nouvelle chaîne de caractères (`String`) contenant le codet UTF-16 présent dans la chaîne courante à l'emplacement indiqué en argument. Cette méthode permet d'utiliser des arguments positifs ou négatifs. Lorsque le paramètre passé est un entier négatif, la recherche s'effectue depuis la fin de la chaîne de caractères.

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

Syntaxe
-------


```js
at(indice);
```

### Paramètres

`indice`

L'indice (c'est-à-dire la position) du caractère de la chaîne de caractères qu'on souhaite récupérer. Les indices relatifs sont pris en charge et on peut ainsi utiliser un indice négatif. Dans ce cas, c'est le caractère situé à la position comptée depuis la fin de la chaîne qui est renvoyé.

### Valeur de retour

Une chaîne de caractères (`String`) contenant un unique codet UTF-16 situé à la position indiquée. Renvoie `undefined` si l'indice indiqué ne peut être trouvé dans la chaîne de caractères.

Exemples
--------

### Renvoyer le dernier caractère d'une chaîne de caractères

Dans l'exemple qui suit, on fournit une fonction qui renvoie le dernier caractère trouvé dans une chaîne de caractères.


```js
// Une fonction qui renvoie le dernier caractère d'une chaîne
function dernierCar(str) {
  return str.at(-1);
}

let refFacture = "maFacture01";

console.log(dernierCar(refFacture));
// Affiche '1' dans la console

refFacture = "maFacture02";

console.log(dernierCar(refFacture));
// Affiche '2' dans la console
```

### Comparaison de méthodes

On compare ici différentes méthodes pour sélectionner l'avant-dernier caractère d'une chaîne de caractères (`String`). Bien que toutes les alternatives proposées ici soient valables, on pourra remarquer la concision et la lisibilité de la méthode `at()`.


```js
const maChaine = "Vers l'infini et au-delà !";

// En utilisant la propriété length et la méthode charAt()
const avecLength = maChaine.charAt(maChaine.length - 2);
console.log(avecLength); // Affiche 'à' dans la console

// En utilisant la méthode slice()
const avecSlice = maChaine.slice(-2, -1);
console.log(avecSlice); // Affiche 'à' dans la console

// En utilisant la méthode at()
const avecAt = maChaine.at(-2);
console.log(avecAt); // Affiche 'à' dans la console
```

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

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

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

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

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

* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
* `String.prototype.charCodeAt()`
* `String.prototype.codePointAt()`
* `String.prototype.split()`
* Prothèses d'émulation (*polyfills*) :
    + Celle de la proposition TC39.
    + Celle de `core-js`
String.prototype.toLocaleUpperCase()
====================================

La méthode **`toLocaleUpperCase()`** renvoie la chaîne de caractères qui appelle la méthode en caractères majuscules, selon les correspondances de caractères propres aux différentes locales.

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

Syntaxe
-------


```js
str.toLocaleUpperCase()
str.toLocaleUpperCase(locale)
str.toLocaleUpperCase([locale, locale, ...])
```

### Paramètres

`locale` Facultatif

Le paramètre `locale` indique la locale dans laquelle convertir la chaîne en majuscules afin que la méthode utilise les correspondances de cette locale. Si plusieurs locales sont fournies au sein d'un tableau, la meilleure locale disponible est alors utilisée. La locale par défaut est celle utilisée par le système hôte.

### Valeur de retour

Une nouvelle chaîne de caractères obtenue en transformant la chaîne de caractères appelante en majuscules et en tenant compte de la locale.

### Exceptions

Cette méthode peut lever les exceptions suivantes :

* `RangeError` ("invalid language tag: xx\_yy") si l'argument `locale` ne correspond pas à une balise de langue valide.
* `TypeError` ("invalid element in locales arguments") si un élément du tableau de locales passé en argument n'est pas une chaîne de caractères.
Description
-----------

La méthode `toLocaleUpperCase()` renvoie la valeur de la chaîne de caractères, convertie en majuscules selon les correspondances propres à la la locale. `toLocaleUpperCase()` ne modifie pas la chaîne d'origine. Dans la plupart des cas, cette méthode produira le même résultat que `toUpperCase()`. En revanche, pour certaines locales, par exemple les locales turques dont les correspondances entre les caractères ne sont pas celles par défaut prévue par Unicode, cette méthode pourra produire un résultat différent.

On notera également que la conversion ne repose pas sur une correspondance un à un de chaque caractère. En effet, certains caractères produisent deux (voire plus) caractères lorsqu'ils sont convertis en majuscules. Ainsi, la longueur de la chaîne passée en majuscules peut être différente de la longueur de la chaîne originale. Cela implique que la transformation n'est pas stable, autrement dit, l'instruction suivante pourra renvoyer `false` : `x.toLocaleLowerCase() === x.toLocaleUpperCase().toLocaleLowerCase()`.

Exemples
--------


```js
"alphabet".toLocaleUpperCase(); // "ALPHABET"
"Gesäß".toLocaleUpperCase(); // 'GESÄSS'
"i\u0307".toLocaleUpperCase("lt-LT"); // "I"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.tolocaleuppercase |
| ECMAScript Internationalization API Specification # sup-string.prototype.tolocaleuppercase |

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.toLowerCase()`
* `String.prototype.toUpperCase()`
String.prototype.italics()
==========================

**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 **`italics()`** permet de créer un élément HTML `<i>` qui permet de représenter la chaîne courante en italique.

Syntaxe
-------


```js
str.italics();
```

### Valeur de retour

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

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

 La méthode `italics` encadre la chaîne de caractères dans une balise `<i>` :
 `"<i>str</i>`"

Exemples
--------

Les méthodes des chaînes de caractères peuvent être utilisées pour changer le formatage d'une chaîne de caractères :


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

console.log(worldString.blink());
console.log(worldString.bold());
console.log(worldString.italics());
console.log(worldString.strike());
```


Cet exemple permet de produire le fragment HTML suivant dans la console :


```html
<blink>Coucou monde</blink>
<b>Coucou monde</b>
<i>Coucou monde</i>
<strike>Coucou monde</strike>
```

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

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

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

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

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

* `String.prototype.blink()`
* `String.prototype.bold()`
* `String.prototype.strike()`
String.prototype.includes()
===========================

La méthode **`includes()`** détermine si une chaîne de caractères est contenue dans une autre et renvoie `true` ou `false` selon le cas de figure.

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

Syntaxe
-------


```js
str.includes(chaîneRecherchée);
str.includes(chaîneRecherchée, position);
```

### Paramètres

`chaîneRecherchée`

Une chaîne à rechercher dans la chaîne courante.

`position` Facultatif

La position dans la chaîne à partir de laquelle commencera la recherche. La valeur par défaut de `position` est 0.

### Valeur de retour

`true` si la chaîne de caractères contient la sous-chaîne recherchée, `false` sinon.

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

Cette méthode détermine si une chaîne de caractères est contenue dans une autre.

### Sensibilité à la case

`includes()` est sensible à la casse. Par exemple, l'expression suivante nous retournera `false` :


```js
"Baleine bleue".includes("baleine"); // false
```

Exemples
--------

### Utiliser `includes()`


```js
const str = "Être ou ne pas être, telle est la question.";

console.log(str.includes("Être")); // true
console.log(str.includes("question")); // true
console.log(str.includes("pléonasme")); // false
console.log(str.includes("Être", 1)); // false
console.log(str.includes("ÊTRE")); // false
console.log(str.includes("")); // true
```

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

Cette méthode a été ajoutée à la spécification ECMAScript 2015 et n'est peut-être pas encore disponible dans toutes les implémentations JavaScript.

Cependant, vous pouvez facilement polyfill cette méthode pour de vieux navigateurs :


```js
if (!String.prototype.includes) {
  String.prototype.includes = function (search, start) {
    "use strict";

    if (search instanceof RegExp) {
      throw TypeError("first argument must not be a RegExp");
    }
    if (start === undefined) {
      start = 0;
    }
    return this.indexOf(search, start) !== -1;
  };
}
```

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

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

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

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

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

* `Array.prototype.includes()`
* `TypedArray.prototype.includes()`
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
* `String.prototype.startsWith()`
* `String.prototype.endsWith()`
String.prototype.fixed()
========================

**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 **`fixed()`** permet de créer un élément HTML `<tt>`, ce qui permet d'afficher le texte de la chaîne de caractère dans une fonte à chasse fixe.

Syntaxe
-------


```js
str.fixed();
```

### Valeur de retour

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

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

 La méthode `fixed()` encadre une chaîne de caractères dans une balise `<tt>` :
 `"<tt>str</tt>`"

Exemples
--------

L'exemple suivant illustre l'utilisation de la méthode `fixed` pour formater une chaîne de caractères :


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

console.log(worldString.fixed());
// "<tt>Coucou monde</tt>"
```

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

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

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

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

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

* `String.prototype.bold()`
* `String.prototype.italics()`
* `String.prototype.strike()`
String.prototype.concat()
=========================

La méthode **`concat()`** combine le texte de plusieurs chaînes avec la chaîne appelante et renvoie la nouvelle chaîne ainsi formée.

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

Syntaxe
-------


```js
str.concat(string2[, string3, ..., stringN])
```

### Paramètres

`string2...stringN`

Chaînes de caractères à concaténer ensemble.

### Valeur de retour

Une nouvelle chaîne de caractères qui contient la concaténation des chaînes de caractères fournies.

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

La fonction `concat()` renvoie une nouvelle chaîne correspondant à la concaténation des différents arguments avec la chaîne courante. La chaîne courante est celle sur laquelle a été appelée la méthode `concat()`. Si les valeurs passées en arguments ne sont pas des chaînes de caractères, elles sont automatiquement converties en chaînes (grâce à leur méthode `toString()` avant la concaténation).

Exemples
--------

L'exemple suivant combine plusieurs chaînes afin d'en former une nouvelle.


```js
var coucou = "Bonjour ";
console.log(coucou.concat("Tristan,", " bonne journée."));

/\* Bonjour Tristan, bonne journée. \*/

var salutation = ["Bonjour", " ", "Alfred", " ", "!"];
"".concat(...salutation); // "Bonjour Alfred !"

"".concat({}); // [object Object]
"".concat([]); // ""
"".concat(null); // "null"
"".concat(true); // "true"
"".concat(4, 5); // "45"
```

Performance
-----------

Il est fortement recommandé d'utiliser les opérateurs d'affectation (+, +=) plutôt que la méthode `concat()` pour des raisons de performance.

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

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

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

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

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

* `Array.prototype.concat()`
* Les opérateurs d'affectation
String.prototype.toLocaleLowerCase()
====================================

La méthode **`toLocaleLowerCase()`** renvoie la chaîne de caractères qui appelle la méthode en une chaîne de caractères représentées en minuscules, en tenant compte des correspondances de caractères propres aux différentes locales.

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

Syntaxe
-------


```js
str.toLocaleLowerCase()
str.toLocaleLowerCase(locale)
str.toLocaleLowerCase([locale, locale, ...])
```

### Paramètres

`locale` Facultatif

Ce paramètre indique la locale dans laquelle convertir la chaîne en minuscules en utilisant les correspondances de cette locale. Si plusieurs locales sont fournies au sein d'un tableau, c'est la meilleure locale disponible qui est utilisée. La locale par défaut est celle utilisée par le système hôte.

### Valeur de retour

Une nouvelle chaîne de caractères obtenue à partir de la chaîne appelante, convertie en minuscules en tenant compte de la locale.

### Exceptions

Cette méthode peut lever les exceptions suivantes :

* `RangeError` ("invalid language tag: xx\_yy") si l'argument `locale` ne correspond pas à une balise de langue valide.
* `TypeError` ("invalid element in locales argument") si un des éléments du tableau passé en argument n'est pas une chaîne de caractères.
Description
-----------

La méthode `toLocaleLowerCase()` renvoie la valeur de la chaîne de caractères, convertie en minuscules selon les correspondances propres à la la locale. `toLocaleLowerCase()` ne modifie pas la chaîne d'origine. Dans la plupart des cas, cette méthode produira le même résultat que `toLowerCase()`. En revanche, pour certaines locales, par exemple les locales turques dont les correspondances entre les caractères ne sont pas celles par défaut, prévues par Unicode, cette méthode pourra produire un résultat différent.

Exemples
--------


```js
"ALPHABET".toLocaleLowerCase(); // "alphabet"

"\u0130".toLocaleLowerCase("tr") === "i"; // true
"\u0130".toLocaleLowerCase("en-US") === "i"; // false
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.tolocalelowercase |
| ECMAScript Internationalization API Specification # sup-string.prototype.tolocalelowercase |

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

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

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

* `String.prototype.toLocaleUpperCase()`
* `String.prototype.toLowerCase()`
* `String.prototype.toUpperCase()`
String.prototype.valueOf()
==========================

La méthode **`valueOf()`** renvoie la valeur primitive de l'objet `String`.

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

Syntaxe
-------


```js
str.valueOf();
```

### Valeur de retour

Une chaîne de caractères qui représente la valeur primitive d'un objet `String`.

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

La méthode `valueOf()` de `String` renvoie la valeur primitive de l'objet `String` sous la forme d'une chaine de caractères. Cette valeur est équivalente à `String.prototype.toString()`.

Cette méthode est généralement appelée en interne par JavaScript et non explicitement dans du code.

Exemples
--------


```js
var x = new String("Coucou monde");
console.log(x.valueOf()); // affiche "Coucou monde"
```

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

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

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

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

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

* `String.prototype.toString()`
* `Object.prototype.valueOf()`