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

**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 **`blink()`** crée un élément HTML `<blink>` qui affiche la chaine de caractères en clignotant.

**Attention :** Les textes clignotants sont fortement déconseillés par de nombreux standards d'accessibilité. L'élément `<blink>` est lui-même non standard et obsolète !

Syntaxe
-------


```js
str.blink();
```

### Valeur de retour

Une chaine de caractères représentant un élément HTML `<blink>`.

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

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

Exemples
--------

L'exemple suivant utilise des méthodes de `String` pour changer l'affichage d'une chaine de caractères :


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

console.log(chaîneMonde.blink());
console.log(chaîneMonde.bold());
console.log(chaîneMonde.italics());
console.log(chaîneMonde.strike());
```


Cet exemple produira le code HTML suivant :


```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.blink |

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.padEnd()
=========================

La méthode **`padEnd()`** 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 la fin.

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

Syntaxe
-------


```js
str.padEnd(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 pour les langues écrites de gauche à droite et la partie la plus à droite pour les langues écrites de droite à gauche). 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.

Exemples
--------


```js
"abc".padEnd(10); // "abc "
"abc".padEnd(10, "toto"); // "abctototot"
"abc".padEnd(6, "123456"); // "abc123"
"abc".padEnd(1); // "abc"
```

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

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

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

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

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

* `String.prototype.padStart()`
String.prototype.small()
========================

**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 **`small()`** permet de créer un élément HTML `<small>`, ce qui permet d'afficher la chaîne de caractères dans une fonte de petite taille.

Syntaxe
-------


```js
str.small();
```

### Valeur de retour

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

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

 La méthode `small()` encadre la chaîne courante dans une balise `<small>` :
 `"<small>str</small>`"

Exemple
-------

### Utiliser la méthode `small()`

L'exemple suivant illustre les différentes méthodes de `String` permettant de changer la taille d'une chaîne de caractères :


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

console.log(worldString.small()); // <small>Coucou monde</small>
console.log(worldString.big()); // <big>Coucou monde</big>
console.log(worldString.fontsize(7)); // <font size="7">Coucou monde</fontsize>
```


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("IDélément").style.fontSize = "0.7em";
```

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

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

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.big()`
String.prototype.normalize()
============================

La méthode **`normalize()`** permet de renvoyer la forme normalisée Unicode d'une chaîne de caractères.

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

Syntaxe
-------


```js
str.normalize([form]);
```

### Paramètres

`form`

Paramètre optionnel. Une chaîne parmi "NFC", "NFD", "NFKC", ou "NFKD", définissant la forme de normalisation Unicode à utiliser. Si le paramètre n'est pas précisé ou vaut `undefined`, la valeur par défaut utilisée sera "`NFC`".

* `NFC` - Normalization Form Canonical Composition.
* `NFD` - Normalization Form Canonical Decomposition.
* `NFKC` - Normalization Form Compatibility Composition.
* `NFKD` - Normalization Form Compatibility Decomposition.

### Valeur de retour

Une chaîne de caractères qui est le forme Unicode normalisée de la chaîne appelante.

### Exceptions

`RangeError`

Une exception `RangeError` est envoyée si le paramètre `form` n'est pas une des valeurs définies ci-avant.

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

La méthode `normalize()` renvoie la forme normalisée Unicode de la chaîne de caractères. Elle n'affecte pas la valeur de la chaîne.

Exemples
--------


```js
// Chaîne initiale

// U+1E9B: LATIN SMALL LETTER LONG S WITH DOT ABOVE
// U+0323: COMBINING DOT BELOW
var str = "\u1E9B\u0323";

// Forme canonique composée (Canonically-composed form) (NFC)

// U+1E9B: LATIN SMALL LETTER LONG S WITH DOT ABOVE
// U+0323: COMBINING DOT BELOW
str.normalize("NFC"); // "\u1E9B\u0323"
str.normalize(); // la même chaîne que précédemment

// Forme canonique décomposée (Canonically-decomposed form) (NFD)

// U+017F: LATIN SMALL LETTER LONG S
// U+0323: COMBINING DOT BELOW
// U+0307: COMBINING DOT ABOVE
str.normalize("NFD"); // "\u017F\u0323\u0307"

// Forme composée compatible (NFKC)

// U+1E69: LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE
str.normalize("NFKC"); // "\u1E69"

// Forme décomposée compatible (NFKD)

// U+0073: LATIN SMALL LETTER S
// U+0323: COMBINING DOT BELOW
// U+0307: COMBINING DOT ABOVE
str.normalize("NFKD"); // "\u0073\u0323\u0307"
```

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

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

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

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

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

* Formes de normalisation Unicode, Annexe n°15 du standard Unicode
* Équivalence Unicode
String.prototype.startsWith()
=============================

La méthode **`startsWith()`** renvoie un booléen indiquant si la chaine de caractères commence par la deuxième chaine de caractères fournie en argument.

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

Syntaxe
-------


```js
str.startsWith(chaîneRecherchée [, position]);
```

### Paramètres

`chaîneRecherchée`

Les caractères à rechercher au début de la chaine de caractères.

`position` Facultatif

La position à laquelle commencer la recherche de `chaîneRecherchée` ; par défaut 0.

### Valeur de retour

`true` si la chaîne de caractères commence avec la sous-chaîne en argument, `false` sinon

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

Cette méthode permet de savoir si une chaine de caractères commence avec une autre chaine de caractères (comme pour les autres méthodes fonctionnant avec les chaînes de caractères, cette méthode est sensible à la casse).

Exemples
--------


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

console.log(str.startsWith("Être")); // true
console.log(str.startsWith("pas être")); // false
console.log(str.startsWith("pas être", 12)); // true
```

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

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

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

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

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

* `String.prototype.endsWith()`
* `String.prototype.includes()`
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
* Prothèse (*polyfill*) de Mathias Bynens
String.prototype[@@iterator]()
==============================

La méthode **`[@@iterator]()`** renvoie un nouvel objet `Iterator` qui itère sur les points de code (codets) d'une chaîne de caractères, en renvoyant chaque point de code sous forme d'une chaîne de caractères.

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

Syntaxe
-------


```js
chaîneDeCaractères[Symbol.iterator];
```

### Valeur de retour

Un nouvel objet `Iterator`.

Exemples
--------

### Utiliser `[@@iterator]()`


```js
var chaîne = "A\uD835\uDC68";

var chaîneIter = chaîne[Symbol.iterator]();

console.log(chaîneIter.next().value); // "A"
console.log(chaîneIter.next().value); // "\uD835\uDC68"
```

### Utiliser `[@@iterator]()` avec une boucle `for..of`


```js
var chaine = "A\uD835\uDC68B\uD835\uDC69C\uD835\uDC6A";

for (var c of chaine) {
  console.log(c);
}
// "A"
// "\uD835\uDC68"
// "B"
// "\uD835\uDC69"
// "C"
// "\uD835\uDC6A"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype-@@iterator |

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

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

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

* Les protocoles d'itération
String.prototype.toLowerCase()
==============================

La méthode **`toLowerCase()`** retourne la chaîne de caractères courante en minuscules.

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

Syntaxe
-------


```js
str.toLowerCase();
```

### Valeur de retour

Une nouvelle chaîne de caractères qui est obtenue en passant la chaîne appelante en minuscules.

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

La méthode `toLowerCase()` renvoie la valeur de la chaîne convertie en minuscules. `toLowerCase()` ne modifie pas la valeur de la chaîne courante.

Exemples
--------


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

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

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

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.toUpperCase()`
String.fromCodePoint()
======================

La méthode statique **`String.fromCodePoint()`** renvoie une chaîne de caractères créée à partir d'un suite de codets.

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

Syntaxe
-------


```js
String.fromCodePoint(num1[, ...[, numN]])
```

### Paramètres

`num1, ..., numN`

Une séquence de codets (*code points*).

### Valeur de retour

Une chaîne de caractères créée à partir de la séquence de codets indiquée.

### Exceptions

* Une exception `RangeError` est renvoyée si un codet (Unicode) invalide est utilisé (par exemple, on pourra avoir "RangeError: NaN is not a valid code point").
Description
-----------

`fromCodePoint()` étant une méthode statique de `String`, elle doit toujours être utilisée avec la syntaxe `String.fromCodePoint()`, plutôt qu'avec une méthode d'un objet `String` qui aurait été créé.

Exemples
--------

### Utiliser `fromCodePoint()`


```js
String.fromCodePoint(42); // "\*"
String.fromCodePoint(65, 90); // "AZ"
String.fromCodePoint(0x404); // "\u0404"
String.fromCodePoint(0x2f804); // "\uD87E\uDC04"
String.fromCodePoint(194564); // "\uD87E\uDC04"
String.fromCodePoint(0x1d306, 0x61, 0x1d307); // "\uD834\uDF06a\uD834\uDF07"

String.fromCodePoint("\_"); // RangeError
String.fromCodePoint(Infinity); // RangeError
String.fromCodePoint(-1); // RangeError
String.fromCodePoint(3.14); // RangeError
String.fromCodePoint(3e-2); // RangeError
String.fromCodePoint(NaN); // RangeError
```

### Comparaison avec `fromCharCode()`

La méthode `String.fromCharCode()` ne peut pas renvoyer les caractères de l'intervalle 0x010000 à 0X10FFFF avec un seul codet, il est nécessaire de lui fournir la paire décomposée (*surrogate pair*) pour obtenr un tel caractère :


```js
String.fromCharCode(0xd83c, 0xdf03); // émoji « nuit étoilée »
String.fromCharCode(55356, 57091); // équivalent en notation décimale
```


`String.fromCodePoint()`, en revanche, peut renvoyer les caractères qui s'expriment sur plus d'un codet de 16 bits grâce à leur codet « simple » :


```js
String.fromCodePoint(0x1f303); // ou 127747 en notation décimale
```

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

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

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

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

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

* `String.fromCharCode()`
* `String.prototype.charAt()`
* `String.prototype.codePointAt()`
* `String.prototype.charCodeAt()`
Constructeur String()
=====================

Le constructeur **`String`** est utilisé afin de créer un nouvel objet `String` qui représente une chaîne de caractères. Lorsqu'il est appelé comme une fonction (et pas comme un constructeur, c'est-à-dire sans être précédé du mot-clé `new`), il effectue une conversion de la valeur fournie en argument en une chaîne de caractères primitive, ce qui peut être plus utile.

Syntaxe
-------


```js
new String(truc);
String(truc);
```

### Paramètres

`truc`

N'importe quelle valeur qui peut être convertie en une chaîne de caractères.

Exemples
--------

### Distinction entre le constructeur `String()` et la fonction `String()`

Selon qu'on utilise `String()` comme une fonction ou comme un constructeur, cela produira différents résultats :


```js
typeof String("Coucou monde"); // string
typeof new String("Coucou monde"); // object
```


Ici, la fonction produit une chaîne de caractères (une valeur primitive). Toutefois, le constructeur produit une instance objet de `String`.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string-constructor |

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

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

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

* L'article sur le formatage du texte dans le guide JavaScript
String.prototype.lastIndexOf()
==============================

La méthode **`lastIndexOf()`** renvoie l'indice, dans la chaîne courante, de la dernière occurence de la valeur donnée en argument. Si cette sous-chaîne n'est pas trouvée, la méthode renvoie -1. La recherche s'effectue de la fin vers le début de la chaîne, à partir de `indiceDébut`.

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

Syntaxe
-------


```js
str.lastIndexOf(valeurRecherchée[, indiceDébut])
```

### Paramètres

`valeurRecherchée`

Une chaîne qu'on recherche dans la chaîne courante. Si ce paramètre n'est pas défini et que `indiceDébut` est utilisé, c'est ce dernier qui sera renvoyé par la fonction.

`indiceDébut` Facultatif

Paramètre optionnel. L'emplacement, dans la chaîne courante, à partir duquel effectuer la recherche (en partant de la fin de la chaîne et en remontant vers le début). Cela peut être n'importe quel entier. La valeur par défaut est `+Infinity`. Si `indiceDébut > str.length`, toute la chaîne sera parcourue. Si `indiceDébut < 0`, on aura le même comportement que si `indiceDébut` valait 0.

### Valeur de retour

L'indice de la dernière occurrence de la valeur indiquée, `-1` si elle n'est pas trouvée.

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

Les caractères d'une chaîne de caractères sont indexés de gauche à droite. L'indice du premier caractère vaut 0 et l'indice du dernier caractère vaut `maChaîne.length - 1`.


```js
"canal".lastIndexOf("a"); // renvoie 3
"canal".lastIndexOf("a", 2); // renvoie 1
"canal".lastIndexOf("a", 0); // renvoie -1
"canal".lastIndexOf("x"); // renvoie -1
"canal".lastIndexOf("c", -5); // renvoie 0
"canal".lastIndexOf("c", 0); // renvoie 0
"canal".lastIndexOf(""); // renvoie 5
"canal".lastIndexOf("", 2); // renvoie 2
```


**Note :** `'abab'.lastIndexOf('ab', 2)` renvoie `2` et pas `0` car l'argument `indiceDébut` ne limite que le début de la correspondance recherchée ( qui est `'ab'`)

### Sensibilité à la casse

La méthode `lastIndexOf()` est sensible à la casse (une lettre en minuscule (i) est différente d'une lettre en majuscule (I)). Ainsi, le résultat de l'expression suivante sera -1 :


```js
"Blue Whale, Killer Whale".lastIndexOf("blue"); // renvoie -1
```

Exemples
--------

Dans l'exemple suivant, on utilise `indexOf()` et `lastIndexOf()` pour situer certaines valeurs dans la chaîne `"Brave new world"`.


```js
var maChaîne = "Brave new world";

console.log("Indice du premier w " + maChaîne.indexOf("w"));
// Affiche 8
console.log("Indice du dernier w " + maChaîne.lastIndexOf("w"));
// Affiche 10

console.log('Indice du premier "new" ' + maChaîne.indexOf("new"));
// Affiche 6
console.log('Indice du dernier "new" ' + maChaîne.lastIndexOf("new"));
// Affiche 6
```

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

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

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

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

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

* `String.prototype.charAt()`
* `String.prototype.indexOf()`
* `String.prototype.split()`
* `Array.prototype.indexOf()`
* `Array.prototype.lastIndexOf()`
String.prototype.bold()
=======================

**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 **`bold()`** crée un élément HTML `<b>` qui affiche la chaine de caractères en gras.

Syntaxe
-------


```js
str.bold();
```

### Valeur de retour

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

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

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

Exemples
--------

L'exemple suivant utilise des méthodes de `String` pour changer l'affichage de la chaine de caractères :


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

console.log(chaîneMonde.blink());
console.log(chaîneMonde.bold());
console.log(chaîneMonde.italics());
console.log(chaîneMonde.strike());
```


Cet exemple produit le même HTML que le code suivant :


```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.bold |

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

La méthode **`toString()`** renvoie une chaine de caractères représentant l'objet renseigné.

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

Syntaxe
-------


```js
str.toString();
```

### Valeur de retour

Une chaîne de caractères représentant la chaîne appelante.

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

L'objet `String` surcharge la méthode `toString()` de l'objet `Object` ; il n'hérite pas de `Object.prototype.toString()`. Pour Les objets `String`, la méthode `toString()` renvoie une chaine de caractères représentant l'objet, et est similaire à la méthode `String.prototype.valueOf()`.

Exemples
--------

L'exemple suivant affiche la valeur textuelle d'un objet `String` :


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

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

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

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

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

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

* `Object.prototype.toSource()`
* `String.prototype.valueOf()`
String.prototype.fontsize()
===========================

**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 propriété **`fontsize()`** permet de créer un élément HTML `<font>` qui permet d'afficher la chaîne de caractères dans une fonte de taille 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.fontsize(taille);
```

### Paramètres

`taille`

Un entier compris entre 1 et 7 ou une chaîne de caractère représentant un nombre signé entre 1 et 7.

### Valeur de retour

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

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

Lorsque le paramètre utilisé est un entier, la taille de la chaîne `str` correspondra à l'une des 7 tailles définies. Lorsque le paramètre utilisé est une chaîne de caractères (par exemple "-2"), la taille de la fonte sera ajustée relativement à la taille définie par l'élément `<basefont>`.

Exemples
--------

L'exemple qui suit illustre comment utiliser les méthodes pour les chaînes de caractères afin de modifier la taille d'une chaîne de caractères :


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

console.log(worldString.small()); // <small>Coucou monde</small>
console.log(worldString.big()); // <big>Coucou monde</big>
console.log(worldString.fontsize(7)); // <font size="7">Coucou monde</fontsize>
```


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("IdElement").style.fontSize = "0.7em";
```

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

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

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

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

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

* `String.prototype.big()`
* `String.prototype.small()`