Chapitre 4: Structures de données : objets et tableaux

Ce chapitre sera consacré à la résolution de quelques problèmes simples. En chemin, nous allons étudier deux nouveaux types de valeurs, les tableaux et les objets, et quelques techniques les concernant.

Considérons la situation suivante : votre tante Émilie l’excentrique, dont la rumeur dit qu’elle vit avec cinquante chats (en fait personne n’arrive à les compter), vous envoie régulièrement des courriels pour vous tenir au courant de ses exploits. Ils sont de la forme suivante :

Mon cher neveu, Ta mère m’a dit que tu t’es mis au parachutisme. Est-ce que c’est vrai ? Fais bien attention à toi, jeune homme ! Tu te souviens de ce qui est arrivé à mon mari ? Et c’était seulement du deuxième étage !

Quoi qu’il en soit, les choses sont très intéressantes de mon côté. J’ai passé toute la semaine à essayer d’attirer l’attention de M. Drake, le gentil monsieur qui a emménagé juste à côté, mais je pense qu’il a peur des chats. À moins qu’il n’y soit allergique ? Je vais essayer de poser Gros Igor sur son épaule la prochaine fois qu’il vient. Je suis curieuse de voir le résultat.

Par ailleurs, l’arnaque dont je t’ai parlé fonctionne mieux que prévu. J’ai déjà récupéré cinq « paiements » et seulement une seule réclamation. Je commence malgré tout à avoir quelques remords. Et puis tu as sans doute raison, ça doit être illégal d’une manière ou d’une autre.

(…etc.)

Grosses bises, Tante Émilie

Décédé le 27/04/2006 : Black Leclère

Est né le 05/04/2006 (mère, Lady Pénélope) : Lion Rouge, Docteur Hobbles III, Petit Iroquois

Pour amuser cette vieille dame, vous voudriez garder une trace de la généalogie de ses chats, pour pouvoir ajouter des commentaires comme « P.-S. J’espère que Docteur Hobbles II a bien fêté son anniversaire samedi ! », ou bien « Comment va cette vieille Lady Pénélope ? Elle a cinq ans maintenant, n’est-ce pas ? », en évitant de préférence de demander des nouvelles des chats décédés. Vous avez une grande quantité de vieux courriels de votre tante et, par chance, elle est très constante dans sa manière de donner les renseignements sur les naissances et décès des chats à la fin de ses courriels, toujours dans le même format.

Vous n’avez pas envie de parcourir à la main tous ces messages. Heureusement, nous avions justement besoin d’un exemple, nous allons donc écrire un programme qui va faire le travail pour nous. Pour commencer, nous allons écrire un programme qui va nous donner la liste des chats qui sont toujours vivants à la fin du dernier courriel.

Avant que vous ne posiez la question, au début de cette correspondance, la tante Émilie n’avait qu’un seul chat : Spot (elle était encore assez conformiste à cette époque).

Il est généralement préférable d’avoir une idée de départ sur ce que va faire un programme avant de se mettre à l’écrire… Voici le plan :

1. Commencer par un ensemble de noms de chats ne comprenant que « Spot ».
2. Parcourir chaque courriel dans l’archive dans l’ordre chronologique.
3. Chercher les paragraphes qui commencent par « Est né le » ou « Décédé le ».
4. Ajouter les noms trouvés dans les paragraphes qui commencent par « Est né le » à l’ensemble de noms.
5. Supprimer les noms de chats trouvés dans les paragraphes qui commencent par « Décédé le » de notre ensemble.

On extraira les noms d’un paragraphe de la façon suivante :

1. Trouver les deux-points (:) dans le paragraphe.
2. Prendre la partie après ce signe.
3. Dans cette partie, séparer les noms en cherchant les virgules.

Cet énoncé d’exercice peut rendre nécessaire d’oublier quelques instants les exceptions possibles et d’accepter aveuglément que tante Émilie utilise toujours le même format d’écriture, qu’elle n’oublie jamais un nom de chat, ni ne fait de faute de frappe. Mais votre tante est comme ça et ça tombe bien pour nous.

D’abord, je vais vous expliquer les propriétés. Beaucoup de valeurs en JavaScript ont d’autres valeurs qui leur sont associées. Ces associations sont appelées propriétés. Chaque chaîne de caractères a une propriété appelée length, (longueur), qui correspond à un nombre, la quantité de caractères dans cette chaîne.

On peut accéder aux propriétés de deux manières :

var texte = "brume pourpre";
show(texte["length"]);
show(texte.length);

La deuxième manière est un raccourci de la première et ne fonctionne que lorsque le nom de la propriété s’écrit comme un nom de variable ― lorsqu’il n’y a pas d’espace ou de symbole et lorsqu’elle ne commence pas par un chiffre.

Les valeurs null et undefined n’ont pas de propriété. Essayez de lire des propriétés de ces valeurs donnera une erreur. Essayez le code suivant, juste pour voir le type de message d’erreur que votre navigateur va retourner dans ce cas de figure (dans certains navigateurs, ce message sera assez mystérieux).

var rienDuTout = null;
show(rienDuTout.length);

Les propriétés d’une chaîne de caractères ne peuvent pas être changées. Elles sont plus nombreuses que la seule longueur length, comme nous allons le voir, mais vous ne pouvez ajouter ni supprimer aucune propriété.

C’est différent avec les valeurs du type object. Leur rôle principal est de conserver d’autres valeurs. Ils ont, en quelque sorte, leur propre jeu de « tentacules » sous forme de propriétés. Vous pouvez les modifier, les supprimer ou en ajouter de nouvelles.

Un objet peut s’écrire de la façon suivante :

var chat = {couleur: "gris", nom: "Spot", taille: 46};
chat.taille = 47;
show(chat.taille);
delete chat.taille;
show(chat.taille);
show(chat);

Comme les variables, chaque propriété attachée à un objet a un nom sous forme d’une chaîne de caractères. La première instruction crée un objet dans lequel la propriété "couleur" contient la chaîne "gris", la propriété "nom" est liée à la chaîne "Spot", et la propriété "taille" fait référence au nombre 46. La deuxième ligne modifie la propriété taille en lui donnant une nouvelle valeur, ce qui se fait de la même manière que pour la modification d’une variable.

Le mot-clé delete supprime les propriétés. Essayer de lire une propriété qui n’existe pas donnera la valeur undefined.

Si une propriété qui n’existe pas encore est affectée avec l’opérateur =, elle est ajoutée à l’objet.

var vide = {};
vide.plusVraiment = 1000;
show(vide.plusVraiment);

Les propriétés dont le nom ne pourrait pas être une variable doivent être mises entre guillemets au moment de la création de l’objet et utilisées avec des crochets :

var truc = {"gabba gabba": "hey", "5": 10};
show(truc["5"]);
truc["5"] = 20;
show(truc[2 + 3]);
delete truc["gabba gabba"];

Comme vous pouvez le voir, on peut mettre n’importe quelle expression entre les crochets. Elle sera convertie en une chaîne pour définir le nom de la propriété. On peut aussi utiliser des variables pour donner un nom à une propriété :

var nomDePropriete = "length";
var texte = "grandeLigne";
show(texte[nomDePropriete]);

L’opérateur in peut servir à tester si un objet possède une certaine propriété. Son résultat est un booléen.

var poupeeRusse = {};
poupeeRusse.contenu = poupeeRusse;
show("contenu" in poupeeRusse);
show("contenu" in poupeeRusse.contenu);

Quand les valeurs d’un objet sont affichées sur la console, on peut cliquer à la souris pour inspecter leurs propriétés. La fenêtre de sortie devient une fenêtre « inspecteur ». Le petit « x » en haut à droite s’utilise pour retourner à la fenêtre de sortie et la flèche gauche permet de retourner aux propriétés de l’objet inspecté.

show(poupeeRusse);

Les valeurs des objets peuvent apparemment changer. Les types de valeurs vues dans le chapitre 2 sont toutes invariables, il n’est pas possible de changer une valeur existante pour ces types de données. Vous pouvez les associer ou en tirer de nouvelles valeurs, mais lorsque vous prenez une chaîne de caractères particulière, le texte à l’intérieur ne peut pas être modifié. Avec les objets, d’un autre côté, le contenu d’une valeur peut être modifié en changeant ses propriétés.

Lorsque nous considérons deux nombres, 120 et 120, il est possible dans tous les cas pratiques de les considérer comme des nombres identiques. Avec des objets, il y a une différence importante entre avoir deux « références » du même objet et avoir deux objets distincts qui possèdent les mêmes propriétés. Considérons le code suivant :

var objet1 = {valeur: 10};
var objet2 = objet1;
var objet3 = {valeur: 10};

show(objet1 == objet2);
show(objet1 == objet3);

objet1.valeur = 15;
show(objet2.valeur);
show(objet3.valeur);

objet1 et objet2 sont deux variables attachées à la même valeur. Il n’y a en fait qu’un seul objet, c’est pourquoi en changeant objet1 on change également la valeur de objet2. La variable objet3 pointe vers un autre objet qui contient au départ la même propriété que objet1 mais elle a une existence distincte.

L’opérateur JavaScript ==, lorsqu’il compare des objets, ne retournera la valeur booléenne true que si chacune des valeurs qu’on lui donne à comparer sont exactement les mêmes. Comparer des objets différents ayant des contenus identiques donnera le résultat false. C’est utile dans certaines situations, mais peu adapté à d’autres.

Les valeurs d’un objet peuvent jouer de nombreux rôles. Se comporter comme un ensemble n’est que l’un d’entre eux. Nous allons voir d’autres utilisations dans ce chapitre et le chapitre 8 montrera d’autres façons importantes d’utiliser les objets.

Dans le plan d’action pour le problème des chats ― en fait, appelons-le un algorithme au lieu d’un plan, cela nous donne l’impression qu’on sait de quoi on parle ― dans l’algorithme, on parle de parcourir chaque courriel contenu dans une archive. Mais comment se présente cette archive ? Et d’où vient-elle ?

Ne vous inquiétez pas de la deuxième question pour le moment. Le chapitre 14 explique quelques-unes des possibilités pour importer des données dans vos programmes. Pour l’instant, on dira que les courriels sont déjà là, comme par magie. La magie est parfois très facile, avec les ordinateurs.

La façon dont l’archive est enregistrée reste une question pertinente. Elle contient quantité de courriels. Un courriel peut être vu comme une chaîne de caractères, c’est évident. Toute l’archive pourrait être mise dans une énorme chaîne de caractères mais ce ne serait pas pratique. Ce qu’il nous faut, c’est une structure de chaînes de caractères distinctes.

Les objets sont justement utilisés pour structurer des choses. On pourrait très bien créer un objet comme celui-ci :

var archiveDeMessages = {"le premier courriel": "Mon cher neveu, …",
                   "le deuxième courriel": "…"
                   /* et ainsi de suite… */};

Mais parcourir les courriels du début à la fin serait difficile ― comment le programme peut-il deviner le nom de ces propriétés ? La solution est d’utiliser des noms de propriétés plus prévisibles :

var archiveDeMessages = {0: "Mon cher neveu, … (courriel numéro 1)",
                   1: "(courriel numéro 2)",
                   2: "(courriel numéro 3)"};

for (var courant = 0; courant in archiveDeMessages; courant++)
  print("Traitement du courriel #", courant, ": ", archiveDeMessages[courant]);

La chance veut qu’il existe un type d’objet particulier qui corresponde exactement à ce type de besoin. Ce sont les tableaux et ils fournissent des commodités très utiles, comme length (longueur), une propriété qui contient le nombre d’éléments dans le tableau et bien d’autres fonctions utiles pour ce type de structure.

Pour créer de nouveaux tableaux on utilise des crochets ([ et ]):

var archiveDeMessages = ["courriel un", "courriel deux", "courriel trois"];

for (var courant = 0; courant < archiveDeMessages.length; courant++)
  print("Traitement du courriel #", courant, ": ", archiveDeMessages[courant]);

Dans cet exemple, le nombre d’éléments n’est plus spécifié explicitement. Le premier a automatiquement le numéro 0, le deuxième le numéro 1 et ainsi de suite.

Pourquoi commencer à 0 ? Dans la vie courante on compte d’habitude à partir de 1. Aussi étrange que cela paraisse, la numérotation à partir de 0 est souvent plus pratique pour programmer. Faites avec pour l’instant, vous allez vous y faire.

Commencer par l’élément 0 veut aussi dire que dans une structure qui a X éléments, le dernier élément sera trouvé à la position X - 1. C’est pourquoi la boucle for dans notre exemple teste la valeur courant < archiveDeMessages.length. Il n’y a pas d’élément à la position archiveDeMessages.length, donc dès que courant atteint cette valeur, on arrête la boucle.

Les objets chaînes de caractères et tableaux contiennent tous deux, outre la propriété length, un certain nombre d’autres propriétés qui font référence à des fonctions.

var doh = "Doh";
print(typeof doh.toUpperCase);
print(doh.toUpperCase());

Chaque chaîne de caractères a une propriété toUpperCase. Lorsqu’elle est appelée, elle retourne une copie de la chaîne, transformée avec chaque lettre en majuscule. Il y a aussi l’équivalent toLowerCase. Devinez le résultat…

Remarquez que même si l’appel de toUpperCase se fait sans arguments, la fonction a malgré tout accès au contenu de la chaîne de caractères "Doh", la valeur dont elle est une propriété. La façon dont cela fonctionne est décrite dans le chapitre 8.

Les propriétés qui se comportent comme des fonctions sont généralement appelées méthodes, ainsi, toUpperCase est une méthode des objets chaînes de caractères.

var flipper = [];
flipper.push("Flipper");
flipper.push("le");
flipper.push("dauphin");
show(flipper.join(" "));
show(flipper.pop());
show(flipper);

La méthode push, associée aux tableaux, peut être utilisée pour ajouter des valeurs à ceux-ci. Nous aurions pu l’utiliser dans l’exercice précédent, à la place de resultat[i] = i. Il y a aussi la méthode pop, complémentaire de push : elle supprime le dernier élément d’un tableau et retourne sa valeur. join construit une seule chaîne de caractères à partir d’un tableau de chaînes de caractères. Le paramètre utilisé avec cette méthode sera inséré entre chaque valeur du tableau, avant l’assemblage de la chaîne de caractères finale.

Revenons à nos chats : nous savons maintenant qu’utiliser un tableau serait une bonne idée pour ranger les archives des courriels. Sur cette page, la fonction recupererLesMessages sera utilisée pour récupérer (magiquement) ce tableau. Parcourir les courriels qu’il contient pour les traiter un par un devient simple comme un jeu d’enfant :

var archiveDeMessages = recupererLesMessages();

for (var i = 0; i < archiveDeMessages.length; i++) {
  var message = archiveDeMessages[i];
  print("Traitement du courriel #", i);
  // Faire plus de choses…
}

Nous avons également décidé d’une manière de représenter un ensemble de chats vivants. Le problème qui reste à traiter, cependant, est celui de détecter des paragraphes d’un courriel qui contiennent "Est né le" ou "Décédé le".

La première question qui vient à l’esprit est de savoir ce qu’est un paragraphe au juste. Dans ce cas, la valeur de la chaîne elle-même n’est pas d’une grande utilité : le concept du texte en JavaScript ne va guère plus loin que l’idée de « suite de caractères », si bien que nous devons définir les paragraphes de cette façon.

Nous avons vu plus haut qu’il existe une chose qui s’appelle un caractère de fin de ligne. C’est ce que la plupart des gens utilisent pour séparer les paragraphes. Nous considérons donc un paragraphe comme une partie du courriel qui commence par un caractère saut de ligne ou au début du contenu du message et se termine au caractère saut de ligne suivant ou bien à la fin du contenu.

Et nous n’avons même pas à écrire nous-mêmes l’algorithme pour scinder une chaîne en paragraphes. Les chaînes ont déjà une méthode appelée split, qui est (pratiquement) l’inverse de la méthode join pour les tableaux. Elle découpe une chaîne en un tableau en utilisant la chaîne fournie comme argument pour déterminer à quel endroit opérer les divisions en paragraphes.

var mots = "Les villes de l’arrière-pays";
show(mots.split(" "));

Ainsi, découper avec des caractères saut de ligne ("\n") est une méthode utilisable pour diviser un courriel en paragraphes.

Les paragraphes qui ne commencent ni par « Né le » ni par « Décédé le » peuvent être ignorés par le programme. Comment peut-on tester si une chaîne commence par un mot particulier ? On peut utiliser la méthode charAt pour obtenir un caractère particulier dans une chaîne. x.charAt(0) donne le premier caractère, 1 est le deuxième et ainsi de suite. Voici une façon de vérifier si une chaîne commence par « Né le» :

var paragraphe = "Est né le 15/11/2003 (mère, Spot) : Croc Blanc";
show(paragraphe.charAt(0) == "E" && paragraphe.charAt(1) == "s" &&
     paragraphe.charAt(2) == "t" && paragraphe.charAt(3) == " " &&
     paragraphe.charAt(4) == "n" && paragraphe.charAt(5) == "é" &&
     paragraphe.charAt(6) == " " && paragraphe.charAt(7) == "l" &&
     paragraphe.charAt(8) == "e");

Mais cela devient un peu pénible ― imaginez que vous devez vérifier la présence d’un mot de 10 caractères. On peut cependant en tirer une leçon utile : si une instruction est démesurément longue, on peut l’étendre sur plusieurs lignes. Le résultat peut être plus facile à lire en alignant le début de la nouvelle ligne avec le premier élément similaire de la première ligne.

Les chaînes possèdent également une méthode nommée slice. Elle permet de copier un morceau de la chaîne de caractères, en commençant par le caractère à la position donnée par le premier argument, et se terminant avant le caractère (non inclus) à la position donnée par le second argument. Cela permet de vérifier une chaîne de caractères en peu de lignes.

show(paragraphe.slice(0, 9) == "Est né le");

Que se passe-t-il quand charAt ou slice sont utilisés pour prendre un fragment de chaîne qui n’existe pas ? Est-ce que la fonction chaineCommencePar que j’ai montrée va encore fonctionner si la chaîne recherchée est plus longue que celle dans laquelle on cherche ?

show("Ouai".charAt(250));
show("Nan".slice(1, 10));

charAt va renvoyer "" s’il n’existe pas de caractère à la position donnée et slice va tout simplement laisser tomber la partie de la nouvelle chaîne qui n’existe pas.

Cela confirme que cette version de chaineCommencePar fonctionne. Quand la fonction chaineCommencePar("Idiots","Mes très chers collègues") est appelée, l’appel à slice renverra toujours une chaîne plus courte que motif, parce que le premier argument, chaine ne comporte pas assez de caractères. C’est pour cette raison que la comparaison avec == renverra false, ce qui est correct.

C’est une bonne idée de toujours consacrer un moment pour prendre en considération les entrées aberrantes (mais valides) dans un programme. On les appelle en général des cas imprévus et il est très fréquent qu’un programme qui tourne à merveille avec toutes les entrées « normales » se plante complètement avec des cas imprévus.

La seule partie de notre problème de chats qui ne soit pas encore résolue est l’extraction des noms d’un paragraphe. L’algorithme était le suivant :

1. Trouver le deux-points (:) dans le paragraphe.
2. Prendre la partie après ce signe.
3. Dans cette partie, séparer les noms en cherchant les virgules.

Il faut reproduire cela à la fois pour les paragraphes qui commencent par Décès le et ceux qui commencent par Est né le. Ce serait une bonne idée de le mettre dans une fonction, de sorte que les deux parties de code qui gèrent les différentes sortes de paragraphes puissent l’utiliser.

Tout ce qui nous reste à faire maintenant, c’est de rassembler les pièces du puzzle. Voici une façon de s’y prendre :

var archiveDeMessages = recupererLesMessages();
var chatsVivants = {"Spot": true};

for (var message = 0; message < archiveDeMessages.length; message++) {
  var paragraphes = archiveDeMessages[message].split("\n");
  for (var paragraphe = 0;
       paragraphe < paragraphes.length;
       paragraphe++) {
    if (chaineCommencePar(paragraphes[paragraphe], "Est né le")) {
      var noms = nomDesChats(paragraphes[paragraphe]);
      for (var nom = 0; nom < noms.length; nom++)
        chatsVivants[noms[nom]] = true;
    }
    else if (chaineCommencePar(paragraphes[paragraphe], "Décédé le")) {
      var noms = nomDesChats(paragraphes[paragraphe]);
      for (var nom = 0; nom < noms.length; noms++)
        delete chatsVivants[noms[nom]];
    }
  }
}

show(chatsVivants);

Voilà un bloc de code assez copieux et dense. Nous allons voir tout de suite comment l’alléger un peu. Mais d’abord jetons un coup d’œil aux résultats. Nous savons comment vérifier si un chat particulier a survécu :

if ("Spot" in chatsVivants)
  print("Spot est vivant !");
else
  print("Ce bon vieux Spot, qu’il repose en paix.");

Mais comment allons-nous faire pour dresser la liste de tous les chats vivants ? Le mot-clé in a une signification légèrement différente lorsqu’il est utilisé avec for :

for (var chat in chatsVivants)
  print(chat);

Une boucle comme celle-là va parcourir les noms des propriétés d’un objet, ce qui nous permettra d’énumérer tous les noms de notre ensemble.

Certaines parties de code ressemblent à une jungle impénétrable. L’exemple de solution pour le problème des chats souffre de ce défaut. Une façon de ménager des clairières consiste tout simplement à ajouter des lignes vides. Cela améliore la lisibilité, mais ne résout pas véritablement le problème.

Ce qu’il nous faut ici, c’est casser le code. Nous avons déjà écrit deux fonctions d’aide, chaineCommencePar et nomDesChats, qui toutes deux résolvent une petite partie du problème de façon compréhensible. Continuons sur cette lancée.

function ajouterAuSet(set, valeurs) {
  for (var i = 0; i < valeurs.length; i++)
    set[valeurs[i]] = true;
}

function enleverDuSet(set, valeurs) {
  for (var i = 0; i < valeurs.length; i++)
    delete set[valeurs[i]];
}

Ces deux fonctions traitent de l’ajout et de la suppression des noms dans l’ensemble. Ce qui supprime déjà les deux plus importantes boucles internes de la solution :

var chatsVivants = {Spot: true};

for (var message = 0; message < archiveDeMessages.length; message++) {
  var paragraphes = archiveDeMessages[message].split("\n");
  for (var paragraphe = 0;
       paragraphe < paragraphes.length;
       paragraphe++) {
    if (chaineCommencePar(paragraphes[paragraphe], "Est né le"))
      ajouterAuSet(chatsVivants, nomDesChats(paragraphes[paragraphe]));
    else if (chaineCommencePar(paragraphes[paragraphe], "Décédé le"))
      enleverDuSet(chatsVivants, nomDesChats(paragraphes[paragraphe]));
  }
}

C’est un sacré progrès, si je peux me permettre. Pourquoi ajouterAuSet et enleverDuSet prennent-ils l’ensemble comme argument ? Ils pourraient utiliser la variable chatsVivants directement, s’ils le voulaient. La raison, c’est que de cette façon elles ne sont pas totalement liées à notre problème. Si ajouterAuSet changeait directement chatsVivants, il faudrait l’appeler ajouterChatsDansEnsembleDeChats ou quelque chose comme ça. Tel que nous l’utilisons, c’est un outil utile pour des cas plus généraux.

Même si nous ne devions jamais utiliser ces fonctions pour quoi que ce soit d’autre, ce qui est très probable, il est utile de les décrire de cette façon. Car elles se « suffisent à elles-même », on peut les lire et les comprendre, sans avoir besoin de connaître une variable externe nommée chatsVivants.

Ces fonctions ne sont pas pures : elles modifient l’objet set qui a été passé en premier argument. Cela rend les choses un peu plus délicates qu’avec des fonctions pures mais c’est déjà beaucoup moins perturbant que des fonctions qui perdent les pédales et modifient les valeurs de variables comme ça leur chante.

Nous continuons à découper l’algorithme en petites unités :

function trouverChatsVivants() {
  var archiveDeMessages = recupererLesMessages();
  var chatsVivants = {"Spot": true};

  function traiterParagraphe(paragraphe) {
    if (chaineCommencePar(paragraphe, "Est né le"))
      ajouterAuSet(chatsVivants, nomDesChats(paragraphe));
    else if (chaineCommencePar(paragraphe, "Décédé le"))
      enleverDuSet(chatsVivants, nomDesChats(paragraphe));
  }

  for (var message = 0; message < archiveDeMessages.length; message++) {
    var paragraphes = archiveDeMessages[message].split("\n");
    for (var i = 0; i < paragraphes.length; i++)
      traiterParagraphe(paragraphes[i]);
  }
  return chatsVivants;
}

var combien = 0;
for (var chat in trouverChatsVivants())
  combien++;
print("Il y a ", combien, " chats.");

La totalité de l’algorithme est encapsulée dans une fonction. Cela signifie qu’elle ne laisse rien traîner en vrac derrière elle après exécution : chatsVivants est maintenant une variable locale dans la fonction et non plus une variable globale, si bien qu’elle n’existe que pendant que la fonction s’exécute. Le code qui a besoin de cet ensemble peut appeler trouverChatsVivants et utiliser la valeur qu’il renvoie.

Il me semble que faire de traiterParagraphe une fonction distincte peut aussi clarifier les choses. Mais celle-ci est si étroitement liée à l’algorithme des chats qu’elle n’aurait aucun sens dans une autre situation. De plus, elle a besoin d’accéder à la variable chatsVivants. C’est donc une candidate parfaite pour devenir une fonction à l’intérieur d’une fonction. Quand elle existe à l’intérieur de trouverChatsVivants, il est clair qu’elle n’est pertinente que là et qu’elle a accès aux variables de sa fonction parente.

Cette solution est en fait plus grande que la précédente. Mais elle est plus propre et j’espère que vous reconnaîtrez qu’elle est plus lisible.

Le programme ignore encore un grand nombre d’informations qui sont incluses dans les courriels. Il s’agit des dates de naissance, de mort et des noms des mères.

Commençons par les dates : quelle pourrait être la meilleure façon de stocker une date ? Nous pourrions créer un objet avec ces trois propriétés, year (année), month (mois), et day (jour) et stocker ensuite des nombres à l’intérieur.

var quand = {year: 1980, month: 2, day: 1};

Mais JavaScript fournit déjà une sorte d’objet pour cela. Un tel objet peut être créé en utilisant le mot-clé new :

var quand = new Date(1980, 1, 1);
show(quand);

Tout comme la notation avec les accolades et les deux-points que nous avons déjà vue, new est une façon de créer des valeurs d’un objet. Au lieu de préciser tous les noms de propriétés et les valeurs, une fonction est utilisée pour créer l’objet. Cela rend possible de définir une sorte de procédure standard pour créer des objets. Les fonctions comme celle-là s’appellent constructeurs et nous verrons comment les écrire dans chapitre 8.

Le constructeur Date peut être utilisé de différentes manières

show(new Date());
show(new Date(1980, 1, 1));
show(new Date(2007, 2, 30, 8, 20, 30));

Comme vous pouvez le voir, ces objets peuvent enregistrer l’heure d’un jour aussi bien qu’une date. Quand aucun argument n’est précisé, un objet représentant l’heure et la date actuelles est créé. Des arguments peuvent être précisés pour stocker une heure et une date précises. L’ordre des arguments est l’année, le mois, le jour, l’heure, la minute, la seconde puis la milliseconde. Les quatre derniers arguments sont optionnels et définis à 0 s’ils ne sont pas précisés.

Pour décrire les mois, on utilise la numérotation de 0 à 11, qui peut provoquer une confusion. Surtout que les nombres définissant les jours commencent eux à 1.

Le contenu de l’objet Date peut être inspecté avec un nombre de méthodes get….

var aujourdHui = new Date();
print("Année : ", aujourdHui.getFullYear(), ", mois : ",
      aujourdHui.getMonth(), ", jour : ", aujourdHui.getDate());
print("Heure : ", aujourdHui.getHours(), ", minutes : ",
      aujourdHui.getMinutes(), ", secondes: ", aujourdHui.getSeconds());
print("Jour de la semaine : ", aujourdHui.getDay());

Tous ces éléments, excepté la méthode getDay, ont une variable set… qui peut être utilisée pour modifier la valeur de l’objet date.

Dans l’objet, une date est représentée par la somme de millisecondes cumulée depuis le 1er Janvier 1970. Vous pouvez imaginer que c’est un nombre assez impressionnant.

var aujourdHui = new Date();
show(aujourdHui.getTime());

Une chose très utile à faire avec les dates, c’est de les comparer.

var chuteDuMur = new Date(1989, 10, 9);
var premiereGuerreDuGolf = new Date (1990, 6, 2);
show(chuteDuMur < premiereGuerreDuGolf);
show(chuteDuMur == chuteDuMur);
// mais
show(chuteDuMur == new Date(1989, 10, 9));

Comparer les dates avec <, >, <= et >= remplit exactement l’office que nous voulons en faire. Quand un objet date est comparé avec lui-même, le résultat est true, ce qui est bien également. Mais quand == est utilisé pour comparer un objet date à un autre objet date distinct mais de même valeur, on obtient false. Étrange, non ?

Comme précisé plus tôt, == retournera la valeur false

var chuteDuMur1 = new Date(1989, 10, 9),
chuteDuMur2 = new Date(1989, 10 ,9);
show(chuteDuMur1.getTime() == chuteDuMur2.getTime());

var maintenant = new Date();
print(maintenant.getTimezoneOffset());

"Décédé le 27/04/2006 : Black Leclère"

function extraireDate(paragraphe) {
  function nombreEnPosition(position, longueur) {
    return Number(paragraphe.slice(position, position + longueur));
  }
  return new Date(nombreEnPosition(16, 4), nombreEnPosition(13, 2) - 1,
                  nombreEnPosition(10, 2));
}

show(extraireDate("Décédé le 27-04-2006 : Black Leclère"));

function enregistrementChat(nom, dateNaissance, mere) {
  return {nom: nom, naissance: dateNaissance, mere: mere};
}

function ajouterChats(set, noms, dateNaissance, mere) {
  for (var i = 0; i < noms.length; i++)
    set[noms[i]] = enregistrementChat(noms[i], dateNaissance, mere);
}
function chatsDecedes(set, noms, dateDeces) {
  for (var i = 0; i < noms.length; i++)
    set[noms[i]].deces = dateDeces;
}

"Est né le 15/11/2003 (mère, Spot): Croc Blanc"

function extraireNomMere(paragraphe) {
  var start = paragraphe.indexOf("(mère, ") + "(mère, ".length;
  var end = paragraphe.indexOf(")");
  return paragraphe.slice(start, end);
}

show(extraireNomMere("Est né le 15/11/2003 (mère, Spot): Croc Blanc"));

function extraireChaineEntre(chaine, debut, fin) {
  var indexDebut = chaine.indexOf(debut) + debut.length;
  var indexFin = chaine.indexOf(fin, indexDebut);
  return chaine.slice(indexDebut, indexFin);
}
show(extraireChaineEntre("bu ] boo [ bah ] gzz", "[ ", " ]"));

function extraireNomMere(paragraphe) {
  return extraireChaineEntre(paragraphe, "(mère, ", ")");
}

function trouverChats() {
  var archiveDeMessages = recupererLesMessages();
  var chats = {"Spot": enregistrementChat("Spot", new Date(1997, 2, 5),
              "inconnue")};

  function traiterParagraphe(paragraphe) {
    if (chaineCommencePar(paragraphe, "Est né le"))
      ajouterChats(chats, nomDesChats(paragraphe), extraireDate(paragraphe),
              extraireNomMere(paragraphe));
    else if (chaineCommencePar(paragraphe, "Décédé le"))
      chatsDecedes(chats, nomDesChats(paragraphe), extraireDate(paragraphe));
  }

  for (var message = 0; message < archiveDeMessages.length; message++) {
    var paragraphes = archiveDeMessages[message].split("\n");
    for (var i = 0; i < paragraphes.length; i++)
      traiterParagraphe(paragraphes[i]);
  }
  return chats;
}

var tousLesChats = trouverChats();

function formatDate(date) {
  return date.getDate() + "/" + (date.getMonth() + 1) +
         "/" + date.getFullYear();
}

function renseignementSurChat(data, nom) {
  if (!(nom in data))
    return "Aucun chat s’appelant " + nom + " n’a été trouvé.";

  var chat = data[nom];
  var message = nom + ", est né le " + formatDate(chat.naissance) +
                " de la mère " + chat.mere;
  if ("deces" in chat)
    message += ", décédé le " + formatDate(chat.deces);
  return message + ".";
}

print(renseignementSurChat(tousLesChats, "Gros Igor"));

function formatDate(date) {
  function pad(nombre) {
    if (nombre < 10)
      return "0" + nombre;
    else
      return nombre;
  }
  return pad(date.getDate()) + "/" + pad(date.getMonth() + 1) +
             "/" + date.getFullYear();
}
print(formatDate(new Date(2000, 0, 1)));

function lePlusVieuxChat(data) {
  var lePlusVieux = null;

  for (var nom in data) {
    var chat = data[nom];
    if (!("deces" in chat) &&
        (lePlusVieux == null || lePlusVieux.naissance > chat.naissance))
      lePlusVieux = chat;
  }

  if (lePlusVieux == null)
    return null;
  else
    return lePlusVieux.nom;
}

print(lePlusVieuxChat(tousLesChats));

function compteurArgument() {
  print("Vous m’avez donné ", arguments.length, " arguments.");
}
compteurArgument("Mort", "Famine", "Fléau");

function ajouter(nombre, combien) {
   if (arguments.length < 2)
     combien = 1;
   return nombre + combien;
}

show(ajouter(6));
show(ajouter(6, 4));

function serie(debut, fin) {
  if (arguments.length < 2) {
    fin = debut;
    debut = 0;
  }
  var resultat = [];
  for (var i = debut; i <= fin; i++)
    resultat.push(i);
  return resultat;
}

show(serie(4));
show(serie(2, 4));

print(somme(serie(1, 10)));

function somme(nombres) {
  var total = 0;
  for (var i = 0; i < nombres.length; i++)
    total += nombres[i];
  return total;
}

print(somme(serie(1, 10)));

for (var nom in Math)
  print(nom);

for (var nom in ["Huey", "Dewey", "Loui"])
  print(nom);

var tableau = ["Ciel", "Terre", "Homme"];
tableau.length = 2;
show(tableau);

1. Il y a quelques problèmes subtils avec cette approche dont nous parlerons et que nous résoudrons dans le chapitre 8. On ne s’en occupera pas pour ce chapitre.