JavaScript : Les chaînes de caractères

Les chaînes sont numérotées de 0 à NombreDeCaractères -1

Récupération de la longueur d'une chaîne : length

var LaChaine = "ab\"cd"
alert (LaChaine.length) // 5 (a,b,",c et d)

Le \" est expliqué plus bas dans cette page

Attention: C'est bien .length et pas .length() !

Mise en majuscule (toUpperCase) et en Minuscule (toLowerCase)

var LaChaine = "abcABC"
alert (LaChaine.toLowerCase()) // abcabc
alert (LaChaine.toUpperCase()) // ABCABC

Extraction d'un caractère dans une chaîne

var X = "123456789"
alert (X.charAt(0)) // 1 (1er caractère)
alert (X.charAt(1)) // 2 (2ème caractère)
alert (X.charAt(8)) // 9 (dernier caractère)
alert (X.charAt(9)) // rien (10 ème caractère)

Récupération du code UniCode (genre d'ASCII) d'un certain caractère d'une chaîne

Il suffit de remplacer charAt par charCodeAt :

var LaChaine = "abc"
alert (LaChaine.charCodeAt(0)) // Renvoie 97 (Caractère Unicode de a qui est le 1er caractère)

Restauration d'une chaîne à partir de ses caractères Unicode

var LaChaine = "N'importe quoi"
LaChaine = String.fromCharCode (65, 66, 67)
alert (LaChaine) // ABC

Extraction d'une sous-chaîne de caractères : substring

Fonctionnement : substring prend le plus petit des 2 paramètres, et renvoie la chaîne de caractères qui va du plus petit au plus grand :

Pour avoir un seul caractère, il faut une différence de 1 entre le plus petit et le plus grand : Par exemple pour avoir le premier caractère, on extrait "du zérotième au premier caractère"

var X = "123456789"
alert (X.substring(1,1))   // rien
alert (X.substring(1,2))   // 2
alert (X.substring(1,3))   // 23
alert (X.substring(1,4))   // 234
alert (X.substring(4,1))   // 234  (aussi)
alert (X.substring(0,0))   // rien
alert (X.substring(0,1))   // 1    (premier caractère)
alert (X.substring(0,2))   // 12
alert (X.substring(10,15)) // rien
alert (X.substring(5,100)) // 6789 (les 4 derniers)

Recherche d'une chaîne dans une autre : indexOf

Permet de trouver la position d'une chaîne dans une autre. Attention : Les majuscules sont différentes des minuscules.

Si la recherche échoue, -1 est renvoyé

var LaChaine = "abcdefg"
alert (LaChaine.indexOf("cde")) // 2
alert (LaChaine.indexOf("abc")) // 0
alert (LaChaine.indexOf("ABC")) // -1 (Case sensitive)
alert (LaChaine.indexOf("xxx")) // -1 (Inexistant)

J'ai trouvé la fonction search qui a l'air d'être similaire (à tester en cas de problèmes avec IndexOf)

La fonction corrélative lastIndexOf permet de retrouver la DERNIERE occurrence d'une chaîne dans une autre :

var LaChaine = "abcabcabcABC"
alert (LaChaine.lastIndexOf("abc")) // 6 (0,1,2,3,4,5,6 (7ème caractère))

Remplacement d'une chaîne de caractères : replace

Par exemple pour remplacer "Le chien noir" par "Le chat noir", nous procéderions comme ceci :

var LaChaine = "Le chien noir"
LaChaine = LaChaine.replace("chien", "chat")
alert (LaChaine) // Le chat noir

Troncage de la partie gauche de la chaîne : slice

var LaChaine = "abcde"
alert(LaChaine.slice(0)) // abcde
alert(LaChaine.slice(1)) // bcde
alert(LaChaine.slice(2)) // cde
alert(LaChaine.slice(4)) // e
alert(LaChaine.slice(5)) // plus rien
alert(LaChaine.slice(100)) // plus rien non plus

Concaténation : concat

La concaténation consiste à coller une chaîne de caractères après une autre

var str1 = "abc"
var str2 = "def"
var s = str1.concat(str2)
alert (s) // abcdef

On peut utiliser le signe + qui est peut être plus simple :

var LaChaine = "abcde"
alert ("*" + LaChaine + "*") // *abcde*

Séparation d'une chaîne en différentes sous chaînes : split ("caractèreDeSéparation")

Il s'agit de séparer différents mots d'une phrase par exemple : C'est à dire qu'à chaque fois qu'on rencontre un espace, il va falloir stocker le mot dans un élément de tableau :

var LaChaine = " Le chat boit."
var TableauResultant
TableauResultant = LaChaine.split(" ") // nous séparons à chaque espace " "
alert (TableauResultant [0]) // rien (le premier espace)
alert (TableauResultant [1]) // Le
alert (TableauResultant [2]) // chat
alert (TableauResultant [3]) // boit.
alert (TableauResultant [4]) // undefined

Transformation de chaînes en nombres : parseInt et parseFloat

ATTENTION : ces 2 fonctions ne sont pas issues de la bibliothèque Math !

alert(parseFloat("1.6"))     // 1.6
alert(parseInt("1.6"))       // 1
alert(parseFloat("1.6xxx"))  // 1.6
alert(parseFloat("x1.6xxx")) // NaN

Caractères spéciaux

Il est parfois nécessaire d'inclure dans des chaînes de caractères des caractères spéciaux, tels que des guillemets justement... C'est dur puisque une chaîne de caractère est encadrée de guillemets :

alert ("Les "nerds" sont des informaticiens")

donnerait une erreur, à cause des guillemets dans les guillemets. On doit remplacer ces guillemets par leur caractère de subsitution : \" (des guillemets précédés d'un \). La commande suivante fonctionne très bien :

alert ("Les \"nerds\" sont des informaticiens")

Liste des caractères de substitution :

\b : espace arrière
\f : saut de page
\n : saut de ligne
\r : retour chariot
\t : tabulation
\' : apostrophe
\" : guillemet
\\ : backslash

alert ("Les nerds\r sont des informaticiens")

Affiche cette phrase sur 2 lignes.

Ajout automatique de balises HTML

Comme JavaScript travaille main dans la main avec HTML, certaines fonctions peuvent automatiquement ajouter les balises nécessaires pour l'affichage en tel ou tel format :

Exemple 1 : <BIG> et </BIG>

Permettent d'écrire en gros, comme ceci

var LaChaine = "abc"
LaChaine = LaChaine.big() // Contient maintenant : <BIG>abc</BIG>
alert (LaChaine)

Ce ne serait évidemment pas bien compliqué de substituer cette fonction toute simple par un concat, mais bon... elle existe, autant l'utiliser...

Exemple 2 : Bold (Gras)

La méthode est strictement la même qu'avec big, mais la fonction s'appelle bold, qui va rajouter les balises <B> et </B>

Voici finalement la liste des balises HTML utilisable avec JavaScript

Balise Explication Exemple Résultat théorique Résultat visible
anchor("NomAncre") Place un point d'ancrage local dans la feuille HTML var strVariable = "abc";
strVariable.anchor("UneAncre");		 <A NAME="UneAncre">abc</A> abc
big() Ecris en plus gros var strVariable = "abc";
strVariable.big( );

<BIG>abc</BIG> abc
bold() Ecris en gras var strVariable = "abc"
strVariable.bold( )

<B>abc</B>. abc
fixed() ? var strVariable = "abc";
strVariable.fixed( );		 <TT>abc</TT> abc
fontcolor("NameColor") Ecris en couleur
Les noms de couleur prédéfinis valides varient selon votre hôte JScript (navigateur, serveur, etc.)		 var strVariable = "abc";
strVariable.fontcolor("red");

<FONT COLOR="RED">abc</FONT>. abc
italics() Ecris en italiques var strVariable = "abc";
strVariable.italics( );		 <I>abc</I> abc
link("http://www.NomDuLien.com") Crée un lien hypertexte var strVariable = "Info 3000";
strVariable.link("http://www.info-3000.com.com");		 <A HREF="http://www.info-3000.com">Info 3000 </A> Info 3000
small() écrit en petit var strVariable = "abc";
strVariable.small( )		 <SMALL>abc</SMALL> abc
strike() écrit en barré var strVariable = "abc";
strVariable.strike( )		 <STRIKE>abc</STRIKE> abc
sub() écrit en indice var strVariable = "abc";
strVariable.sub( );		 <SUB>abc</SUB> abc
sup() écrit en exposant (superscript) - (je suppose) var strVariable = "abc";
strVariable.sup( );		 <SUP>abc</SUP>. abc

Traitement des caractères spéciaux tels que les accents : escape, unescape

Dans le code source HTML, on constate qu'il y a peu ou prou de caractères spéciaux tels que é, qui est plutôt représenté par %E9. Les fonctions escape et unescape permettent de transformer les chaînes de caractères de l'un dans l'autre mode :

alert(escape("éléphant"))       // %E9l%E9phant
alert(unescape("%E9l%E9phant")) // éléphant

Notes

Les objets String peuvent être créés implicitement au moyen d'opérateurs sur chaîne. Les objets String créés de cette manière (appelés chaînes standard) sont traités différemment des objets String créés au moyen de l'opérateur new. Tous les opérateurs sur chaîne partagent un seul objet chaîne globale. Par conséquent, si une propriété est ajoutée à un opérateur de chaîne, elle est disponible pour tous les objets chaîne standard :

var alpha, beta
alpha = "Ceci est une chaîne"
beta = "Ceci est aussi une chaîne"
alpha.test = 10

Dans cet exemple, test est à présent défini pour beta et pour tous les opérateurs sur chaîne à venir. Dans l'exemple suivant, cependant, les propriétés ajoutées sont traitées différemment :

var gamma, delta
gamma = new String("Ceci est une chaîne")
delta = new String("Ceci est aussi une chaîne")
gamma.test = 10

Dans ce cas, test n'est pas défini pour delta. Chaque objet String déclaré comme un nouvel (new) objet String possède son propre jeu de membres. C'est le seul cas où les objets String et les opérateurs sur chaîne sont traités différemment.