JavaScript
Cordes

Syntaxe

• "littéral de chaîne"
• 'littéral de chaîne'
• "chaîne littérale avec 'citations incompatibles'" // pas d'erreurs; les citations sont différentes.
• "chaîne littérale avec" guillemets échappés "" // pas d'erreurs; les citations sont échappées.
• `template string $ {expression}`
• String ("ab c") // renvoie une chaîne lorsqu'elle est appelée dans un contexte non constructeur
• new String ("ab c") // l'objet String, pas la primitive de chaîne

Informations de base et concaténation de chaînes

Les chaînes en JavaScript peuvent être placées entre guillemets simples 'hello' , les guillemets doubles "Hello" et (à partir de ES2015, ES6) dans les littéraux de modèle ( backticks ) `hello` .

var hello  = "Hello";
var world  = 'world';
var helloW = `Hello World`;              // ES2015 / ES6

Les chaînes peuvent être créées à partir d'autres types à l'aide de la fonction String() .

var intString = String(32); // "32"
var booleanString = String(true); // "true"
var nullString = String(null); // "null" 

Ou, toString() peut être utilisé pour convertir des nombres, des booléens ou des objets en chaînes.

var intString = (5232).toString(); // "5232"
var booleanString = (false).toString(); // "false"
var objString = ({}).toString(); // "[object Object]"

Des chaînes peuvent également être créées en utilisant la méthode String.fromCharCode .

String.fromCharCode(104,101,108,108,111) //"hello"

La création d'un objet String à l'aide du new mot-clé est autorisée, mais n'est pas recommandée car elle se comporte comme des objets contrairement aux chaînes primitives.

var objectString = new String("Yes, I am a String object");
typeof objectString;//"object"
typeof objectString.valueOf();//"string"

Cordes concaténantes

La concaténation de chaînes peut être effectuée avec l'opérateur de concaténation + ou avec la méthode concat() sur le prototype d'objet String.

var foo = "Foo";
var bar = "Bar";
console.log(foo + bar);        // => "FooBar"
console.log(foo + " " + bar);  // => "Foo Bar"

foo.concat(bar)            // => "FooBar"
"a".concat("b", " ", "d")  // => "ab d"

Les chaînes peuvent être concaténées avec des variables autres que des chaînes mais convertissent les variables autres que les chaînes en chaînes.

var string = "string";
var number = 32;
var boolean = true;

console.log(string + number + boolean); // "string32true"

Modèles de chaînes

var greeting = `Hello`;

var place = `World`;
var greet = `Hello ${place}!`

console.log(greet); // "Hello World!"

`a\\b` // =  a\b
String.raw`a\\b` // = a\\b

Citations échappant

Si votre chaîne est entourée (c.-à-d. Entre guillemets simples), vous devez échapper à la citation littérale interne avec une barre oblique inverse \

var text = 'L\'albero means tree in Italian';
console.log( text ); \\ "L'albero means tree in Italian"

Même chose pour les doubles citations:

var text = "I feel \"high\"";

Une attention particulière doit être accordée aux guillemets échappant si vous stockez des représentations HTML dans une chaîne, car les chaînes HTML utilisent largement les guillemets, c'est-à-dire dans les attributs:

var content = "<p class=\"special\">Hello World!</p>";        // valid String
var hello   = '<p class="special">I\'d like to say "Hi"</p>'; // valid String

Les citations dans les chaînes HTML peuvent également être représentées à l'aide de ' (ou ' ) en un seul devis et " (ou " ) sous forme de guillemets doubles.

var hi    = "<p class='special'>I'd like to say &quot;Hi&quot;</p>"; // valid String
var hello = '<p class="special">I&apos;d like to say "Hi"</p>';      // valid String

Note: L'utilisation de ' et " n'écrasera pas les guillemets que les navigateurs peuvent placer automatiquement sur les guillemets d'attributs. Par exemple, <p class=special> est défini sur <p class="special"> , en utilisant " peut conduire à <p class=""special""> où \" sera <p class="special"> .

var x = `"Escaping " and ' can become very annoying`;

Chaîne inverse

Le moyen le plus "populaire" d'inverser une chaîne en JavaScript est le fragment de code suivant, qui est assez courant:

function reverseString(str) {
    return str.split('').reverse().join('');
}

reverseString('string');    // "gnirts"

Cependant, cela ne fonctionnera que tant que la chaîne en cours d'inversion ne contient pas de paires de substitution. Les symboles astraux, c'est-à-dire les caractères extérieurs au plan multilingue de base, peuvent être représentés par deux unités de code et conduiront à cette technique naïve pour produire des résultats erronés. De plus, les caractères avec des marques combinées (par exemple, diaérèse) apparaîtront sur le caractère logique "suivant" au lieu de l'original avec lequel il a été combiné.

'𝌆■.'.split('').reverse().join(''); //fails

Bien que la méthode fonctionne correctement pour la plupart des langages, un algorithme vraiment précis et respectueux de l'encodage pour l'inversion des chaînes est légèrement plus complexe. Une de ces implémentations est une minuscule bibliothèque appelée Esrever , qui utilise des expressions régulières pour associer des marques de combinaison et des paires de substitution afin d'effectuer parfaitement l'inversion.

Explication

En utilisant un opérateur de spread

function reverseString(str) {
    return [...String(str)].reverse().join('');    
}

console.log(reverseString('stackoverflow'));  // "wolfrevokcats"
console.log(reverseString(1337));             // "7331"
console.log(reverseString([1, 2, 3]));        // "3,2,1"

Fonction reverse() personnalisée

function reverse(string) {
    var strRev = "";
    for (var i = string.length - 1; i >= 0; i--) {
        strRev += string[i];
    }
    return strRev; 
}

reverse("zebra");  // "arbez"

Couper les espaces

Pour couper des espaces à partir des bords d'une chaîne, utilisez String.prototype.trim :

"    some whitespaced string  ".trim();  // "some whitespaced string"

De nombreux moteurs JavaScript, mais pas Internet Explorer , ont implémenté des méthodes trimLeft et trimRight non standard. Il y a une proposition , actuellement à l'étape 1 du processus, pour les méthodes trimStart et trimEnd standardisées, trimLeft à trimLeft et trimRight pour la compatibilité.

// Stage 1 proposal
"    this is me    ".trimStart();  // "this is me    "
"    this is me    ".trimEnd();  // "    this is me"

// Non-standard methods, but currently implemented by most engines
"    this is me    ".trimLeft();  // "this is me    "
"    this is me    ".trimRight();  // "    this is me"

Substrings avec une tranche

Utilisez .slice() pour extraire des sous-chaînes avec deux indices:

var s = "0123456789abcdefg";
s.slice(0, 5);  // "01234"
s.slice(5, 6);  // "5"

Étant donné un index, cela prendra de cet index à la fin de la chaîne:

s.slice(10);    // "abcdefg"

Fractionner une chaîne en un tableau

Utilisez .split pour passer des chaînes à un tableau des sous-chaînes fractionnées:

var s = "one, two, three, four, five"
s.split(", ");  // ["one", "two", "three", "four", "five"]

Utilisez la méthode de tableau .join pour revenir à une chaîne:

s.split(", ").join("--");  // "one--two--three--four--five"

Les chaînes sont unicode

Toutes les chaînes JavaScript sont unicode!

var s = "some ∆≈ƒ unicode ¡™£¢¢¢";
s.charCodeAt(5);  // 8710

Il n'y a pas d'octets bruts ou de chaînes binaires dans JavaScript. Pour gérer efficacement les données binaires, utilisez les tableaux typés .

Détecter une chaîne

Pour détecter si un paramètre est une chaîne primitive , utilisez typeof :

var aString = "my string";
var anInt = 5;
var anObj = {};
typeof aString === "string";   // true
typeof anInt === "string";     // false
typeof anObj === "string";     // false

Si vous avez déjà un objet String , via new String("somestr") , ce qui précède ne fonctionnera pas. Dans ce cas, nous pouvons utiliser instanceof :

var aStringObj = new String("my string");
aStringObj instanceof String;    // true

Pour couvrir les deux instances, nous pouvons écrire une fonction d'assistance simple:

var isString = function(value) {
    return typeof value === "string" || value instanceof String;
};

var aString = "Primitive String";
var aStringObj = new String("String Object");
isString(aString); // true
isString(aStringObj); // true
isString({}); // false
isString(5); // false

Ou nous pouvons utiliser la fonction toString d' Object . Cela peut être utile si nous devons également rechercher d'autres types dans une instruction switch, car cette méthode prend également en charge d'autres types de données, tout comme typeof .

var pString = "Primitive String";
var oString = new String("Object Form of String");
Object.prototype.toString.call(pString);//"[object String]"
Object.prototype.toString.call(oString);//"[object String]"    

Une solution plus robuste consiste à ne pas détecter de chaîne du tout, plutôt que de vérifier les fonctionnalités requises. Par exemple:

var aString = "Primitive String";
// Generic check for a substring method
if(aString.substring) {

}
// Explicit check for the String substring prototype method
if(aString.substring === String.prototype.substring) {
    aString.substring(0, );
}

Comparer les chaînes Lexicographiquement

Pour comparer les chaînes par ordre alphabétique, utilisez localeCompare() . Cela retourne une valeur négative si la chaîne de référence est lexicographiquement (alphabétiquement) avant la chaîne comparée (le paramètre), une valeur positive si elle vient après et une valeur de 0 si elles sont égales.

var a = "hello";
var b = "world";

console.log(a.localeCompare(b)); // -1

Les opérateurs > et < peuvent également être utilisés pour comparer des chaînes lexicographiquement, mais ils ne peuvent pas renvoyer une valeur de zéro (cela peut être testé avec l'opérateur d'égalité == ). Par conséquent, une forme de la fonction localeCompare() peut être écrite comme localeCompare() :

function strcmp(a, b) {
    if(a === b) {
        return 0;
    }

    if (a > b) {
        return 1;
    }

    return -1;
}

console.log(strcmp("hello", "world")); // -1
console.log(strcmp("hello", "hello")); //  0
console.log(strcmp("world", "hello")); //  1

Cela est particulièrement utile lorsque vous utilisez une fonction de tri qui se base sur le signe de la valeur de retour (par exemple, le sort ).

var arr = ["bananas", "cranberries", "apples"];
arr.sort(function(a, b) {
    return a.localeCompare(b);
});
console.log(arr); // [ "apples", "bananas", "cranberries" ]

Chaîne en majuscule

String.prototype.toUpperCase ():

console.log('qwerty'.toUpperCase()); // 'QWERTY'

Chaîne en minuscule

String.prototype.toLowerCase ()

console.log('QWERTY'.toLowerCase()); // 'qwerty'

Compteur de mots

Disons que vous avez un <textarea> et que vous souhaitez récupérer des informations sur le nombre de:

• Caractères (total)
• Caractères (pas d'espaces)
• Mots
• Lignes

function wordCount( val ){
    var wom = val.match(/\S+/g);
    return {
        charactersNoSpaces : val.replace(/\s+/g, '').length,
        characters         : val.length,
        words              : wom ? wom.length : 0,
        lines              : val.split(/\r*\n/).length
    };
}


// Use like:
wordCount( someMultilineText ).words;   // (Number of words)

jsFiddle exemple

Caractère d'accès à l'index dans la chaîne

Utilisez charAt() pour obtenir un caractère à l'index spécifié dans la chaîne.

var string = "Hello, World!";
console.log( string.charAt(4) ); // "o"

Comme les chaînes peuvent être traitées comme des tableaux, vous pouvez également utiliser l'index via la notation entre crochets .

var string = "Hello, World!";
console.log( string[4] ); // "o"

Pour obtenir le code de caractère du caractère à un index spécifié, utilisez charCodeAt() .

var string = "Hello, World!";
console.log( string.charCodeAt(4) ); // 111

Notez que ces méthodes sont toutes des méthodes getter (renvoyer une valeur). Les chaînes en JavaScript sont immuables. En d'autres termes, aucun d'eux ne peut être utilisé pour définir un caractère à une position dans la chaîne.

Fonctions de recherche et de remplacement de chaîne

Pour rechercher une chaîne dans une chaîne, il existe plusieurs fonctions:

indexOf( searchString ) et lastIndexOf( searchString )

indexOf() retournera l'index de la première occurrence de searchString dans la chaîne. Si searchString n'est pas trouvé, -1 est renvoyé.

var string = "Hello, World!";
console.log( string.indexOf("o") ); // 4
console.log( string.indexOf("foo") ); // -1

De même, lastIndexOf() retournera l'index de la dernière occurrence de searchstring ou -1 s'il n'est pas trouvé.

var string = "Hello, World!";
console.log( string.lastIndexOf("o") );   // 8
console.log( string.lastIndexOf("foo") ); // -1

includes( searchString, start )

includes() retourne un booléen qui indique si searchString existe dans la chaîne, à partir de l' index start (par défaut 0). C'est mieux que indexOf() si vous avez simplement besoin de tester l'existence d'une sous-chaîne.

var string = "Hello, World!";
console.log( string.includes("Hello") ); // true
console.log( string.includes("foo") );   // false

replace( regexp|substring, replacement|replaceFunction )

replace() renvoie une substring contenant toutes les occurrences de sous-chaînes correspondant à l' regexp RegExp ou à la substring avec un replacement chaîne ou la valeur renvoyée par replaceFunction .

Notez que cela ne modifie pas la chaîne en place, mais renvoie la chaîne avec des remplacements.

var string = "Hello, World!";
string = string.replace( "Hello", "Bye" );
console.log( string ); // "Bye, World!"

string = string.replace( /W.{3}d/g, "Universe" );
console.log( string ); // "Bye, Universe!"

replaceFunction peut être utilisé pour les remplacements conditionnels d'objets d'expression régulière (c.-à-d. avec l'utilisation d' regexp ). Les paramètres sont dans l'ordre suivant:

Notez que tous les paramètres sont facultatifs.

var string = "heLlo, woRlD!";
string = string.replace( /([a-zA-Z])([a-zA-Z]+)/g, function(match, g1, g2) {
    return g1.toUpperCase() + g2.toLowerCase();
}); 
console.log( string ); // "Hello, World!"

Rechercher l'index d'une sous-chaîne dans une chaîne

La méthode .indexOf renvoie l'index d'une sous-chaîne dans une autre chaîne (si existante, ou -1 si autrement)

'Hellow World'.indexOf('Wor');    // 7

.indexOf accepte également un argument numérique supplémentaire qui indique sur quel index la fonction doit commencer à chercher

"harr dee harr dee harr".indexOf("dee", 10); // 14

Vous devriez noter que .indexOf est sensible à la casse

 'Hellow World'.indexOf('WOR');    // -1

Représentations de chaînes de nombres

JavaScript a une conversion native de Number en une représentation String pour toute base de 2 à 36 .

La représentation la plus courante après la décimale (base 10) est hexadécimale (base 16) , mais le contenu de cette section fonctionne pour toutes les bases de la plage.

Afin de convertir un nombre de décimales (base 10) à sa hexadécimal (base 16) représentation de chaîne la méthode toString peut être utilisé avec radix 16 .

// base 10 Number
var b10 = 12;

// base 16 String representation
var b16 = b10.toString(16); // "c"

Si le nombre représenté est un nombre entier, l'opération inverse peut être effectuée avec parseInt et la base 16 nouveau

// base 16 String representation
var b16 = 'c';

// base 10 Number
var b10 = parseInt(b16, 16); // 12

Pour convertir un nombre arbitraire (c.-à-d. Non entier) de sa représentation sous forme de chaîne en un nombre , l'opération doit être divisée en deux parties; la partie entière et la partie fraction.

let b16 = '3.243f3e0370cdc';
// Split into integer and fraction parts
let [i16, f16] = b16.split('.');

// Calculate base 10 integer part
let i10 = parseInt(i16, 16); // 3

// Calculate the base 10 fraction part
let f10 = parseInt(f16, 16) / Math.pow(16, f16.length); // 0.14158999999999988

// Put the base 10 parts together to find the Number
let b10 = i10 + f10; // 3.14159

Note 1: Soyez prudent car de petites erreurs peuvent être dans le résultat en raison de différences dans ce qui peut être représenté dans différentes bases. Il peut être souhaitable d'effectuer un arrondi après.
Remarque 2: Les très longues représentations de nombres peuvent également entraîner des erreurs en raison de la précision et des valeurs maximales des nombres d’environnement dans lesquels les conversions ont lieu.

Répéter une chaîne

"abc".repeat(3);  // Returns "abcabcabc"
"abc".repeat(0);  // Returns ""
"abc".repeat(-1); // Throws a RangeError

var myString = "abc";
var n = 3;

new Array(n + 1).join(myString);  // Returns "abcabcabc"

Code de caractère

La méthode charCodeAt récupère le code de caractère Unicode d'un seul caractère:

var charCode = "µ".charCodeAt(); // The character code of the letter µ is 181

Pour obtenir le code de caractère d'un caractère dans une chaîne, la position 0 du caractère est transmise en tant que paramètre à charCodeAt :

var charCode = "ABCDE".charCodeAt(3); // The character code of "D" is 68

// The Grinning Face Emoji has code point 128512 or 0x1F600
var codePoint = "😀".codePointAt();