Section courante

A propos

Section administrative du site

Les premiers pas

Et pour les problèmes complexes exigeant des structures de données complexes, les déclarations sont une bonne idée. Mais pour de nombreux problèmes simples et quotidiens, vous voudriez un langage de programmation dans lequel vous pouvez simplement dire :

  1. print "Bonjour, tout le monde !\n" ; 

et attendez-vous à ce que le programme fasse exactement cela. Le langage de programmation Perl est un tel langage. En fait, cet exemple est un programme complet, et si vous le fournissez à l'interpréteur Perl, il affichera «Bonjour, tout le monde !» sur votre écran. (Le «\n» dans l'exemple produit une nouvelle ligne à la fin de la sortie.) Et c'est tout. Vous n'avez pas à dire grand-chose après avoir dit ce que vous voulez dire non plus. Contrairement à de nombreux langages de programmation, Perl pense que la fin de votre programme n'est qu'un moyen normal de quitter le programme. Vous pouvez certainement appeler explicitement la fonction exit si vous le souhaitez, tout comme vous pouvez déclarer certaines de vos variables, ou même vous forcer à déclarer toutes vos variables. Mais c'est votre choix. Avec le langage de programmation Perl, vous êtes libre de faire la bonne chose, quelle que soit la manière dont vous vous souciez de la définir.

Langages naturelles et artificielles

Les langages ont d'abord été inventées par les humains, au profit des humains. Dans les annales de l'informatique, ce fait a parfois été oublié. Depuis que Perl a été conçu (en gros) par un linguiste occasionnel, il a été conçu pour fonctionner de la même manière que le langage naturel fonctionne sans coups. Naturellement, cela comporte de nombreux aspects, car le langage naturel fonctionne bien à plusieurs niveaux simultanément. Nous pourrions énumérer plusieurs de ces principes linguistiques ici, mais le principe le plus important de la conception du langage est que les choses faciles doivent être faciles et que les choses difficiles doivent être possibles. (En fait, ce sont deux principes.) Ils peuvent vous sembler évidents, mais de nombreux langages informatiques échouent à l'un ou l'autre. Les langues naturelles sont bonnes dans les deux cas parce que les gens essaient continuellement d'exprimer à la fois des choses faciles et évolue pour gérer les deux. Le Perl a d'abord été conçu pour évoluer, et en effet il a évolué. De nombreuses personnes ont contribué à l'évolution de Perl au fil des ans.

Maintenant, quand quelqu'un prononce le mot "linguistique", beaucoup de gens se concentrent sur l'une des deux choses. Soit ils pensent à des mots, soit ils pensent à des phrases. Mais les mots et les phrases ne sont que deux façons pratiques de «fragmenter» le discours. L'une ou l'autre peut être décomposée en unités de signification plus petites ou combinées en unités de signification plus grandes. Et la signification de toute unité dépend fortement du contexte syntaxique, sémantique et pragmatique dans lequel l'unité est située. La langue naturelle a des mots de différentes sortes : des noms et des verbes et autres. Si quelqu'un dit «chien» de façon isolé, vous le considérez comme un nom, mais vous pouvez également utiliser le mot d'autres manières. C'est-à-dire qu'un nom peut fonctionner comme un verbe, un adjectif ou un adverbe lorsque le contexte l'exige, différemment selon les contextes.

La plupart des langages informatiques font cette distinction, seulement nous appelons l'un particulier une valeur et le générique une variable. Une valeur existe juste quelque part, qui sait où, mais une variable est associée à une ou plusieurs valeurs au cours de sa durée de vie. Ainsi, celui interprétant la variable doit garder une trace de cette association. Cet interprète peut être dans votre cerveau ou dans votre ordinateur.

Syntaxe des variables

Une variable est juste un endroit pratique pour garder quelque chose, un endroit avec un nom, donc vous savez où trouver votre quelque chose de spécial lorsque vous revenez le chercher plus tard. Comme dans la vraie vie, il existe différents types d'endroits pour entreposer des choses, certains d'entre eux plutôt privés, et d'autres en public. Certains endroits sont temporaires et d'autres sont plus permanents. Les informaticiens adorent parler de la «portée» des variables, mais c'est tout ce qu'ils entendent par là. Le Perl dispose de divers moyens pratiques pour traiter les problèmes de cadrage.

Mais un moyen plus immédiatement utile de classer les variables est le type de données qu'elles peuvent contenir. Comme en anglais, la principale distinction de type de Perl est entre les données singulières et plurielles. Les chaînes de caractères et les nombres sont des données singulières, tandis que les listes de chaînes de caractères ou de nombres sont au pluriel. (Et quand nous arrivons à la programmation orientée objet, vous constaterez que l'objet typique semble singulier de l'extérieur mais pluriel de l'intérieur, comme une classe d'étudiants.) Nous appelons une variable singulière un scalaire et une variable plurielle un tableau. Puisqu'une chaîne de caractères peut être entreposée dans une variable scalaire, nous pourrions écrire une version légèrement plus longue (et commentée) de notre premier exemple comme ceci :

  1. my $phrase = "Salut Gladir.com !\n";       # Créer une variable
  2. print $phrase;                             # Affiche la variable

Le mot réservé my indique à Perl que $phrase est une toute nouvelle variable, il ne devrait donc pas en chercher une existante. Notez que nous n'avons pas besoin d'être très précis sur le type de variable $phrase. Le caractère $ indique à Perl que la phrase est une variable scalaire, c'est-à-dire une variable contenant une valeur singulière. Une variable de tableau, en revanche, commencerait par un caractère @. (Cela peut vous aider à vous rappeler qu'un $ est un «s» stylisé pour «scalaire», tandis que @ est un «a» stylisé pour «tableau».)

Le Perl a d'autres types de variables, avec des noms improbables comme «hash», «handle» et «typeglob». Comme les scalaires et les tableaux, ces types de variables sont également précédés de caractères amusants, communément appelés sigils. Pour être complet, le tableau suivant répertorie tous les sigils que vous rencontrerez :

Type Sigil Exemple Est un nom pour
Scalaire $ $cents Une valeur individuelle (nombre ou chaîne de caractères)
Tableau @ @large Une liste de valeurs, codées par numéro
Haché % %interet Un groupe de valeurs, saisies par chaîne de caractères
Sous-routine & &comment Un morceau appelé de code Perl
Typeglob * *structure Tout ce qui est nommé a frappé

Certains puristes du langage de programmation désignent ces sigils comme une raison de détester Perl. C'est superficiel. Les sigils présentent de nombreux avantages, notamment le fait que les variables peuvent être interpolées en chaînes de caractères sans syntaxe supplémentaire. Les scripts Perl sont également faciles à lire car les noms se démarquent des verbes. Et de nouveaux verbes peuvent être ajoutés au langage sans casser les anciens scripts. (Nous vous avons dit que Perl a été conçu pour évoluer.) Et l'analogie des noms n'est pas frivole - il existe de nombreux précédents en anglais et dans d'autres langues pour exiger des marqueurs grammaticaux.

Singularités

D'après notre exemple précédent, vous pouvez voir que les scalaires peuvent recevoir une nouvelle valeur avec l'opérateur =, tout comme dans de nombreux autres langages informatiques. Les variables scalaires peuvent être affectées à n'importe quelle forme de valeur scalaire : entiers, nombres à virgule flottante, chaînes de caractères et même des éléments ésotériques comme des références à d'autres variables ou à des objets. Il existe de nombreuses façons de générer ces valeurs pour l'affectation. Comme dans l'interpréteur de commande Unix, vous pouvez utiliser différents mécanismes de citation pour créer différents types de valeurs. Les guillemets doubles (guillemets doubles) effectuent une interpolation de variable et une interpolation de barre oblique inverse (comme transformer \n en une nouvelle ligne), tandis que les guillemets simples suppriment l'interpolation. Et les guillemets arrière (ceux penchant vers la gauche) exécuteront un programme externe et renverront la sortie du programme, vous pouvez donc la capturer comme une seule chaîne de caractères contenant toutes les lignes de sortie.

  1. my $reponse = 42;                      # Un entier
  2. my $pi = 3.14159265;                   # Un nombre réel
  3. my $avocats = 6.02e23;                 # Notation scientifique
  4. my $animal = "Chameau";                # Chaîne de caractères
  5. my $signe = "J'ai l'animal $animal";   # Chaîne de caractères avec interpolation
  6. my $cout = 'Il coute $100';            # Chaîne de caractères sans interpolation
  7. my $dela = $dou;                       # La valeur d'une autre variable
  8. my $salsa = $moles * $avocats;         # Une expression gastrochimique
  9. my $sortie = system("vi $file");       # État numérique d'une commande
  10. my $cwd = `pwd`;                       # Sortie de chaîne d'une commande

Il également possible que les scalaires contiennent des références à d'autres structures de données, y compris des sous-routines et des objets :

  1. my $tbl1 = \@montableau;               # Référence à un tableau nommé
  2. my $hch1 = \%monhach;                  # Référence à un hachage nommé
  3. my $routine1 = \&maroutine;            # Référence à un sous-programme nommé
  4. my $tbl2 = [1,2,3,4,5];                # Référence à un tableau sans nom
  5. my $hch2 = {Na => 19, Cl => 35};       # Référence à un hachage sans nom
  6. my $routine2 = sub { print $state };   # Référence à un sous-programme sans nom
  7. my $fido = Chameau->new("Amélie");     # référence à un objet

Lorsque vous créez une nouvelle variable scalaire, mais avant de lui affecter une valeur, elle est automatiquement initialisée avec la valeur que nous appelons undef, qui, comme vous pouvez le deviner, signifie «non définie». Selon le contexte, cette valeur indéfinie peut être interprétée comme une valeur nulle légèrement plus définie, telle que "" ou 0. Plus généralement, selon la façon dont vous les utilisez, les variables seront interprétées automatiquement comme des chaînes de caractères, comme des nombres ou comme "true" et "false" (communément appelées valeurs booléennes). Rappelez-vous à quel point le contexte est important dans les langues humaines. En Perl, divers opérateurs attendent certains types de valeurs singulières comme paramètres, nous parlerons donc de ces opérateurs comme «fournissant» un contexte scalaire à ces paramètres. Parfois, il est plus précis de dire qu'il fournit un contexte numérique, un contexte de chaîne de caractères ou un contexte Boolean à ces paramètres. Le Perl convertira automatiquement les données dans la forme requise par le contexte actuel, dans la limite de la raison. Par exemple, supposons que vous disiez ceci :

  1. my $chameau = "123";
  2. print $chameau + 1, "\n"

La première valeur attribuée à $chameau est une chaîne de caractères, mais elle est convertie en un nombre pour y ajouter 1, puis reconvertie en une chaîne de caractères à afficher sous la forme 124. La nouvelle ligne, représentée par "\n", est également dans la chaîne de caractères de contexte, mais comme c'est déjà une chaîne de caractères, aucune conversion n'est nécessaire. Mais notez que nous devions utiliser des guillemets doubles ici - utiliser des guillemets simples pour dire '\n' entraînerait une chaîne de deux caractères composée d'une barre oblique inverse suivie d'un "n", qui n'est pas une nouvelle ligne selon la définition de quiconque. un sens, les guillemets doubles et les guillemets simples sont encore une autre façon de spécifier le contexte. L'interprétation des entrailles d'une chaîne de caractères entre guillemets dépend des guillemets que vous utilisez. (Plus tard, nous verrons d'autres opérateurs fonctionnant comme des guillemets, mais utilisent la chaîne de caractères d'une manière spéciale, comme pour la correspondance de motifs ou la substitution. Ils fonctionnent tous aussi comme des chaînes de caractères entre guillemets. Le contexte de guillemets doubles est le " de Perl, et il est fourni par de nombreux opérateurs ne ressemblant pas à des guillemets doubles.) De même, une référence se comporte comme une référence lorsque vous lui donnez un contexte de déréférencement, mais agit autrement comme une simple valeur scalaire. Par exemple, on pourrait dire :

  1. my $fido = Chameau->new("Amélie");
  2. if (not $fido) { 
  3.   die "Chameau terminer"; 
  4. }
  5. $fido->saddle();

Ici, nous créons une référence à un objet Chameau et la mettons dans une nouvelle variable, $fido. Sur la ligne suivante, nous testons $fido en tant que Boolean scalaire pour voir s'il est «true», et nous lançons une exception (c'est-à-dire que nous nous plaignons) si ce n'est pas vrai, ce qui dans ce cas signifierait que le Chameau-> le nouveau constructeur n'a pas réussi à créer un objet Chameau approprié. Mais sur la dernière ligne, nous traitons $fido comme une référence en lui demandant de rechercher la méthode selle pour l'objet contenu dans $fido, se trouvant être un Chameau, donc Perl recherche la méthode selle pour les objets Chameau.



Dernière mise à jour : Jeudi, le 17 janvier 2019