Section courante

A propos

Section administrative du site

 Langage  Installation  Elément  Tutoriel  Programmation  Bibliothèque  Cadre d'application  IDE  Annexe  Aide 
ABAP/4
Ada
Assembleur
Assembly & bytecode
ASP (Active Server Pages)
Basic
C
C++
C# (C Sharp)
Cobol
ColdFusion
Fortran
HTML
Java
JavaScript
LISP
Logo
LotusScript
Oberon
Pascal
Perl
PHP
PL/1
Prolog
Python
Rebol
REXX
Ruby
Rust
SAS
NoSQL
SQL
Swift
X++ (Axapta)
GNAT
SMALLAda
VHDL
Assembleur 370
Assembleur 1802
Assembleur 4004
Assembleur 6502
Assembleur 6800
Assembleur 68000
Assembleur 8080 et 8085
Assembleur 8089
Assembleur 80x86
Assembleur AGC4
Assembleur ARM
Assembleur DPS 8000
Assembleur i860
Assembleur Itanium
Assembleur MIPS
Assembleur PDP-11
Assembleur PowerPC
Assembleur RISC-V
Assembleur SPARC
Assembleur SuperH
Assembleur UNIVAC I
Assembleur VAX
Assembleur Z80
Assembleur Z8000
Assembleur z/Architecture
ASSEMBLER/MONITOR 64
Micol Assembler
GFA Assembler
A86
MASM (Macro Assembler)
TASM (Turbo Assembler)
CIL
Jasmin
LLVM
MSIL
Parrot
P-Code (PCode)
SWEET16
G-Pascal
ASP 1.0
ASP 2.0
ASP 3.0
ASP.NET
ASP.NET Core
ABasiC (Amiga)
Adam SmartBASIC
Altair BASIC
AmigaBASIC (Amiga)
AMOS Basic (Amiga)
Atari Basic (Atari 400, 600 XL, 800, 800XL)
Basic Apple II (Integer BASIC/APPLESOFT)
Basic Commodore 64 (CBM-BASIC)
Basic Commodore 128 (BASIC 7.0)
Basic Commodore VIC-20 (CBM-BASIC 2.0)
Basic Coco 1 (Color Basic)
Basic Coco 2 (Extended Color Basic)
Basic Coco 3 (Extended Color Basic 2.0)
BASICA (PC DOS)
Basic Pro
BBC BASIC
Blitz BASIC (Amiga)
DarkBASIC
Dartmouth BASIC
GFA-Basic (Atari ST/Amiga)
GWBASIC (MS-DOS)
Liberty BASIC
Locomotive BASIC (Amstrad CPC)
MSX-Basic
Omikron Basic (Atari ST)
Oric Extended Basic
Power Basic
Quick Basic/QBasic (MS-DOS)
Sinclair BASIC (ZX80, ZX81, ZX Spectrum)
ST BASIC (Atari ST)
Turbo Basic
Vintage BASIC
VBScript
Visual Basic (VB)
Visual Basic .NET (VB .NET)
Visual Basic pour DOS
Yabasic
BeckerBASIC
SIMONS' BASIC
Basic09 d'OS-9
Disk Extended Color Basic
Basic09 d'OS-9
Disk Extended Color Basic
Access
Excel
Visual Basic pour Windows
Visual Basic .NET pour Windows
C Shell Unix (csh)
C pour Amiga
C pour Atari ST
C pour DOS
C pour Falcon030
C pour GEMDOS (Atari ST)
C pour Linux
C pour PowerTV OS
C pour OS/2
C pour Unix
C pour Windows
Aztec C
CoCo-C
GNU C
HiSoft C
IBM C/2
Introl-C
Lattice C
Microsoft C
MinGW C
MSX-C
Open Watcom C
OS-9 C Compiler
Pure C
Quick C
Turbo C
HiSoft C for Atari ST
HiSoft C for CP/M (Amstrad CPC)
C++ pour OS/2
C++ pour Windows
Borland C++
C++Builder
IBM VisualAge C++
Intel C++
MinGW C++
Open Watcom C++
Symantec C++
Turbo C++
Visual C++
Visual C++ .NET
Watcom C++
Zortech C++
C# (C Sharp) pour Windows
Apple III Cobol
Microsoft Cobol
BlueDragon
Lucee
OpenBD
Railo
Smith Project
Microsoft Fortran
WATFOR-77
CSS
FBML
Open Graph
SVG
XML
XSL/XSLT
LESS
SASS
GCJ (GNU)
JSP
Jython
Visual J++
Node.js
TypeScript
AutoLISP
ACSLogo
LotusScript pour Windows
Amiga Oberon
Oberon .NET
Apple Pascal
Delphi/Kylix/Lazarus
Free Pascal
GNU Pascal
HighSpeed Pascal
IBM Personal Computer Pascal
Lisa Pascal
Maxon Pascal
MPW Pascal
OS-9 Pascal
OSS Personal Pascal
Pascal-86
Pascal du Cray Research
Pascal/VS
Pascal-XT
PURE Pascal
QuickPascal
RemObjets Chrome
Sun Pascal
THINK Pascal
Tiny Pascal (TRS-80)
Turbo Pascal
UCSD Pascal
VAX Pascal
Virtual Pascal
Turbo Pascal for CP/M-80
Turbo Pascal for DOS
Turbo Pascal for Macintosh
Turbo Pascal for Windows
CodeIgniter (Cadre d'application)
Drupal (Projet)
Joomla! (Projet)
Phalanger (PHP .NET)
phpBB (Projet)
Smarty (balise)
Twig (balise)
Symfony (Cadre d'application)
WordPress (Projet)
Zend (Cadre d'application)
PL360
PL/M-80
PL/M-86
Turbo Prolog
CPython
IronPython
Jython
PyPy
AREXX
Regina REXX
JMP
Btrieve
Cassandra
Clipper
CouchDB
dBASE
Hbase
Hypertable
MongoDB
Redis
Access
BigQuery
DB2
H2
Interbase
MySQL
Oracle
PostgreSQL
SAP HANA
SQL Server
Sybase
U-SQL
Installation sous le système d'exploitation Windows XP
Introduction
Les remarques
Les opérateurs
Les expressions régulières (regex)
Les types de données
Les instuctions conditionnelles
Les instructions de boucles
Définition de fonction
Référence de fonctions
Référence de pragmas
Référence de modules
Catégorie
Exécution
Fichier
Hachage
Liste
Mathématique
Processus
Scalaires
Tableau
Taille fixe
Trigonométrie
Les premiers pas
Bonjour
Astronomie
Base de données
Biochimie
Colorimétrie
Conversion
Fichier
Finance
Fractale
Géographie
Géométrie
Gouvernement
Histoire
Jeux & stratégies
Mathématique
Médicale
Météorologie
Océanographie
Sport
Temps
Tri
Trigonométrie
Validation
Web
Phase lunaire
Table MySQL
Formulaire MySQL
Calcul du calcium corrigé
Calcul le taux d'alcoolémie
Boite en 3D de couleur RVB
Bin,Hex,Base62,...
Lecture d'un fichier texte séquentiel
Ecriture d'un fichier texte séquentiel
IPaymt/Interet
NPer
PPaymt/Principal
Triangle de «Sierpinski»
Distance en Km entre deux longitudes et latitudes
Aire d'un cercle
Aire d'une surface de prisme rectangulaire
Aire d'un triangle
Distance entre deux points
Treillis
Taxe de vente canadienne
Chiffre romain
Tours d'Hanois
Ackermann
Exp
Factoriel
Fibonacci
Log
Nombre premier
Odd
Random
Sqrt
Triangle Pascal
Hauteur utérine
Unité de mesure
Fréquence des vagues
Hockey
Année bissextile
Calendrier
Date de la Pâque
Heure courante
FirstDayOfMonth
Horloge à aiguille
Tri à bulle (Bubble Sort)
Tri Shell Sort
ArcCos
ArcSin
Atn/ATan/ArcTan/ArcTangente
Cos
Sin
Courriel
Bonjour
Optimisation
AJAX
LibreSSL
OpenSSL
Catalyst
CGI::Application
Dancer
Komodo IDE
Padre
Perl Express
SET's Editor
Téléchargement
Base de connaissances
Bibliographie
Préface
Notes légal
Dictionnaire
Recherche

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.



PARTAGER CETTE PAGE SUR
Dernière mise à jour : Jeudi, le 17 janvier 2019