SELFHTML: CGI/Perl / Éléments de langage Perl / Programmation orientée sur l'objet

	Programmation orientée sur l'objet
	Programmation orientée sur l'objet (OOP) Programmation orientée sur l'objet en Perl Exemple simple: l'objet HTMLprint Exemple avec des données d'objet: l'objet VCard

Programmation orientée sur l'objet (OOP)

Il est important avant tout pour les projets de programmation plus importants de na pas se lancer tête baissée dans la programmation, mais de réfléchir auparavant à ce que l'application doit pouvoir faire, sous quelle forme elle doit sauvegarder les données, quelles interfaces utilisateur sont indispensables etc... À ce stade, il n'est pas du tout important, à vrai dire même gênant, d'avoir sans arrêt des bribes de code source qui trottent dans la tête. Il est préférable de modeler l'application à partir d'une réflexion naturelle.

La réflexion naturelle de l'homme moderne n'est aussi structurée que la programmation classique. Elle ne pense pas en adresses de saut et en structure de contrôle mais en unités propres plus importantes (les hommes, les machines etc...), en mesure de maîtriser les informations et les capacités de communiquer l'un avec l'autre pour créer quelque chose de nouveau.

Même un livre de visites basé sur CGI se conçoit de cette façon. Il y a là par exemple un gestionnaire de formulaires qui prend en charge l'évaluation des formulaires remplis, un gestionnaire de fichiers dont la tâche est de sauvegarder et de lire les données de façon fiable et homogène, et un gestionnaire de configuration qui décide quelles possibilités du livre de visites sont utilisées dans un cas concret et sous quelle forme. Ici par exemple, le gestionnaire de configuration doit demander au gestionnaire de fichiers de lire certaines données de configuration. De lui même, il ne le peut pas, c'est le travail du gestionnaire de fichiers. Il est tout aussi impossible au gestionnaire de fichiers d'aller purement et simplement se chercher les formulaires HTML qui ont été envoyés par l'utilisateur. Pour cela le gestionnaire de formulaire est habilité qui devra peut être demander au gestionnaire de configuration comment il doit transmettre les données avant de les remettre au gestionnaire de fichiers pour être sauvegardées conformément à la réponse du gestionnaire de configuration.

Ces unités capables de collaborer sont désignées comme objets dans la programmation orientée sur l'objet. Un objet a des propriétés et peut faire quelque chose. Certaines des propriétés et capacités viennent d'autres objets que l'objet lui-même a incorporés et dont il a ainsi hérité et d'autres à leur tour sont des propriétés et capacités tout à fait distinctes et particulières de cet objet.

Ceci n'est pas le cadre pour divulguer la théorie de la programmation orientée sur l'objet. Vous devez cependant connaître certains termes importants:

classe:
Une classe est la somme des capacités programmées d'un objet. Tout ce dont est constitué un objet et ce qu'il peut faire doit être programmé quelque part. Une classe est néanmoins programmée "abstraitement", elle n'exécute aucun code. Ainsi que l'on a un certaine idée de l'appareil si on pense à un "récepteur du monde à ondes courtes", un objet concret dans la programmation sur l'objet ne peut être dérivé que de sa classe. Un objet concret a les propriétés et les capacités de sa classe, ainsi que l'on dirait d'un récepteur du monde à ondes courtes que l'on tient dans la main que c'est un récepteur du monde à ondes courtes parce qu'il en les propriétés et les fonctions et donc qu'il correspond à l'idée qu'on se fait d'un récepteur du monde à ondes courtes. Dans une application orientée sur l'objet, vous pouvez dire: pour le travail que je désire résoudre, j'ai d'abord besoin d'une classe déterminée, ainsi qu'on pourrait dire: pour ce travail j'ai besoin d'un récepteur du monde à ondes courtes.

instance:
Une instance est un objet concret d'une certaine classe. Avec le seul concept de récepteur du monde à ondes courtes vous ne pouvez toujours pas faire le moindre travail. Vous avez besoin d'un récepteur du monde à ondes courtes bien réel pour le faire. De la même façon, vous avez besoin de l'instance bien réelle d'une classe pour que votre application orientée sur l'objet réalise un travail. Votre objet concret reçoit un nom individuel sous lequel vous pouvez l'adresser.

Propriétés et méthodes:
Vous ne pouvez pas attendre plus d'une instance d'un objet que ce de quoi l'objet est capable en fonction de sa classe. Ce de quoi l'objet est capable est fixé par ce qui est programmé dans sa classe. Les propriétés (également nommées attributs) sont des variables que vous avez à votre disposition quand vous avez créé une instance d'un objet. Les méthodes sont des fonctions qu'une instance d'un objet met à votre disposition. Une instance de la classe "gestionnaire de formulaires" pourrait par exemple mettre à disposition en tant que propriété une structure de données dans laquelle elle tient commodément à disposition les données de formulaires ayant été lues. Cette instance pourrait par exemple proposer des fonctions de filtre comme méthodes, pour ne proposer par exemple que les données des champs cachés du formulaire. Sans votre application, vous pouvez utiliser les propriétés et les méthodes en "pointant" sur leur nom dans une instance concrète. C'est comme si, lorsque vous avez un récepteur du monde à ondes courtes dans les mains, vous vous actionniez la fonction (une méthode) "recherche l'émetteur suivant qui soit suffisamment puissant" et que pour l'émetteur ainsi trouvé, vous puissiez en lire la fréquence sur le cadran (une propriété).

Fonctions destruction et construction:
Un fonction construction prend en charge la façon de créer une instance d'un objet. Dans une certaine mesure, elle fait du concept du récepteur du monde à ondes courtes, un récepteur du monde à ondes courtes bien réel. Maintenant que vous l'avez avec vous, à un moment ou à un autre vous n'aurez plus besoin du récepteur du monde à ondes courtes. Alors il devient un bagage inutile. C'est la raison pour laquelle vous pouvez alors le détruire. C'est judicieux tout au moins dans l'ordinateur car cela permet de libérer des ressources mémoire. Pour détruire des instances d'objet, il existe une fonction destruction.

Programmation orientée sur l'objet en Perl

L'interpréteur Perl soutient la programmation orientée sur l'objet depuis la version 5.0. Pour programmer une classe, donc ce de quoi dérive une instance d'objet, vous avez besoin en Perl d'un Package (progiciel) distinct, à savoir d'un espace de nommage distinct. Les sous-programmes, qui sont notés dans le progiciel sont des méthodes des objets de cette classe. Vous pouvez même d'une certaine façon définir des propriétés d'objet à l'intérieur de ces méthodes. Les packages peuvent certes être définis dans un fichier Perl (voir l'exemple sur la fonction Perl package), mais normalement un package est un fichier Perl séparé qui n'a pas d'autre vocation que d'être "incorporé" dans des scripts Perl. En bref: un package est en Perl la plupart du temps un module avec l'extension de fichier correspondante .pm. À partir de là la programmation orientée sur les modules et la programmation orientée sur l'objet sont en Perl étroitement liées.

Néanmoins un package n'est pas pour autant automatiquement une classe pour les objets. Les packages sont en fin de compte des espaces de nommage et par là même l'"environnement dans lequel les classes d'objet peuvent prospérer". Pour que Perl reconnaisse une classe pour objets en tant que telle, elle doit être créée et définie comme telle.

Il en va de même avec les instances objets. Vous devez d'abord faire savoir à Perl que vous désirez créer une instance objet. Quand c'est fait, vous pouvez ensuite adresser les propriétés et méthodes de cet objet par une syntaxe déterminée.

Attention:

Perl propose également d'autres propriétés de la programmation orientée sur l'objet, par exemple l'héritage et la liaison de méthodes à des variables. Ces autres propriétés ne sont cependant pas traitées dans cette introduction.

Exemple simple: l'objet HTMLprint

Il est montré dans cet exemple comment vous établissez un module en tant que classe d'objet, créez une instance de cet objet dans un script Perl, et travaillez avec les méthodes de cet objet. L'exemple réalise un simple objet pour des sorties HTML dans le navigateur.

Exemple du fichier module `HTMLprint.pm`:

package HTMLprint;

sub new {
 my $objet = shift;
 my $reference = {};
 bless($reference,$objet);
 return($reference);
}

sub commencement {
  my $objet = shift;
  my $titre = shift;
  print "Content-type: text/html\n\n";
  print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
  print "<html><head><title>$titre</title></head><body>\n";
}

sub titre {
  my $objet = shift;
  my $texte_sorti = shift;
  print "<h1>$texte_sorti</h1>\n";
}

sub texte {
  my $objet = shift;
  my $texte_sorti = shift;
  print "<p>$texte_sorti</p>\n";
}

sub fin {
  my $objet = shift;
  print "</body></html>\n";
}

1;

Exemple d'un script CGI complet en Perl:

#!/usr/bin/perl -w

use strict;
use CGI::Carp qw(fatalsToBrowser);
use HTMLprint;

my $html = HTMLprint -> new();
$html->commencement("Perl tout à fait élégant");
$html->titre("Perl tout à fait élégant");
$html->texte("HTML misérable mais programmé de façon très moderne!");
$html->fin();

Explication:

Le fichier module commence simplement avec une instruction package qui donne le nom du module. Le nom doit être identique à celui du module sans extension. Si le fichier module donc s'appelle comme dans l'exemple HTMLprint.pm, l'instruction doit alors être package HTMLprint;.

Le fichier module de l'exemple contient au total cinq sous-programmes. Le premier d'entre eux est la fonction construction. Elle reçoit habituellement le nom new, mais pourrait aussi théoriquement recevoir un autre nom. Comment est bâtie le fonction construction peut varier d'un cas à l'autre. Dans tous les cas, la fonction construction doit contenir un appel de la fonction bless . Celle-ci lie une référence à une classe, de façon à ce qu'ensuite il puisse être accédé à cet objet par cette référence. La fonction construction montrée dans l'exemple ci-dessus en fait certes déjà un peu plus qu'il n'est nécessaire à l'exemple, mais est cependant bien appropriée sous cette forme comme fonction de construction standard avec laquelle on ne peut pas faire grand chose de faux.

Avec my $objet = shift; le premier paramètre que la fonction de construction new se voit transmettre, est simplement lu. Elle reçoit à vrai dire comme premier paramètre transmis quand elle est appelée automatiquement le nom de classe, dans l'exemple donc le nom HTMLprint. C'est dans l'exemple la valeur qui figure ensuite dans $objet.
Avec my $reference = {}; une référence, est déclarée à savoir un pointeur. Ce pointeur est nécessaire pour que la fonction bless puisse être utilisée correctement et puisse lier le pointeur à l'objet. Maintenant se pose la question comment faire de la variable scalaire $reference une référence. Il faut bien qu'elle se réfère à ce qu'elle désigne. L'affectation {} est idéale pour le faire. C'est simplement une référence à un Hash vide et sans nom. C'est idéal pour la simple raison que ce hash est également approprié pour la définition des données d'objet, ce qui n'est de toutes façons pas encore le cas dans ce premier exemple simple. Ainsi on en reste au hash vide et $reference est un pointeur.
Avec bless($reference,$objet); la liaison nécessaire entre la référence et l'objet est réalisée. Ensuite $reference est retournée.

Les quatre autres sous-programmes dans le fichier module HTMLprint.pm sont tous très semblables. Ils créent à l'aide d'instructions print du code HTML. Le sous-programme commencement écrit d'abord l'entête HTTP nécessaire pour les sorties HTML à un navigateur appelant.

Pour tous les sous-programmes qui fonctionnent comme méthodes d'un objet, s'applique ceci: ils se voient transmettre au moins un paramètre, à savoir le pointeur sur l'objet qui a été créé et lié à l'objet dans la fonction de construction. Les sous-programmes de l'exemple n'ont pas besoin de ce pointeur. Mais commencement, titre et texte attendent encore un deuxième paramètre tout à fait ordinaire, à savoir le contenu qu'ils doivent sortir en HTML. Maintenant, les sous-programmes peuvent se chercher également le contenu de ce deuxième paramètre directement avec $_[1]. Mais la notation avec l'appel de la fonction shift présente l'avantage de traiter proprement et dans l'ordre la liste de paramètres en les effaçant après traitement. Avec le deuxième appel respectif de shift les trois sous-programmes mentionnés accèdent donc au deuxième paramètre.

Il est encore important de mentionner que les fichiers module pm doivent toujours contenir à la fin une instruction isolée 1; (ou quelque chose de similaire). Cela signifie que le fichier module renvoie une valeur vrai. Faute de quoi l'interpréteur Perl annoncerait une erreur.

Le script Perl proprement dit dans l'exemple est à vrai dire tout à fait simple. Avec la fonction use et l'instruction use HTMLprint; il incorpore le fichier module HTMLprint.pm. Incorporé sous cette forme, le fichier HTMLprint.pm doit se trouver soit dans le même répertoire que le script ou bien dans l'un des répertoires centraux dans lesquels Perl recherche les modules (de plus amples détails à ce sujet dans la partie traitant de l' emplacement de sauvegarde des modules et de la liste @INC).

Avec my $html = HTMLprint -> new(); la fonction de construction du fichier module est appelée. C'est l'instruction déterminante avec laquelle une nouvelle instance de l'objet HTMLprint est créée! L'instruction consiste à déclarer une scalaire qui dans l'exemple reçoit pour nom $html, et à l'initialiser avec une valeur. La valeur affectée consiste à faire pointer le nom de la classe d'objet désirée donc HTMLprint, à l'aide de l'opérateur flèche -> sur la fonction de construction new. Étant donné que la fonction de construction renvoie une référence qui est liée à l'objet par l'appel de bless, $html est automatiquement une référence, donc un pointeur sur l'instance objet nouvellement créée. Par $html et l'opérateur flèche -> peut continuer à accéder aux sous-programmes du module incorporé. Dans le contexte objets, on ne parle néanmoins plus de sous-programmes mais de méthodes.
Avec une instruction telle que $html->commencement("Perl tout à fait élégant"); le script accède donc à une méthode de l'objet HTMLprint, à savoir à l'instance de l'objet liée au pointeur $html.

Exemple avec des données d'objet: l'objet VCard

L'exemple suivant montre comment des données se laissent gérer avec des objets. Il s'agit ici de données d'adresses dans le format standard international VCard (extension typique de fichier: *.vcf), tel qu'il est développé par l' Internet Mail Consortium (IMC). Dans le fichier module VCard.pm sont définies la classe VCard ainsi que les données d'objet et les méthodes. Dans le script principal, deux instances objet de cette classe sont définies et les méthodes de l'objet sont essayées.

Exemple du fichier module `VCard.pm`:

package VCard;

$objets = 0;

sub new {
 my $objet = shift;
 my $Version = shift;
 my $reference = {};
 bless($reference,$objet);
 $objets += 1;
 $reference->VCinit($Version);
 return($reference);
}

sub VCinit {
  my $objet = shift;
  my $Version = shift;
  $objet->{BEGIN} = "VCARD";
  $objet->{VERSION} = $Version;
  $objet->{END} = "VCARD";
}

sub VCset {
  my $objet = shift;
  my $clef = shift;
  my $valeur = shift;
  $objet->{$clef} = $valeur;
}

sub VCget {
  my $objet = shift;
  my $clef = shift;
  return($objet->{$clef});
}

sub VCsave {
  my $objet = shift;
  my $fichier = shift;
  open(FICHIER, ">$fichier") or return(-1);
  print FICHIER "BEGIN:VCARD\nVERSION:$objet->{VERSION}\n";
  while ((my $clef, my $valeur) = each %{ $objet } ) {
    next if ($clef eq 'BEGIN' or $clef eq 'VERSION' or $clef eq 'END');
    $clef =~ s/_/\;/g;
    print FICHIER "$clef:$valeur\n";
  }
  print FICHIER "END:VCARD\n";
  close(FICHIER);
  return($fichier);
}

sub VCopen {
  my $objet = shift;
  my $fichier = shift;
  $objet->VCreset();
  open(FICHIER, "<$fichier") or return;
  my @lignes = <FICHIER>;
  close(FICHIER);
  foreach (@lignes) {
   (my $clef, my $valeur) = split(/:/);
    $clef =~ s/\;/_/g;
    $objet->{$clef} = $valeur;
  }
  return( %{ $objet } );
}

sub VCreset {
  my $objet = shift;
  %{ $objet } = ();
}

1;

Exemple d'un script CGI complet en Perl:

#!/usr/bin/perl -w

use strict;
use CGI::Carp qw(fatalsToBrowser);
use VCard;

print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
print "<h1>Tests avec l'objet VCard</h1>\n";

my $Thomas = VCard->new("2.1");
my $Delphine = VCard->new("2.1");

print "<p><b>Valeur de la propri&eacute;t&eacute; d'objet BEGIN cr&eacute;&eacute;e dans le module:</b> $Delphine->{BEGIN}<br>\n";
my $Sauvegarde = $Delphine->{BEGIN};
$Delphine->{BEGIN} = "Commen&ccedil;ons";
print "<b>BEGIN apr&egrave;s la modification de valeur:</b> $Delphine->{BEGIN}<br>\n";
$Delphine->{BEGIN} = $Sauvegarde;
print "&Eacute;tant donn&eacute; que cela n'a pas grand sens,
la valeur a &eacute;t&eacute; fix&eacute;e &agrave; '$Delphine->{BEGIN}'.</p>\n";

$Thomas->VCset("FN","Thomas Thuvu");
$Thomas->VCset("TEL_CELL_VOICE","(0170) 398373740");
$Delphine->VCset("FN","Delphine Naliste");
$Delphine->VCset("EMAIL_PREF_INTERNET","naliste\@football.org");

print "<p><b>Nom:</b> ",$Thomas->VCget('FN'),"<br>\n";
print "<b>Handy:</b> ",$Thomas->VCget('TEL_CELL_VOICE'),"</p>\n";
print "<p><b>Nom:</b> ",$Delphine->VCget('FN'),"<br>\n";
print "<b>Portable:</b> ",$Delphine->VCget('EMAIL_PREF_INTERNET'),"</p>\n";
print "<p><b>Nombre d'objets définis:</b> $VCard::objets </p>\n";


if(my $fichier = $Thomas->VCsave("/donnees/vcard/thuvu.vcf")) {
 print "<p>VCard de Thomas Thuvu est sauvegardé dans <tt>$fichier</tt>!<br>"
}
else {
 print "VCard de Thomas Thuvu n'a pas pu &ecirc;tre sauvegard&eacute;!";
}
$Thomas->VCreset();
print "<p><b>Nom de Thomas apr&egraves initialisation de l'objet:</b> ",$Thomas->VCget('FN'),"<br>\n";
print "<b>Portable de Thomas apr&egraves initialisation de l'objet:</b> ",$Thomas->VCget('TEL_CELL_VOICE'),"</p>\n";

if($Thomas->VCopen("/donnees/vcard/thuvu.vcf")) {
 print "VCard de Thomas Thuvu est &agrave; nouveau ouvert!<br>";
 print "<p><b>Nom de Thomas apr&egraves l'ouverture du fichier:</b> ",$Thomas->VCget('FN'),"<br>\n";
 print "<b>Portable de Thomas apr&egraves l'ouverture du fichier:</b> ",$Thomas->VCget('TEL_CELL_VOICE'),"</p>\n";
}
else {
 print "VCard von Thomas Thuvu n'a pas pu &ecirc;tre ouvert!";
}

print "</body></html>\n";

Exemple du fichier créé `thuvu.vcf`:

BEGIN:VCARD
VERSION:2.1
TEL;CELL;VOICE:(0170) 398373740
FN:Thomas Thuvu
END:VCARD

Explication:

Sur le principe, cet exemple fonctionne exactement comme l'exemple avec l' objet HTMLprint - c'est pourquoi ne sont intéressantes ici que les choses qui diffèrent du premier exemple.

Les données d'objet (ou les propriétés d'un objet) sont des variables. Il ne suffit pourtant pas de déclarer simplement ces variables n'importe où dans le fichier module. Une variable comme la scalaire $objets, qui dans l'exemple est déclarée au début du fichier module VCard.pm et qui sert de compteur pour les instances objets, ne fait pas partie des données d'objet! Ces variables sont ce qu'on appelle des variables de classe, étant donné qu'elles ne sont disponibles qu'une fois pour la classe complète et pour chaque instance objet. Étant donné que le module est incorporé exactement une fois dans le script principal, ces variables ne sont également disponibles que dans une seule exécution. Le script principal peut tout à fait avec la syntaxe $VCard::objets accéder à la valeur de la scalaire $objets. Mais cette variable ne fait pas partie pour autant de l'objet. Les données d'objet sont davantage celles qui à chaque nouvelle instance d'un objet sont à nouveau disponibles.

La solution la plus simple pour les données d'objet est la Hash. Dans la fonction de construction new un tel hash est défini - avec l'instruction my $reference = {};. On ne voit pas grand chose du hash ici. Cependant les parenthèses accolades vides symbolise un hash vide que l'on dit anonyme. Ce hash est une espèce de conteneur vide qui pourra plus tard enregistrer les données d'objet. La raison pour laquelle on choisit un hash en règle générale pour les données d'objet, est que le hash peut sauvegarder un nombre dynamique de données. Un tel hash permet de prédéfinir des données d'objet aussi bien dans le module lui-même que dans le script principal (les deux cas sont exposés dans l'exemple ci-dessus). Un Array le pourrait certes théoriquement aussi mais la recherche de la date objet désirée dans le script principal serait ensuite plus compliquée. Les hashes facilitent l'accès direct aux données par la clé nommée. Par l'affectation du hash anonyme à une scalaire - dans l'exemple à $reference - cette scalaire est une référence, donc un pointeur sur le hash anonyme. Par ce pointeur l'accès au hash anonyme est rendu possible.

Les données d'objet sont créées en remplissant dans un premier temps le hash anonyme de la fonction de construction avec des données. Dans l'exemple, cela se fait d'abord dans le sous-programme ou plutôt la méthode VCinit. Cette méthode est déjà appelée dans la fonction de construction new, à savoir avec $reference->VCinit($Version);. Comme dans la fonction de construction $reference est le pointeur d'objet, vous pouvez y appeler d'autres sous-programmes selon le schéma $reference->Methode(); ils seront ainsi liés à l'objet. Par cette forme d'appel les sous programmes reçoivent aussi toujours automatiquement comme premier paramètre transmis, un pointeur sur l'objet, avec lequel elles peuvent ensuite travailler. Il en va de même pour la méthode VCinit de l'exemple. Par le pointeur d'objet qu'elle va se chercher dans la liste des paramètres transmis avec my $objet = shift;, elle peut ensuite accéder à l'objet et également par là même au hash anonyme.

Avec une instruction telle que $objet->{BEGIN} = "VCARD"; une propriété d'objet est créée. $objet->{BEGIN} pointe sur le hash anonyme et revient à dire: "Ainsi le hash anonyme reçoit une clé du nom de BEGIN". Par ailleurs, une valeur a déjà été affectée à cette clé, à savoir VCARD. De la même manière trois propriétés d'objet en tout sont créées dans VCinit. Les deux autres s'appellent VERSION et END. La raison pour ces noms est dans l'exemple que celui-ci utilise comme noms de clé les noms de propriétés qu'un fichier du type .vcf peut contenir. À quoi un tel fichier ressemble, c'est ce que vous voyez dans le fichier thuvu.vcf . Chaque ligne d'un fichier VCard comporte une propriété et sa valeur séparées par deux points. Trois lignes doivent figurer dans chaque fichier vcf: BEGIN:VCARD, VERSION:[mention de version] et END:VCARD. Pour ces trois lignes standard, sont créées dans l'exemple trois propriétés d'objet du même nom.

D'autres propriétés d'objet sont créées dans le script principal de l'exemple. Tout d'abord il faut à nouveau pour le faire créer une instance de la classe VCard. Dans l'exemple deux instances sont créées:
my $Thomas = VCard->new("2.1"); my $Delphine = VCard->new("2.1"); À l'appel de la fonction de construction, le numéro de version pour le format VCard désiré est transmis. Pour l'heure les versions 2.1 et 3.0 ont cours.
Après que les deux instances d'objet sont créées, l'accès à toutes les données d'objet est possible. Dans le script principal, c'est ce qui est d'abord démontré avec l'objet pour Delphine. Par le pointeur d'objet $Delphine il est possible, avec $Delphine->{BEGIN} d'accéder à la propriété d'objet BEGIN. Le script montre aussi comment une telle propriété d'objet peut être modifiée. La construction $Delphine->{BEGIN} peut être traitée comme une scalaire tout à fait normale.
Comme pour la programmation orientée sur l'objet, celui-ci est une entité abstraite dont le contenu ne vous concerne à vrai dire en rien en tant qu'utilisateur, vous devez renoncer à accéder directement aux propriétés d'objet. D'abord rien ne dit que pour un objet (quelconque) les données seront tenues dans un hash et ensuite, la tenue de ces données peut varier avec l'évolution des différentes versions du module.

Le script principal crée aussi encore d'autres nouvelles propriétés d'objet en leur donnant une valeur. Car un fichier VCard doit bien contenir différentes données d'adresse. Cela est possible dans l'exemple par l'appel de la méthode VCset, définie dans le fichier module. Avec une instruction comme:
$Thomas->VCset("FN","Thomas Thuvu");
une nouvelle propriété d'objet nommée FN est créée pour l'objet de Thomas, et reçoit la valeur Thomas Thuvu. Dans l'exemple, vous voyez que tant l'objet de Thomas que l'objet de Delphine reçoivent la propriété d'objet FN, chacun avec sa valeur propre. On peut très bien y reconnaître qu'il s'agit effectivement de différentes instances de l'objet VCard, et que chaque instance a son propre ensemble de données sans qu'il y ait de collision avec d'autres instances de l'objet existant en même temps-.

Tandis que l'appel de la méthode VCset peut être à peu près bien retracé, ce qui se passe dans le fichier module à l'intérieur de cette méthode, n'est pas si facile à comprendre. VCset - comme toutes les méthodes - reçoit automatiquement comme premier paramètre transmis le pointeur d'objet. VCset ne fait rien d'autre qu'insérer un nom de clé et sa valeur dans le hash anonyme avec $objet->{$clef} = $valeur. Tous deux donc le nom de clé et sa valeur, sont attendus comme paramètres par la méthode - ce qui explique les instructions qui précèdent telles que $clef = shift;. Les appels de cette méthode dans le script principal transmettent aussi les deux paramètres requis.

Les autres méthodes du fichier module sont construites de façon très similaires. Elles prennent en charge différentes tâches que l'on peut envisager avec des données adresse:
VCget donne la valeur correspondant à une clé. Pratique pour des requêtes. Pour être précis une requête telle que $Thomas->VCget('FN') dans le script principal revient au même que s'il y figurait. $Thomas->{FN}. Quant à savoir si on a besoin de ces méthodes relève simplement de la conception d'un objet. Pour faciliter la maintenance du programme, vous devez cependant toujours mettre à disposition des méthodes à cet effet.
VCsave sauvegarde les données d'un objet dans un fichier .vcf et d'après le standard VCF. Dans le script cette fonction est appelée une fois pour écrire le fichier thuvu.vcf, dont le contenu est représenté.
VCopen lit un fichier VCF quelconque et sauvegarde son contenu dans l'objet affecté. Vous pouvez donc utiliser cette méthode quand vous avez des fichiers VCF existants, par exemple par l'exportation à partir des données adresse d'un programme de courrier électronique compatible VCard. VCreset efface toutes les données d'un objet. Cette méthode rétablit donc l'état d'origine du hash anonyme. Cette méthode est nécessaire dans le fichier module dans VCopen. Mais vous pouvez naturellement aussi appeler cette méthode dans le script principal pour mettre une instance d'objet dans son état vierge. Dans le script principal de l'exemple ci dessus, la démonstration en est faite sur l'objet de Thomas.

Si vous voulez utiliser dans la pratique l'objet VCard de l'exemple, il vous faut connaître les noms de propriétés VCard. Ceux-ci sont documentés par l'Internet Mail Consortium. Il est important de toujours remplacer un point virgule par un tiret de soulignement. Ainsi une propriété VCard comme TEL;CELL;VOICE est notée, lors de l'appel d'une méthode comme VCset, comme TEL_CELL_VOICE. Quelques unes des propriétés Vcard possibles contiennent également encore d'autres signes comme = et -. Pour traiter celles-ci correctement, vous devez sans doute encore étendre les méthodes VCopen et VCsave de l'objet ce à quoi il a été renoncé dans l'exemple pour des raisons de simplification.