mozilla
Vos résultats de recherche

    String

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

    Syntaxe

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

    'texte de chaînes de caractères'
    "texte de chaînes de caractères"
    "中文 español English हिन्दी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어"

    Depuis ECMAScript 6, les littéraux de chaînes de caractères peuvent être des gabarits de chaînes :

    `Coucou monde`
    `Coucou !
    monde !`
    `Coucou ${qui}`
    escape `<a>${qui}</a>`
    

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

    Code Résultat
    \0 le caractère NUL
    \' simple quote
    \" double quote
    \\ barre oblique inversée
    \n nouvelle ligne
    \r retour chariot
    \v tabulation verticale
    \t tabulation
    \b retour arrière
    \f saut de page (form feed)
    \uXXXX point de code Unicode
    \xXX caractère Latin-1

    On peut aussi utiliser l'objet global String directement :

    String(chaîne)
    new String(chaîne)

    Paramètres

    chaîne
    Tout objet pouvant être converti en une chaîne de caractères.

    Description

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

    Accéder à un caractère

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

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

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

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

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

    Comparer des chaînes de caractères

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

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

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

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

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

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

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

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

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

    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 :

    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

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

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

    console.log(eval(s2.valueOf())); // renvoie  4
    Note : Une autre approche pour gérer des chaînes de caractères en JavaScript consiste à utiliser StringView – une représentation semblable à celle utilisée par le langage C pour traîter les chaînes comme des tableaux typés.

    Propriétés

    Pour les propriétés héritées par les instances de String, consultez Propriétés des instances de String.

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

    Propriétés héritées de Function:

    Méthodes

    Pour les méthodes héritées par les instances de String, consultez Méthodes des instances de String.

    String.fromCharCode()
    Renvoie une chaine de caractères créée en utilisant la séquence de valeurs Unicode fournie.
    String.fromCodePoint()
    Renvoie une chaine de caractères créée en utilisant la séquence de points de code fournie.
    String.raw()
    Renvoie une chaine de caractères à partir d'un modèle brut de chaine de caractères.
    Méthodes héritées de Function:

    Méthodes génériques de String

    Les méthodes pour les instances de String sont également disponibles, pour Firefox et JavaScript 1.6, sur l'objet String afin d'appliquer des méthodes de String à n'importe quel objet. Cela ne fait pas partie du standard ECMAScript. Par exemple :

    var num = 15;
    console.log(String.replace(num, /5/, '2'));

    Les méthodes génériques sont également disponibles pour les méthodes de Array.

    Prothèse d'émulation (polyfill)

    Le fragment de code suivant permet de faire face au cas où le navigateur utilisé ne supporterait pas cette notation :

    /*définition globale*/
    // On part du principe que toutes les méthodes des instances
    // de String sont disponibles
    // (on les émulera avec d'autre code si besoin)
    (function () {
        'use strict';
    
        var i,
            // Le tableau suivant aurait pu être construit en utilisant le code suivant
            // sauf que getOwnPropertyNames() ne peut être émulée :
            // Object.getOwnPropertyNames(String).filter(function (methodName)
            //  {return typeof String[methodName] === 'function'});
            methods = [
                'quote', 'substring', 'toLowerCase', 'toUpperCase', 'charAt',
                'charCodeAt', 'indexOf', 'lastIndexOf', 'startsWith', 'endsWith',
                'trim', 'trimLeft', 'trimRight', 'toLocaleLowerCase',
                'toLocaleUpperCase', 'localeCompare', 'match', 'search',
                'replace', 'split', 'substr', 'concat', 'slice'
            ],
            methodCount = methods.length,
            assignStringGeneric = function (methodName) {
                var method = String.prototype[methodName];
                String[methodName] = function (arg1) {
                    return method.apply(arg1, Array.prototype.slice.call(arguments, 1));
                };
            };
    
        for (i = 0; i < methodCount; i++) {
            assignStringGeneric(methods[i]);
        }
    }());

    Instances de String

    Propriétés

    Méthodes

    Exemples

    Conversion en String

    Il est possible d'utiliser String comme une alternative à toString(). Cela utilise toString(), mais permet de traiter les valeurs null et undefined. Ainsi :

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

    Spécifications

    Spécification Statut Commentaires
    Première édition d'ECMAScript. Standard Définition initiale.
    ECMAScript 5.1 (ECMA-262)
    La définition de 'String' dans cette spécification.
    Standard  
    ECMAScript 6 (ECMA-262)
    La définition de 'String' dans cette spécification.
    En cours de validation comme recommandation  

    Compatibilité des navigateurs

    Fonctionnalité Chrome Firefox (Gecko) Internet Explorer Opera Safari
    Support simple 0.2 (Oui) (Oui) (Oui) (Oui)
    \u{XXXXXX} ? 40 (40) ? ? ?
    Fonctionnalité Android Chrome for Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
    Support simple (Oui) (Oui) (Oui) (Oui) (Oui) (Oui)
    \u{XXXXXX} ? ? 40.0 (40) ? ?  

    Voir aussi

    Étiquettes et contributeurs liés au document

    Contributors to this page: tregagnon, fscholz, SphinxKnight, daniel35310, teoli, rat
    Dernière mise à jour par : SphinxKnight,
    Masquer la barre latérale