From ab2aff1ee80285446667c9e4439c8e4e4492613c Mon Sep 17 00:00:00 2001 From: SphinxKnight Date: Sat, 3 Jul 2021 12:50:31 +0200 Subject: Fixes #1309 - Update String landing page vs. en-US (#1322) * Fixes #1309 - Update String landing page vs. en-US * FIX: Adding comma Co-authored-by: tristantheb --- .../reference/global_objects/string/index.html | 444 +++++++++++++-------- 1 file changed, 276 insertions(+), 168 deletions(-) (limited to 'files/fr/web/javascript/reference') diff --git a/files/fr/web/javascript/reference/global_objects/string/index.html b/files/fr/web/javascript/reference/global_objects/string/index.html index bdc9a465a8..11a12969ca 100644 --- a/files/fr/web/javascript/reference/global_objects/string/index.html +++ b/files/fr/web/javascript/reference/global_objects/string/index.html @@ -2,49 +2,116 @@ title: String slug: Web/JavaScript/Reference/Global_Objects/String tags: + - Class - ECMAScript 2015 - JavaScript - Reference - String - - polyfill translation_of: Web/JavaScript/Reference/Global_Objects/String original_slug: Web/JavaScript/Reference/Objets_globaux/String +browser-compat: javascript.builtins.String ---
{{JSRef}}
-

L'objet global String est un constructeur de chaînes de caractères.

+

Un objet String est utilisé afin de représenter et de manipuler une chaîne de caractères.

-

Syntaxe

+

Description

-

Les littéraux de chaînes de caractères peuvent avoir l'une des formes suivantes :

+

Les chaînes de caractères sont utiles pour stocker des données qui peuvent être représentées sous forme de texte. Parmi les opérations les plus utilisées pour manipuler les chaînes de caractères, on a : la vérification de leur longueur avec length, la construction et la concaténation avec les opérateurs + et +=, la recherche de sous-chaîne avec les méthodes includes() ou indexOf() ou encore l'extraction de sous-chaînes avec la méthode substring().

-
'texte de chaînes de caractères'
-"texte de chaînes de caractères"
-"中文 español English देवनागरी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어 עברית"
+

Créer des chaînes de caractères

-

Les chaînes peuvent également être créées en utilisant directement le constructeur String :

+

Il est possible de créer des chaînes de caractères comme des valeurs primitives ou comme des objets avec le constructeur String() :

-
String(texte)
+
+const string1 = "Une chaîne de caractères primitive";
+const string2 = 'Là encore une valeur de chaîne de caractères primitive';
+const string3 = `Et ici aussi`;
-

Paramètres

+
+const string4 = new String("Un objet String");
+
-
-
texte
-
Une valeur qu'on souhaite convertir en une chaîne de caractères.
-
+

Les valeurs primitives ou les objets représentant des chaînes de caractères peuvent être utilisés de façon interchangeable dans la plupart des situations. Voir ci-après Chaînes de caractères : valeurs primitives et objets.

+ +

Les valeurs littérales pour les chaînes de caractères peuvent être indiquées avec des simples quotes ('), des doubles quotes (") ou encore par des accents graves (`). Cette dernière forme permet de définir un littéral de gabarit de chaîne de caractères avec lequel on pourra interpoler des expressions dans une chaîne de caractères.

+ +

Accéder à un caractère

+ +

Il existe deux façons d'accéder à un caractère dans une chaîne. La première façon consiste à utiliser la méthode charAt() :

+ +
+return 'chat'.charAt(2); // renvoie "a"
+
+ +

La seconde méthode, introduite avec ECMAScript 5, est de manipuler la chaîne comme un tableau, où les caractères sont les éléments du tableau et ont un indice correspondant à leur position :

+ +
+return 'chat'[2]; // renvoie "a"
+
+ +

En utilisant la seconde notation, il est impossible de supprimer ou d'affecter une valeur à ces propriétés. En effet, les propriétés concernées ne sont ni accessibles en écriture ni configurables. Pour plus d'informations, voir la page de Object.defineProperty().

+ +

Comparer des chaînes de caractères

+ +

Les développeurs C utilisent la fonction strcmp() pour comparer des chaînes de caractères. En JavaScript, il est possible d'utiliser les opérateurs inférieur et supérieur :

+ +
+let a = "a";
+let b = "b";
+if (a < b) { // true
+  console.log(a + " est inférieure à " + b);
+} else if (a > b) {
+  console.log(a + " est supérieure à " + b);
+} else {
+  console.log(a + " et " + b + " sont égales.");
+}
+
+ +

On peut obtenir un résultat semblable avec la méthode localeCompare() qui permet de prendre en compte la locale utilisée et qui est héritée par toutes les instances de String.

+ +

On notera que a == b compare les chaînes de caractères a et b de façon sensible à la casse. Si on souhaite comparer des chaînes sans être sensible à la casse, on pourra utiliser une fonction semblable à :

-

Littéraux de gabarits

+
+function isEqual(str1, str2) {
+  return str1.toUpperCase() === str2.toUpperCase()
+}
+
+ +

On utilise ici une conversion en majuscules plutôt qu'en minuscules, car cela cause certains problèmes de conversion pour certains caractères UTF-8.

+ +

Les différences entre les objets String et le type primitif pour les chaînes de caractères

+ +

En JavaScript, on distingue d'une part les objets String et d'autre par les valeurs primitives qui sont des chaînes de caractères (il en va de même pour les booléens/Boolean et les nombres/Number).

-

Depuis ECMAScript 2015, les littéraux de chaînes de caractères sont également appelés des littéraux de gabarits :

+

Les valeurs littérales (délimitées par des simples quotes, des doubles quotes ou des accents graves et les chaînes de caractères renvoyées par les appels à String sans le mot-clé new sont des chaînes de caractères primitives. JavaScript convertit automatiquement les valeurs primitives en objets String et il est donc possible d'utiliser les méthodes objet de String sur les chaînes de caractères primitives. Dans les contextes où une méthode est appelée sur une chaîne de caractères primitive ou alors qu'on recherche une propriété, JavaScript convertira implicitement la valeur primitive et appellera la méthode ou accèdera à la propriété correspondante.

-
`Coucou monde`
-`Coucou !
-monde !`
-`Coucou ${qui}`
-tag `<a>${qui}</a>`
+
+let s_prim = "toto";
+let s_obj = new String(s_prim);
+
+console.log(typeof s_prim); // affiche "string"
+console.log(typeof s_obj);  // affiche "object"
 

 
-
Échappement des caractères

+
Les chaînes primitives et les objets String renvoient des résultats différents lorsqu'ils sont évalués avec eval(). Les chaînes primitives sont traitées comme du code source, tandis que les objets String sont traités comme tous les autres objets, en renvoyant l'objet. Par exemple :

+
+
+let s1 = "2 + 2";                // crée une chaîne primitive
+let s2 = new String("2 + 2");    // crée un objet String
+console.log(eval(s1));           // renvoie le nombre 4
+console.log(eval(s2));           // renvoie la chaîne "2 + 2"
+

+
+
Pour ces raisons, il peut y avoir certains problèmes quand le code attend une chaîne primitive plutôt qu'un objet String. Toutefois, cette distinction est rarement nécessaire en pratique.

+
+
Un objet String peut toujours être converti en son équivalent primitif grâce à la méthode valueOf().

+
+
+console.log(eval(s2.valueOf())); // renvoie  4
+

+
+
Échappement des caractères

 
 
En dehors des caractères classiques, des caractères spéciaux peuvent être encodés grâce à l'échappement :

 
@@ -57,227 +124,268 @@ tag `<a>${qui}</a>`
  
  
   
-   \XXX (XXX = 1 à 3 chiffres octaux pour l'intervalle 0 - 377)
-   Caractère ISO-8859-1. Point de code Unicode entre U+0000 et U+00FF
+   \0
+   Caractère nul (U+0000 NULL)
   
   
    \'
-   simple quote
+   simple quote (U+0027 APOSTROPHE)
   
   
    \"
-   double quote
+   double quote (U+0022 QUOTATION MARK)
   
   
    \\
-   barre oblique inversée
+   barre oblique inversée (U+005C REVERSE SOLIDUS)
   
   
    \n
-   nouvelle ligne
+   nouvelle ligne (U+000A LINE FEED; LF)
   
   
    \r
-   retour chariot
+   retour chariot (U+000D CARRIAGE RETURN; CR)
   
   
    \v
-   tabulation verticale
+   tabulation verticale (U+000B LINE TABULATION)
   
   
    \t
-   tabulation
+   tabulation (U+0009 CHARACTER TABULATION)
   
   
    \b
-   retour arrière
+   retour arrière (U+0008 BACKSPACE)
   
   
    \f
-   saut de page (form feed)
+   saut de page (U+000C FORM FEED)
   
   
    \uXXXX (XXXX étant 4 chiffres hexadécimaux pour l'intervalle of 0x0000 - 0xFFFF)
-   Codet UTF-16. Point de code Unicode entre U+0000 et U+FFFF
+   Point de code Unicode entre U+0000 et U+FFFF (représente le plan Unicode multilingue basique)
   
   
    \u{X} ... \u{XXXXXX} (X…XXXXXX étant 1 à 6 chiffres hexadécimaux pour l'intervalle 0x0 - 0x10FFFF)
-   Codet UTF-32. Point de code Unicode entre U+0000 et U+10FFFF {{experimental_inline}}
+   Point de code Unicode entre U+0000 et U+10FFFF (représente l'intégralité d'Unicode)
   
   
    \xXX (XX étant 2 chiffres hexadécimaux pour l'intervalle 0x00 - 0xFF)
-   Caractère ISO-8859-1. Point de code Unicode entre U+0000 et U+00FF
+   Point de code Unicode entre U+0000 et U+00FF (correspond à Basic Latin et Latin-1 supplement ; équivalent à ISO-8859-1)
   
  
 
 
-

-
Note : À la différence d'autres langages, JavaScript ne différencie pas les chaînes contenues dans des doubles quotes (") de celles contenues dans des simples quotes ('). Pour cette raison, les chaînes d'échappement présentées ci-avant fonctionnent sur les chaînes, peu importe la façon dont elles sont encadrées.

-

+
Littéraux pour les chaînes longues

 
-
Littéraux pour les chaînes longues

+
Il peut arriver que le code contienne des chaînes plutôt longues. Plutôt que d'avoir des lignes qui s'étirent sur tout le fichier et dans un éditeur de code, il est possible de casser la chaîne sur plusieurs lignes sans que cela modifie le contenu de la chaîne. Il existe deux façons de faire.

 
-
Il peut arriver que le code contienne des chaînes plutôt longues. Plutôt que d'avoir des lignes qui s'étirent sur tout le fichier et dans un éditeur de code, il est possible de casser la chaîne sur plusieurs lignes sans que cela modifie le contenu de la chaîne. Il existe deux façons pour le faire :

+
Méthode 1

 
-
let chaîneLongue = "Voici une très longue chaîne qui a besoin " +
+
+let chaineLongue = "Voici une très longue chaîne qui a besoin " +
                    " d'être passée à la ligne parce que sinon " +
-                   " ça risque de devenir illisible.";

-
-
ou on peut utiliser le caractère barre oblique inversée "\" à la fin de chaque ligne pour indiquer que la chaîne continue sur la ligne suivante. Il faut bien faire attention à ce que la barre oblique soit bien le dernier caractère de la ligne avant le saut de ligne. Sinon, cela ne fonctionnera pas. Voilà comment se présente cette forme :

-
-
let chaîneLongue = "Voici une très longue chaîne qui a besoin \
-d'être passée à la ligne parce que sinon \
-ça risque de devenir illisible.";

-
-
Description

-
-
Les chaînes de caractères sont utiles pour représenter des données textuelles. Les opérations les plus fréquentes qui concernent les chaînes de caractères sont : la vérification de leur {{jsxref("String.length", "longueur")}}, la concaténation de plusieurs chaînes grâce aux opérateurs + et +=, étudier la présence et la position de fragments de chaînes avec les méthodes {{jsxref("String.prototype.indexOf", "indexOf()")}} et {{jsxref("String.prototype.substring", "substring()")}}.

-
-
Accéder à un caractère

-
-
Il existe deux façons d'accéder à un caractère dans une chaîne. La première façon consiste à utiliser la méthode {{jsxref("String.prototype.charAt", "charAt()")}} :

-
-
return 'chat'.charAt(2); // renvoie "a"

-
-
La seconde méthode, introduite avec ECMAScript 5, est de manipuler la chaîne comme un tableau, où les caractères sont les éléments du tableau et ont un indice correspondant à leur position :

-
-
return 'chat'[2]; // renvoie "a"

-
-
En utilisant la seconde notation, il est impossible de supprimer ou d'affecter une valeur à ces propriétés. En effet, les propriétés concernées ne sont ni accessibles en écriture ni configurables. Pour plus d'informations, voir la page de {{jsxref("Object.defineProperty()")}}.

-
-
Comparer des chaînes de caractères

-
-
Les développeurs C utilisent la fonction strcmp() pour comparer des chaînes de caractères. En JavaScript, il est possible d'utiliser les opérateurs inférieur et supérieur :

-
-
var a = "a";
-var b = "b";
-if (a < b) { // true
-  console.log(a + " est inférieure à " + b);
-} else if (a > b) {
-  console.log(a + " est supérieure à " + b);
-} else {
-  console.log(a + " et " + b + " sont égales.");
-}

-
-
On peut obtenir un résultat semblable avec la méthode {{jsxref("String.prototype.localeCompare()", "localeCompare()")}} qui permet de prendre en compte la locale utilisée et qui est héritée par toutes les instances de String.

-
-
Les différences entre les objets String et le type primitif pour les chaînes de caractères

-
-
Les objets String sont créés en appelant le constructeur new String(). L'objet String encapsule le type de données primitif string de JavaScript en fournissant les méthodes décrites plus bas. La fonction globale String() peut également être appelée sans l'opérateur new pour créer une chaîne primitive. Les chaînes littérales dans le code JavaScript sont des chaînes primitives. (On a la même analogie pour {{jsxref("Boolean")}} et {{jsxref("Objets_globaux/Number","Numbers")}}.)

-
-
Étant donné que JavaScript effectue automatiquement les conversions entre chaînes primitives et objets String, toute méthode de l'objet String peut être appelée sur une chaîne primitive. JavaScript convertira automatiquement la chaîne en un objet String temporaire, appellera la méthode, puis détruira l'objet temporaire. Par exemple, on peut utiliser la propriété String.length sur une chaîne créée de manière littérale :

-
-
var s_prim = "toto";
-var s_obj = new String(s_prim);
-
-console.log(typeof s_prim); // affiche "string"
-console.log(typeof s_obj);  // affiche "object"

+                   " ça risque de devenir illisible.";
+

 
-
(Une chaîne littérale peut être délimitée par des guillemets simples ou doubles.)

+
Méthode 2

 
-
Les objets String peuvent être convertis en chaînes primitives à l'aide de String.valueOf().

+
On peut sinon utiliser le caractère barre oblique inversée "\" à la fin de chaque ligne pour indiquer que la chaîne continue sur la ligne suivante. Il faut bien faire attention à ce que la barre oblique soit bien le dernier caractère de la ligne avant le saut de ligne. Sinon, cela ne fonctionnera pas. Voilà comment se présente cette forme :

 
-
Les chaînes primitives et les objets String renvoient des résultats différents lorsqu'ils sont évalués en JavaScript. Les chaînes primitives sont traitées comme du code source, tandis que les objets String sont traités comme un objet de séquence de caractères. Par exemple :

+
+let chaineLongue = "Voici une très longue chaîne qui a besoin \
+d'être passée à la ligne parce que sinon \
+ça risque de devenir illisible.";
+

 
-
s1 = "2 + 2";                    // crée une chaîne primitive
-s2 = new String("2 + 2");        // crée un objet String
-console.log(eval(s1));           // renvoie le nombre 4
-console.log(eval(s2));           // renvoie la chaîne "2 + 2"
-console.log(eval(s2.valueOf())); // renvoie le nombre 4

+
Méthode 3

 
-
Pour ces raisons, il peut y avoir certains problèmes quand le code attend une chaîne primitive plutôt qu'un objet String. Généralement la distinction n'a pas besoin d'être utilisée.

+
Si les sauts de ligne doivent faire partie du résultat, on peut utiliser l'accent grave comme délimiteur de chaîne. Celui-ci permet d'utiliser des sauts de ligne à l'intérieur de la valeur littérale.

 
-
Un objet String peut toujours être converti en son équivalent primitif grâce à la méthode {{jsxref("String.prototype.valueOf()", "valueOf()")}}.

+
+let chaineLongue = `Voici une très longue chaîne qui a besoin
+d'être passée à la ligne parce que sinon
+ça risque de devenir illisible.`;
+

 
-
console.log(eval(s2.valueOf())); // renvoie  4

+
Constructeur

 
-
Note : Une autre approche pour gérer des chaînes de caractères en JavaScript consiste à utiliser StringView – une représentation semblable à celle utilisée par le langage C pour traîter les chaînes comme des tableaux typés.

+

+  
String()

+  
Crée un nouvel String. S'il est appelé comme une fonction plutôt que comme un constructeur, il effectue une conversion de la valeur en chaîne de caractères.

+

 
-
Propriétés

+
Méthodes statiques

 
 

- 
{{jsxref("String.prototype")}}

- 
permet d'ajouter des propriétés à tous les objets String.

+  
String.fromCharCode(num1 [, ...[,numN]])

+  
Renvoie une chaîne de caractères créée en utilisant la séquence indiquée de valeurs Unicode.

+  
String.fromCodePoint(num1 [, ...[,numN]])

+  
Renvoie une chaîne de caractères créée en utilisant la séquence indiquée de points de code.

+  
String.raw()

+  
Renvoie une chaîne de caractères créée à partir d'un gabarit de chaîne de caractères brut.

 

 
-
Méthodes

+
Propriétés des instances

 
 

- 
{{jsxref("String.fromCharCode()")}}

- 
Renvoie une chaine de caractères créée en utilisant la séquence de valeurs Unicode fournie.

- 
{{jsxref("String.fromCodePoint()")}}

- 
Renvoie une chaine de caractères créée en utilisant la séquence de points de code fournie.

- 
{{jsxref("String.raw()")}} {{experimental_inline}}

- 
Renvoie une chaine de caractères à partir d'un modèle brut de chaine de caractères.

+  
String.prototype.length

+  
Cette propriété indique la longueur de la chaîne de caractères. Elle est en lecture seule.

 

 
-
Instances de String

+
Méthodes des instances

 
-
Propriétés

-
-
{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/String/prototype', 'Propriétés')}}

+

+ 
String.prototype.at(index){{Experimental_Inline}}

+ 
Renvoie le caractère (exactement un seul codet UTF-16) à l'indice indiqué par index. Les indices négatifs sont acceptés, dans ce cas ils indiquent la position par rapport au dernier caractère.

+  
String.prototype.charAt(index)

+  
Renvoie le caractère (exactement un seul codet UTF-16) à l'indice indiqué par index.

+  
String.prototype.charCodeAt(index)

+  
Renvoie un nombre qui est la valeur du codet UTF-16 à l'indice indiqué par index.

+  
String.prototype.codePointAt(pos)

+  
Renvoie un entier positif qui correspond à la valeur du codet UTF-16 à la position indiquée par pos.

+  
String.prototype.concat(str [,...strN ])

+  
Combine le texte de deux (ou plusieurs) chaînes en une nouvelle chaîne de caractères.

+  
String.prototype.includes(searchString [, position])

+  
Détermine si la chaîne de caractères courante contient searchString.
+  

+  
String.prototype.endsWith(searchString [, length])

+  
Détermine si la chaîne de caractères courante se termine par searchString.

+  
String.prototype.indexOf(searchValue [, fromIndex])

+  
Renvoie l'indice, au sein de la chaîne courante, de la première occurrence de searchValue ou -1 si ce motif n'est pas trouvé.
+  

+  
String.prototype.lastIndexOf(searchValue [, fromIndex])
+  

+  
Renvoie l'indice, au sein de la chaîne courant, de la dernière occurrence de searchValue ou -1 si ce motif n'est pas trouvé.
+  

+  
String.prototype.localeCompare(compareString [, locales [, options]])

+  
Renvoie un nombre indiquant si la chaîne courante vient avant ou après (ou est équivalente à ) compareString pour l'ordre de tri.

+  
String.prototype.match(regexp)
+  

+  
Permet de tester la correspondance d'une expression rationnelle entre regexp et la chaîne de caractères courante.
+  

+  
String.prototype.matchAll(regexp)

+  
Renvoie un itérateur contenant l'ensemble des correspondances de l'expression rationnelle regexp au sein de la chaîne de caractères courante.

+  
String.prototype.normalize([form])

+  
Renvoie la forme Unicode normalisée de la chaîne courante.

+  
String.prototype.padEnd(targetLength [, padString])

+  
Complète la chaîne courante à la fin avec une chaîne donnée afin d'obtenir une longueur cible targetLength et renvoie la chaîne ainsi construite.

+  
String.prototype.padStart(targetLength [, padString])

+  
Complète la chaîne courante au début avec une chaîne donnée afin d'obtenir une longueur cible targetLength et renvoie la chaîne ainsi construite.

+  
String.prototype.repeat(count)
+  

+  
Renvoie une chaîne de caractères qui est la répétition (count fois) de la chaîne de caractères courante.

+  
String.prototype.replace(searchFor, replaceWith)

+  
Remplace les occurrences de searchFor par replaceWith. searchFor peut être une chaîne de caractères ou une expression rationnelle et replaceWith peut être une chaîne de caractères ou une fonction.

+  
String.prototype.replaceAll(searchFor, replaceWith)

+  
Remplace toutes les occurrences de searchFor avec replaceWith. searchFor peut être une chaîne de caractères ou une expression rationnelle et replaceWith peut être une chaîne de caractères ou une fonction.

+  
String.prototype.search(regexp)

+  
Recherche une correspondance entre une expression rationnelle regexp et la chaîne de caractères courante.

+  
String.prototype.slice(beginIndex[, endIndex])

+  
Extrait une section de la chaîne de caractères et renvoie une nouvelle chaîne de caractères.

+  
String.prototype.split([sep [, limit] ])

+  
Renvoie un tableau de chaînes de caractères composé des fragments de la chaîne courante scindée à chaque occurrence de la sous-chaîne sep.

+  
String.prototype.startsWith(searchString [, length])

+  
Détermine si la chaîne courante commence par la chaîne de caractères indiquée en paramètre (searchString).

+  
String.prototype.substring(indexStart [, indexEnd])

+  
Renvoie une nouvelle chaîne de caractères contenant les caractères de la chaîne courante, situés à partir de l'indice donné ou entre les indices donnés.

+  
String.prototype.toLocaleLowerCase( [locale, ...locales])
+  

+  

+    
Renvoie une conversion en minuscules de la chaîne de caractères courante qui respecte la locale indiquée.

+
+    
Pour la plupart des langues, cela renverra la même valeur que toLowerCase().

+  

+  
String.prototype.toLocaleUpperCase( [locale, ...locales])
+  

+  

+    
Renvoie une conversion en majuscules de la chaîne de caractères courante qui respecte la locale indiquée.

+
+    
Pour la plupart des langues, cela renverra la même valeur que toUpperCase().

+  

+  
String.prototype.toLowerCase()

+  
Renvoie la valeur de la chaîne de caractères, convertie en minuscules.

+  
String.prototype.toString()

+  
Renvoie une chaîne de caractères représentant l'objet courant. Surcharge la méthode Object.prototype.toString().

+  
String.prototype.toUpperCase()

+  
Renvoie la valeur de la chaîne de caractères, convertie en majuscules.

+  
String.prototype.trim()

+  
Retire les blancs situés au début et à la fin de la chaîne de caractères.

+  
String.prototype.trimStart()

+  
Retire les blancs situés au début de la chaîne de caractères.

+  
String.prototype.trimEnd()

+  
Retire les blancs situés à la fin de la chaîne de caractères.

+  
String.prototype.valueOf()

+  
Renvoie la valeur primitive de l'objet courant. Surcharge la méthode Object.prototype.valueOf().

+  
String.prototype.@@iterator()

+  
Renvoie un nouvel objet itérateur qui permet d'itérer sur les points de code composant la chaîne de caractère. Chaque point de code est renvoyé comme une chaîne de caractères.

+

 
-
Méthodes

+
Méthodes de conversion HTML

 
-
Méthodes non liées à HTML

+

+  
Attention : Ces méthodes sont dépréciées et ne doivent plus être utilisées.

 
-
{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/String/prototype', 'Méthodes non liées à HTML')}}

+  
Elles ont des possibilités limitées et ne concernent qu'une petite sous-partie des éléments et attributs HTML disponibles.

+

 
-
Méthodes de transformation à HTML

+

+  
String.prototype.anchor()

+  
<a name="name"> (cible hypertexte)

+  
String.prototype.big()

+  
<big>

+  
String.prototype.blink()

+  
<blink>

+  
String.prototype.bold()

+  
<b>

+  
String.prototype.fixed()

+  
<tt>

+  
String.prototype.fontcolor()

+  
<font color="color">

+  
String.prototype.fontsize()

+  
<font size="size">

+  
String.prototype.italics()

+  
<i>

+  
String.prototype.link()

+  
<a href="url"> (lien d'une URL)

+  
String.prototype.small()

+  
<small>

+  
String.prototype.strike()

+  
<strike>

+  
String.prototype.sub()

+  
<sub>

+  
String.prototype.sup()

+  
<sup>

+

 
-
{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/String/prototype', 'Méthodes de transformation HTML')}}

+
Exemples

 
-
Exemples

+
Conversion en chaîne de caractères

 
-
Il est possible d'utiliser String comme une alternative à {{jsxref("String.prototype.toString()", "toString()")}} car cela permet de traiter les valeurs {{jsxref("null")}}, {{jsxref("undefined")}} et les {{jsxref("Symbol","symboles","",1)}}. Ainsi :

+
Il est possible d'utiliser String comme une alternative à toString() car cela permet de traiter les valeurs null, undefined et les symboles. Ainsi :

 
-
var chainesSortie= [];
-for (let i = 0, n = valeursEntrée.length; i < n; ++i) {
-  chainesSortie.push(String(valeursEntrée[i]));
-}

+
+let chainesSortie = []
+for (let i = 0, n = valeursEntree.length; i < n; ++i) {
+  chainesSortie.push(String(valeursEntree[i]));
+}
+

 
-
Spécifications

+
Spécifications

 
-
- 
-  
-   
-   
-   
-  
- 
- 
-  
-   
-   
-   
-  
-  
-   
-   
-   
-  
-  
-   
-   
-   
-  
-  
-   
-   
-   
-  
- 
-
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale.
{{SpecName('ES5.1', '#sec-15.5', 'String')}}{{Spec2('ES5.1')}}
{{SpecName('ES2015', '#sec-string-objects', 'String')}}{{Spec2('ES2015')}}
{{SpecName('ESDraft', '#sec-string-objects', 'String')}}{{Spec2('ESDraft')}}

+
{{Specifications}}

 
-
Compatibilité des navigateurs

+
Compatibilité des navigateurs

 
-
{{Compat("javascript.builtins.String",2)}}

+
{{Compat}}

 
-
Voir aussi

+
Voir aussi

 
 
-- 
cgit v1.2.3-54-g00ecf