diff options
| author | Florian Merz <me@fiji-flo.de> | 2021-02-11 12:36:08 +0100 |
|---|---|---|
| committer | Florian Merz <me@fiji-flo.de> | 2021-02-11 12:36:08 +0100 |
| commit | 39f2114f9797eb51994966c6bb8ff1814c9a4da8 (patch) | |
| tree | 66dbd9c921f56e440f8816ed29ac23682a1ac4ef /files/fr/web/javascript/reference/global_objects/string | |
| parent | 8260a606c143e6b55a467edf017a56bdcd6cba7e (diff) | |
| download | translated-content-39f2114f9797eb51994966c6bb8ff1814c9a4da8.tar.gz translated-content-39f2114f9797eb51994966c6bb8ff1814c9a4da8.tar.bz2 translated-content-39f2114f9797eb51994966c6bb8ff1814c9a4da8.zip | |
unslug fr: move
Diffstat (limited to 'files/fr/web/javascript/reference/global_objects/string')
52 files changed, 6156 insertions, 0 deletions
diff --git a/files/fr/web/javascript/reference/global_objects/string/@@iterator/index.html b/files/fr/web/javascript/reference/global_objects/string/@@iterator/index.html new file mode 100644 index 0000000000..ada824203d --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/@@iterator/index.html @@ -0,0 +1,89 @@ +--- +title: 'String.prototype[@@iterator]()' +slug: Web/JavaScript/Reference/Objets_globaux/String/@@iterator +tags: + - ECMAScript 2015 + - Iterator + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/@@iterator +--- +<div>{{JSRef}}</div> + +<p>La méthode <strong><code>[@@iterator]()</code></strong> renvoie un nouvel objet <code><a href="/fr/docs/Web/JavaScript/Guide/Le_protocole_iterator">Iterator</a></code> 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.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-iterator.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>chaîneDeCaractères</var>[Symbol.iterator]</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un nouvel objet <code>Iterator</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_iterator()">Utiliser <code>[@@iterator]()</code></h3> + +<pre class="brush: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" +</pre> + +<h3 id="Utiliser_iterator()_avec_une_boucle_for..of">Utiliser <code>[@@iterator]()</code> avec une boucle <code>for..of</code></h3> + +<pre class="brush: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" +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.prototype-@@iterator', 'String.prototype[@@iterator]()')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype-@@iterator', 'String.prototype[@@iterator]()')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.@@iterator")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration">Les protocoles d'itération</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/anchor/index.html b/files/fr/web/javascript/reference/global_objects/string/anchor/index.html new file mode 100644 index 0000000000..b5f3fb1ea1 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/anchor/index.html @@ -0,0 +1,86 @@ +--- +title: String.prototype.anchor() +slug: Web/JavaScript/Reference/Objets_globaux/String/anchor +tags: + - JavaScript + - Méthode + - Prototype + - Reference + - String + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/String/anchor +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>anchor()</strong></code> permet de créer une ancre HTML {{HTMLElement("a")}} qui est utilisé comme cible hypertexte.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.anchor(<var>name</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>name</code></dt> + <dd>Une chaîne de caractères représentant l'attribut <code>name</code> de la balise à créér.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères qui représente un élément HTML {{HTMLElement("a")}}.</p> + +<h2 id="Description">Description</h2> + +<p>On utilise la méthode <code>anchor()</code> pour créer et afficher des ancres dans un document HTML à l'aide de JavaScript.</p> + +<p>Ici la chaîne représente le texte que verra l'utilisateur. Le paramètre <code>name</code> représente l'attribut <code>name</code> de l'élément {{HTMLElement("a")}}.</p> + +<p>Les ancres créées avec la méthode <code>anchor</code> deviennent des éléments accessibles à travers le tableau {{domxref("document.anchors")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush:js">var maChaîne = "Table des matières"; + +document.body.innerHTML = maChaîne.anchor("ancre_contenu");</pre> + +<p>produira le code HTML suivant :</p> + +<pre class="brush: html"><a name="ancre_contenu">Table des matières</a></pre> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<pre class="brush: js">if (!String.prototype.anchor){ + String.prototype.anchor = function(x){ + return '<a name="' + x + '">' + this + '</a>' + }; +} +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.anchor', 'String.prototype.anchor')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0. Défini dans l'annexe (normative) B sur les fonctionnalités additionnelles des navigateurs web.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.anchor")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.link()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/big/index.html b/files/fr/web/javascript/reference/global_objects/string/big/index.html new file mode 100644 index 0000000000..f661ae9149 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/big/index.html @@ -0,0 +1,81 @@ +--- +title: String.prototype.big() +slug: Web/JavaScript/Reference/Objets_globaux/String/big +tags: + - Dépréciée + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/big +--- +<div>{{JSRef}}{{deprecated_header}}</div> + +<p>La méthode <code><strong>big()</strong></code> crée un élément HTML {{HTMLElement("big")}} qui affichera la chaine de caractères avec une taille de police importante.</p> + +<div class="note"> +<p><strong>Note d'utilisation :</strong> L'élément <code><big></code> a été retiré de <a href="/fr/docs/Web/Guide/HTML/HTML5">HTML5</a> et ne doit pas être utilisé. À la place, les développeurs web doivent utiliser les propriétés <a href="/fr/docs/Web/CSS">CSS</a>.</p> +</div> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.big()</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères qui représente un élément HTML {{HTMLElement("big")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>big()</code> place la chaine de caractères dans une balise <code><big></code> :<br> + <code>"<big>str</big></code>"</p> + +<h2 id="Exemples">Exemples</h2> + +<p>L'exemple suivant montre les méthodes de <code>String</code> pour changer la taille d'une chaine de caractères :</p> + +<pre class="brush: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></pre> + +<p>Avec l'objet {{domxref("HTMLElement.style", "element.style")}}, il est possible d'accéder à l'attribut <code>style</code> de l'élément et de le manipuler. Par exemple :</p> + +<pre class="brush: js">document.getElementById('idÉlément').style.fontSize = '2em'</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.big', 'String.prototype.big')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe normative pour les fonctionnalités supplémentaires des navigateurs web.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.big', 'String.prototype.big')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript supplémentaires des navigateurs web.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.big")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.fontsize()")}}</li> + <li>{{jsxref("String.prototype.small()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/blink/index.html b/files/fr/web/javascript/reference/global_objects/string/blink/index.html new file mode 100644 index 0000000000..086a52c93b --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/blink/index.html @@ -0,0 +1,85 @@ +--- +title: String.prototype.blink() +slug: Web/JavaScript/Reference/Objets_globaux/String/blink +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/blink +--- +<div>{{JSRef}}{{deprecated_header}}</div> + +<p>La méthode <code><strong>blink()</strong></code> crée un élément HTML {{HTMLElement("blink")}} qui affiche la chaine de caractères en clignotant.</p> + +<div class="warning"><strong>Avertissement :</strong> Les textes clignotants sont fortement déconseillés par de nombreux standards d'accessibilité. L'élément <code><blink></code> est lui-même non standard et obsolète !</div> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.blink()</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaine de caractères représentant un élément HTML {{HTMLElement("blink")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>blink()</code> place la chaine de caractères dans une balise <code><blink></code> :<br> + <code>"<blink>str</blink></code>"</p> + +<h2 id="Exemples">Exemples</h2> + +<p>L'exemple suivant utilise des méthodes de <code>String</code> pour changer l'affichage d'une chaine de caractères :</p> + +<pre class="brush: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());</pre> + +<p>Cet exemple produira le code HTML suivant :</p> + +<pre class="brush:html"><blink>Coucou monde</blink> +<b>Coucou monde</b> +<i>Coucou monde</i> +<strike>Coucou monde</strike></pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.blink', 'String.prototype.blink')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités additionnelles des navigateurs web.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.blink', 'String.prototype.blink')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Définie dans l'annexe B (normative) pour les fonctionnalités additionnelles des navigateurs web.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.blink")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/bold/index.html b/files/fr/web/javascript/reference/global_objects/string/bold/index.html new file mode 100644 index 0000000000..4a2970edfc --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/bold/index.html @@ -0,0 +1,83 @@ +--- +title: String.prototype.bold() +slug: Web/JavaScript/Reference/Objets_globaux/String/bold +tags: + - Déprécié + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/bold +--- +<div>{{JSRef}}{{deprecated_header}}</div> + +<p>La méthode <code><strong>bold()</strong></code> crée un élément HTML {{HTMLElement("b")}} qui affiche la chaine de caractères en gras.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.bold()</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("b")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>bold()</code> place la chaine de caractères dans une balise <code><b></code> :<br> + <code>"<b>str</b></code>"</p> + +<h2 id="Exemples">Exemples</h2> + +<p>L'exemple suivant utilise des méthodes de <code>String</code> pour changer l'affichage de la chaine de caractères :</p> + +<pre class="brush: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() );</pre> + +<p>Cet exemple produit le même HTML que le code suivant :</p> + +<pre class="brush:html"><blink>Coucou monde</blink> +<b>Coucou monde</b> +<i>Coucou monde</i> +<strike>Coucou monde</strike> +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.bold', 'String.prototype.bold')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités additionnelles des navigateurs web.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.bold', 'String.prototype.bold')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Définie dans l'annexe B (normative) pour les fonctionnalités additionnelles des navigateurs web.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.bold")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/charat/index.html b/files/fr/web/javascript/reference/global_objects/string/charat/index.html new file mode 100644 index 0000000000..712ffd5ff3 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/charat/index.html @@ -0,0 +1,249 @@ +--- +title: String.prototype.charAt() +slug: Web/JavaScript/Reference/Objets_globaux/String/charAt +tags: + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/charAt +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>charAt()</strong></code> renvoie une nouvelle chaîne contenant le caractère (ou, plus précisément, le point de code UTF-16) à la position indiquée en argument.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-charat.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.charAt(<var>index</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>index</code></dt> + <dd>Un entier entre 0 et la longueur de la chaîne - 1. Si aucun index n'est fourni (ce qui correspond à fournir {{jsxref("undefined")}}) ou si l'index ne peut pas être converti en entier, la recherche sera effectuée à l'index 0 et le premier caractère sera donc renvoyé.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères qui représente le point de code UTF-16 à la position indiquée. Si la position est dehors de la chaîne, ce sera une chaîne vide.</p> + +<h2 id="Description">Description</h2> + +<p>Les caractères d'une chaîne sont indexés de la gauche vers la droite. L'indice du premier caractère est 0 et l'indice du dernier caractère est la longueur de la chaîne moins un (par exemple, si on a une chaîne <code>toto</code>, le dernier caractère de la chaine aura l'indice <code>toto.length - 1</code>). Si l'indice fourni est en dehors de cet intervalle, la méthode renverra une chaîne vide. Si aucun indice n'est fourni, la valeur par défaut utilisée sera 0.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Afficher_les_caractères_situés_à_différentes_positions_d'une_chaîne">Afficher les caractères situés à différentes positions d'une chaîne</h3> + +<p>L'exemple suivant affiche les caractères à différentes positions de la chaîne "<code>Coucou tout le monde</code>" :</p> + +<pre class="brush:js">var uneChaîne = "Coucou tout le monde"; + +console.log("La caractère d'indice 0 est '" + uneChaîne.charAt(0) + "'"); +console.log("La caractère d'indice 1 est '" + uneChaîne.charAt(1) + "'"); +console.log("La caractère d'indice 2 est '" + uneChaîne.charAt(2) + "'"); +console.log("La caractère d'indice 3 est '" + uneChaîne.charAt(3) + "'"); +console.log("La caractère d'indice 4 est '" + uneChaîne.charAt(4) + "'"); +console.log("La caractère d'indice 999 est '" + uneChaîne.charAt(999) + "'"); +</pre> + +<p>Ces lignes afficheront respectivement :</p> + +<pre class="brush: js">La caractère d'indice 0 est 'C' +La caractère d'indice 1 est 'o' +La caractère d'indice 2 est 'u' +La caractère d'indice 3 est 'c' +La caractère d'indice 4 est 'o' +La caractère d'indice 999 est '' +</pre> + +<h3 id="Obtenir_des_caractères_complets">Obtenir des caractères complets</h3> + +<p>Le code qui suit permet de s'assurer qu'on récupère des caractères complets et ce même si la chaîne de caractères contient des caractères en dehors du plan multilingue de base (BMP) (qui sont donc représentés sur deux unités de code/codets) :</p> + +<pre class="brush:js">var str = 'A \uD87E\uDC04 Z'; // On pourrait aussi utiliser un caractère hors du BMP directement +for (var i=0, chr; i < str.length; i++) { + if ((chr = getWholeChar(str, i)) === false) { + continue; + } // On adapte cette ligne pour chaque boucle, en passant la chaîne de caractères + // et on renvoie une variable représentant le caractère individuel + + console.log(chr); +} + +function getWholeChar(str, i) { + var code = str.charCodeAt(i); + + if (Number.isNaN(code)) { + return ''; // la position n'a pas pu être trouvée + } + if (code < 0xD800 || code > 0xDFFF) { + return str.charAt(i); + } + + // On traite ici le demi codet supérieur (high surrogate) + // La borne supérieure du test pourrait être 0xDB7F afin de prendre en compte + // les demi-codets privés comme des caractères uniques + if (0xD800 <= code && code <= 0xDBFF) { + if (str.length <= (i+1)) { + throw 'le demi-codet supérieur n'est pas suivi par un demi-codet inférieur'; + } + var next = str.charCodeAt(i+1); + if (0xDC00 > next || next > 0xDFFF) { + throw 'le demi-codet supérieur n'est pas suivi par un demi-codet inférieur'; + } + return str.charAt(i)+str.charAt(i+1); + } + // on gère le demi codet inférieur (0xDC00 <= code && code <= 0xDFFF) + if (i === 0) { + throw 'le demi-codet inférieur n'est pas précédé d'un demi-codet supérieur'; + } + var prev = str.charCodeAt(i-1); + + // (la borne supérieure pourrait être modifiée en 0xDB7F afin de traiter + // les demi-codets supérieurs privés comme des caractètres uniques) + if (0xD800 > prev || prev > 0xDBFF) { + throw 'le demi-codet inférieur n'est pas précédé d'un demi-codet supérieur'; + } + // on peut passer des demis codets inférieurs comme deuxième composant + // d'une paire déjà traitée + return false; +} + +</pre> + +<p>Dans un environnement ECMAScript 2016 qui permet d'utiliser l'affectation par décomposition, on peut obtenir une version plus succincte et flexible :</p> + +<pre class="brush: js">var str = 'A\uD87E\uDC04Z'; // We could also use a non-BMP character directly +for (var i=0, chr; i < str.length; i++) { + [chr, i] = getWholeCharAndI(str, i); + // Adapt this line at the top of each loop, passing in the whole string and + // the current iteration and returning an array with the individual character + // and 'i' value (only changed if a surrogate pair) + + console.log(chr); +} + +function getWholeCharAndI(str, i) { + var code = str.charCodeAt(i); + + if (Number.isNaN(code)) { + return ''; // Position not found + } + if (code < 0xD800 || code > 0xDFFF) { + return [str.charAt(i), i]; // Normal character, keeping 'i' the same + } + + // High surrogate (could change last hex to 0xDB7F to treat high private + // surrogates as single characters) + if (0xD800 <= code && code <= 0xDBFF) { + if (str.length <= (i+1)) { + throw 'High surrogate without following low surrogate'; + } + var next = str.charCodeAt(i+1); + if (0xDC00 > next || next > 0xDFFF) { + throw 'High surrogate without following low surrogate'; + } + return [str.charAt(i)+str.charAt(i+1), i+1]; + } + // Low surrogate (0xDC00 <= code && code <= 0xDFFF) + if (i === 0) { + throw 'Low surrogate without preceding high surrogate'; + } + var prev = str.charCodeAt(i-1); + + // (could change last hex to 0xDB7F to treat high private surrogates + // as single characters) + if (0xD800 > prev || prev > 0xDBFF) { + throw 'Low surrogate without preceding high surrogate'; + } + // Return the next character instead (and increment) + return [str.charAt(i+1), i+1]; +}</pre> + +<h3 id="Créer_une_version_de_charAt_qui_permet_de_supporter_des_caractères_hors_du_plan_basique_multilingue_(BMP)">Créer une version de <code>charAt</code> qui permet de supporter des caractères hors du plan basique multilingue (BMP)</h3> + +<p>Si on souhaite récupérer les paires de codets des caractères hors du plan classique, on peut utiliser le code suivant :</p> + +<pre class="brush: js">function fixedCharAt (str, idx) { + var ret = ''; + str += ''; + var end = str.length; + + var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g; + while ((surrogatePairs.exec(str)) != null) { + var li = surrogatePairs.lastIndex; + if (li - 2 < idx) { + idx++; + } else { + break; + } + } + + if (idx >= end || idx < 0) { + return ''; + } + + ret += str.charAt(idx); + + if (/[\uD800-\uDBFF]/.test(ret) && /[\uDC00-\uDFFF]/.test(str.charAt(idx+1))) { + // On avance d'un puisque l'un des caractères fait partie de la paire + ret += str.charAt(idx+1); + } + return ret; +}</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.4', 'String.prototype.charAt')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.charat', 'String.prototype.charAt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.charat', 'String.prototype.charAt')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.charAt")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li><a href="https://mathiasbynens.be/notes/javascript-unicode">JavaScript a un problème avec Unicode</a>, billet de Mathias Bynens (en anglais)</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/charcodeat/index.html b/files/fr/web/javascript/reference/global_objects/string/charcodeat/index.html new file mode 100644 index 0000000000..1295d3edc5 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/charcodeat/index.html @@ -0,0 +1,173 @@ +--- +title: String.prototype.charCodeAt() +slug: Web/JavaScript/Reference/Objets_globaux/String/charCodeAt +tags: + - JavaScript + - Méthode + - Reference + - String + - Unicode +translation_of: Web/JavaScript/Reference/Global_Objects/String/charCodeAt +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>charCodeAt()</strong></code> retourne un entier compris entre 0 et 65535 qui correspond au code UTF-16 d'un caractère de la chaîne situé à une position donnée.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-charcodeat.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<p>Le codet UTF-16 renvoyé correspond au codet Unicode si le caractère peut être représenté sur un seul codet. Si le codet Unicode ne peut pas être représenté sur un seul codet UTF-16 (car sa valeur est supérieure à <code>0xFFFF</code>), seule la première partie de la paire sera renvoyée. Si vous souhaitez obtenir l'ensemble de la valeur, vous pouvez utiliser la méthode {{jsxref("String.prototype.codePointAt()","codePointAt()")}}.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.charCodeAt(<var>indice</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>indice</code></dt> + <dd>Un entier supérieur ou égal à zéro et strictement inférieur à la longueur de la chaîne. La valeur par défaut (si le paramètre est absent ou n'est pas un nombre) sera zéro (0).</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un nombre qui représente la valeur du point de code UTF-16 pour le caractère à la position indiquée. Si <code>index</code> pointe en dehors de la chaîne, ce sera {{jsxref("Objets_globaux/NaN","NaN")}} qui sera renvoyé.</p> + +<h2 id="Description">Description</h2> + +<p>Les codets Unicode vont de 0 à 1 114 111 (0x10FFFF). Les 128 premiers caractères Unicode correspondent aux caractères ASCII (leur encodage est le même). Pour plus d'informations sur la gestion de l'Unicode en JavaScript, voir le <a href="/fr/docs/Web/JavaScript/Guide/Valeurs,_variables,_et_littéraux#Unicode">Guide JavaScript</a>.</p> + +<p>La méthode <code>charCodeAt()</code> renverra toujours une valeur inférieure à 65 536. En effet, les caractères encodés sur les plus grandes valeurs sont encodés sur deux « demi-codets » (appelés <em>surrogate pair</em> en anglais). Pour recomposer de tels caractères, il faut donc utiliser <code>charCodeAt(i)</code> <strong>et aussi</strong> <code>charCodeAt(i+1)</code> afin de pouvoir récupérer chaque demi-codet. Pour plus de détails, voir le deuxième et troisième exemples.</p> + +<p><code>charCodeAt()</code> renverra {{jsxref("NaN")}} si l'indice fourni est strictement inférieur à 0 ou dépasse la longueur de la chaîne.</p> + +<p>Dans les anciennes versions (JavaScript 1.2 par exemple) la méthode <code>charCodeAt()</code> renvoyait la valeur du caractère selon l'encodage ISO-Latin-1. L'encodage ISO-Latin-1 permet de représenter des caractères dont les valeurs vont de 0 à 255. Les valeurs 0 à 127 correspondent aux différentes valeurs ASCII.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_charCodeAt">Utiliser <code>charCodeAt()</code></h3> + +<p>L'exemple suivant retourne 65, la valeur Unicode de A.</p> + +<pre class="brush: js notranslate">"ABC".charCodeAt(0) // returns 65 +</pre> + +<h3 id="Utiliser_charCodeAt_pour_gérer_les_caractères_hors_du_plan_multilingue_de_base_sans_hypothèse_sur_leur_présence">Utiliser charCodeAt pour gérer les caractères hors du plan multilingue de base sans hypothèse sur leur présence</h3> + +<p>Cette fonction peut être utilisée dans des boucles ou autres dans les cas où on ne sait pas si des caractères représentés sur deux demi-codets (hors du plan BMP) existent avant la position indiquée.</p> + +<pre class="brush:js notranslate">function fixedCharCodeAt (str, idx) { + // ex. fixedCharCodeAt ('\uD800\uDC00', 0); // 65536 + // ex. fixedCharCodeAt ('\uD800\uDC00', 1); // false + idx = idx || 0; + var code = str.charCodeAt(idx); + var hi, low; + + // On gère le demi-codet supérieur (la borne supérieure + // utilisée pourrait être 0xDB7F afin de traiter les + // paires surrogates privées comme des caractères uniques) + if (0xD800 <= code && code <= 0xDBFF) { + hi = code; + low = str.charCodeAt(idx+1); + if (isNaN(low)) { + throw "Le demi-codet supérieur n'est pas suivi "+ + "par un demi-codet inférieur dans fixedCharCodeAt()"; + } + return ((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000; + } + if (0xDC00 <= code && code <= 0xDFFF) { + // Demi-codet inférieur + + // On renvoie false pour permettre aux boucles + // car le cas a normalement déjà été géré avec + // l'étape précédente + return false; + } + return code; +} +</pre> + +<h3 id="Utiliser_charCodeAt_pour_gérer_les_caractères_du_plan_multilingue_de_base_en_sachant_quils_sont_présents">Utiliser <code>charCodeAt()</code> pour gérer les caractères du plan multilingue de base (en sachant qu'ils sont présents)</h3> + +<pre class="brush:js notranslate">function knownCharCodeAt (str, idx) { + str += ''; + var code, + end = str.length; + + var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g; + while ((surrogatePairs.exec(str)) != null) { + var li = surrogatePairs.lastIndex; + if (li - 2 < idx) { + idx++; + } + else { + break; + } + } + + if (idx >= end || idx < 0) { + return NaN; + } + + code = str.charCodeAt(idx); + + var hi, low; + if (0xD800 <= code && code <= 0xDBFF) { + hi = code; + low = str.charCodeAt(idx+1); + // On prend un caractère de plus + // car on a deux demi-codets à récupérer + return ((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000; + } + return code; +} + +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.5', 'String.prototype.charCodeAt')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.charcodeat', 'String.prototype.charCodeAt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.charcodeat', 'String.prototype.charCodeAt')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.charCodeAt")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.fromCharCode()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/codepointat/index.html b/files/fr/web/javascript/reference/global_objects/string/codepointat/index.html new file mode 100644 index 0000000000..016b2d6aae --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/codepointat/index.html @@ -0,0 +1,144 @@ +--- +title: String.prototype.codePointAt() +slug: Web/JavaScript/Reference/Objets_globaux/String/codePointAt +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Prototype + - Reference + - String + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/String/codePointAt +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>codePointAt()</strong></code> renvoie un entier positif qui correspond au code Unicode (<em>code point</em>) du caractère de la chaîne à la position donnée.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-codepointat.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.codePointAt(<var>pos</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>pos</code></dt> + <dd>La position de l'élément dans la chaîne de caractères dont on souhaite obtenir la valeur du codet.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un nombre qui représente la valeur du point de code du caractère à la position indiqué. C'est la valeur {{jsxref("undefined")}} qui est renvoyée s'il n'y aucun élément à <code>pos</code>.</p> + +<h2 id="Description">Description</h2> + +<p>S'il n'y a pas d'élément à la position donnée, la valeur renvoyée sera {{jsxref("undefined")}}. Si ce n'est pas un élément représenté sur deux demi-codets (<em>surrogate pair</em>) UTF-16 et qui commence à <code>pos</code>, le codet de l'élément à l'indice <code>pos</code> est renvoyé.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">'ABC'.codePointAt(1); // 66 +'\uD800\uDC00'.codePointAt(0); // 65536 + +'XYZ'.codePointAt(42); // undefined +</pre> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<p>Le fragment de code suivant permet d'ajouter la méthode <code>codePointAt()</code> pour les chaînes de caractères (<code>String</code>). En effet, cette méthode fait partie de ECMAScript 2015 et certains navigateurs peuvent ne pas proposer cette fonction nativement.</p> + +<pre class="brush:js">/*! https://mths.be/codepointat v0.2.0 by @mathias */ +if (!String.prototype.codePointAt) { + (function() { + 'use strict'; // needed to support `apply`/`call` with `undefined`/`null` + var defineProperty = (function() { + // IE 8 only supports `Object.defineProperty` on DOM elements + try { + var object = {}; + var $defineProperty = Object.defineProperty; + var result = $defineProperty(object, object, object) && $defineProperty; + } catch(error) {} + return result; + }()); + var codePointAt = function(position) { + if (this == null) { + throw TypeError(); + } + var string = String(this); + var size = string.length; + // `ToInteger` + var index = position ? Number(position) : 0; + if (index != index) { // better `isNaN` + index = 0; + } + // Account for out-of-bounds indices: + if (index < 0 || index >= size) { + return undefined; + } + // Get the first code unit + var first = string.charCodeAt(index); + var second; + if ( // check if it’s the start of a surrogate pair + first >= 0xD800 && first <= 0xDBFF && // high surrogate + size > index + 1 // there is a next code unit + ) { + second = string.charCodeAt(index + 1); + if (second >= 0xDC00 && second <= 0xDFFF) { // low surrogate + // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae + return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000; + } + } + return first; + }; + if (defineProperty) { + defineProperty(String.prototype, 'codePointAt', { + 'value': codePointAt, + 'configurable': true, + 'writable': true + }); + } else { + String.prototype.codePointAt = codePointAt; + } + }()); +} +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.prototype.codepointat', 'String.prototype.codePointAt')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.codepointat', 'String.prototype.codePointAt')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.codePointAt")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li>{{jsxref("String.fromCharCode()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/concat/index.html b/files/fr/web/javascript/reference/global_objects/string/concat/index.html new file mode 100644 index 0000000000..184d38d6fc --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/concat/index.html @@ -0,0 +1,106 @@ +--- +title: String.prototype.concat() +slug: Web/JavaScript/Reference/Objets_globaux/String/concat +tags: + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/concat +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>concat()</strong></code> combine le texte de plusieurs chaînes avec la chaîne appelante et renvoie la nouvelle chaîne ainsi formée.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-concat.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.concat(<var>string2</var>[, <var>string</var>3, ..., <var>stringN</var>])</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>string2...string<em>N</em></code></dt> + <dd>Chaînes de caractères à concaténer ensemble.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une nouvelle chaîne de caractères qui contient la concaténation des chaînes de caractères fournies.</p> + +<h2 id="Description">Description</h2> + +<p>La fonction <code>concat()</code> 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 <code>concat()</code>. 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 <code>toString()</code> avant la concaténation).</p> + +<h2 id="Exemples">Exemples</h2> + +<p>L'exemple suivant combine plusieurs chaînes afin d'en former une nouvelle.</p> + +<pre class="brush: js notranslate">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" + +</pre> + +<h2 id="Performance">Performance</h2> + +<p>Il est fortement recommandé d'utiliser les {{jsxref("Opérateurs/Opérateurs_d_affectation", "opérateurs d'affectation", "", 1)}} (+, +=) plutôt que la méthode <code>concat()</code> pour des raisons de performance.</p> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.6', 'String.prototype.concat')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.concat', 'String.prototype.concat')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.concat', 'String.prototype.concat')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.concat")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Array.prototype.concat()")}}</li> + <li>{{jsxref("Opérateurs/Opérateurs_d_affectation", "Les opérateurs d'affectation", "", 1)}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/endswith/index.html b/files/fr/web/javascript/reference/global_objects/string/endswith/index.html new file mode 100644 index 0000000000..32e72b6791 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/endswith/index.html @@ -0,0 +1,103 @@ +--- +title: String.prototype.endsWith() +slug: Web/JavaScript/Reference/Objets_globaux/String/endsWith +tags: + - JavaScript + - Méthode + - Prototype + - Reference + - String + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/String/endsWith +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>endsWith()</strong></code> renvoie un booléen indiquant si la chaine de caractères se termine par la chaine de caractères fournie en argument.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-endswith.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.endsWith(chaîneRecherchée[, <var>position</var>]);</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>chaîneRecherchée</code></dt> + <dd>Les caractères à rechercher à la fin de la chaine de caractères.</dd> + <dt><code>position</code> {{optional_inline}}</dt> + <dd>Paramètre optionnel. Permet de rechercher dans la chaine de caractères comme si elle faisait cette longueur ; par défaut il s'agit de la longueur de la chaine de caractères <code>chaîneRecherchée</code>. Si la valeur fournie est supérieure à la longueur de la chaine de caractères, elle ne sera pas prise en compte.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p><code>true</code> si la chaîne de caractères se termine par la sous-chaîne indiquée, <code>false</code> sinon.</p> + +<h2 id="Description">Description</h2> + +<p>Cette méthode permet de savoir si une chaine de caractères se termine avec une certaine chaine de caractères (comme les autres méthodes fonctionnant avec des chaînes de caractères, cette méthode est sensible à la casse).</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush:js;">var str = "Être, ou ne pas être : telle est la question."; + +console.log(str.endsWith("question.")); // true +console.log(str.endsWith("pas être")); // false +console.log(str.endsWith("pas être", 20)); // true +</pre> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<p>Cette méthode a été ajoutée dans la spécification ECMAScript 6 et peut ne pas être disponible dans toutes les implémentations de JavaScript. Cependant, il est possible d'émuler le comportement de <code>String.prototype.endsWith</code> avec le fragment de code suivant :</p> + +<pre class="brush: js">if (!String.prototype.endsWith) { + String.prototype.endsWith = function(searchString, position) { + var subjectString = this.toString(); + if (typeof position !== 'number' || !isFinite(position) || Math.floor(position) !== position || position > subjectString.length) { + position = subjectString.length; + } + position -= searchString.length; + var lastIndex = subjectString.lastIndexOf(searchString, position); + return lastIndex !== -1 && lastIndex === position; + }; +} +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.endsWith")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.startsWith()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/fixed/index.html b/files/fr/web/javascript/reference/global_objects/string/fixed/index.html new file mode 100644 index 0000000000..711a2310de --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/fixed/index.html @@ -0,0 +1,74 @@ +--- +title: String.prototype.fixed() +slug: Web/JavaScript/Reference/Objets_globaux/String/fixed +tags: + - Déprécié + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/fixed +--- +<div>{{JSRef}}{{deprecated_header}}</div> + +<p>La méthode <code><strong>fixed()</strong></code> permet de créer un élément HTML {{HTMLElement("tt")}}, ce qui permet d'afficher le texte de la chaîne de caractère dans une fonte à chasse fixe.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.fixed()</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("tt")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>fixed()</code> encadre une chaîne de caractères dans une balise <code><tt></code> :<br> + <code>"<tt>str</tt></code>"</p> + +<h2 id="Exemples">Exemples</h2> + +<p>L'exemple suivant illustre l'utilisation de la méthode <code>fixed</code> pour formater une chaîne de caractères :</p> + +<pre class="brush:js">var worldString = "Coucou monde"; + +console.log(worldString.fixed()); +// "<tt>Coucou monde</tt>" +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.fixed', 'String.prototype.fixed')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.fixed', 'String.prototype.fixed')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.fixed")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/fontcolor/index.html b/files/fr/web/javascript/reference/global_objects/string/fontcolor/index.html new file mode 100644 index 0000000000..19e2c9ff30 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/fontcolor/index.html @@ -0,0 +1,89 @@ +--- +title: String.prototype.fontcolor() +slug: Web/JavaScript/Reference/Objets_globaux/String/fontcolor +tags: + - Déprécié + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/fontcolor +--- +<div>{{JSRef}}{{deprecated_header}}</div> + +<p>La méthode <code><strong>fontcolor()</strong></code> permet de créer un élément {{HTMLElement("font")}} qui permet d'afficher la chaine de caractères dans une fonte utilisant la couleur donnée.</p> + +<div class="note"> +<p><strong>Note :</strong> L'élément <font> a été retiré dans <a href="/fr/docs/Web/Guide/HTML/HTML5">HTML5</a> et ne devrait plus être utilisé. Les propriétés <a href="/fr/docs/Web/CSS">CSS</a> permettent de modifier les aspects de mise en forme et doivent donc être utilisées à la place.</p> +</div> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.fontcolor(<var>couleur</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>couleur</code></dt> + <dd>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 <a href="/fr/docs/Web/CSS/color_value#Valeurs">référence des couleurs CSS</a>.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("font")}}.</p> + +<h2 id="Description">Description</h2> + +<p>Si la couleur est représentée sous forme d'un triplet RVB, le format attendu est <code>rrvvbb</code>. Ainsi, pour représenter un rose saumon, les différentes composantes seront rouge = FA, vert = 80, et bleu = 72, le triplet s'écrit donc "<code>FA8072</code>".</p> + +<h2 id="Exemples">Exemples</h2> + +<p>L'exemple qui suit illustre comment utiliser la méthode <code>fontcolor()</code> pour modifier la couleur d'une chaîne de caractères en créant une balise <code><font></code> qui encadre la chaîne.</p> + +<pre class="brush: 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' +</pre> + +<p>L'objet {{domxref("HTMLElement.style", "element.style")}} permet d'utiliser l'attribut <code>style</code> de l'élément et de le manipuler de façon générique. Par exemple :</p> + +<pre class="brush: js">document.getElementById('IDdeVotreElement').style.color = 'red'</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.fontcolor', 'String.prototype.fontcolor')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.fontcolor', 'String.prototype.fontcolor')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.fontcolor")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.fontsize()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/fontsize/index.html b/files/fr/web/javascript/reference/global_objects/string/fontsize/index.html new file mode 100644 index 0000000000..33241acfbd --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/fontsize/index.html @@ -0,0 +1,88 @@ +--- +title: String.prototype.fontsize() +slug: Web/JavaScript/Reference/Objets_globaux/String/fontsize +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/fontsize +--- +<div>{{JSRef}}{{deprecated_header}}</div> + +<p>La propriété <code><strong>fontsize()</strong></code> permet de créer un élément HTML {{HTMLElement("font")}} qui permet d'afficher la chaîne de caractères dans une fonte de taille donnée.</p> + +<div class="note"> +<p><strong>Note : </strong>L'élément <font> a été retiré dans <a href="/fr/docs/Web/Guide/HTML/HTML5">HTML5</a> et ne devrait plus être utilisé. Les propriétés <a href="/fr/docs/Web/CSS">CSS</a> permettent de modifier les aspects de mise en forme et doivent donc être utilisées à la place.</p> +</div> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.fontsize(<var>taille</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>taille</code></dt> + <dd>Un entier compris entre 1 et 7 ou une chaîne de caractère représentant un nombre signé entre 1 et 7.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("font")}}.</p> + +<h2 id="Description">Description</h2> + +<p>Lorsque le paramètre utilisé est un entier, la taille de la chaîne <code>str</code> 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 {{HTMLElement("basefont")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>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 :</p> + +<pre class="brush: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></pre> + +<p>L'objet {{domxref("HTMLElement.style", "element.style")}} permet d'utiliser l'attribut <code>style</code> de l'élément et de le manipuler de façon générique. Par exemple :</p> + +<pre class="brush: js">document.getElementById('IdElement').style.fontSize = '0.7em'</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.fontsize', 'String.prototype.fontsize')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.fontsize', 'String.prototype.fontsize')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.fontsize")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.big()")}}</li> + <li>{{jsxref("String.prototype.small()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/fromcharcode/index.html b/files/fr/web/javascript/reference/global_objects/string/fromcharcode/index.html new file mode 100644 index 0000000000..5648f25e05 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/fromcharcode/index.html @@ -0,0 +1,117 @@ +--- +title: String.fromCharCode() +slug: Web/JavaScript/Reference/Objets_globaux/String/fromCharCode +tags: + - JavaScript + - Méthode + - Reference + - String + - UTF-16 + - Unicode +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCharCode +--- +<div>{{JSRef}}</div> + +<p>La méthode statique <code><strong>String.fromCharCode()</strong></code> renvoie une chaîne de caractères créée à partir de points de code UTF-16.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-fromcharcode.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">String.fromCharCode(<var>num1</var>, <var>...</var>, <var>numN</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>num1, ..., num<em>N</em></code></dt> + <dd>Une séquence de nombres représentant des points de code UTF-16 entre 0 et 65535 (<code>0xFFFF</code>). Les nombres supérieurs à <code>0xFFFF</code> sont tronqués.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères qui contient les caractères correspondants à la série de points de code UTF-16.</p> + +<h2 id="Description">Description</h2> + +<p>Cette méthode renvoie une chaîne de caractère et non un objet {{jsxref("String")}}.</p> + +<p>La méthode <code>fromCharCode()</code> étant une méthode statique de l'objet <code>String</code>, elle doit toujours être utilisée avec la syntaxe <code>String.fromCharCode()</code> plutôt qu'en appelant la méthode à partir d'un objet <code>String</code> construit sur mesure.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>Pour les caractères du plan multilingue de base, UTF-16 utilise une seule unité de code :</p> + +<pre class="brush:js">String.fromCharCode(65,66,67); // ABC +String.fromCharCode(0x2014); // "<span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body"><span class="objectBox objectBox-string">—" +String.fromCharCode(0x12014); // "—" également, le 1 a été tronqué +String.fromCharCode(8212); // renvoie également "—" car 8212 + // est la forme décimale</span></span></span></span> +</pre> + +<p>Les caractères hors de ce plan utilisent deux unités de code (on parle de <em>surrogate pair</em>) :</p> + +<pre class="brush: js">String.fromCharCode(0xD83C, 0xDF03); // Point de code U+1F303 pour l'émoji nuit étoilée + +// Forme décimale équivalente : +String.fromCharCode(55356, 57091); + +String.fromCharCode(0xD834, 0xDF06, 0x61, 0xD834, 0xDF07); +// "\uD834\uDF06a\uD834\uDF07" +</pre> + +<h2 id="Utiliser_des_valeurs_Unicode_plus_grandes">Utiliser des valeurs Unicode plus grandes</h2> + +<p>En UTF-16, les caractères les plus communs sont représentables sur une seule valeur de 16 bits. Toutefois, cet ensemble de caractères (aussi appelé plan multilingue de base ou BMP en anglais) ne représente qu'1/17e de l'espace total représenté par les caractères Unicode. Le reste des points de code, sur l'intervalle 65536 (0x010000) à 1114111 (0x10FFFF) sont des caractères additionnels qui sont représentés par deux valeurs sur 16 bits qu'on appelle <em>surrogate pairs</em> en anglais.</p> + +<p>La méthode <code>fromCharCode()</code> ne fonctionne qu'avec des valeurs sur 16 bits et il faudra donc fournir une paire de codets pour obtenir certains caractères. Ainsi, <code>String.fromCharCode(0xD83C, 0xDF03)</code> renvoie le point de code U+1F303 qui représente l'émoji « nuit étoilée ».</p> + +<p>Bien qu'il y ait une relation mathématique entre la valeur composée et les deux codets qui forment la paire, on a besoin d'une étape supplémentaire à chaque fois. Aussi, il sera plus pratique d'utiliser {{jsxref("String.fromCodePoint()")}} (ES2015 / ES6) qui permet de manipuler les codes des caractères hors BMP : on pourra ainsi écrire <code>String.fromCodePoint(0x1F303)</code> pour renvoyer le caractère U+1F303 (émoji « nuit étoilée »).</p> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.3.2', 'StringfromCharCode')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.fromcharcodes', 'String.fromCharCode')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.fromcharcodes', 'String.fromCharCode')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.fromCharCode")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/fromcodepoint/index.html b/files/fr/web/javascript/reference/global_objects/string/fromcodepoint/index.html new file mode 100644 index 0000000000..387ecf4878 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/fromcodepoint/index.html @@ -0,0 +1,111 @@ +--- +title: String.fromCodePoint() +slug: Web/JavaScript/Reference/Objets_globaux/String/fromCodePoint +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Reference + - String + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint +--- +<div>{{JSRef}}</div> + +<p>La méthode statique <strong><code>String.fromCodePoint()</code></strong> renvoie une chaîne de caractères créée à partir d'un suite de codets.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-fromcodepoint.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">String.fromCodePoint(<var>num1</var>[, ...[, <var>numN</var>]])</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>num1, ..., num<em>N</em></code></dt> + <dd>Une séquence de codets (<em>code points</em>).</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères créée à partir de la séquence de codets indiquée.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<ul> + <li>Une exception {{jsxref("Erreurs/Not_a_codepoint","RangeError")}} est renvoyée si un codet (Unicode) invalide est utilisé (par exemple, on pourra avoir "RangeError: NaN is not a valid code point").</li> +</ul> + +<h2 id="Description">Description</h2> + +<p><code>fromCodePoint()</code> étant une méthode statique de {{jsxref("String")}}, elle doit toujours être utilisée avec la syntaxe <code>String.fromCodePoint()</code>, plutôt qu'avec une méthode d'un objet {{jsxref("String")}} qui aurait été créé.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_fromCodePoint()">Utiliser <code>fromCodePoint()</code></h3> + +<pre class="brush: 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 +</pre> + +<h3 id="Comparaison_avec_fromCharCode()">Comparaison avec <code>fromCharCode()</code></h3> + +<p>La méthode {{jsxref("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 (<em>surrogate pair</em>) pour obtenr un tel caractère :</p> + +<pre class="brush: js">String.fromCharCode(0xD83C, 0xDF03); // émoji « nuit étoilée » +String.fromCharCode(55356, 57091); // équivalent en notation décimale</pre> + +<p><code>String.fromCodePoint()</code>, en revanche, peut renvoyer les caractères qui s'expriment sur plus d'un codet de 16 bits grâce à leur codet « simple » :</p> + +<pre class="brush: js">String.fromCodePoint(0x1F303); // ou 127747 en notation décimale</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.fromcodepoint', 'String.fromCodePoint')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.fromcodepoint', 'String.fromCodePoint')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.fromCodePoint")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.fromCharCode()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/includes/index.html b/files/fr/web/javascript/reference/global_objects/string/includes/index.html new file mode 100644 index 0000000000..7da8d0e57e --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/includes/index.html @@ -0,0 +1,129 @@ +--- +title: String.prototype.includes() +slug: Web/JavaScript/Reference/Objets_globaux/String/includes +tags: + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/includes +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>includes()</strong></code> détermine si une chaîne de caractères est contenue dans une autre et renvoie <code>true</code> ou <code>false</code> selon le cas de figure.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-includes.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.includes(<var>chaîneRecherchée</var>); +<var>str</var>.includes(<var>chaîneRecherchée</var>, <var>position</var>);</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>chaîneRecherchée</code></dt> + <dd>Une chaîne à rechercher dans la chaîne courante.</dd> + <dt><code>position</code> {{optional_inline}}</dt> + <dd>La position dans la chaîne à partir de laquelle commencera la recherche. La valeur par défaut de <code><var>position</var></code> est 0.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p><code>true</code> si la chaîne de caractères contient la sous-chaîne recherchée, <code>false</code> sinon.</p> + +<h2 id="Description">Description</h2> + +<p>Cette méthode détermine si une chaîne de caractères est contenue dans une autre.</p> + +<h3 id="Sensibilité_à_la_case">Sensibilité à la case</h3> + +<p><code>includes()</code> est sensible à la casse. Par exemple, l'expression suivante nous retournera <code>false</code> :</p> + +<pre class="brush: js">'Baleine bleue'.includes('baleine'); // false</pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_includes">Utiliser <code>includes()</code></h3> + +<pre class="brush: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 +</pre> + +<h2 id="Prothèse_démulation_polyfill"><a name="polyfill">Prothèse d'émulation (<em>polyfill</em>)</a></h2> + +<p>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.</p> + +<p>Cependant, vous pouvez facilement {{Glossary('polyfill')}} cette méthode pour de vieux navigateurs :</p> + +<pre class="brush: 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; + }; +}</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.includes', 'String.prototype.includes')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.includes', 'String.prototype.includes')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_du_navigateur">Compatibilité du navigateur</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.includes")}}</p> + +<h2 id="String.prototype.contains">String.prototype.contains</h2> + +<p>Les versions de Firefox allant de Firefox 18 à Firefox 39 utilisent cette méthode avec le nom <code>contains()</code>. Cette méthode a été renommée en <code>includes()</code> via {{bug(1102219)}} pour la raison suivante :</p> + +<p>Il a été <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=789036">rapporté</a> que certains sites web utilisant MooTools 1.2 plantaient sur Firefox 17. Cette version de MooTools vérifie que <code>String.prototype.contains()</code> existe bien, et si ce n'est pas le cas, ajoute sa propre fonction similaire. Avec l'introduction de cette fonction dans Firefox 17, le comportement de ce contrôle a changé de telle manière qu'il cause un plantage du code de MooTools implémenté pour <code>String.prototype.contains()</code>. En conséquence, cette implémentation a été <a href="https://hg.mozilla.org/releases/mozilla-aurora/rev/086db97198a8" title="https://bugzilla.mozilla.org/show_bug.cgi?id=793781">désactivée</a> de Firefox 17. <code>String.prototype.contains()</code> est ainsi disponible sur une version ultérieure : Firefox 18 lorsque <a href="https://mootools.net/blog/2013/02/19/mootools-1-2-6-released">MooTools a déclenché la sortie de la version 1.2.6.</a></p> + +<p>MooTools 1.3 force sa propre version de <code>String.prototype.includes()</code>, les sites Web l'implémentant ne sont donc pas perturbés. Néanmoins, il faut noter que les signatures des méthodes diffèrent entre <a href="https://mootools.net/docs/core/Types/String#String:includes">MooTools 1.3</a> et ECMAScript 2015 (pour le second paramètre). <a href="https://github.com/mootools/mootools-core/blob/master/Docs/Types/String.md#note">MooTools 1.5+ a modifié sa signature afin de prendre en compte le standard de ES2015.</a></p> + +<p>Dans Firefox 48, la méthode <code>String.prototype.contains()</code> a été retirée. <code>String.prototype.includes()</code> doit être utilisée à la place.</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Array.prototype.includes()")}}</li> + <li>{{jsxref("TypedArray.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.startsWith()")}}</li> + <li>{{jsxref("String.prototype.endsWith()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/index.html b/files/fr/web/javascript/reference/global_objects/string/index.html new file mode 100644 index 0000000000..acb1dd450e --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/index.html @@ -0,0 +1,284 @@ +--- +title: String +slug: Web/JavaScript/Reference/Objets_globaux/String +tags: + - ECMAScript 2015 + - JavaScript + - Reference + - String + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/String +--- +<div>{{JSRef}}</div> + +<p>L'objet global <strong><code>String</code></strong> est un constructeur de chaînes de caractères.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<p>Les littéraux de chaînes de caractères peuvent avoir l'une des formes suivantes :</p> + +<pre class="syntaxbox">'texte de chaînes de caractères' +"texte de chaînes de caractères" +"中文 español English देवनागरी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어 עברית"</pre> + +<p>Les chaînes peuvent également être créées en utilisant directement le constructeur <code>String</code> :</p> + +<pre class="syntaxbox">String(texte)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>texte</code></dt> + <dd>Une valeur qu'on souhaite convertir en une chaîne de caractères.</dd> +</dl> + +<h3 id="Littéraux_de_gabarits">Littéraux de gabarits</h3> + +<p>Depuis ECMAScript 2015, les littéraux de chaînes de caractères sont également appelés des <a href="/fr/docs/Web/JavaScript/Reference/Gabarit_chaînes_caractères">littéraux de gabarits</a> :</p> + +<pre class="syntaxbox">`Coucou monde` +`Coucou ! +monde !` +`Coucou ${qui}` +tag `<a>${qui}</a>` +</pre> + +<h3 id="Échappement_des_caractères">Échappement des caractères</h3> + +<p>En dehors des caractères classiques, des caractères spéciaux peuvent être encodés grâce à l'échappement :</p> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Code</th> + <th scope="col">Résultat</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>\XXX</code> (<code>XXX</code> = 1 à 3 chiffres octaux pour l'intervalle 0 - 377)</td> + <td>Caractère ISO-8859-1. Point de code Unicode entre U+0000 et U+00FF</td> + </tr> + <tr> + <td><code>\'</code></td> + <td>simple quote</td> + </tr> + <tr> + <td><code>\"</code></td> + <td>double quote</td> + </tr> + <tr> + <td><code>\\</code></td> + <td>barre oblique inversée</td> + </tr> + <tr> + <td><code>\n</code></td> + <td>nouvelle ligne</td> + </tr> + <tr> + <td><code>\r</code></td> + <td>retour chariot</td> + </tr> + <tr> + <td><code>\v</code></td> + <td>tabulation verticale</td> + </tr> + <tr> + <td><code>\t</code></td> + <td>tabulation</td> + </tr> + <tr> + <td><code>\b</code></td> + <td>retour arrière</td> + </tr> + <tr> + <td><code>\f</code></td> + <td>saut de page (<em>form feed</em>)</td> + </tr> + <tr> + <td><code>\uXXXX</code> (<code>XXXX</code> étant 4 chiffres hexadécimaux pour l'intervalle of 0x0000 - 0xFFFF)</td> + <td>Codet UTF-16. Point de code Unicode entre U+0000 et U+FFFF</td> + </tr> + <tr> + <td><code>\u{X}</code> ... <code>\u{XXXXXX}</code> (<code>X…XXXXXX</code> étant 1 à 6 chiffres hexadécimaux pour l'intervalle 0x0 - 0x10FFFF)</td> + <td>Codet UTF-32. Point de code Unicode entre U+0000 et U+10FFFF {{experimental_inline}}</td> + </tr> + <tr> + <td><code>\xXX</code> (<code>XX</code> étant 2 chiffres hexadécimaux pour l'intervalle 0x00 - 0xFF)</td> + <td>Caractère ISO-8859-1. Point de code Unicode entre U+0000 et U+00FF</td> + </tr> + </tbody> +</table> + +<div class="note"> +<p><strong>Note :</strong> À 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.</p> +</div> + +<h3 id="Littéraux_pour_les_chaînes_longues">Littéraux pour les chaînes longues</h3> + +<p>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 :</p> + +<pre class="brush: js">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.";</pre> + +<p>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 :</p> + +<pre class="brush: js">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.";</pre> + +<h2 id="Description">Description</h2> + +<p>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 <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Addition_()">+ et +=</a>, é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()")}}.</p> + +<h3 id="Accéder_à_un_caractère">Accéder à un caractère</h3> + +<p>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()")}} :</p> + +<pre class="brush: js">return 'chat'.charAt(2); // renvoie "a"</pre> + +<p>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 :</p> + +<pre class="brush: js">return 'chat'[2]; // renvoie "a"</pre> + +<p>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()")}}.</p> + +<h3 id="Comparer_des_chaînes_de_caractères">Comparer des chaînes de caractères</h3> + +<p>Les développeurs C utilisent la fonction <code>strcmp()</code> pour comparer des chaînes de caractères. En JavaScript, il est possible d'utiliser <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison">les opérateurs inférieur et supérieur </a>:</p> + +<pre class="brush: js">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."); +}</pre> + +<p>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 <code>String</code>.</p> + +<h3 id="Les_différences_entre_les_objets_String_et_le_type_primitif_pour_les_chaînes_de_caractères">Les différences entre les objets <code>String</code> et le type primitif pour les chaînes de caractères</h3> + +<p>Les objets <code>String</code> sont créés en appelant le constructeur <code>new String()</code>. L'objet <code>String</code> encapsule le type de données primitif string de JavaScript en fournissant les méthodes décrites plus bas. La fonction globale <code>String()</code> peut également être appelée sans l'opérateur <code>new</code> 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")}}.)</p> + +<p>Étant donné que JavaScript effectue automatiquement les conversions entre chaînes primitives et objets String, toute méthode de l'objet <code>String</code> peut être appelée sur une chaîne primitive. JavaScript convertira automatiquement la chaîne en un objet <code>String</code> temporaire, appellera la méthode, puis détruira l'objet temporaire. Par exemple, on peut utiliser la propriété <code>String.length</code> sur une chaîne créée de manière littérale :</p> + +<pre class="brush: js">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"</pre> + +<p>(Une chaîne littérale peut être délimitée par des guillemets simples ou doubles.)</p> + +<p>Les objets String peuvent être convertis en chaînes primitives à l'aide de <code>String.valueOf()</code>.</p> + +<p>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 :</p> + +<pre class="brush: js">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</pre> + +<p>Pour ces raisons, il peut y avoir certains problèmes quand le code attend une chaîne primitive plutôt qu'un objet <code>String</code>. Généralement la distinction n'a pas besoin d'être utilisée.</p> + +<p>Un objet <code>String</code> peut toujours être converti en son équivalent primitif grâce à la méthode {{jsxref("String.prototype.valueOf()", "valueOf()")}}.</p> + +<pre class="brush: js">console.log(eval(s2.valueOf())); // renvoie 4</pre> + +<div class="note"><strong>Note :</strong> Une autre approche pour gérer des chaînes de caractères en JavaScript consiste à utiliser <a href="/fr/Add-ons/Code_snippets/StringView"><code>StringView</code> – une représentation semblable à celle utilisée par le langage C pour traîter les chaînes comme des tableaux typés</a>.</div> + +<h2 id="Propriétés">Propriétés</h2> + +<dl> + <dt>{{jsxref("String.prototype")}}</dt> + <dd>permet d'ajouter des propriétés à tous les objets <code>String</code>.</dd> +</dl> + +<h2 id="Méthodes">Méthodes</h2> + +<dl> + <dt>{{jsxref("String.fromCharCode()")}}</dt> + <dd>Renvoie une chaine de caractères créée en utilisant la séquence de valeurs Unicode fournie.</dd> + <dt>{{jsxref("String.fromCodePoint()")}}</dt> + <dd>Renvoie une chaine de caractères créée en utilisant la séquence de points de code fournie.</dd> + <dt>{{jsxref("String.raw()")}} {{experimental_inline}}</dt> + <dd>Renvoie une chaine de caractères à partir d'un modèle brut de chaine de caractères.</dd> +</dl> + +<h2 id="Instances_de_String">Instances de <code>String</code></h2> + +<h3 id="Propriétés_2">Propriétés</h3> + +<p>{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/String/prototype', 'Propriétés')}}</p> + +<h3 id="Méthodes_2">Méthodes</h3> + +<h4 id="Méthodes_non_liées_à_HTML">Méthodes non liées à HTML</h4> + +<p>{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/String/prototype', 'Méthodes non liées à HTML')}}</p> + +<h4 id="Méthodes_de_transformation_à_HTML">Méthodes de transformation à HTML</h4> + +<p>{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/String/prototype', 'Méthodes de transformation HTML')}}</p> + +<h2 id="Exemples">Exemples</h2> + +<p>Il est possible d'utiliser <code>String</code> 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 :</p> + +<pre class="brush: js">var chainesSortie= []; +for (let i = 0, n = valeursEntrée.length; i < n; ++i) { + chainesSortie.push(String(valeursEntrée[i])); +}</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5', 'String')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string-objects', 'String')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string-objects', 'String')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String",2)}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{domxref("DOMString")}}</li> + <li><a href="/fr/Add-ons/Code_snippets/StringView"><code>StringView</code></a></li> + <li><a href="/fr/docs/Web/API/DOMString/Binary">Chaînes binaires</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/indexof/index.html b/files/fr/web/javascript/reference/global_objects/string/indexof/index.html new file mode 100644 index 0000000000..370aa6d397 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/indexof/index.html @@ -0,0 +1,161 @@ +--- +title: String.prototype.indexOf() +slug: Web/JavaScript/Reference/Objets_globaux/String/indexOf +tags: + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/indexOf +--- +<div>{{JSRef}}</div> + +<p>La méthode <strong><code>indexOf()</code></strong> renvoie l'indice de la première occurence de la valeur cherchée au sein de la chaîne courante (à partir de <code>indexDébut</code>). Elle renvoie -1 si la valeur cherchée n'est pas trouvée.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-indexof.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<div class="note"> +<p><strong>Note :</strong> Pour la méthode associée aux tableaux, voir la page {{jsxref("Array.prototype.indexOf()")}}.</p> +</div> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.indexOf(<var>valeurRecherchée</var>) +<var>str</var>.indexOf(<var>valeurRecherchée</var>, <var>indexDébut</var>) +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>valeurRecherchée</code></dt> + <dd>Une chaîne représentant la valeur qu'on cherche dans la chaîne courante. Si aucune valeur n'est fournie explicitement,<a href="https://tc39.github.io/ecma262/#sec-tostring"> <code>valeurRecherchée</code> sera convertie en <code>"undefined"</code> et c'est cette chaîne qui sera recherchée</a>.</dd> + <dt><code>indexDébut</code></dt> + <dd>Paramètre optionnel. L'indice à partir duquel commencer la recherche, effectuée du début vers la fin de la liste. Cela peut être n'importe quel entier. La valeur par défaut est 0. Si <code>indexDébut < 0</code> la chaîne sera parcourue en entier (ce qui équivaut à utiliser 0). Si <code>indexDébut >= str.length</code>, la méthode renverra -1 sauf si <code>valeurRecherchée</code> est la chaîne vide, auquel cas, la méthode renverra <code>str.length</code>.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>L'indice de la première occurrence de la valeur indiquée, <code>-1</code> si elle n'est pas trouvée. Si la valeur recherchée est la chaîne vide, une correspondance sera trouvée à n'importe quel index entre <code>0</code> et <code>str.length</code>.</p> + +<h2 id="Description">Description</h2> + +<p>Les caractères dans une chaîne de caractères sont indexés de la gauche à la droite. L'indice du premier caractère est 0, celui du dernier caractère (d'une chaîne <code>str</code>) est <code>str.length - 1.</code></p> + +<pre class="brush: js">"Blue Whale".indexOf("Blue"); // retourne 0 +"Blue Whale".indexOf("Blute"); // retourne -1 +"Blue Whale".indexOf("Whale", 0); // retourne 5 +"Blue Whale".indexOf("Whale", 5); // retourne 5 +"Blue Whale".indexOf(""); // retourne 0 +"Blue Whale".indexOf("", 9); // retourne 9 +"Blue Whale".indexOf("", 10); // retourne 10 +"Blue Whale".indexOf("", 11); // retourne 10</pre> + +<h3 id="Sensibilité_à_la_casse">Sensibilité à la casse</h3> + +<p>La méthode <code>indexOf()</code> est sensible à la casse. Par exemple, l'expression suivante retourne -1 :</p> + +<pre class="brush: js">"Blue Whale".indexOf("blue") // retourne -1 +</pre> + +<p>Attention : <code>0</code> n'est pas une valeur qui peut être évaluée à <code>true</code> et <code>-1</code> n'est pas une valeur qui peut être évaluée à <code>false</code>. Ainsi, si on souhaite tester si une chaîne de caractères existe au sein d'une autre chaîne de caractères, on procèdera de cette façon (ou on utilisera {{jsxref("String.prototype.includes()")}}</p> + +<pre class="brush: js">"Blue Whale".indexOf("Blue") != -1; // true +"Blue Whale".indexOf("Bloe") != -1; // false</pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_indexOf()_et_lastIndexOf()">Utiliser <code>indexOf()</code> et <code>lastIndexOf()</code></h3> + +<p>L'exemple suivant utilise <code>indexOf()</code> et <code>lastIndexOf()</code> pour localiser différentes valeurs dans la chaîne de caractères "<code>Brave new world</code>".</p> + +<pre class="brush: js">const uneChaîne = "Brave new world" + +console.log("Indice du premier w " + uneChaîne.indexOf("w")); +// Affiche 8 +console.log("Indice du dernier w " + uneChaîne.lastIndexOf("w")); +// Affiche 10 + +console.log("Indice du premier 'new' " + uneChaîne.indexOf("new")); +// Affiche 6 +console.log("Indice du dernier 'new' " + uneChaîne.lastIndexOf("new")); +// Affiche 6 +</pre> + +<h3 id="indexOf()_et_la_sensibilité_à_la_casse"><code>indexOf()</code> et la sensibilité à la casse</h3> + +<p>L'exemple suivant définit 2 chaînes de caractères. Ces variables contiennent la meme chaîne de caractères sauf que la seconde chaîne de caractères contient des lettres majuscules. La première méthode <code>writeln</code> affiche 19. Cependant, comme la méthode <code>indexOf</code> est sensible à la casse, la chaîne de caractères "<code>cheddar</code>" n'est pas trouvée dans <code>myCapString</code>, donc le second résultat affiche -1.</p> + +<pre class="brush: js">const maChaîne = "brie, reblochon, cheddar"; +const maChaîneMajuscules = "Brie, Reblochon, Cheddar"; + +console.log('maChaîne.indexOf("cheddar") is '+ maChaîne.indexOf("cheddar")); +// Affiche 19 +console.log('maChaîneMajuscules.indexOf("cheddar") is ' + maChaîneMajuscules.indexOf("cheddar")); +// Affiche -1</pre> + +<h3 id="Utiliser_indexOf()_pour_compter_le_nombre_d'occurences_dans_une_chaîne_de_caractères">Utiliser <code>indexOf()</code> pour compter le nombre d'occurences dans une chaîne de caractères</h3> + +<p>L'exemple suivant utilise la variable <code>count</code> pour stocker le nombre d'occurences de la lettre <code>x</code> dans la chaîne de caractère <code>str</code> :</p> + +<pre class="brush: js">const str = "Chaîne x de test x"; +let count = 0; +let pos = str.indexOf("x"); + +while ( pos != -1 ) { + count++; + pos = str.indexOf( "x",pos + 1 ); +} +console.log(count); // Affiche 2</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.7', 'String.prototype.indexOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.indexOf")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/italics/index.html b/files/fr/web/javascript/reference/global_objects/string/italics/index.html new file mode 100644 index 0000000000..399dfe4113 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/italics/index.html @@ -0,0 +1,83 @@ +--- +title: String.prototype.italics() +slug: Web/JavaScript/Reference/Objets_globaux/String/italics +tags: + - Déprécié + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/italics +--- +<div>{{JSRef}}{{deprecated_header}}</div> + +<p>La méthode <code><strong>italics()</strong></code> permet de créer un élément HTML {{HTMLElement("i")}} qui permet de représenter la chaîne courante en italique.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.italics()</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("i")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>italics</code> encadre la chaîne de caractères dans une balise <code><i></code> :<br> + <code>"<i>str</i></code>"</p> + +<h2 id="Exemples">Exemples</h2> + +<p>Les méthodes des chaînes de caractères peuvent être utilisées pour changer le formatage d'une chaîne de caractères :</p> + +<pre class="brush:js">var worldString = "Coucou monde"; + +console.log(worldString.blink()); +console.log(worldString.bold()); +console.log(worldString.italics()); +console.log(worldString.strike()); +</pre> + +<p>Cet exemple permet de produire le fragment HTML suivant dans la console :</p> + +<pre class="brush:html"><blink>Coucou monde</blink> +<b>Coucou monde</b> +<i>Coucou monde</i> +<strike>Coucou monde</strike></pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.italics', 'String.prototype.italics')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.italics', 'String.prototype.italics')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.italics")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/lastindexof/index.html b/files/fr/web/javascript/reference/global_objects/string/lastindexof/index.html new file mode 100644 index 0000000000..c45c3fc280 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/lastindexof/index.html @@ -0,0 +1,125 @@ +--- +title: String.prototype.lastIndexOf() +slug: Web/JavaScript/Reference/Objets_globaux/String/lastIndexOf +tags: + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf +--- +<div>{{JSRef}}</div> + +<p>La méthode <strong><code>lastIndexOf()</code></strong> 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 <code>indiceDébut</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-lastindexof.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.lastIndexOf(<var>valeurRecherchée</var>[, <var>indiceDébut</var>])</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>valeurRecherchée</code></dt> + <dd>Une chaîne qu'on recherche dans la chaîne courante. Si ce paramètre n'est pas défini et que <code>indiceDébut</code> est utilisé, c'est ce dernier qui sera renvoyé par la fonction.</dd> + <dt><code>indiceDébut </code>{{optional_inline}}</dt> + <dd>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 <code>+Infinity</code>. Si<code> indiceDébut > str.length</code>, toute la chaîne sera parcourue. Si <code>indiceDébut < 0</code>, on aura le même comportement que si <code>indiceDébut</code> valait 0.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>L'indice de la dernière occurrence de la valeur indiquée, <code>-1</code> si elle n'est pas trouvée.</p> + +<h2 id="Description">Description</h2> + +<p>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 <code>maChaîne.length - 1</code>.</p> + +<pre class="brush: js notranslate">'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 +</pre> + +<div class="blockIndicator note"> +<p><strong>Note</strong> : <code>'abab'.lastIndexOf('ab', 2)</code> renvoie <code>2</code> et pas <code>0</code> car l'argument <code>indiceDébut</code> ne limite que le début de la correspondance recherchée ( qui est <code>'ab'</code>)</p> +</div> + +<h3 id="Sensibilité_à_la_casse">Sensibilité à la casse</h3> + +<p>La méthode <code>lastIndexOf()</code> 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 :</p> + +<pre class="brush: js notranslate">'Blue Whale, Killer Whale'.lastIndexOf('blue'); // renvoie -1 +</pre> + +<h2 id="Exemples">Exemples</h2> + +<p>Dans l'exemple suivant, on utilise {{jsxref("String.prototype.indexOf()", "indexOf()")}} et <code>lastIndexOf()</code> pour situer certaines valeurs dans la chaîne <code>"Brave new world"</code>.</p> + +<pre class="brush: js notranslate">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 +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.8', 'String.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.lastIndexOf")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> + <li>{{jsxref("Array.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/length/index.html b/files/fr/web/javascript/reference/global_objects/string/length/index.html new file mode 100644 index 0000000000..9e1614ddcd --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/length/index.html @@ -0,0 +1,101 @@ +--- +title: String.length +slug: Web/JavaScript/Reference/Objets_globaux/String/length +tags: + - JavaScript + - Propriété + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/length +--- +<div>{{JSRef}}</div> + +<p>La propriété <strong><code>length</code></strong> 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.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-length.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.length</pre> + +<h2 id="Description">Description</h2> + +<p>Cette propriété renvoie le nombre de « codets » (ou unités de code ou bien <em>code units</em> en anglais) d'une chaîne de caractères. {{interwiki("wikipedia", "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 <code>length</code> ne correspondra alors pas au nombre de caractères dans la chaîne.</p> + +<p>ECMAScript 2016 (la septième édition) établit une longueur maximale de <code>2<sup>53</sup> - 1</code> éléments. Auparavant, aucune longueur maximale n'était spécifiée. Pour Firefox, les chaînes ont une longueur maximale de <code>2<sup>30</sup>-2</code> caractères (environ 1 Go). Pour les versions de Firefox antérieures à Firefox 65, la taille maximale était de de <code>2<sup>28</sup>-1</code> (environ 256 Mo).</p> + +<p>Pour une chaine vide, on aura <code>length</code> égal à 0.</p> + +<p>La propriété statique <code>String.length</code> renvoie la valeur 1.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_String.length">Utiliser <code>String.length</code></h3> + +<pre class="brush: 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" */</pre> + +<h3 id="Affecter_une_valeur_à_length">Affecter une valeur à <code>length</code></h3> + +<pre class="brush: js"><code>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</code> +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Statut</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale.<br> + Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.5.1', 'String.prototype.length')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-properties-of-string-instances-length', 'String.prototype.length')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-properties-of-string-instances-length', 'String.prototype.length')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.length")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li><a href="http://developer.teradata.com/blog/jasonstrimpel/2011/11/javascript-string-length-and-internationalizing-web-applications">La propriété JavaScript <code>String.length</code> et l'internationalisation des applications web</a> (en anglais)</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/link/index.html b/files/fr/web/javascript/reference/global_objects/string/link/index.html new file mode 100644 index 0000000000..e36f231d3c --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/link/index.html @@ -0,0 +1,85 @@ +--- +title: String.prototype.link() +slug: Web/JavaScript/Reference/Objets_globaux/String/link +tags: + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/link +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>link()</strong></code> permet de créer une chaîne de caractères représentant un élément HTML {{HTMLElement("a")}}, ce qui permet d'afficher la chaîne de caractères comme un lien hypertexte vers une URL donnée.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.link(<var>url</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>url</code></dt> + <dd>Toute chaîne de caractères pouvant être utilisée comme valeur pour l'attribut <code>href</code> de la balise <code>a</code>. Cette chaîne doit être une URL valide (relative ou absolue) dont les caractères <code>&</code> sont échappés en <code>&amp;</code>, et dont les doubles quotes (<code>"</code>) doivent être échappées avec l'entité <code>&quot;</code>.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("a")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>link</code> permet de créer un fragment HTML avec un lien hypertexte. Le chaîne renvoyée par la méthode peut ensuite être ajoutée au document grâce aux méthodes {{domxref("document.write()")}} ou {{domxref("element.innerHTML")}}.</p> + +<p>Les liens créés avec la méthode <code>link</code> deviennent des éléments du tableau <code>links</code>, membre de l'objet <code>document</code>. Voir {{ Domxref("document.links") }}.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>L'exemple qui suit affiche le texte "MDN" avec un hyperlien qui envoie l'utilisateur vers le site du Mozilla Developer Network.</p> + +<pre class="brush:js">var texteAffiché = "MDN"; +var URL = "https://developer.mozilla.org/"; + +console.log("Cliquer ici pour revenir sur " + texteAffiché.link(URL)); +// Cliquer ici pour revenir sur <a href="https://developer.mozilla.org/">MDN</a></pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.link', 'String.prototype.link')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0. Définie dans l'Annexe B (normative) pour les fonctionnalités ECMAScript additionnelles concernant les navigateurs web.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.link', 'String.prototype.link')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Définie dans l'Annexe B (normative) pour les fonctionnalités ECMAScript additionnelles concernant les navigateurs web.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.link")}}</p> + +<h2 id="Notes_relatives_à_Gecko">Notes relatives à Gecko</h2> + +<ul> + <li>À partir de Gecko 17.0 {{geckoRelease("17")}} le symbole de double quote <strong>"</strong> est automatiquement remplacé par l'entité HTML de référence dans le paramètre <code>url</code>.</li> +</ul> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.anchor()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/localecompare/index.html b/files/fr/web/javascript/reference/global_objects/string/localecompare/index.html new file mode 100644 index 0000000000..e7e2a2cffd --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/localecompare/index.html @@ -0,0 +1,183 @@ +--- +title: String.prototype.localeCompare() +slug: Web/JavaScript/Reference/Objets_globaux/String/localeCompare +tags: + - Internationalisation + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/localeCompare +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>localeCompare()</strong></code> renvoie un nombre indiquant si la chaîne de caractères courante se situe avant, après ou est la même que la chaîne passée en paramètre, selon l'ordre lexicographique.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-localecompare.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<p>Les arguments <code>locales</code> et <code>options</code> permettent de définir la locale et des options pour adapter le comportement de la fonction. Les anciennes implémentations ignoreront les arguments <code>locales</code> et <code>options</code>. L'ordre de tri utilisé sera entièrement dépendant de l'implémentation.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.localeCompare(<var>chaineÀComparer</var> [, <var>locales</var> [, <var>options</var>]])</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<p>Voir le <a href="#compat" title="#Browser_compatibility">tableau de compatibilité des navigateurs</a> pour savoir quels navigateurs prennent en charge les arguments <code>locales</code> et <code>options</code>. L'<a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/localeCompare#Vérifier_le_support_des_arguments_locales_et_options">exemple pour vérifier le support des arguments <code>locales</code> et <code>options</code></a> fournit un fragment de code pour détecter la prise en charge de ces fonctionnalités.</p> + +<dl> + <dt><code>chaineÀComparer</code></dt> + <dd>La chaîne avec laquelle on souhaite comparer la chaîne de caractères courante.</dd> +</dl> + +<div>{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/Collator','Param.C3.A8tres')}}</div> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un nombre négatif si la chaîne de appelante est ordonnée avant la chaîne passée en argument, un nombre positif si elle se situe après, 0 si les deux chaînes sont équivalentes.</p> + +<h2 id="Description">Description</h2> + +<p>Cette méthode renvoie un nombre entier qui indique si la chaîne de caractères courante se situe avant ou après la chaîne passée en argument selon l'ordre lexicographique tenant compte de la locale. Cette méthode renvoie</p> + +<ul> + <li>un nombre négatif si la chaîne de caractères courant se situe avant la chaîne <code>chaineÀComparer</code></li> + <li>un nombre positif si elle se situe après</li> + <li>0 si les deux chaînes se situent au même niveau</li> +</ul> + +<p>Attention à ne pas tester que les valeurs -1 et 1. Les valeurs entières utilisées peuvent varier en fonction des navigateurs et de leurs versions. En effet, la spécification indique uniquement le signe de la valeur à fournir. Par exemple, certains navigateurs pourront renvoyer -2 ou 2 (voire d'autres valeurs).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_la_méthode_localeCompare()">Utiliser la méthode <code>localeCompare()</code></h3> + +<p>L'exemple qui suit illustre les différents cas de figures lors de la comparaison des chaînes de caractères :</p> + +<pre class="brush: js">console.log('a'.localeCompare('c')); // -2, ou -1, ou toute autre valeur négative +console.log('c'.localeCompare('a')); // 2, ou 1, ou toute autre valeur positive +console.log('a'.localeCompare('a')); // 0 +</pre> + +<p>Les résultats illustrés ici peuvent varier entre les différents navigateurs et selon les versions des navigateurs. En effet, les valeurs renvoyées sont spécifiques selon les implémentations. La spécification définit uniquement le signe de la valeur à renvoyer.</p> + +<h3 id="Trier_un_tableau">Trier un tableau</h3> + +<p><code>localeCompare()</code> permet de trier un tableau sans tenir compte de la casse :</p> + +<pre class="brush: js">var items = ['réservé', 'Premier', 'Cliché', 'communiqué', 'café', 'Adieu']; +items.sort((a, b) => a.localeCompare(b, 'fr', {ignorePunctuation: true})); +// ['Adieu', 'café', 'Cliché', 'communiqué', 'Premier', 'réservé'] +</pre> + +<h3 id="Vérifier_le_support_des_arguments_locales_et_options">Vérifier le support des arguments <code>locales</code> et <code>options</code></h3> + +<p>Les argument <code>locales</code> et <code>options</code> ne sont pas supportés par tous les navigateurs. Pour vérifier qu'une implémentation supporte ces paramètres, il est possible d'utiliser un cas d'erreur quand on utilise une balise de langue incorrecte (ce qui provoque une exception {{jsxref("RangeError")}}) :</p> + +<pre class="brush: js">function localeCompareSupportsLocales() { + try { + "a".localeCompare("b", "i"); + } catch (e) { + return e.name === "RangeError"; + } + return false; +} +</pre> + +<h3 id="Utiliser_le_paramètre_locales">Utiliser le paramètre <code>locales</code></h3> + +<p>Les résultats fournis par la méthode <code>localeCompare()</code> peuvent varier selon les langues utilisées. Pour spécifier la langue à utiliser pour votre application, utiliser l'argument <code>locales</code> pour définir la locale à utiliser (et éventuellement des langues de recours) :</p> + +<pre class="brush: js">console.log('ä'.localeCompare('z', 'de')); // une valeur négative : en allemand ä est avant z +console.log('ä'.localeCompare('z', 'sv')); // une valeur positive : en suédois, ä arrive après z +</pre> + +<h3 id="Utiliser_le_paramètre_options">Utiliser le paramètre <code>options</code></h3> + +<p>Les résultats construits par la méthode <code>localeCompare()</code> peuvent être adaptés grâce au paramètre <code>options</code> :</p> + +<pre class="brush: js">// en allemand, ä et a ont la même lettre de base +console.log('ä'.localeCompare('a', 'de', {sensitivity: "base"})); // 0 + +// en suédois, ä et a n'ont pas la même lettre de base +console.log('ä'.localeCompare('a', 'sv', {sensitivity: "base"})); // une valeur positive +</pre> + +<h3 id="Tri_numérique">Tri numérique</h3> + +<pre class="brush: js">// Par défaut, selon l'ordre lexicographique, "2" est supérieur à "10" +console.log("2".localeCompare("10")); // 1 + +// En utilisant un ordre numérique : +console.log("2".localeCompare("10", undefined, {numeric: true})); // -1 + +// En utilisant une balise de locale: +console.log("2".localeCompare("10","en-u-kn-true")); // -1 +</pre> + +<h2 id="Performances">Performances</h2> + +<p>Pour comparer un grand nombre de chaînes de caractères, par exemple pour trier de grands tableaux, il est préférable de créer un objet {{jsxref("Objets_globaux/Collator", "Intl.Collator")}} et utiliser la fonction fournie par la propriété {{jsxref("Collator.prototype.compare", "compare")}}.</p> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Définition initiale.<br> + Implémentée avec JavaScript 1.2</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.9', 'String.prototype.localeCompare')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.localecompare', 'String.prototype.localeCompare')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.localecompare', 'String.prototype.localeCompare')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int 1.0', '#sec-13.1.1', 'String.prototype.localeCompare')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Définition des paramètres<code> locale</code> et <code>option</code></td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-13.1.1', 'String.prototype.localeCompare')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-String.prototype.localeCompare', 'String.prototype.localeCompare')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.localeCompare")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Objets_globaux/Collator", "Intl.Collator")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/match/index.html b/files/fr/web/javascript/reference/global_objects/string/match/index.html new file mode 100644 index 0000000000..cfa8ed4e58 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/match/index.html @@ -0,0 +1,157 @@ +--- +title: String.prototype.match() +slug: Web/JavaScript/Reference/Objets_globaux/String/match +tags: + - Expressions rationnelles + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/match +--- +<div>{{JSRef}}</div> + +<p>La méthode <strong><code>match()</code></strong> permet d'obtenir le tableau des correspondances entre la chaîne courante et une expression rationnelle.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-match.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.match(<var>regexp</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>regexp</code></dt> + <dd>Un objet représentant une expression rationnelle. Si ce n'est pas un objet de type <code>RegExp</code>, celui-ci sera converti en un objet {{jsxref("RegExp")}} grâce à <code>new RegExp(regexp)</code>. Si aucun paramètre n'est utilisé, cela renverra un tableau contenant un élément étant la chaîne vide : <code>[""]</code>.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un tableau ({{jsxref("Array")}}) contenant les correspondances et les groupes capturés avec les parenthèses ou {{jsxref("null")}} s'il n'y a pas de correspondance. Le contenu de ce tableau dépend de l'utilisation du marqueur pour la recherche globale <code>g</code> :</p> + +<ul> + <li>Si le marqueur <code>g</code> est utilisé, tous les résultats correspondants à l'expression rationnelle complète seront renvoyés mais les groupes capturants ne seront pas renvoyés.</li> + <li>Si le marqueur <code>g</code> n'est pas utilisé, seule la première correspondance et ses groupes capturants seront renvoyés. Dans ce cas, l'élément renvoyé aura des propriétés supplémentaires listées ci-après.</li> +</ul> + +<h4 id="Propriétés_supplémentaires">Propriétés supplémentaires</h4> + +<p>Comme indiqué ci-avant, les résultats peuvent contenir certaines propriétés supplémentaires :</p> + +<ul> + <li><code>groups</code> : un tableau de groupes capturants nommés ou {{jsxref("undefined")}} si aucun groupe capturant n'a été défini. Voir <a href="/fr/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges">la page sur les groupes et les intervalles</a> pour plus d'informations.</li> + <li><code>index</code> : l'indice de la chaîne de caractères où a été trouvée la correspondance.</li> + <li><code>input</code> : une copie de la chaîne sur laquelle a été effectuée la recherche.</li> +</ul> + +<h2 id="Description">Description</h2> + +<p>Si l'expression n'utilise pas le drapeau (<em>flag</em>) <code>g</code>, le résultat obtenu sera le même qu'avec {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}}.</p> + +<h3 id="Voir_aussi_les_méthodes_de_RegExp">Voir aussi : les méthodes de <code>RegExp</code></h3> + +<ul> + <li>Si on souhaite savoir s'il existe des correspondances entre une chaîne de caractères et une expression rationnelle {{jsxref("RegExp")}}, on pourra utiliser {{jsxref("RegExp.prototype.test()", "RegExp.test()")}}.</li> + <li>Si on ne souhaite obtenir que la première correspondance, on pourra plutôt utiliser {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}} à la place.</li> + <li>Si on souhaite obtenir les groupes correspondants et que le drapeau « global » est activé, il faudra utiliser {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}} à la place.</li> +</ul> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_match()">Utiliser <code>match()</code></h3> + +<p>Dans l'exemple suivant, on utilise <code>match()</code> afin de trouver la chaîne <code>'Chapitre'</code> suivie par un ou plusieurs chiffres séparés par des points. L'expression utilisée active le drapeau <code>i</code> afin que la casse ne soit pas prise en compte.</p> + +<pre class="brush: js">var str = 'Pour plus d\'informations, voir le chapitre 3.4.5.1'; +var re = /(chapitre \d+(\.\d)*)/i; +var trouvé = str.match(re); + +console.log(trouvé); + +// logs ['chapitre 3.4.5.1', 'chapitre 3.4.5.1', '.1'] + +// 'chapitre 3.4.5.1' est la première correspondance +// 'chapitre 3.4.5.1' est la valeur gardée en mémoire par +// `(chapitre \d+(\.\d)*)`. +// '.1' est la valeur gardée en mémoire par `(\.\d)`. +</pre> + +<h3 id="Utiliser_les_drapeaux_g_(global)_et_i_(ignorer_la_casse)_avec_match()">Utiliser les drapeaux <code>g</code> (global) et <code>i</code> (ignorer la casse) avec <code>match()</code></h3> + +<p>Dans cet exemple, on illustre comment utiliser des drapeaux avec l'expression rationnelle qui est un argument de <code>match()</code>. Chaque lettre de A à E et de a à e est renvoyée, chacune dans un élément du tableau de résultat.</p> + +<pre class="brush: js">var str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'; +var regexp = /[A-E]/gi; +var tableau_correspondances = str.match(regexp); + +console.log(tableau_correspondances); +// ['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e'] +</pre> + +<h3 id="Utiliser_un_paramètre_qui_n'est_pas_une_RegExp">Utiliser un paramètre qui n'est pas une <code>RegExp</code></h3> + +<p>Lorsque le paramètre passé à la fonction est une chaîne de caractères ou un nombre, il est converti de façon implicite en un objet {{jsxref("RegExp")}} grâce à <code>new RegExp(obj)</code>. Si c'est un nombre positif avec le signe +, la méthode <code>RegExp()</code> ignorera ce signe.</p> + +<pre class="brush: js">var str1 = "NaN signifie : qui n'est pas un nombre."; +var str2 = "Mon père a 65 ans." +str1.match("nombre"); // "nombre" est une chaîne, renvoie ["nombre"] +str1.match(NaN); // NaN est de type number, renvoie ["NaN"] +str2.match(65); // Renvoie ["65"] +str2.match(+65); // Renvoie également ["65"]</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.10', 'String.prototype.match')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.match', 'String.prototype.match')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.match', 'String.prototype.match')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.match")}}</p> + +<h2 id="Notes_spécifiques_à_FirefoxGecko">Notes spécifiques à Firefox/Gecko</h2> + +<ul> + <li><code>flags</code> était un second argument non standard présent uniquement sur Gecko : <var>str</var>.match(<var>regexp, flags</var>) et a été retiré avec Firefox 49.</li> + <li>À partir de Firefox 27, cette méthode a été ajustée afin d'être conforme à ECMAScript. Lorsque <code>match()</code> est appelée sur une expression rationnelle globale, la propriété {{jsxref("RegExp.lastIndex")}} de l'objet sera redéfini à <code>0</code> ({{bug(501739)}}).</li> +</ul> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("RegExp")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/matchall/index.html b/files/fr/web/javascript/reference/global_objects/string/matchall/index.html new file mode 100644 index 0000000000..adf4f5bac6 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/matchall/index.html @@ -0,0 +1,122 @@ +--- +title: String.prototype.matchAll() +slug: Web/JavaScript/Reference/Objets_globaux/String/matchAll +tags: + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/matchAll +--- +<div>{{JSRef}}</div> + +<p>La méthode <strong><code>matchAll()</code></strong> renvoie un itérateur contenant l'ensemble des correspondances entre une chaîne de caractères d'une part et une expression rationnelle d'autre part (y compris les groupes capturants).</p> + +<div>{{EmbedInteractiveExample("pages/js/string-matchall.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuer à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.matchAll(<var>regexp</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>regexp</code></dt> + <dd>Un objet représentant une expression rationnelle. Si cet objet n'est pas une instance de {{jsxref("RegExp")}}, il est automatiquement et implicitement converti en une telle instance à l'aide de <code>new RegExp(obj)</code>.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un <a href="https://developer.mozilla.org/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs">itérateur</a>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Regexp.exec()_et_matchAll()"><code>Regexp.exec()</code> et <code>matchAll()</code></h3> + +<p>Avant l'apparition de <code>matchAll()</code> en JavaScript, il était possible d'utiliser {{jsxref("RegExp.exec")}} (et des expressions rationnelles utilisant le marqueur <code>/g</code>) dans une boucle afin d'obtenir l'ensemble des correspondances :</p> + +<pre class="brush: js">const regexp = RegExp('foo*','g'); +const str = 'table football, foosball'; + +while ((matches = regexp.exec(str)) !== null) { + console.log(`${matches[0]} trouvé. Prochaine recherche à partir de ${regexp.lastIndex}.`); + // dans la console : "foo trouvé. Prochaine recherche à partir de 9." + // dans la console : "foo trouvé. Prochaine recherche à partir de 19." +} +</pre> + +<p>Avec <code>matchAll()</code>, on peut éviter la boucle <code>while</code> et le marqueur global. On récupère l'itérateur et on utilise une boucle <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of">for...of</a></code>, <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Syntaxe_décomposition">la décomposition de tableau</a> ou encore {{jsxref("Array.from()")}} :</p> + +<pre class="brush: js">const regexp = RegExp('foo*','g'); +const str = 'table football, foosball'; +let matches = str.matchAll(regexp); + +for (const match of matches) { + console.log(match); +} +// Array [ "foo" ] +// Array [ "foo" ] + +// l'itérateur est épuise après l'itération via for..of +// On rappelle matchAll afin de créer un nouvel itérateur +matches = str.matchAll(regexp); + +Array.from(matches, m => m[0]); +// Array [ "foo", "foo" ] +</pre> + +<h3 id="Meilleur_accès_aux_groupes_capturants">Meilleur accès aux groupes capturants</h3> + +<p>Un autre avantage de <code>matchAll()</code> est un meilleur accès aux groupes capturants. De fait, les groupes capturants sont ignorés par <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/match">match()</a></code> lorsqu'on utilise le marqueur global <code>/g</code> :</p> + +<pre class="brush: js">var regexp = /t(e)(st(\d?))/g; +var str = 'test1test2'; + +str.match(regexp); +// Array ['test1', 'test2']</pre> + +<p>Avec <code>matchAll()</code>, on peut y accéder :</p> + +<pre class="brush: js">let array = [...str.matchAll(regexp)]; + +array[0]; +// ['test1', 'e', 'st1', '1', index: 0, input: 'test1test2', length: 4] +array[1]; +// ['test2', 'e', 'st2', '2', index: 5, input: 'test1test2', length: 4] +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.matchall', 'String.prototype.matchAll')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div> + +<p>{{Compat("javascript.builtins.String.matchAll")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("RegExp")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/normalize/index.html b/files/fr/web/javascript/reference/global_objects/string/normalize/index.html new file mode 100644 index 0000000000..398c9eaefe --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/normalize/index.html @@ -0,0 +1,127 @@ +--- +title: String.prototype.normalize() +slug: Web/JavaScript/Reference/Objets_globaux/String/normalize +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Prototype + - Reference + - String + - Unicode +translation_of: Web/JavaScript/Reference/Global_Objects/String/normalize +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>normalize()</strong></code> permet de renvoyer la forme normalisée Unicode d'une chaîne de caractères (si la valeur n'est pas une chaîne de caractères, elle sera convertie).</p> + +<div>{{EmbedInteractiveExample("pages/js/string-normalize.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.normalize([<var>form</var>]);</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>form</code></dt> + <dd>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 {{jsxref("undefined")}}, la valeur par défaut utilisée sera "<code>NFC</code>". + <ul> + <li><code>NFC</code> - Normalization Form Canonical Composition.</li> + <li><code>NFD</code> - Normalization Form Canonical Decomposition.</li> + <li><code>NFKC</code> - Normalization Form Compatibility Composition.</li> + <li><code>NFKD</code> - Normalization Form Compatibility Decomposition.</li> + </ul> + </dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères qui est le forme Unicode normalisée de la chaîne appelante.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Une exception <code>RangeError</code> est envoyée si le paramètre <code>form</code> n'est pas une des valeurs définies ci-avant.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>normalize()</code> renvoie la forme normalisée Unicode de la chaîne de caractères. Elle n'affecte pas la valeur de la chaîne.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: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" +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.prototype.normalize', 'String.prototype.normalize')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.normalize', 'String.prototype.normalize')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.normalize")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li><a href="https://www.unicode.org/reports/tr15/">Formes de normalisation Unicode, Annexe n°15 du standard Unicode</a></li> + <li><a href="https://en.wikipedia.org/wiki/Unicode_equivalence">Équivalence Unicode</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/padend/index.html b/files/fr/web/javascript/reference/global_objects/string/padend/index.html new file mode 100644 index 0000000000..4bb1897fe1 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/padend/index.html @@ -0,0 +1,76 @@ +--- +title: String.prototype.padEnd() +slug: Web/JavaScript/Reference/Objets_globaux/String/padEnd +tags: + - JavaScript + - Méthode + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/padEnd +--- +<div>{{JSRef}}</div> + +<p>La méthode <strong><code>padEnd()</code></strong> 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.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-padend.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.padEnd(<var>longueurCible</var> [, <var>chaîneComplémentaire</var>])</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>longueurCible</code></dt> + <dd>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.</dd> + <dt><code>chaîneComplémentaire</code> {{optional_inline}}</dt> + <dd>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.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères ({{jsxref("String")}}) dont la longueur est celle indiquée, complétée avec la chaîne fournie.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">'abc'.padEnd(10); // "abc " +'abc'.padEnd(10, "toto"); // "abctototot" +'abc'.padEnd(6,"123456"); // "abc123" +'abc'.padEnd(1); // "abc" +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.padend', 'String.prototype.padEnd')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES8', '#sec-string.prototype.padend', 'String.prototype.padEnd')}}</td> + <td>{{Spec2('ES8')}}</td> + <td>Définition initiale.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.padEnd")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.padStart()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/padstart/index.html b/files/fr/web/javascript/reference/global_objects/string/padstart/index.html new file mode 100644 index 0000000000..d5c3500027 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/padstart/index.html @@ -0,0 +1,78 @@ +--- +title: String.prototype.padStart() +slug: Web/JavaScript/Reference/Objets_globaux/String/padStart +tags: + - JavaScript + - Méthode + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/padStart +--- +<div>{{JSRef}}</div> + +<p>La méthode <strong><code>padStart()</code></strong> 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.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-padstart.html")}}</div> + +<div class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</div> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.padStart(<var>longueurCible</var> [, <var>chaîneComplémentaire</var>])</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>longueurCible</code></dt> + <dd>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.</dd> + <dt><code>chaîneComplémentaire</code> {{optional_inline}}</dt> + <dd>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.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères ({{jsxref("String")}}) dont la longueur est celle indiquée, complétée avec la chaîne fournie au début de la chaîne courante.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">'abc'.padStart(10); // " abc" +'abc'.padStart(10, "toto"); // "totototabc" +'abc'.padStart(6,"123465"); // "123abc" +'abc'.padStart(8, "0"); // "00000abc" +'abc'.padStart(1); // "abc"</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.padstart', 'String.prototype.padStart')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES8', '#sec-string.prototype.padstart', 'String.prototype.padStart')}}</td> + <td>{{Spec2('ES8')}}</td> + <td>Définition initiale.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> + +<p>{{Compat("javascript.builtins.String.padStart")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.padEnd()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/raw/index.html b/files/fr/web/javascript/reference/global_objects/string/raw/index.html new file mode 100644 index 0000000000..f509b557ce --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/raw/index.html @@ -0,0 +1,116 @@ +--- +title: String.raw() +slug: Web/JavaScript/Reference/Objets_globaux/String/raw +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/raw +--- +<div>{{JSRef}}</div> + +<p>La méthode statique <code><strong>String.raw()</strong></code> est une fonction d'étiquetage (<em>tag function</em>) pour les <a href="/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits#Les_gabarits_étiquetés">gabarits de chaînes de caractères</a> (elle est <a href="https://bugs.chromium.org/p/v8/issues/detail?id=5016">semblable</a> au préfixe <code>r</code> en Python ou au préfixe <code>@</code> 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. <code>${toto}</code>) sont traités).</p> + +<div>{{EmbedInteractiveExample("pages/js/string-raw.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox notranslate">String.raw(callSite, <em>...substitutions</em>) + +String.raw`gabaritChaîne` +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>callSite</code></dt> + <dd>Un site d'appel bien formé pour un gabarit (<em>call site object</em>) tel que <code>{raw: "string"}</code>.</dd> + <dt>...substitutions</dt> + <dd>Paramètre contenant les valeurs à substituer.</dd> + <dt>gabaritChaîne</dt> + <dd><a href="/fr/docs/Web/JavaScript/Reference/Gabarit_chaînes_caractères">Un gabarit de chaîne de caractères</a>, éventuellement avec des substitutions (<code>${...}</code>).</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>La chaîne de caractères brute correspondant à un gabarit donné.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Une exception <code>TypeError</code> est renvoyée si le premier argument n'est pas un objet bien formé.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>Dans la plupart des cas, <code>String.raw()</code> 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 <a href="/fr/docs/Web/JavaScript/Reference/Gabarit_chaînes_caractères#Les_gabarits_de_cha.C3.AEnes_.C3.A9tiquett.C3.A9s">fonctions d'étiquetage (<em>tag</em>)</a>.</p> + +<p>La méthode <code>String.raw()</code> 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.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js notranslate">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" +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.raw', 'String.raw')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.raw', 'String.raw')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.raw")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Reference/Gabarit_chaînes_caractères">Gabarits de chaînes de caractères</a></li> + <li>{{jsxref("String")}}</li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale">Grammaire lexicale JavaScript</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/repeat/index.html b/files/fr/web/javascript/reference/global_objects/string/repeat/index.html new file mode 100644 index 0000000000..3245288bd9 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/repeat/index.html @@ -0,0 +1,87 @@ +--- +title: String.prototype.repeat() +slug: Web/JavaScript/Reference/Objets_globaux/String/repeat +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Prototype + - Reference + - String + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>repeat()</strong></code> 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.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-repeat.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.repeat(<var>compte</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>compte</code></dt> + <dd>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.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une nouvelle chaîne de caractères composée du nombre indiqué de copies de la chaîne appelante.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<ul> + <li>{{jsxref("Erreurs/Negative_repetition_count", "RangeError")}} : le nombre de répétition doit être positif.</li> + <li>{{jsxref("Erreurs/Resulting_string_too_large", "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.</li> +</ul> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>La compteur doit être positif et inférieur à l'infini.</dd> +</dl> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: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)</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaire</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Première définition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.repeat")}}</p> diff --git a/files/fr/web/javascript/reference/global_objects/string/replace/index.html b/files/fr/web/javascript/reference/global_objects/string/replace/index.html new file mode 100644 index 0000000000..8d4f5d44a5 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/replace/index.html @@ -0,0 +1,309 @@ +--- +title: String.prototype.replace() +slug: Web/JavaScript/Reference/Objets_globaux/String/replace +tags: + - Chaîne + - Expression + - JavaScript + - Méthode + - Prototype + - Reference + - Régulière +translation_of: Web/JavaScript/Reference/Global_Objects/String/replace +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>replace()</strong></code> renvoie une nouvelle chaîne de caractères dans laquelle tout ou partie des correspondances à un <code>modèle</code> sont remplacées par un <code>remplacement</code>. Le <code>modèle</code> utilisé peut être une {{jsxref("RegExp")}} et le remplacement peut être une chaîne ou une fonction à appeler pour chaque correspondance. Si <code>modèle</code> est une chaîne de caractères, seule la première correspondance sera remplacée.</p> + +<p>La chaîne de caractère originale reste inchangée.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-replace.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>chn</var>.replace(<var>regexp</var>|<var>souschn</var>, nouv<var>Souschn</var>|<var>fonction</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>regexp</code> (modèle)</dt> + <dd>Un objet ou un littéral {{jsxref("RegExp")}}. La ou les correspondances sont remplacées par <code>nouvSouschn</code> ou par la valeur retournée par la <code>fonction</code> indiquée.</dd> + <dt><code>souschn</code> (modèle)</dt> + <dd>Une {{jsxref("String")}} qui est à remplacer par <code>nouvSouschn</code>. Elle est traitée comme une chaîne de caractères verbatim et elle n'est <em>pas</em> interprétée comme une expression régulière. Seule la première occurrence sera remplacée.</dd> + <dt><code>nouvSouschn</code> (remplacement)</dt> + <dd>La {{jsxref("String")}} qui remplace la chaîne de caractères indiquée par le paramètre <code>regexp</code> ou <code>souschn</code>. Un certain nombre de modèles de remplacement spéciaux sont supportés ; voir la section "<a href="#Indiquer_une_chaîne_de_caractère_comme_paramètre">Indiquer une chaîne de caractères comme paramètre</a>" ci-dessous.</dd> + <dt><code>fonction</code> (remplacement)</dt> + <dd>Une fonction à appeler pour créer la nouvelle sous-chaîne de caractères à utiliser pour remplacer la <code>regexp</code> ou la <code>souschn</code> donnée. Les arguments passés à cette fonction sont décrits dans la section "<a href="#Indiquer_une_fonction_comme_paramètre">Indiquer une fonction comme paramètre</a>" ci-dessous.</dd> +</dl> + +<h3 id="Valeur_retournée">Valeur retournée</h3> + +<p>Une nouvelle chaîne de caractères avec tout ou partie des correspondances du modèle remplacées par un remplacement.</p> + +<h2 id="Description">Description</h2> + +<p>Cette méthode ne change pas l'objet {{jsxref("String")}} auquel elle est appliquée. Elle retourne simplement une nouvelle chaîne de caractères.</p> + +<p>Pour réaliser une recherche et remplacement global(e), incluez le commutateur <code>g</code> dans l'expression régulière.</p> + +<h3 id="Indiquer_une_chaîne_de_caractère_comme_paramètre">Indiquer une chaîne de caractère comme paramètre</h3> + +<p>La chaîne de caractère de remplacement peut inclure les modèles de remplacement spéciaux suivants :</p> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">Modèle</td> + <td class="header">Insère</td> + </tr> + <tr> + <td><code>$$</code></td> + <td>Insère un "$".</td> + </tr> + <tr> + <td><code>$&</code></td> + <td>Insère la chaine de caractère en correspondance.</td> + </tr> + <tr> + <td><code>$`</code></td> + <td>Insère la partie de la chaîne de caractère qui précède la sous-chaîne en correspondance.</td> + </tr> + <tr> + <td><code>$'</code></td> + <td>Insère la partie de la chaîne de caractère qui suit la sous-chaîne en correspondance.</td> + </tr> + <tr> + <td><code>$<em>n</em></code></td> + <td> + <p>Où <code><em>n</em></code> est un entier positif inférieur à 100. Insère la <em>n</em> ième chaîne de sous-correspondance entre parenthèses, à condition que le premier argument ait été un objet {{jsxref("RegExp")}}. Notez que ceci est réalisé en indices base 1.</p> + </td> + </tr> + </tbody> +</table> + +<h3 id="Indiquer_une_fonction_comme_paramètre">Indiquer une fonction comme paramètre</h3> + +<p>Vous pouvez indiquer une fonction comme second paramètre. Dans ce cas, cette fonction sera appelée après que la recherche a été effectuée. Le résultat de la fonction (valeur retournée) sera utilisé comme chaîne de remplacement. (Note : les modèles de remplacement spéciaux mentionnés ci-dessus ne s'appliquent <em>pas</em> dans ce cas). Notez que cette fonction sera appelée plusieurs fois, pour chaque correspondance complète à remplacer si l'expression régulière dans le premier paramètre est globale.</p> + +<p>Les arguments de cette fonction sont les suivants :</p> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">Nom possible</td> + <td class="header">Valeur fournie</td> + </tr> + <tr> + <td><code>correspondance</code></td> + <td>La chaîne de caractère en correspondance. (Correspond au <code>$&</code> défini ci-dessus.)</td> + </tr> + <tr> + <td><code>p1, p2, ...</code></td> + <td> + <p>La <em>n</em>-ième chaîne de sous-correspondance entre parenthèses capturantes, à condition que le premier argument de <code>replace()</code> soit un objet <code>RegExp</code>. (Correspond aux <code>$1</code>, <code>$2</code>, etc. ci-dessus.) Par exemple, si <code>/(\a+)(\b+)/</code> a été indiqué, <code>p1</code> correspond à <code>\a+</code>, et <code>p2</code> à <code>\b+</code>.</p> + </td> + </tr> + <tr> + <td><code>decalage</code></td> + <td>Le décalage entre la sous-chaîne en correspondance à l'intérieur de la chaîne complète en cours d'analyse. (Par exemple, si la chaîne complète était <code>'abcd'</code>, et que le chaîne en correspondance était <code>'bc'</code>, alors cet argument vaudra 1.)</td> + </tr> + <tr> + <td><code>chaine</code></td> + <td>La chaîne complète en cours d'analyse.</td> + </tr> + </tbody> +</table> + +<p>(Le nombre exact d'arguments varie suivant que le premier paramètre est ou non un objet {{jsxref("RegExp")}} et, dans ce cas, du nombre de sous-correspondances entre parenthèses qu'il indique.)</p> + +<p>L'exemple suivant affectera <code>'abc - 12345 - #$*%'</code> à la variable <code>nouvelleChaine</code> :</p> + +<pre class="brush: js">function remplaceur(correspondance, p1, p2, p3, decalage, chaine) { + // p1 est non numérique, p2 numérique, et p3 non-alphanumérique + return [p1, p2, p3].join(' - '); +} +var nouvelleChaine = 'abc12345#$*%'.replace(/([^\d]*)(\d*)([^\w]*)/, remplaceur); +console.log(nouvelleChaine); // abc - 12345 - #$*% +</pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Définition_de_lexpression_régulière_dans_replace">Définition de l'expression régulière dans <code>replace()</code></h3> + +<p>Dans l'exemple suivant, l'expression régulière est définie dans <code>replace()</code> et inclut l'indicateur d'indifférence à la casse.</p> + +<pre class="brush: js">var chn = 'Twas the night before Xmas...'; +var nouvChn = chn.replace(/xmas/i, 'Christmas'); +console.log(nouvChn); // Twas the night before Christmas...</pre> + +<p>Cela affiche 'Twas the night before Christmas...'.</p> + +<div class="blockIndicator note"> +<p>Note : Voir <a href="/fr/docs/Web/JavaScript/Guide/Expressions_r%C3%A9guli%C3%A8res">ce guide</a> pour plus d'explications concernant les expressions régulières.</p> +</div> + +<h3 id="Utilisation_de_global_et_ignore_avec_replace">Utilisation de <code>global</code> et <code>ignore</code> avec <code>replace()</code></h3> + +<p>Le remplacement global ne peut être fait qu'avec une expression régulière. Dans l'exemple suivant, l'expression régulière inclut les indicateurs global et indifférence à la casse, qui permettent à <code>replace()</code> de remplacer chaque occurrence de 'pommes' dans la chaîne par 'oranges'.</p> + +<pre class="brush: js">var re = /pommes/gi; +var chn = 'Les pommes sont rondes, et les pommes sont juteuses.'; +var nouvChn = chn.replace(re, 'oranges'); +console.log(nouvChn); // Les oranges sont rondes, et les oranges sont juteuses. +</pre> + +<p>Cela affiche 'Les oranges sont rondes, et les oranges sont juteuses.'.</p> + +<h3 id="Inverser_des_mots_dans_une_chaîne_de_caractères">Inverser des mots dans une chaîne de caractères</h3> + +<p>Le script suivant intervertit les mots dans la chaîne de caractères. Pour le texte de remplacement, le script utilise les modèles de remplacement <code>$1</code> et <code>$2</code>.</p> + +<pre class="brush: js">var re = /(\w+)\s(\w+)/; +var chn = 'Jean Martin'; +var nouvChn = chn.replace(re, "$2, $1"); +console.log(nouvChn); // Martin, Jean +</pre> + +<p>Cela affiche 'Martin, Jean'.</p> + +<h3 id="Utilisation_dune_fonction_inline_modifiant_les_caractères_en_correspondance">Utilisation d'une fonction inline modifiant les caractères en correspondance</h3> + +<p>Dans cet exemple, toutes les occurrences des lettres majuscules sont converties en minuscules, et un tiret est inséré juste avant l'emplacement de la correspondance. La chose importante ici est que des opérations suppémentaires sont nécessaires sur l'élément en correspondance avant qu'il ne soit retourné comme remplacement.</p> + +<p>La fonction de remplacement accepte le fragment en correspondance comme paramètre, et elle l'utilise pour transformer sa casse et y concaténer le tiret avant de le retourner.</p> + +<pre class="brush: js">function styleFormatTiret(nomPropriete) { + function majusculesEnTiretMinuscules(correspondance, decalage, chaine) { + return (decalage > 0 ? '-' : '') + correspondance.toLowerCase(); + } + return nomPropriete.replace(/[A-Z]/g, majusculesEnTiretMinuscules); +} +</pre> + +<p>Avec <code>styleFormatTiret(</code><code>'borderTop')</code>, cela renvoie 'border-top'.</p> + +<p>Du fait que nous voulons transformer davantage le résultat de la correspondance avant la substitution finale, nous devons utiliser une fonction. Cela force l'évaluation de la correspondance avant la méthode {{jsxref ("String.prototype.toLowerCase()", "toLowerCase()")}}. Si nous avions essayé de le faire en utilisant la correspondance sans fonction, le {{jsxref ("String.prototype.toLowerCase()", "toLowerCase()")}} n'aurait eu aucun effet.</p> + +<pre class="brush: js">var nouvChn = nomPropriete.replace(/[A-Z]/g, '-' + '$&'.toLowerCase()); // ne fonctionne pas +</pre> + +<p>Ceci est dû au fait que <code>'$&'.toLowerCase()</code> serait d'abord évalué comme un littéral de chaîne (résultant en le même <code>'$&'</code>) avant d'utiliser les caractères comme modèle.</p> + +<h3 id="Remplacer_un_degré_Fahrenheit_par_son_équivalent_Celsius">Remplacer un degré Fahrenheit par son équivalent Celsius</h3> + +<p>L'exemple suivant remplace des degrés Fahrenheit par leur équivalent en degrés Celsius. Les degrés Fahrenheit doivent être un nombre se terminant par F. La fonction renvoie le nombre en Celsius se terminant par C. Par exemple, si le nombre de départ est 212F, la fonction renvoie 100C. Si le nombre de départ est 0F, la fonction retourne -17.77777777777778C.</p> + +<p>L'expression régulière <code>test</code> vérifie tout nombre se terminant par F. Le nombre de degrés Fahrenheit est accessible à la fonction via son deuxième paramètre, <code>p1</code>. La fonction définit le nombre Celsius sur la base des degrés Fahrenheit transmis dans une chaîne à la fonction <code>f2c()</code>. <code>f2c()</code> renvoie ensuite le nombre Celsius. Cette fonction se rapproche de l'indicateur <code>s///e</code> de Perl.</p> + +<pre class="brush: js">function f2c(x) { + function convertir(chn, p1, decalage, s) { + return ((p1-32) * 5/9) + 'C'; + } + var s = String(x); + var test = /(-?\d+(?:\.\d*)?)F\b/g; + return s.replace(test, convertir); +} +</pre> + +<h3 id="Utiliser_une_fonction_inline_avec_une_expression_régulière_pour_éviter_des_boucles_for">Utiliser une fonction inline avec une expression régulière pour éviter des boucles <code>for</code></h3> + +<p>L'exemple suivant accepte un modèle chaîne et le convertit en un tableau d'objets.</p> + +<p><strong>Entrée : </strong></p> + +<p>Une chaîne de caractères composée des caractères <code>x</code>, <code>-</code> et <code>_</code></p> + +<pre class="brush: js">x-x_ +x---x---x---x--- +x-xxx-xx-x- +x_x_x___x___x___</pre> + +<div><strong>Sortie :</strong></div> + +<div></div> + +<div>Un tableau d'objets. Un <code>'x'</code> dénote un état <code>'marche'</code>, un <code>'-'</code> symbolise un état '<font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">arret</span></font>' et un <code>'_'</code> (blanc souligné) symbolise la longueur d'un état <code>'<font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">marche</span></font>'</code>.</div> + +<div></div> + +<pre class="brush: json">[ + { marche: true, longueur: 1 }, + { marche: false, longueur: 1 }, + { marche: true, longueur: 2 } + ... +]</pre> + +<div><strong>Fragment :</strong></div> + +<div></div> + +<div> +<pre class="brush: js">var chn = 'x-x_'; +var tabRet = []; +chn.replace(/(x_*)|(-)/g, function(correspondance, $1, $2){ + if($1) tabRet.push({ marche: true, longueur: $1.length }); + if($2) tabRet.push({ marche: false, longueur: 1 }); +}); + +console.log(tabRet);</pre> +</div> + +<div>Ce fragment génère un tableau de 3 objets au format désiré sans utiliser de boucle <code>for</code>.</div> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Statut</th> + <th scope="col">Commentaire</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Définition initiale. Implémentée en JavaScript 1.2</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.11', 'String.prototype.replace')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.replace', 'String.prototype.replace')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.replace', 'String.prototype.replace')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, regardez <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et envoyez nous une pull request.</p> + +<p>{{Compat("javascript.builtins.String.replace")}}</p> + +<h2 id="Notes_spécifiques_à_Firefox">Notes spécifiques à Firefox</h2> + +<ul> + <li><code>flags</code> était un troisième argument non standard disponible uniquement dans Gecko : <var>str</var>.replace(<var>regexp</var>|<var>substr</var>, <var>newSubStr</var>|<var>function, flags</var>)</li> + <li>À partir de Gecko 27 {{geckoRelease(27)}}, cette méthode a été modifiée pour être conforme à la spécification ECMAScript. Lorsque <code>replace()</code> est appelée avec une expression régulière globale, la propriété {{jsxref("RegExp.lastIndex")}} (si elle est définie) sera remise à <code>0</code> ({{bug(501739)}}).</li> + <li>À partir de Gecko 39 {{geckoRelease(39)}}, l'argument non-standard <code>flags</code> est désapprouvé et déclenche un avertissement dans la console ({{bug(1142351)}}).</li> + <li>À partir de Gecko 47 {{geckoRelease(47)}}, l'argument non-standard <code>flags</code> n'est plus supporté dans les versions non distribution et sera bientôt retiré complètement ({{bug(1245801)}}).</li> + <li>À partir de Gecko 49 {{geckoRelease(49)}}, l'argument non-standard <code>flags</code> n'est plus supporté ({{bug(1108382)}}).</li> +</ul> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.match()")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/replaceall/index.html b/files/fr/web/javascript/reference/global_objects/string/replaceall/index.html new file mode 100644 index 0000000000..d526ea36f7 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/replaceall/index.html @@ -0,0 +1,170 @@ +--- +title: String.prototype.replaceAll() +slug: Web/JavaScript/Reference/Objets_globaux/String/replaceAll +translation_of: Web/JavaScript/Reference/Global_Objects/String/replaceAll +--- +<div>{{JSRef}}</div> + +<p><span class="seoSummary">La méthode <strong><code>replaceAll()</code></strong> retourne une nouvelle chaîne de caractères dans la quelle toutes les occurences de <code>pattern</code> ont été remplacés par <code>replacement</code>.</span>L'argument <code>pattern</code> peut être de type chaîne de caractères ou {{jsxref("RegExp")}}, et l'argument <code>replacement</code> peut être une chaîne de caractères ou une fonction qui sera appelée pour trouver chaque correspondances.</p> + +<p>La chaîne de caractères initiale restera inchangée.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-replaceall.html")}}</div> + +<p class="hidden">La source de cet exemple intéractif est stocké dans un dépôt GitHub. Si vous souhaitez y contribuer, s'il vous plait, clonez <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et envoyez nous un requête "pull".</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox notranslate">const newStr = <var>str</var>.replaceAll(<var>regexp</var>|<var>substr</var>, <var>newSubstr</var>|<var>function</var>) +</pre> + +<div class="blockIndicator note"> +<p>Quand une `<var>regexp</var>` est utilisée, il est préférable d'utiliser le marqueur global ("g"); autrement, l'erreur <code>TypeError</code>: "replaceAll must be called with a global RegExp" sera retournée.</p> +</div> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code><var>regexp</var></code> (pattern)</dt> + <dd>Un objet ou litérale {{jsxref("RegExp")}} avec le marqueur global. Les correspondances sont remplacées par <code><var>newSubstr</var></code> ou la valeur retournée par la <code><var>function</var></code> spécifiée. Une RegExp sans le marqueur global ("g") renverra l'erreur <code>TypeError</code>: "replaceAll must be called with a global RegExp".</dd> + <dt><code><var>substr</var></code></dt> + <dd>Une {{jsxref("String")}} qui sera remplacée par <code><var>newSubstr</var></code>. Elle est traité comme une chaîne de caracère litéral et <em>non pas</em> comme une expression régulière.</dd> + <dt><code><var>newSubstr</var></code> (remplacement)</dt> + <dd>La {{jsxref("String")}} qui remplacera la sous-chaîne indiqué par la <code><var>regexp</var></code> ou <code><var>substr</var></code> donnée en paramètre. Un certain nombre de pattern sont supportés, voir la section "<a href="#Spécifier_une_chaîne_de_caractères_comme_paramètre">Spécifier une chaîne de caractères comme paramètre</a>" ci-dessous.</dd> + <dt><code><var>function</var></code> (remplacement)</dt> + <dd>Une fonction qui a pour but de créer la nouvelle sous-chaîne qui remplacera les occurences trouvés via la <code><var>regexp</var></code> ou <code><var>substr</var></code> donnée en paramètre. Les arguments passés à cette fonction sont détaillé dans la section "<a href="#Spécifier_une_fonction_comme_paramètre">Spécifier une fonction comme paramètre</a>" ci-dessous.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une nouvelle chaîne avec toutes les occurences trouvés remplacés par le pattern de remplacement.</p> + +<h2 id="Description">Description</h2> + +<p>Cette méthode ne remplace ni ne modifie l'objet {{jsxref("String")}} original. Elle retourne juste une nouvelle chaîne de caractères.</p> + +<h3 id="Spécifier_une_chaîne_de_caractères_comme_paramètre">Spécifier une chaîne de caractères comme paramètre</h3> + +<p>La chaîne de caractère de remplacement peut inclure les patterns de remplacement spéciaux suivant :</p> + +<table class="standard-table"> + <thead> + <tr> + <th class="header" scope="col">Pattern</th> + <th class="header" scope="col">Insertion</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>$$</code></td> + <td>Insert un <code>"$"</code>.</td> + </tr> + <tr> + <td><code>$&</code></td> + <td>Insert la chaîne de caracètre trouvée.</td> + </tr> + <tr> + <td><code>$`</code></td> + <td>Insert la portion de chaîne de caracètre qui précède celle trouvée.</td> + </tr> + <tr> + <td><code>$'</code></td> + <td>Inserts la portion de chaîne de caracètre qui suit celle trouvée.</td> + </tr> + <tr> + <td><code>$<var>n</var></code></td> + <td>Où <code><var>n</var></code> est un entier positif inférieur à 100. Insert la n-ième occurence trouvée, à condition que le premier argument un objet {{jsxref("RegExp")}} . Note that this is <code>1</code>-indexed.</td> + </tr> + </tbody> +</table> + +<h3 id="Spécifier_une_fonction_comme_paramètre">Spécifier une fonction comme paramètre</h3> + +<p>Vous pouvez passer une fonction comlme second paramètre. Dans ce cas, la fonction sera appelée après qu'une occorence soit trouvée. Le résultat de la fonction (valeur de retour) sera utilisé comme chaîne de remplacement. (<strong>Note: </strong>Les remplacement spéciaux mentionner plus haut <em>ne s'appliqueront pas</em> dans ce cas.)</p> + +<p>A noter que la fonction sera utilisé à chaque fois qu'une occurence sera rencontrée, si l'expression régulière donné en paramètre est global.</p> + +<p>La fonction admet les argumetns suivants :</p> + +<table class="standard-table"> + <thead> + <tr> + <th class="header" scope="col">Nom Possible</th> + <th class="header" scope="col">Valeur fournit</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>match</code></td> + <td>L'occurence trouvée. (Correspond au <code>$&</code> du précédent tableau.)</td> + </tr> + <tr> + <td><code>p1, p2, ...</code></td> + <td> + <p>Le n-ième chaîne de caractères trouvée par une sous correspondance entre parenthèses, à condition que le premier paramètre soit un objet de type {{jsxref("RegExp")}} object.<br> + (Correspond aux <code>$1</code>, <code>$2</code>, ... précédents.) Par exemple, si <code>/(\a+)(\b+)/</code> à été en paramètres, <code>p1</code> est la correspondance pour <code>\a+</code>, et <code>p2</code> pour <code>\b+</code>.</p> + </td> + </tr> + <tr> + <td><code>offset</code></td> + <td>Le décalage de la sous-chaîne trouvée dans la chaîne d'entrée. (par exemple, si la chaîne complète d'entrée était <code>'abcd'</code> et la sous-chaîne <code>'bc'</code> alors, cet argument vaudra 1.)</td> + </tr> + <tr> + <td><code>string</code></td> + <td>La chaîne compète examinée.</td> + </tr> + </tbody> +</table> + +<p>(Le nombre d'arguments exact dépend de si le premier arguments de <code>replaceAll()</code> est un objet de type {{jsxref("RegExp")}} et, si tel est le cas, du nombre le sous correspondance entre parenthèses qu'il spécifie.)</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_replaceAll">Utiliser replaceAll</h3> + +<pre class="brush: js notranslate">'aabbcc'.replaceAll('b', '.'); +// 'aa..cc'</pre> + +<h3 id="Les_retour_de_regex_non_global">Les retour de regex non global</h3> + +<p>Quand on utilise une expression régulère pour chercher une valeur, elle doit être global. Cela ne marchera donc pas:</p> + +<pre class="brush: js; example-bad notranslate">'aabbcc'.replaceAll(/b/, '.'); +TypeError: replaceAll must be called with a global RegExp +</pre> + +<p>Ceci marchera:</p> + +<pre class="brush: js; example-good notranslate">'aabbcc'.replaceAll(/b/g, '.'); +"aa..cc" +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.replaceall', 'String.prototype.replaceAll')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p class="hidden">La table de compatibilité de cette page est générée a partir d'une donnée structurée. Si vous souhaitez y contribuer, s'il vous plait, aller voir: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et envoyer une requête "pull".</p> + +<p>{{Compat("javascript.builtins.String.replaceAll")}}</p> + +<h2 id="A_voir_également">A voir également</h2> + +<ul> + <li>{{jsxref("String.prototype.replace", "String.prototype.replace()")}}</li> + <li>{{jsxref("String.prototype.match", "String.prototype.match()")}}</li> + <li>{{jsxref("RegExp.prototype.exec", "RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test", "RegExp.prototype.test()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/search/index.html b/files/fr/web/javascript/reference/global_objects/string/search/index.html new file mode 100644 index 0000000000..76ddab1f26 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/search/index.html @@ -0,0 +1,106 @@ +--- +title: String.prototype.search() +slug: Web/JavaScript/Reference/Objets_globaux/String/search +tags: + - Expressions rationnelles + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/search +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>search()</strong></code> éxecute une recherche dans une chaine de caractères grâce à une expression rationnelle appliquée sur la chaîne courante.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-search.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.search(<var>regexp</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>regexp</code></dt> + <dd>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 {{jsxref("RegExp")}} en utilisant <code>new RegExp(obj)</code>.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Si la recherche aboutit, <code>search()</code> 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 <code>-1</code>.</p> + +<h2 id="Description">Description</h2> + +<p>Si la recherche est positive, <code>search()</code> 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.</p> + +<p>Si on souhaite savoir si un motif est trouvé dans une chaine de caractères, on utilisera cette méthode (semblable à la méthode {{jsxref("RegExp.prototype.test", "test()")}}) du prototype de <code>RegExp</code> ; pour plus d'informations (mais une éxecution plus lente), on utilisera {{jsxref("String.prototype.match", "match()")}} (semblable à la méthode {{jsxref("RegExp.prototype.exec", "exec()")}} pour les expressions rationnelles). La méthode <code>test</code> est semblable mais renvoie uniquement un booléen indiquant si une correspondance a été trouvée.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>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).</p> + +<pre class="brush: 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</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.2</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.12', 'String.prototype.search')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.search', 'String.prototype.search')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.search', 'String.prototype.search')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.search")}}</p> + +<h2 id="Notes_spécifiques_à_Gecko">Notes spécifiques à Gecko</h2> + +<ul> + <li><code>flags</code> était un second argument non standard présent uniquement sur Gecko : <var>str</var>.search(<var>regexp, flags</var>)</li> + <li>Avant {{Gecko("8.0")}}, <code>search()</code> n'était pas implémenté correctement ; quand il était appelé sans paramètre ou avec {{jsxref("undefined")}}, la recherche validait la chaine de caractères "undefined", au lieu de valider une chaine de caractères vide. Cela a été corrigé ; désormais, <code>"a".search()</code> et <code>"a".search(undefined)</code> renvoient bien 0.</li> + <li>À partir de Gecko 39 {{geckoRelease(39)}}, les arguments non-standards (<code>flags</code>) pour les drapeaux sont dépréciés et déclenchent des avertissements dans la console ({{bug(1142351)}}). Cette propriété est spécifique à Gecko et sera retirée à l'avenir.</li> + <li>À partir de Gecko 47 {{geckoRelease(47)}}, l'argument non-standard <code>flags</code> n'est plus supporté dans les versions hors <em>release</em> et sera bientôt retiré définitivement ({{bug(1245801)}}).</li> + <li>À partir de Gecko 49 {{geckoRelease(49)}}, l'argument non-standard <code>flags</code> n'est plus pris en charge ({{bug(1108382)}}).</li> +</ul> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.match()")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/slice/index.html b/files/fr/web/javascript/reference/global_objects/string/slice/index.html new file mode 100644 index 0000000000..d01c172fec --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/slice/index.html @@ -0,0 +1,129 @@ +--- +title: String.prototype.slice() +slug: Web/JavaScript/Reference/Objets_globaux/String/slice +tags: + - Chaîne + - JavaScript + - Méthode + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/String/slice +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>slice()</strong></code> extrait une section d'une chaine de caractères et la retourne comme une nouvelle chaine de caractères. La chaîne de caractères courante n'est pas modifiée.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-slice.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><em>chn</em>.slice(<em>indiceDe<var>but</var></em>[, <em>indiceF</em><var><em>in</em></var>])</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>indiceDebut</code></dt> + <dd>L'indice base 0 auquel commencer l'extraction. Si négatif, il est traité comme (<code>longueurSource + indiceDebut</code>) où <code>longueurSource</code> est la longueur de la chaine de caractères (par exemple, si <code>indiceDebut</code> est -3, il sera traité comme <code>longueurSource - 3</code>). Si <code>indiceDebut</code> est supérieur à la longueur de la chaîne, <code>slice()</code> renvoie une chaîne vide.</dd> + <dt><code>indiceFin</code></dt> + <dd>Paramètre optionnel. Un indice base 0 <em>avant</em> lequel terminer l'extraction. Le caractère à cet indice ne sera pas inclus. Si <code>indiceFin</code> est absent, <code>slice()</code> extraira jusqu'à la fin de la chaine de caractères. Si négatif, il sera traité comme (<code>longueurSource + indiceFin</code>) où <code>longueurSource</code> est la longueur de la chaine de caractères (par exemple s'il vaut <code>-3</code>, il sera traité comme <code>longueurSource - 3</code>)</dd> +</dl> + +<h3 id="Valeur_retournée">Valeur retournée</h3> + +<p>Une nouvelle chaîne de caractères contenant la section extraite de la chaîne.</p> + +<h2 id="Description">Description</h2> + +<p><code>slice()</code> extrait le texte d'une chaine de caractères et retourne une nouvelle chaîne de caractères. Les changements au texte dans une chaine de caractères n'affectent pas l'autre chaîne.</p> + +<p><code>slice()</code> extrait jusqu'à <code>indiceFin</code>, mais sans l'inclure. Par exemple, <code>chn.slice(1, 4)</code> extrait du second caractère jusqu'au quatrième caractère (caractères d'indices 1, 2 et 3).</p> + +<p>Par exemple, <code>chn.slice(2, -1)</code> extrait du troisième caractère jusqu'à l'avant-dernier caractère de la chaine de caractères.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilisation_de_slice()_pour_créer_une_nouvelle_chaîne_de_caractères">Utilisation de <code>slice()</code> pour créer une nouvelle chaîne de caractères</h3> + +<p>L'exemple suivant utilise <code>slice()</code> pour créer une nouvelle chaîne de caractères.</p> + +<pre class="brush: js">var chn1 = 'Le matin est sur nous.', // la longueur de chn1 est de 22 +<code> </code>chn<code>2 = </code>chn<code>1.slice(1, 8), + </code>chn<code>3 = </code>chn<code>1.slice(3, -2), + </code>chn<code>4 = </code>chn<code>1.slice(13), + </code>chn<code>5 = </code>chn<code>1.slice(30); +console.log(</code>chn<code>2); // SORTIE : </code>e matin<code> +console.log(</code>chn<code>3); // SORTIE : m</code>atin est sur nou<code> +console.log(</code>chn<code>4); // SORTIE : </code>sur nous.<code> +console.log(</code>chn<code>5); // SORTIE : ""</code></pre> + +<h3 id="Utilisation_de_slice()_avec_des_indices_négatifs">Utilisation de <code>slice()</code> avec des indices négatifs</h3> + +<p>L'exemple suivant utilise <code>slice()</code> avec des indices négatifs.</p> + +<pre class="brush:js">var chn = 'Le matin est sur nous.'; +chn.slice(-3); // retourne "us." +chn.slice(-3, -1); // retourne "us" +chn.slice(0, -1); // retourne "Le matin est sur nous" +</pre> + +<p>Dans l'exemple qui suit, on commence à chercher l'indice de début à partir de la fin de la chaîne avec l'argument <code>-11</code> et on utilise un indice de fin positif avec <code>16</code> :</p> + +<pre class="brush: js">console.log(chn.slice(-11, 16)); // "st sur"</pre> + +<p>On utilise ensuite un indice de début positif (la recherche est effectuée depuis le début de la chaîne) et un indice de fin négatif pour parvenir au même résultat :</p> + +<pre class="brush: js">console.log(chn.slice(10, -5)); // "st sur"</pre> + +<p>Enfin, on utilise deux indices négatifs : la position de début et la position de fin sont recherchées à parti de la fin de la chaîne :</p> + +<pre class="brush: js">console.log(chn.slice(-11, -5)); // "st sur"</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Statut</th> + <th scope="col">Commentaire</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Définition initiale. Implémentée dans JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.13', 'String.prototype.slice')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.slice', 'String.prototype.slice')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.slice', 'String.prototype.slice')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer aux données, regardez <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et envoyez-nous une pull request.</p> + +<p>{{Compat("javascript.builtins.String.slice")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.substr()")}} {{deprecated_inline}}</li> + <li>{{jsxref("String.prototype.substring()")}}</li> + <li>{{jsxref("Array.prototype.slice()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/small/index.html b/files/fr/web/javascript/reference/global_objects/string/small/index.html new file mode 100644 index 0000000000..080d6f7993 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/small/index.html @@ -0,0 +1,80 @@ +--- +title: String.prototype.small() +slug: Web/JavaScript/Reference/Objets_globaux/String/small +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/small +--- +<div>{{JSRef}}{{deprecated_header}}</div> + +<p>La méthode <code><strong>small()</strong></code> permet de créer un élément HTML {{HTMLElement("small")}}, ce qui permet d'afficher la chaîne de caractères dans une fonte de petite taille.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.small()</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("small")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>small()</code> encadre la chaîne courante dans une balise <code><small></code> :<br> + <code>"<small>str</small></code>"</p> + +<h2 id="Exemple">Exemple</h2> + +<h3 id="Utiliser_la_méthode_small()">Utiliser la méthode <code>small()</code></h3> + +<p>L'exemple suivant illustre les différentes méthodes de <code>String</code> permettant de changer la taille d'une chaîne de caractères :</p> + +<pre class="brush: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></pre> + +<p>L'objet {{domxref("HTMLElement.style", "element.style")}} permet d'utiliser l'attribut <code>style</code> de l'élément et de le manipuler de façon générique. Par exemple :</p> + +<pre class="brush: js">document.getElementById('IDélément').style.fontSize = '0.7em'</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.small', 'String.prototype.small')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.small', 'String.prototype.small')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.small")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.fontsize()")}}</li> + <li>{{jsxref("String.prototype.big()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/split/index.html b/files/fr/web/javascript/reference/global_objects/string/split/index.html new file mode 100644 index 0000000000..bf5822183c --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/split/index.html @@ -0,0 +1,239 @@ +--- +title: String.prototype.split() +slug: Web/JavaScript/Reference/Objets_globaux/String/split +tags: + - Expressions rationnelles + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/split +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>split()</strong></code> permet de diviser une chaîne de caractères à partir d'un séparateur pour fournir un tableau de sous-chaînes.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-split.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.split([<var>séparateur</var>[, qtéMax]])</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>séparateur</code> {{optional_inline}}</dt> + <dd> + <p>Paramètre optionnel qui définit le ou les caractères à utiliser pour scinder la chaîne. Le <code>séparateur</code> est considéré comme une chaîne ou une {{jsxref("RegExp", "expression rationnelle", "", 1)}}. Si le <code>séparateur</code> est omis ou qu'il n'apparaît pas dans la chaîne, le tableau retourné contiendra un unique élément contenant la chaîne entière. Si le <code>séparateur</code> est une chaîne vide, la chaîne <code>str</code> sera convertie en un tableau dont les éléments seront les caractères de la chaîne. Si le <code>séparateur</code> contient un ou plusieurs caractères, la chaîne de caractères entière doit être trouvée pour effectuer une césure.</p> + + <p class="warning"><strong>Attention !</strong> Si c'est la chaîne vide qui est utilisée comme séparateur, la chaîne ne sera pas découpée entre chaque caractère visible (<a href="https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries">grapheme cluster</a>) mais entre chaque codet UTF-16 et les paires de <em><a href="http://unicode.org/faq/utf_bom.html#utf16-2">surrogates</a></em> seront détruites.</p> + </dd> + <dt><code>qtéMax</code> {{optional_inline}}</dt> + <dd>Paramètre optionnel. Un entier définissant la limite sur le nombre de sous-chaînes à retourner. La méthode <code>split</code> scindera toujours la chaîne à partir du <code>séparateur</code>, mais le tableau retourné contiendra au plus <code>qtéMax</code> sous-chaînes.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un tableau ({{jsxref("Array")}}) qui contient les fragments de la chaîne appelante, découpée en fonction du séparateur indiqué.</p> + +<h2 id="Description">Description</h2> + +<p>Lorsqu'il est trouvé, le <code>séparateur</code> est supprimé de la chaîne et les sous-chaînes sont retournées dans un tableau. Si le <code>séparateur</code> est omis, le tableau contiendra un élément correspondant à la chaîne courante. Si le <code>séparateur</code> est une chaîne vide, la chaîne courante est convertie en un tableau composé des caractères de la chaîne. Si le séparateur est uniquement présent au début et/ou à la fin de la chaîne, le tableau contiendra une chaîne vide comme premier et/ou dernier élément (si on utilise cette méthode sur une chaîne qui ne contient que le séparateur, le tableau obtenu aura deux éléments qui seront chacun une chaîne vide).</p> + +<p>Si le <code>séparateur</code> est une expression rationnelle qui contient des parenthèses groupantes, les résultats (incluant tout résultat indéfini) des groupes iront alors dans le tableau retourné à chaque fois qu'une correspondance du <code>séparateur</code> sera trouvée. Cependant, tous les navigateurs ne supportent pas cette possibilité.</p> + +<p>La méthode <code>split()</code> ne modifie pas le tableau courant, elle renvoie un nouveau tableau.</p> + +<p>Lorsque le séparateur fourni est un tableau, le tableau est automatiquement converti en une chaîne de caractères et c'est cette chaîne qui est utilisée comme séparateur.</p> + +<p>{{Note("Quand la chaîne est vide, <code>split()</code> retourne un tableau contenant une chaîne vide, plutôt qu'un tableau vide. Si la chaîne et le séparateur sont tous les deux des chaînes vides, un tableau vide sera renvoyé.")}}</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_split">Utiliser <code>split()</code></h3> + +<p>L'exemple suivant définit une fonction qui divise une chaîne en un tableau de chaînes selon un délimiteur spécifié. Après la coupe de la chaîne, la fonction affiche des messages indiquant la chaîne initiale (avant la coupe), le délimiteur utilisé, le nombre d'éléments dans le tableau, et les éléments du tableau retourné.</p> + +<pre class="brush: js notranslate">function splitString(stringToSplit, separator) { + var arrayOfStrings = stringToSplit.split(separator); + + console.log('La chaine d\'origine est : "' + stringToSplit + '"'); + console.log('Le délimiteur est : "' + separator + '"'); + console.log("Le tableau comporte " + arrayOfStrings.length + " elements : "); + + for (var i=0; i < arrayOfStrings.length; i++) + print(arrayOfStrings[i] + " / "); +} + +var tempestString = "Oh brave new world that has such people in it."; +var monthString = "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec"; + +var espace = " "; +var virgule = ","; + +splitString(tempestString, espace); +splitString(tempestString); +splitString(monthString, virgule); +</pre> + +<p>Cet exemple produira la sortie suivante :</p> + +<pre class="brush: js notranslate">La chaine d'origine est : "Oh brave new world that has such people in it." +Le délimiteur est : " " +Le tableau comporte 10 elements : Oh / brave / new / world / that / has / such / people / in / it. / + +La chaine d'origine est : "Oh brave new world that has such people in it." +Le délimiteur est : "undefined" +Le tableau comporte 1 elements : Oh brave new world that has such people in it. / + +La chaine d'origine est : "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec" +Le délimiteur est : "," +Le tableau comporte 12 elements : Jan / Feb / Mar / Apr / May / Jun / Jul / Aug / Sep / Oct / Nov / Dec / +</pre> + +<h3 id="Supprimer_les_espaces_dune_chaîne">Supprimer les espaces d'une chaîne</h3> + +<p>Dans l'exemple suivant, <code>split</code> recherche zéro ou plusieurs espaces suivis d'un point-virgule, lui-même suivi par zéro ou plus espaces. Lorsque ce « motif » est trouvé, cela supprime celui-ci de la chaîne. <code>nameList</code> est le tableau retourné du résultat de <code>split</code>.</p> + +<pre class="brush: js notranslate">var names = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand "; + +console.log(names); + +var re = /\s*(;|$)\s*/; +var nameList = names.split(re); + +console.log(nameList); +</pre> + +<p>Ceci affichera deux lignes dans la console ; la première ligne correspondant à la chaîne d'origine, et la seconde au tableau de résultats.</p> + +<pre class="brush: js notranslate">Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand +["Harry Trump","Fred Barney","Helen Rigby","Bill Abel","Chris Hand"] +</pre> + +<h3 id="Retourner_un_nombre_limité_de_sous-chaînes">Retourner un nombre limité de sous-chaînes</h3> + +<p>Dans l'exemple suivant, <code>split()</code> recherche des espaces dans une chaîne et retourne les 3 premières sous-chaînes qui correspondent.</p> + +<pre class="brush: js notranslate">var myString = "Hello World. How are you doing?"; +var splits = myString.split(" ", 3); + +console.log(splits); +</pre> + +<p>Ce script affichera :</p> + +<pre class="brush: js notranslate">["Hello", "World.", "How"] +</pre> + +<h3 id="Découper_une_expression_rationnelle_-_Parenthèses_capturantes">Découper une expression rationnelle - Parenthèses capturantes</h3> + +<p>Si le paramètre <code>séparateur</code> est une expression rationnelle qui contient des parenthèses de capture, les résultats seront retournés dans le tableau.</p> + +<pre class="brush: js notranslate">var myString = "Hello 1 word. Sentence number 2."; +var splits = myString.split(/(\d)/); /* Ce motif correspond à un chiffre et est équivalent à [0-9] */ + +console.log(splits); +</pre> + +<p>Ce script affichera :</p> + +<pre class="brush: js notranslate">Hello ,1, word. Sentence number ,2,. +</pre> + +<h3 id="Découper_une_chaîne_avec_un_tableau_comme_séparateur">Découper une chaîne avec un tableau comme séparateur</h3> + +<pre class="brush: js notranslate">var maChaine = "Ceci|est|un|test"; +var morceaux = maChaine.split(['|']); + +console.log(morceaux); // ["Ceci", "est", "un", "test"] + +var maChaine2 = "ca,bc,a,bca,bca,bc"; +var morceaux2 = maChaine2.split(["a", "b"]); + +console.log(morceaux2); // ["c", "c,", "c", "c", "c"] +</pre> + +<h3 id="Inverser_une_chaîne_en_utilisant_split">Inverser une chaîne en utilisant <code>split()</code></h3> + +<pre class="brush: js notranslate">var str = 'asdfghjkl'; +var strReverse = str.split('').reverse().join(''); // 'lkjhgfdsa' +// split renvoie un tableau sur lequel on peut appliquer reverse +// enfin on utilise join pour assembler le tout.</pre> + +<div class="note"> +<p><strong>Note :</strong> Si on souhaite tester si la chaîne courante est un palindrome, on pourra utiliser l'opérateur {{jsxref("Opérateurs/Opérateurs_de_comparaison","===","#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)")}}.</p> +</div> + +<p>Attention, cela ne fonctionne pas si la chaîne de caractères contient des groupes de graphèmes, même lorsqu'on utilise une méthode de découpage sensible à Unicode.</p> + +<pre class="brush: js notranslate">var str = 'résumé'; +var strReverse = str.split(/(?:)/u).reverse().join(''); +// => "émusér" +</pre> + +<p>On pourra utiliser une bibliothèque (cf. <a href="https://github.com/mathiasbynens/esrever">esrever</a>) si besoin.</p> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.14', 'String.prototype.split')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.split', 'String.prototype.split')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.split', 'String.prototype.split')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.split")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("Array.prototype.join()")}}</li> +</ul> + +<p>{{SpecName('ES6', '#sec-arraybuffer-constructor', 'ArrayBuffer')}} {{Spec2('ES6')}} Définition initiale au sein d'un standard ECMA.</p> + +<h2 id="Compatibilité_des_navigateurs_2">Compatibilité des navigateurs</h2> + +<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div> + +<p>{{Compat("javascript.builtins.String.split")}}</p> + +<h2 id="Voir_aussi_2">Voir aussi</h2> + +<ul> + <li><a href="/fr/docs/Web/JavaScript/Tableaux_typés">Les tableaux typés JavaScript</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/startswith/index.html b/files/fr/web/javascript/reference/global_objects/string/startswith/index.html new file mode 100644 index 0000000000..060bd27d32 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/startswith/index.html @@ -0,0 +1,87 @@ +--- +title: String.prototype.startsWith() +slug: Web/JavaScript/Reference/Objets_globaux/String/startsWith +tags: + - ECMAScript6 + - JavaScript + - Méthode + - Prototype + - Reference + - String + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/String/startsWith +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>startsWith()</strong></code> renvoie un booléen indiquant si la chaine de caractères commence par la deuxième chaine de caractères fournie en argument.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-startswith.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.startsWith(<var>chaîneRecherchée</var> [, <var>position</var>]);</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>chaîneRecherchée</code></dt> + <dd>Les caractères à rechercher au début de la chaine de caractères.</dd> + <dt><code>position</code> {{optional_inline}}</dt> + <dd>La position à laquelle commencer la recherche de <code><var>chaîneRecherchée</var></code> ; par défaut 0.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p><code>true</code> si la chaîne de caractères commence avec la sous-chaîne en argument, <code>false</code> sinon</p> + +<h2 id="Description">Description</h2> + +<p>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).</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: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</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.prototype.startswith', 'String.prototype.startsWith')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.startswith', 'String.prototype.startsWith')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.startsWith")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.endsWith()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li><a href="https://github.com/mathiasbynens/String.prototype.startsWith">Prothèse (<em>polyfill</em>) de Mathias Bynens</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/strike/index.html b/files/fr/web/javascript/reference/global_objects/string/strike/index.html new file mode 100644 index 0000000000..e53530aa1f --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/strike/index.html @@ -0,0 +1,83 @@ +--- +title: String.prototype.strike() +slug: Web/JavaScript/Reference/Objets_globaux/String/strike +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/strike +--- +<div>{{JSRef}}{{deprecated_header}}</div> + +<p>La méthode <code><strong>strike()</strong></code> permet de créer un élément HTML {{HTMLElement("strike")}} qui permet d'afficher la chaîne comme un texte barré.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.strike()</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("strike")}}.</p> + +<h2 id="Description">Description</h2> + +<p>Cette méthode encadre la chaîne de caractères dans une balise <code><strike></code> :<br> + <code>"<strike>str</strike></code>"</p> + +<h2 id="Exemples">Exemples</h2> + +<p>Les méthodes suivantes peuvent être utilisées pour modifier le formatage d'une chaîne de caractères :</p> + +<pre class="brush:js">var worldString = "Coucou monde"; + +console.log(worldString.blink()); +console.log(worldString.bold()); +console.log(worldString.italics()); +console.log(worldString.strike());</pre> + +<p>Cela produira le code HTML suivant dans la console :</p> + +<pre class="brush:html"><blink>Coucou monde</blink> +<b>Coucou monde</b> +<i>Coucou monde</i> +<strike>Coucou monde</strike></pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.strike', 'String.prototype.strike')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.strike', 'String.prototype.strike')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.strike")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/sub/index.html b/files/fr/web/javascript/reference/global_objects/string/sub/index.html new file mode 100644 index 0000000000..5b68b64892 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/sub/index.html @@ -0,0 +1,76 @@ +--- +title: String.prototype.sub() +slug: Web/JavaScript/Reference/Objets_globaux/String/sub +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/sub +--- +<div>{{JSRef}}{{deprecated_header}}</div> + +<p>La méthode <code><strong>sub()</strong></code> crée un élément HTML {{HTMLElement("sub")}} qui entraîne l'affichage de la chaîne en indice.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.sub()</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("sub")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>sub</code> encapsule une chaîne dans une balise <code><sub></code> :<br> + <code>"<sub>str</sub></code>".</p> + +<h2 id="Exemples">Exemples</h2> + +<p>L'exemple suivant utilise les méthodes <code>sub()</code> et {{jsxref("String.prototype.sup()", "sup()")}} pour mettre en forme une chaîne :</p> + +<pre class="brush: 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></pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaire</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.sub', 'String.prototype.sub')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale. Implementée avec JavaScript 1.0. Définie dans l'annexe B (normative) des fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.sub', 'String.prototype.sub')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Définie dans l'annexe B (normative) des fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.sub")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.sup()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/substr/index.html b/files/fr/web/javascript/reference/global_objects/string/substr/index.html new file mode 100644 index 0000000000..b747e71c56 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/substr/index.html @@ -0,0 +1,139 @@ +--- +title: String.prototype.substr() +slug: Web/JavaScript/Reference/Objets_globaux/String/substr +tags: + - Déprécié + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/substr +--- +<div>{{JSRef}}</div> + +<div class="warning"><strong>Attention !</strong> Bien que <code>String.prototype.substr(…)</code> ne soit pas strictement obsolète (au sens où elle n'a pas été retirée des standards), elle est définie au sein de <a href="https://www.ecma-international.org/ecma-262/9.0/index.html#sec-additional-ecmascript-features-for-web-browsers">l'Annexe B</a> du standard ECMA-262 qui définit l'ensemble des fonctionnalités historiques qui doivent être évitées autant que possible. On utilisera la méthode {{jsxref("String.prototype.substring()")}} à la place.</div> + +<p>La méthode <strong><code>substr()</code></strong> retourne la partie d'une chaîne de caractères comprise entre l'indice de départ et un certain nombre de caractères après celui-ci.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-substr.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><em>chn</em>.substr(<var>début</var>[, <var>longueur</var>])</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>début</code></dt> + <dd>L'indice du premier caractère à inclure dans la sous-chaîne retournée.</dd> + <dt><code>longueur</code></dt> + <dd>Optionnel. Le nombre de caractères à extraire.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une nouvelle chaîne contenant la partie indiquée de la chaîne donnée.</p> + +<h2 id="Description">Description</h2> + +<p><code>substr()</code> extrait <code>longueur</code> caractères d'une <code>string</code>, en comptant à partir de l'indice <code>début</code>.</p> + +<p>Si <code>début</code> est un nombre positif, l'indice commence à compter du début de la chaîne. Sa valeur est limitée à <code>chn.length</code>.</p> + +<p>Si <code>début</code> est un nombre négatif, l'indice commence à compter de la fin de la chaîne. Sa valeur est limitée à <code>-chn.length</code>.</p> + +<p>Note : dans JScript de Microsoft, les valeurs négatives de l'argument <code>début</code> ne sont pas considérées comme faisant référence à la fin de la chaîne.</p> + +<p>Si <code>longueur</code> est omise, <code>substr()</code> extrait les caractères jusqu'à la fin de la chaîne.</p> + +<p>Si <code>longueur</code> est {{jsxref("undefined")}}, <code>substr()</code> extrait les caractères jusqu'à la fin de la chaîne.</p> + +<p>Si <code>longueur</code> est négative, elle est traitée comme 0.</p> + +<p>Pour <code>début</code> comme pour <code>longueur</code>, NaN est traité comme 0.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">var uneChaine = 'Mozilla'; + +<code>console.log(</code>uneChaine<code>.substr(0, 1)); // 'M' +console.log(</code>uneChaine<code>.substr(1, 0)); // '' +console.log(</code>uneChaine<code>.substr(-1, 1)); // 'a' +console.log(</code>uneChaine<code>.substr(1, -1)); // '' +console.log(</code>uneChaine<code>.substr(-3)); // 'lla' +console.log(</code>uneChaine<code>.substr(1)); // 'ozilla' +console.log(</code>uneChaine<code>.substr(-20, 2)); // 'Mo' +console.log(</code>uneChaine<code>.substr(20, 2)); // ''</code></pre> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<p>JScript de Microsoft ne supporte pas les valeurs négatives pour l'indice de début. Pour utiliser cette fonctionnalité, vous pouvez utiliser le code suivant :</p> + +<pre class="brush: js">// N'appliquer que lorsque la fonction est incomplète +if ('ab'.substr(-1) != 'b') { + /** + * Obtenir la sous-chaîne d'une chaîne + * @param {entier} début où démarrer la sous-chaîne + * @param {entier} longueur combien de caractères à retourner + * @return {chaîne} + */ + String.prototype.substr = function(substr) { + return function(début, longueur) { + <code>// Appel de la méthode originale + return </code>substr<code>.call(this,</code> + // Si on a un début négatif, calculer combien il vaut à partir du début de la chaîne + // Ajuster le paramètre pour une valeur négative +<code> début < 0 ? this.length + début : début, + longueur) + </code>} + }(String.prototype.substr); +} +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Définie dans la Compatibility Annex B (informative). Implémentée dans JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.3', 'String.prototype.substr')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Définie dans la Compatibility Annex B (informative).</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.substr', 'String.prototype.substr')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définie dans l'Annex B (normative) pour les Additional ECMAScript Features for Web Browsers.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.substr', 'String.prototype.substr')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Définie dans l'Annex B (normative) pour les Additional ECMAScript Features for Web Browsers</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, voyez <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et envoyez-nous une <em>pull request</em>.</p> + +<p>{{Compat("javascript.builtins.String.substr")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.slice()")}}</li> + <li>{{jsxref("String.prototype.substring()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/substring/index.html b/files/fr/web/javascript/reference/global_objects/string/substring/index.html new file mode 100644 index 0000000000..eedcb92d58 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/substring/index.html @@ -0,0 +1,180 @@ +--- +title: String.prototype.substring() +slug: Web/JavaScript/Reference/Objets_globaux/String/substring +tags: + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/substring +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>substring()</strong></code> retourne une sous-chaîne de la chaîne courante, entre un indice de début et un indice de fin.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-substring.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.substring(<var>indiceA</var>[, <var>indiceB</var>])</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>indiceA</code></dt> + <dd>Un entier compris entre 0 et la longueur de la chaîne.</dd> + <dt><code>indiceB</code></dt> + <dd>Paramètre optionnel : un entier compris entre 0 et la longueur de la chaine.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une nouvelle chaîne de caractères qui correspond à la section souhaitée de la chaîne appelante.</p> + +<h2 id="Description">Description</h2> + +<p><code>substring</code> extrait des caractères de la chaîne courante à partir de <code>indiceA</code> jusqu'à <code>indiceB</code> (non compris). On a notamment :</p> + +<ul> + <li>Si <code>indiceA</code> est égal à <code>indiceB</code>, <code>substring</code> retournera une chaîne vide.</li> + <li>Si <code>indiceB</code> est omis, <code>substring</code> effectuera l'extraction des caractères jusqu'à la fin de la chaîne.</li> + <li>Si l'un des deux arguments est négatif ou vaut {{jsxref("NaN")}}, il sera traité comme 0.</li> + <li>Si l'un des deux arguments est plus grand que <code>str.length</code>, il sera traité comme <code>str.length</code>.</li> +</ul> + +<p>Si <code>indiceA</code> est supérieur à <code>indiceB</code>, la fonction <code>substring()</code> intervertira ces deux valeurs afin de les traiter comme si elles avaient été passées dans le bon ordre. Par exemple : <code><var>str</var>.substring(1, 0) == <var>str</var>.substring(0, 1)</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_substring()">Utiliser <code>substring()</code></h3> + +<p>Les exemples suivants utilisent la méthode <code>substring()</code> pour extraire et afficher des caractères à partir de la chaine "<code>Mozilla</code>" :</p> + +<pre class="brush:js">var uneChaîne = "Mozilla"; + +// Affiche "Moz" +console.log(uneChaîne.substring(0,3)); +console.log(uneChaîne.substring(3,0)); + +// Affiche "lla" +console.log(uneChaîne.substring(4,7)); +console.log(uneChaîne.substring(4)); +console.log(uneChaîne.substring(7,4)); + +// Affiche "Mozill" +console.log(uneChaîne.substring(0,6)); + +// Affiche "Mozilla" +console.log(uneChaîne.substring(0,7)); +console.log(uneChaîne.substring(0,10)); +</pre> + +<h3 id="Remplacer_une_sous-chaîne_dans_une_chaîne">Remplacer une sous-chaîne dans une chaîne</h3> + +<p>L'exemple suivant remplace une partie d'une chaine. Elle remplace à la fois les caractères individuels et les sous-chaines. La fonction appelée à la fin de cet exemple transforme la chaine "<code>Brave New World</code>" en "<code>Brave New Web</code>".</p> + +<pre class="brush:js">function replaceString(oldS, newS, fullS) { +// On remplace oldS avec newS dans fullS + for (var i = 0; i < fullS.length; i++) { + if (fullS.substring(i, i + oldS.length) == oldS) { + fullS = fullS.substring(0, i) + newS + fullS.substring(i + oldS.length, fullS.length); + } + } + return fullS; +} + +replaceString("World", "Web", "Brave New World");</pre> + +<p>Attention : ceci peut résulter en une boucle infinie si <code>oldS</code> est elle-même une sous-chaine de <code>newS</code> -- par exemple, si on essaie de remplacer "World" par "OtherWorld". Une meilleure solution serait de remplacer les chaines de cette manière :</p> + +<pre class="brush:js">function replaceString(oldS, newS,fullS){ + return fullS.split(oldS).join(newS); +}</pre> + +<p>Le code ci-dessus sert d'exemple pour les opérations sur les sous-chaines. S'il est nécessaire de remplacer des sous-chaines, la plupart du temps il faudrait préférer l'utilisation de {{jsxref("String.prototype.replace()")}}.</p> + +<h3 id="Différence_entre_substring()_et_substr()">Différence entre <code>substring()</code> et <code>substr()</code></h3> + +<p>Il existe une légère différence entre les méthodes <code>substring()</code> et {{jsxref("String.substr", "substr()")}}. Les deux ne doivent pas être confondues.</p> + +<p>Les arguments de la méthode <code>substring()</code> représentent les indices de début et de fin sur la chaîne. Pour <code>substr()</code>, les arguments représentent l'indice de début et le nombre de caractères à utiliser pour la chaîne résultante.</p> + +<pre class="brush: js">var texte = "Mozilla"; +console.log(texte.substring(2,5)); // => "zil" +console.log(texte.substr(2,3)); // => "zil" +</pre> + +<h3 id="Différences_entre_substring()_et_slice()">Différences entre <code>substring()</code> et <code>slice()</code></h3> + +<p>Les méthodes <code>substring()</code> et {{jsxref("String.slice", "slice()")}} sont très proches mais certaines différences les distinguent, notamment la façon de gérer les arguments négatifs.</p> + +<p>La méthode <code>substring()</code> échangera les deux arguments si <code>indiceA</code> est supérieur à <code>indiceB</code> et renverra donc une chaîne de caractères. La méthode {{jsxref("String.slice", "slice()")}} n'échange pas les arguments et renvoie donc une chaîne vide si le premier est supérieur au second :</p> + +<pre class="brush: js">var text = 'Mozilla'; +console.log(text.substring(5, 2)); // => "zil" +console.log(text.slice(5, 2)); // => "" +</pre> + +<p>Si l'un ou l'autre des arguments sont négatifs ou valent <code>NaN</code>, la méthode <code>substring()</code> les traitera comme s'ils valaient <code>0</code>.</p> + +<pre class="brush: js">console.log(text.substring(-5, 2)); // => "Mo" +console.log(text.substring(-5, -2)); // => "" +</pre> + +<p><code>slice()</code> traite également <code>NaN</code> comme <code>0</code>, mais parcourt la chaîne à partir de la fin lorsque des arguments négatifs sont utilisés.</p> + +<pre class="brush: js">console.log(text.slice(-5, 2)); // => "" +console.log(text.slice(-5, -2)); // => "zil" +</pre> + +<p>Pour plus d'exemples sur l'utilisation d'arguments négatifs, voir la page {{jsxref("String.slice", "slice()")}}.</p> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.15', 'String.prototype.substring')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.substring', 'String.prototype.substring')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.substring', 'String.prototype.substring')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.substring")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.substr()")}} {{deprecated_inline}}</li> + <li>{{jsxref("String.prototype.slice()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/sup/index.html b/files/fr/web/javascript/reference/global_objects/string/sup/index.html new file mode 100644 index 0000000000..f56e0f2a9b --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/sup/index.html @@ -0,0 +1,76 @@ +--- +title: String.prototype.sup() +slug: Web/JavaScript/Reference/Objets_globaux/String/sup +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/sup +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>La méthode <code><strong>sup()</strong></code> crée un élément HTML {{HTMLElement("sup")}} qui entraîne l'affichage de la chaîne en exposant.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.sup()</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("sup")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>sup</code> encapsule une chaîne dans une balise <code><sup></code> :<br> + <code>"<sup>str</sup></code>".</p> + +<h2 id="Exemples">Exemples</h2> + +<p>L'exemple suivant utilise les méthodes {{jsxref("String.prototype.sub()", "sub()")}} et <code>sup</code> pour mettre en forme une chaîne :</p> + +<pre class="brush: 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>. +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.sup', 'String.prototype.sup')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles des navigateurs web.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.sup', 'String.prototype.sup')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles des navigateurs web.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.sup")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.sub()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/tolocalelowercase/index.html b/files/fr/web/javascript/reference/global_objects/string/tolocalelowercase/index.html new file mode 100644 index 0000000000..583232b3cf --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/tolocalelowercase/index.html @@ -0,0 +1,109 @@ +--- +title: String.prototype.toLocaleLowerCase() +slug: Web/JavaScript/Reference/Objets_globaux/String/toLocaleLowerCase +tags: + - Internationalisation + - JavaScript + - Méthode + - Prototype + - Reference + - String + - i18n +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>toLocaleLowerCase()</strong></code> 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.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-tolocalelowercase.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.toLocaleLowerCase() +<var>str</var>.toLocaleLowerCase(locale) +<var>str</var>.toLocaleLowerCase([locale, locale, ...])</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>locale</code> {{optional_inline}}</dt> + <dd>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.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une nouvelle chaîne de caractères obtenue à partir de la chaîne appelante, convertie en minuscules en tenant compte de la locale.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<p>Cette méthode peut lever les exceptions suivantes :</p> + +<ul> + <li>{{jsxref("RangeError")}} ("invalid language tag: xx_yy") si l'argument <code>locale</code> ne correspond pas à une balise de langue valide.</li> + <li>{{jsxref("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.</li> +</ul> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>toLocaleLowerCase()</code> renvoie la valeur de la chaîne de caractères, convertie en minuscules selon les correspondances propres à la la locale. <code>toLocaleLowerCase()</code> ne modifie pas la chaîne d'origine. Dans la plupart des cas, cette méthode produira le même résultat que {{jsxref("String.toLowerCase", "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.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush:js">"ALPHABET".toLocaleLowerCase(); // "alphabet" + +"\u0130".toLocaleLowerCase("tr") === "i"; // true +"\u0130".toLocaleLowerCase("en-US") === "i"; // false +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.17', 'String.prototype.toLocaleLowerCase')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sup-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td>Ajout du paramètre <code>locale</code> dans ES Intl 2017</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.toLocaleLowerCase")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html b/files/fr/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html new file mode 100644 index 0000000000..41e4a41e44 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html @@ -0,0 +1,110 @@ +--- +title: String.prototype.toLocaleUpperCase() +slug: Web/JavaScript/Reference/Objets_globaux/String/toLocaleUpperCase +tags: + - Internationalisation + - JavaScript + - Méthode + - Prototype + - Reference + - String + - i18n +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>toLocaleUpperCase()</strong></code> 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.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-tolocaleuppercase.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.toLocaleUpperCase() +<var>str</var>.toLocaleUpperCase(locale) +<var>str</var>.toLocaleUpperCase([locale, locale, ...])</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>locale</code> {{optional_inline}}</dt> + <dd>Le paramètre <code>locale</code> 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.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>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.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<p>Cette méthode peut lever les exceptions suivantes :</p> + +<ul> + <li>{{jsxref("RangeError")}} ("invalid language tag: xx_yy") si l'argument <code>locale</code> ne correspond pas à une balise de langue valide.</li> + <li>{{jsxref("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.</li> +</ul> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>toLocaleUpperCase()</code> renvoie la valeur de la chaîne de caractères, convertie en majuscules selon les correspondances propres à la la locale. <code>toLocaleUpperCase()</code> ne modifie pas la chaîne d'origine. Dans la plupart des cas, cette méthode produira le même résultat que {{jsxref("String.toUpperCase", "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.</p> + +<p>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 <code>false</code> : <code>x.toLocaleLowerCase() === x.toLocaleUpperCase().toLocaleLowerCase()</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">"alphabet".toLocaleUpperCase(); // "ALPHABET" +'Gesäß'.toLocaleUpperCase(); // 'GESÄSS' +"i\u0307".toLocaleUpperCase("lt-LT"); // "I" +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.19', 'String.prototype.toLocaleUpperCase')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sup-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td>Ajout du paramètre <code>locale</code> dans ES Intl 2017.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.toLocaleUpperCase")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/tolowercase/index.html b/files/fr/web/javascript/reference/global_objects/string/tolowercase/index.html new file mode 100644 index 0000000000..22a5b3f34a --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/tolowercase/index.html @@ -0,0 +1,81 @@ +--- +title: String.prototype.toLowerCase() +slug: Web/JavaScript/Reference/Objets_globaux/String/toLowerCase +tags: + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLowerCase +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>toLowerCase()</strong></code> retourne la chaîne de caractères courante en minuscules.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-tolowercase.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.toLowerCase()</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une nouvelle chaîne de caractères qui est obtenue en passant la chaîne appelante en minuscules.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>toLowerCase()</code> renvoie la valeur de la chaîne convertie en minuscules. <code>toLowerCase()</code> ne modifie pas la valeur de la chaîne courante.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">console.log( "ALPHABET".toLowerCase() ); // "alphabet" +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.16', 'String.prototype.toLowerCase')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.toLowerCase")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/tosource/index.html b/files/fr/web/javascript/reference/global_objects/string/tosource/index.html new file mode 100644 index 0000000000..19b1006e1d --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/tosource/index.html @@ -0,0 +1,58 @@ +--- +title: String.prototype.toSource() +slug: Web/JavaScript/Reference/Objets_globaux/String/toSource +tags: + - JavaScript + - Méthode + - Non-standard + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toSource +--- +<div>{{JSRef}} {{Non-standard_header}}</div> + +<p>La méthode <code><strong>toSource()</strong></code> permet de renvoyer une chaîne de caractères représentant le code source de l'objet.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">String.toSource() +<var>str</var>.toSource() +</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères qui représente le code source de la chaîne de caractères appelante.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>toSource()</code> renvoie les valeurs suivantes :</p> + +<ul> + <li>Pour l'objet natif {{jsxref("String")}}, <code>toSource()</code> renvoie la chaîne de caractère suivante, indiquant que le code source n'est pas disponible : + + <pre class="brush: js">function String() { + [native code] +} +</pre> + </li> + <li>Pour les instances de {{jsxref("String")}} ou les littéraux de chaînes de caractères, <code>toSource()</code> renvoie une chaîne de caractère représentant le code source.</li> +</ul> + +<p>Généralement, cette méthode est appelée par du code interne au moteur JavaScript et n'est pas trouvée dans du code JavaScript externe.</p> + +<h2 id="Spécifications">Spécifications</h2> + +<p>Cette méthode ne fait partie d'aucun standard. Elle a été implémentée avec JavaScript 1.3.</p> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.toSource")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/tostring/index.html b/files/fr/web/javascript/reference/global_objects/string/tostring/index.html new file mode 100644 index 0000000000..ef3618a8b5 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/tostring/index.html @@ -0,0 +1,82 @@ +--- +title: String.prototype.toString() +slug: Web/JavaScript/Reference/Objets_globaux/String/toString +tags: + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toString +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>toString()</strong></code> renvoie une chaine de caractères représentant l'objet renseigné.</p> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<div>{{EmbedInteractiveExample("pages/js/string-tostring.html")}}</div> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.toString()</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères représentant la chaîne appelante.</p> + +<h2 id="Description">Description</h2> + +<p>L'objet {{jsxref("String")}} surcharge la méthode <code>toString()</code> de l'objet {{jsxref("Object")}} ; il n'hérite pas de {{jsxref("Object.toString","Object.prototype.toString()")}}. Pour Les objets <code>String</code>, la méthode <code>toString()</code> renvoie une chaine de caractères représentant l'objet, et est similaire à la méthode {{jsxref("String.prototype.valueOf()")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>L'exemple suivant affiche la valeur textuelle d'un objet {{jsxref("String")}} :</p> + +<pre class="brush:js">var x = new String("coucou monde"); +console.log(x.toString()); // affiche "coucou monde"</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.2', 'String.prototype.toString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.tostring', 'String.prototype.toString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.tostring', 'String.prototype.toString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.toString")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> + <li>{{jsxref("String.prototype.valueOf()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/touppercase/index.html b/files/fr/web/javascript/reference/global_objects/string/touppercase/index.html new file mode 100644 index 0000000000..9f456170cf --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/touppercase/index.html @@ -0,0 +1,107 @@ +--- +title: String.prototype.toUpperCase() +slug: Web/JavaScript/Reference/Objets_globaux/String/toUpperCase +tags: + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toUpperCase +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>toUpperCase()</strong></code> retourne la valeur de la chaîne courante, convertie en majuscules.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-touppercase.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.toUpperCase()</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une nouvelle chaîne de caractères obtenue à partir de la chaîne appelante, passée en majuscules.</p> + +<h3 id="Exceptions_levées">Exceptions levées</h3> + +<dl> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Une telle exception sera levée si on appelle cette méthode sur {{jsxref("null")}} ou {{jsxref("undefined")}} (en utilisant <code>Function.prototype.call()</code> par exemple).</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>toUpperCase()</code> retourne la valeur de la chaîne convertie en majuscules. <code>toUpperCase</code> n'affecte pas la valeur de la chaîne elle-même.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_toUpperCase()">Utiliser <code>toUpperCase()</code></h3> + +<pre class="brush: js">console.log( "alphabet".toUpperCase() ); // "ALPHABET"</pre> + +<h3 class="brush: js" id="Convertir_une_valeur_this_en_chaîne_de_caractères">Convertir une valeur <code>this</code> en chaîne de caractères</h3> + +<p class="brush: js">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 <code>this</code> : </p> + +<pre class="brush: 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 +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.18', 'String.prototype.toUpperCase')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.toUpperCase")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/trim/index.html b/files/fr/web/javascript/reference/global_objects/string/trim/index.html new file mode 100644 index 0000000000..963280c9e7 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/trim/index.html @@ -0,0 +1,96 @@ +--- +title: String.prototype.trim() +slug: Web/JavaScript/Reference/Objets_globaux/String/trim +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Prototype + - Reference + - String + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/String/Trim +--- +<div>{{JSRef}}</div> + +<p>La méthode <strong><code>trim()</code></strong> 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.).</p> + +<div>{{EmbedInteractiveExample("pages/js/string-trim.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.trim()</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>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.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>trim()</code> renvoie la chaîne sans blanc au début et à la fin. La méthode <code>trim()</code> n'affecte pas la valeur de la chaîne courante.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>L'exemple qui suit affiche la chaîne <code>'toto'</code> :</p> + +<pre class="brush: 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' +</pre> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<p>Si l'environnement utilisé ne possède pas cette méthode, il est possible de l'émuler avec le fragment de code suivant :</p> + +<pre class="brush: js">if (!String.prototype.trim) { + String.prototype.trim = function () { + return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ''); + }; +} +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.20', 'String.prototype.trim')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.8.1.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.trim', 'String.prototype.trim')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.trim', 'String.prototype.trim')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.trim")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.trimStart()")}}</li> + <li>{{jsxref("String.prototype.trimEnd()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/trimend/index.html b/files/fr/web/javascript/reference/global_objects/string/trimend/index.html new file mode 100644 index 0000000000..e85452758d --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/trimend/index.html @@ -0,0 +1,82 @@ +--- +title: String.prototype.trimEnd() +slug: Web/JavaScript/Reference/Objets_globaux/String/trimEnd +tags: + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/trimEnd +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>trimEnd()</strong></code> permet de retirer les blancs situés à la fin d'une chaîne de caractères. <code>trimRight()</code> est un synonyme pour cette méthode.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-trimend.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.trimEnd(); +str.trimRight();</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>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.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>trimEnd()</code> renvoie la chaîne de caractères sans les blancs présents à partir de la droite de la chaîne. <code>trimEnd()</code> ne modifie pas la chaîne elle-même.</p> + +<h3 id="Synonyme">Synonyme</h3> + +<p>Pour des raisons de cohérence avec les méthodes existantes comme {{jsxref("String.prototype.padEnd")}}, le nom standard de cette méthode est <code>trimEnd</code>. Toutefois, à des fins de compatibilité web, <code>trimRight</code> est un synonyme de <code>trimEnd</code>. Pour certains moteurs JavaScript, on pourra donc avoir :</p> + +<pre class="brush: js">String.prototype.trimRight.name === "trimEnd";</pre> + +<h2 id="Exemples">Exemples</h2> + +<p>L'exemple qui suit illustre comment afficher la chaîne " toto":</p> + +<pre class="brush:js;highlight:[5]">var str = " toto "; + +console.log(str.length); // 9 + +str = str.trimEnd(); +console.log(str.length); // 7 +console.log(str); // " toto" +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + </thead> + <tbody> + <tr> + <td>Proposition pour <code><a href="https://github.com/tc39/proposal-string-left-right-trim/#stringprototypetrimstart--stringprototypetrimend">String.prototype.{trimStart,trimEnd}</a></code></td> + <td>Brouillon de niveau 4</td> + <td>Attendu pour ES2019</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.trimEnd")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.trim()")}}</li> + <li>{{jsxref("String.prototype.trimStart()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/trimstart/index.html b/files/fr/web/javascript/reference/global_objects/string/trimstart/index.html new file mode 100644 index 0000000000..320efbdfd6 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/trimstart/index.html @@ -0,0 +1,82 @@ +--- +title: String.prototype.trimStart() +slug: Web/JavaScript/Reference/Objets_globaux/String/trimStart +tags: + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/trimStart +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>trimStart()</strong></code> permet de retirer les blancs au début de la chaîne de caractères. <code>trimLeft()</code> est un synonyme pour cette méthode.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-trimstart.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.trimStart(); +<var>str</var>.trimLeft();</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>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.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>trimStart()</code> renvoie la chaîne de caractères dont les blancs à gauche ont été retirés. <code>trimStart</code> ne modifie pas la chaîne elle-même.</p> + +<h3 id="Synonyme">Synonyme</h3> + +<p>Pour des raisons de cohérences avec les méthodes préexistantes (telles que {{jsxref("String.prototype.padStart")}}), le nom standard de cette méthode est <code>trimStart</code>. Toutefois, à des fins de compatibilité web, le nom <code>trimLeft</code> sera gardé comme un synonyme. Pour certains moteurs JavaScript, on pourra donc avoir :</p> + +<pre class="brush: js">String.prototype.trimLeft.name === "trimStart";</pre> + +<h2 id="Exemple">Exemple</h2> + +<p>L'exemple qui suit illustre comment afficher la chaîne de caractères <code>"toto "</code> en minuscules :</p> + +<pre class="brush:js;highlight:[5]">var str = " toto "; + +console.log(str.length); // 8 + +str = str.trimStart(); +console.log(str.length); // 5 +console.log(str); // "toto " +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + </thead> + <tbody> + <tr> + <td>Proposition pour <code><a href="https://github.com/tc39/proposal-string-left-right-trim/#stringprototypetrimstart--stringprototypetrimend">String.prototype.{trimStart,trimEnd}</a></code></td> + <td>Brouillon de niveau 4</td> + <td>Attendu pour ES2019</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.trimStart")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.trim()")}}</li> + <li>{{jsxref("String.prototype.trimEnd()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/string/valueof/index.html b/files/fr/web/javascript/reference/global_objects/string/valueof/index.html new file mode 100644 index 0000000000..58c9fb66bf --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/string/valueof/index.html @@ -0,0 +1,83 @@ +--- +title: String.prototype.valueOf() +slug: Web/JavaScript/Reference/Objets_globaux/String/valueOf +tags: + - JavaScript + - Méthode + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/valueOf +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>valueOf()</strong></code> renvoie la valeur primitive de l'objet {{jsxref("String")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-valueof.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>str</var>.valueOf()</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères qui représente la valeur primitive d'un objet {{jsxref("String")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>valueOf()</code> de <code>String</code> renvoie la valeur primitive de l'objet <code>String</code> sous la forme d'une chaine de caractères. Cette valeur est équivalente à {{jsxref("String.prototype.toString()")}}.</p> + +<p>Cette méthode est généralement appelée en interne par JavaScript et non explicitement dans du code.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">var x = new String("Coucou monde"); +console.log(x.valueOf()); // affiche "Coucou monde" +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.3', 'String.prototype.valueOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.valueof', 'String.prototype.valueOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.valueof', 'String.prototype.valueOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.String.valueOf")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("String.prototype.toString()")}}</li> + <li>{{jsxref("Object.prototype.valueOf()")}}</li> +</ul> |