jeu de devinette de nombre en Perl

jeu de devinette de nombre en Perl : Le guide complet

Non classé
Tutoriel Perl

jeu de devinette de nombre en Perl : Le guide complet

Créer un jeu de devinette de nombre en Perl est un excellent exercice pour tout développeur souhaitant solidifier sa maîtrise des structures de contrôle, de la gestion des entrées utilisateur et des fonctions de base de Perl. Ce concept n’est pas uniquement un passe-temps ; il sert de modèle pédagogique parfait pour comprendre comment les applications console interactives sont structurées. Que vous soyez un débutant découvrant la puissance des variables Perl ou un développeur expérimenté cherchant à réviser les meilleures pratiques de la programmation procédurale, cet article est conçu pour vous fournir une base solide et des techniques de niveau professionnel.

Le contexte d’utilisation d’un tel jeu de devinette de nombre en Perl est extrêmement large. Au-delà du simple divertissement, il modélise des systèmes de validation et de boucles de rétroaction. On peut le retrouver dans des outils d’apprentissage interactifs pour l’école, des mécanismes de sécurisation simple (vérification de codes), ou même des mini-jeux intégrés dans des outils CLI (Command Line Interface) plus complexes. Maîtriser ce type de jeu permet de consolider des compétences fondamentales comme la gestion des erreurs (try/catch ou équivalents en Perl) et la mise en place de boucles conditionnelles robustes. Nous verrons que l’approche Perl, avec sa syntaxe riche et ses capacités de traitement de texte puissantes, rend ce type de projet à la fois simple à démarrer et profondément enrichissant à optimiser.

Pour atteindre un niveau de compréhension complet, nous allons suivre un plan détaillé. Dans un premier temps, nous installerons les prérequis nécessaires pour faire tourner notre application. Ensuite, nous plongerons dans les fondations théoriques, en expliquant pourquoi Perl est particulièrement adapté pour ce genre de logique. Nous présenterons ensuite le code source complet du jeu, suivi d’une analyse exhaustive ligne par ligne. Nous aborderons enfin des cas d’usage avancés, allant au-delà du simple jeu en console, pour intégrer le concept dans un écosystème de développement réel. Ce parcours progressif garantira que même les lecteurs ayant une expérience modérée en Perl repartiront avec une expertise de niveau avancé sur la création de ce type de jeu de devinette de nombre en Perl.

jeu de devinette de nombre en Perl
jeu de devinette de nombre en Perl — illustration

🛠️ Prérequis

Avant de commencer notre exploration du jeu de devinette de nombre en Perl, il est crucial de s’assurer d’avoir un environnement de développement correctement configuré. La préparation de cet environnement est la première étape vers la réussite de tout projet Perl.

Prérequis Matériels et Logiciels

  • Perl Interpreter : Le langage lui-même doit être installé sur votre système. Nous recommandons la version 5.30 ou ultérieure, car elle bénéficie des dernières améliorations de performance et de fonctionnalités modernes.
  • Cygwin ou WSL (Windows) : Pour les utilisateurs Windows, l’utilisation de Cygwin ou du Sous-système Windows pour Linux (WSL) est fortement recommandée pour garantir une compatibilité optimale avec les outils de ligne de commande Unix standards.

Outils de Développement

  • Éditeur de Texte : Visual Studio Code (VS Code) est idéal grâce à ses extensions Perl dédiées qui offrent la colorisation syntaxique et l’autocomplétion.
  • Gestionnaire de dépendances (CPAN) : Le module de gestion des packages Perl, CPAN, est nécessaire pour installer des librairies externes si le jeu devait évoluer (bien que ce simple jeu n’en ait pas besoin, c’est une bonne pratique).

Connaissances Préalables Recommandées

Bien que ce tutoriel soit très détaillé, il est fortement recommandé d’avoir déjà une compréhension de base des concepts suivants :

  • La syntaxe de base de Perl (variables, boucles while/for, conditionnels if/else).
  • La gestion des I/O (lecture et écriture depuis la console via le STDIN et STDOUT).
  • La compréhension des notions de chaînes de caractères et de nombres en programmation.

Pour installer Perl et ses dépendances sur un système Debian/Ubuntu (méthode universelle) :sudo apt update && sudo apt install perl. Assurez-vous de toujours vérifier votre version avec perl -v pour confirmer que vous utilisez une version récente.

📚 Comprendre jeu de devinette de nombre en Perl

Le cœur de ce projet réside dans la compréhension des mécanismes fondamentaux de la logique de jeu et de la manipulation de l’état (state machine) en Perl. Un jeu de devinette de nombre en Perl n’est rien d’autre qu’une machine à états simple : il est initialisé dans un état (le nombre secret), attend une entrée, modifie son état (nombre de tentatives, affichage des indices) et détermine la transition vers l’état suivant (gain, perte, ou nouvelle tentative). Comprendre ce flux est essentiel. En Perl, nous utilisons des boucles de type while pour maintenir l’état du jeu tant que l’utilisateur n’a pas gagné ou n’a pas épuisé ses chances.

Analogiquement, gérer ce jeu est comme jouer au loto. Vous fixez un nombre (le nombre secret), vous avez un nombre limité de tickets (les tentatives), et à chaque tentative, vous vérifiez si votre choix correspond. Perl gère cela élégamment avec des variables de compteur et un mécanisme de boucle qui ne s’arrête que lorsque la condition de succès ou d’échec est atteinte. Contrairement à un jeu qui pourrait utiliser une structure orientée objet complète, le jeu de devinette de nombre en Perl nous permet de nous concentrer sur les mécanismes procéduraux puissants de Perl, comme l’utilisation des opérateurs de test (comparisons) et le traitement des entrées. Ce focus est idéal pour apprendre la puissance de Perl dans les scripts utilitaires CLI.

La Mécanique du Nombre Aléatoire en Perl

Pour garantir la rejouabilité, l’utilisation de fonctions de génération de nombres aléatoires est incontournable. En Perl, on utilise généralement le module rand() en conjonction avec des fonctions pour définir la plage de nombres. La fonction srand() peut être appelée pour seed l’aléatoire, assurant que le jeu commence par une séquence véritablement imprévisible à chaque exécution. Le nombre secret est généré au tout début du programme, définissant ainsi la référence constante de la session de jeu. Le programme doit ensuite fonctionner en boucle tant que l’utilisateur n’a pas deviné ce nombre secret.

Quelle est la différence avec Python ? En Python, on utiliserait souvent une boucle while True: avec des mécanismes de break. En Perl, la boucle while est le standard pour les boucles basées sur un état logique. La gestion de l’entrée utilisateur avec readline ou STDIN nécessite toujours une validation rigoureuse pour s’assurer que l’input est bien un entier, évitant ainsi les plantages de type.

Le cœur du jeu de devinette de nombre en Perl repose donc sur trois piliers : 1) L’initialisation sécurisée d’un nombre secret. 2) Une boucle while conditionnelle. 3) Une gestion rigoureuse des entrées utilisateur et du décompte des tentatives. Comprendre ces mécanismes assure une excellente base pour l’écriture de tout autre outil CLI en Perl.

jeu de devinette de nombre en Perl
jeu de devinette de nombre en Perl

🐪 Le code — jeu de devinette de nombre en Perl

Perl
use strict;
use warnings;

# 1. Initialisation du jeu
my $MIN = 1;
my $MAX = 100;
my $MAX_TENTATIVES = 7;

# Génération du nombre secret aléatoire
# On utilise rand() pour un nombre entre 0 et 1, et on le mappe à la plage [MIN, MAX]
my $nombre_secret = int(rand($MAX - $MIN + 1) + $MIN);
my $tentatives_restantes = $MAX_TENTATIVES;

print "=========================================\n";
print "Bienvenue au jeu de devinette de nombre en Perl !\n";
print "J'ai choisi un nombre entre $MIN et $MAX. Vous avez $MAX_TENTATIVES essais.\n";
print "-----------------------------------------\n";

# 2. Boucle principale du jeu
while ($tentatives_restantes > 0) {
    print "Tentatives restantes : $tentatives_restantes\n";
    print "Entrez votre proposition (un nombre) : ";
    
    # Récupération de l'entrée utilisateur
    my $proposition = <STDIN>;
    chomp($proposition);

    # 3. Validation de l'entrée (gestion des cas limites)
    # On s'assure que l'input est un nombre entier et qu'il est dans la plage.
    unless ($proposition =~ /^\d+$/ && $proposition >= $MIN && $proposition <= $MAX) {
        print "Erreur : Veuillez entrer un nombre entier valide dans la plage. Votre tour est perdu.\n";
        # Ne décrémente pas les tentatives en cas d'erreur de format pour être indulgent
        next;
    }

    my $proposition_int = int($proposition);
    $tentatives_restantes--;

    # 4. Logique de comparaison
    if ($proposition_int == $nombre_secret) {
        print "\n****************************************\n";
        print "Félicitations ! Vous avez trouvé le nombre $nombre_secret !\n";
        print "Vous avez réussi en $MAX_TENTATIVES - $tentatives_restantes tentatives.\n";
        print "****************************************\n";
        last;
    } elsif ($proposition_int < $nombre_secret) {
        print "Trop bas ! Essayez un nombre plus grand.\n";
    } else { # $proposition_int > $nombre_secret
        print "Trop haut ! Essayez un nombre plus petit.\n";
    }
}

# 5. Fin de partie (cas de défaite)
if ($tentatives_restantes == 0 && !defined $nombre_secret) {
    print "\n=========================================\n";
    print "Dommage ! Vous avez épuisé toutes vos tentatives.\n";
    print "Le nombre secret était : $nombre_secret.\n";
    print "Meilleure chance la prochaine fois !\n";
    print "=========================================\n";
} else {
    print "\nFin du jeu.\n";
}

📖 Explication détaillée

Ce premier snippet est une implémentation complète et fonctionnelle du jeu de devinette de nombre en Perl. Il est conçu pour être immédiatement jouable en mode console. Son efficacité réside dans la gestion rigoureuse des flux de données et l’utilisation judicieuse des structures de contrôle Perl. Analysons chaque section pour comprendre les choix techniques qui garantissent sa robustesse.

Analyse du Code Perl : Mécanismes de Jeu

1. Initialisation (Variables et Génération Aléatoire) :

Nous débutons par use strict; et use warnings;. Ce sont les deux directives de sécurité les plus importantes en Perl, car elles forcent le développeur à déclarer explicitement ses variables (prévient les variables ‘undefined’ accidentelles) et détectent les erreurs potentielles. La génération du nombre secret my $nombre_secret = int(rand($MAX - $MIN + 1) + $MIN); est une méthode standard et efficace pour mapper la plage de nombres aléatoires souhaitée. L’utilisation de int() garantit que le résultat de rand() est bien un entier, évitant des imprécisions de virgule flottante.

2. La Structure de Boucle (Game Loop) :

Le while ($tentatives_restantes > 0) { ... } constitue le cœur du jeu. C’est une boucle conditionnelle, le mécanisme parfait pour maintenir un état actif jusqu’à ce qu’une condition (le succès ou l’épuisement des tentatives) ne soit plus vraie. Chaque cycle de cette boucle représente une tentative de l’utilisateur. Le last; est crucial : lorsque l’utilisateur trouve le nombre, nous devons sortir de la boucle immédiatement, même si des tentatives restaient théoriquement. Ce contrôle du flux est fondamental pour un jeu interactif.

3. Gestion des Entrées Utilisateur et Validation :

La réception de l’entrée se fait avec my $proposition = ;. L’utilisation de l’opérateur <> ou la lecture depuis STDIN est la manière idiomatique en Perl de lire des entrées console. La fonction chomp() est vitale car elle retire le caractère de nouvelle ligne (‘
‘) qui est automatiquement inclus lors de la lecture standard. La validation unless ($proposition =~ /^\d+$/ && $proposition >= $MIN && $proposition <= $MAX) { ... } est le point technique le plus délicat. L'expression régulière /^\d+$/ garantit que l'input n'est *que* composé de chiffres (pas de lettres, de symboles, etc.). Cette vérification préventive empêche les crashs liés aux types de données et améliore l'expérience utilisateur, ce qui est une bonne pratique de conception de jeu. Si la validation échoue, nous utilisons next;, qui saute le reste du code de cette itération et passe au début de la boucle suivante, sans décrémenter les tentatives de l'utilisateur.

4. Logique de Jeu :

La série de conditions if/elsif/else implémente la logique de comparaison : égalité, inférieur, supérieur. Ces comparaisons simples sont le moteur qui détermine l'état du jeu pour l'itération suivante. En choisissant des opérateurs de comparaison stricts, nous nous assurons que la logique de décompte est cohérente et que le feedback utilisateur est précis. C'est cette combinaison de la boucle de contrôle et de la validation d'entrée qui rend le jeu de devinette de nombre en Perl stable et professionnel.

🔄 Second exemple — jeu de devinette de nombre en Perl

Perl
use strict;
use warnings;

# Module complémentaire : Suivi des tentatives et remise à zéro

sub reinitialiser_jeu {
    my ($min, $max, $max_t) = @_\;
    my $nombre = int(rand($max - $min + 1) + $min);
    my $historique = [];
    return (
        nombre_secret => $nombre,
        max_tentatives => $max_t,
        tentatives_actuelles => 0,
        historique_proposes => $historique
    );
}

sub afficher_historique {
    my ($historique) = @_\;
    print "\n--- Historique des tentatives ---\n";
    if (!@$historique) {
        print "Aucune tentative enregistrée pour le moment.\n";
    } else {
        my $index = 1;
        foreach my $guess (@$historique) {
            print "#$index: $guess\n";
            $index++;
        }
    }
}

# --- Simulation d'utilisation ---
my ($secret_obj) = reinitialiser_jeu(1, 10, 5);
print "Nouveau jeu initié. Nombre secret enregistré.\n";

# Simulation de l'utilisateur qui propose un nombre
my $guess1 = 50;
push @{$secret_obj->{historique_proposes}}, $guess1;
$secret_obj->{tentatives_actuelles}++;

# Logique de vérification (simulée)
if ($guess1 < $secret_obj->{nombre_secret}) {
    print "Proposition $guess1 : Trop bas.\n";
} elsif ($guess1 > $secret_obj->{nombre_secret}) {
    print "Proposition $guess1 : Trop haut.\n";
} else {
    print "Gagné !\n";
}

afficher_historique($secret_obj);

▶️ Exemple d'utilisation

Pour visualiser le déroulement de ce jeu de devinette de nombre en Perl, supposons que le nombre secret généré soit 73. Nous exécutons le script en console, et le mécanisme de validation et de feedback se déclenche de manière interactive.

Scénario : Un utilisateur ne connaît pas le nombre. Le script lui donne des indices successifs.

Appel du code (dans le terminal) :perl nom_du_script.pl

Sortie Console Attendue (simulation de 4 tours) :

=========================================
Bienvenue au jeu de devinette de nombre en Perl !
J'ai choisi un nombre entre 1 et 100. Vous avez 7 essais.
-----------------------------------------
Tentatives restantes : 7
Entrez votre proposition (un nombre) : 50
Trop bas ! Essayez un nombre plus grand.

Tentatives restantes : 6
Entrez votre proposition (un nombre) : 80
Trop haut ! Essayez un nombre plus petit.

Tentatives restantes : 5
Entrez votre proposition (un nombre) : 65
Trop bas ! Essayez un nombre plus grand.

Tentatives restantes : 4
Entrez votre proposition (un nombre) : 73

****************************************
Félicitations ! Vous avez trouvé le nombre 73 !
Vous avez réussi en 4 tentatives.
****************************************

Analyse de la sortie :

  • Première exécution : Le programme initialise les variables et affiche l'en-tête. Le nombre 50 est proposé et le script répond "Trop bas

🚀 Cas d'usage avancés

Le concept de jeu de devinette de nombre en Perl est un excellent point de départ, mais son potentiel s'étend bien au-delà d'une simple console. Voici comment il peut être intégré dans des projets réels et avancés.

1. Système de Quiz Basé sur la Console (CLI Educational Tool)

Au lieu de deviner un nombre, le jeu pourrait deviner une réponse parmi un ensemble de réponses multiples (QCM). Nous utiliserions la structure de devinette, mais à la place d'une plage numérique, nous aurions une liste de chaînes de caractères. Le script devra lire les questions et les options à partir d'un fichier externe (ex: CSV ou YAML), rendant le jeu beaucoup plus modulaire.

Code avancé pour la gestion des questions :# Simulation de lecture de questions depuis un fichier 'quiz.txt'
open my $fh, '<', 'quiz.txt' or die "Impossible d'ouvrir le fichier : $!";
my $question = <$fh>;
print "$question";
close $fh;

2. Intégration API de Sécurité (OTP Simulation)

Le principe de déduction est utilisé dans la simulation des One-Time Passwords (OTP). L'utilisateur reçoit un code secret (le nombre), mais le script peut simuler un système où l'utilisateur doit deviner une série de chiffres en utilisant une interface de type "Master Code". Ce cas exige une gestion des sessions plus fine, potentiellement avec le module Time::HiRes pour gérer l'expiration des codes.

Code avancé pour la gestion des sessions :# Nécessite la gestion des états globaux ou des classes (OOP)
my $expiration = time() + 300; # Code expire dans 5 minutes
sub verifier_code {
my $code_entree = shift;
if (time() > $expiration) {
return "CODE EXPIRÉ";
} elsif ($code_entree eq "123456") {
return "SUCCÈS";
} else {
return "ÉCHEC";
}
}

3. Jeu Réseau Simple (Client/Serveur Perl)

Le niveau de complexité monte d'un cran lorsque nous passons au réseau. Le serveur génère le nombre secret, et le client tente de le deviner. Perl est historiquement excellent pour les applications réseau. Nous utiliserions les modules IO::Socket::INET. Le serveur maintiendrait l'état du jeu et enverrait le feedback (Trop haut/Trop bas) au client via un socket TCP. C'est un cas d'usage extrêmement avancé qui transforme le jeu de devinette de nombre en Perl en une véritable application réseau.

Le code ci-dessous montre l'approche du serveur qui génère le nombre :use IO::Socket::INET;
# ... Initialisation du serveur ...
my $nombre_secret = int(rand(100));
# Envoi du nombre secret (ici, il serait envoyé crypté)
send($sock, "Nouveau jeu, secret : $nombre_secret\n");
# ... Boucle de réception des devinettes et des feedbacks ...

4. Simulation d'Algorithmes Mathématiques

On peut adapter le jeu pour deviner non pas un nombre aléatoire, mais le résultat d'une formule complexe ou d'un algorithme connu (ex: la N-ième suite de Fibonacci). Le programme devient alors un outil de vérification mathématique, où l'utilisateur doit anticiper la séquence. Cela permet de garder la structure du jeu de devinette de nombre en Perl tout en augmentant sa profondeur mathématique et sa valeur pédagogique.

⚠️ Erreurs courantes à éviter

Lors de la réalisation d'un jeu de devinette de nombre en Perl, de nombreux développeurs, même expérimentés, tombent dans des pièges syntaxiques ou logiques. Il est essentiel d'en connaître les subtilités pour garantir un code robuste et professionnel.

1. Oubli des directives 'use strict' et 'use warnings'

C'est l'erreur cardinale en Perl. Ne les utiliser pas, et vous vous exposez aux pièges du *magic variable* (variables implicitement créées), ou aux failles de type où Perl tente de deviner si vous voulez comparer un nombre ou une chaîne. Solution : Toujours commencer un script par use strict; use warnings;. Ces deux lignes font de vous un code Perl moderne, sûr et maintenable.

2. Gestion insuffisante des entrées utilisateur (Input Validation)

Un novice peut se contenter d'utiliser chomp(), mais oublier de vérifier que l'entrée est bien un entier. Si l'utilisateur entre "abc

✔️ Bonnes pratiques

Pour qu'un jeu de devinette de nombre en Perl passe d'un simple script d'apprentissage à une application professionnelle, l'adoption de bonnes pratiques de codage est indispensable. Ces conseils vont améliorer la lisibilité, la performance et la maintenabilité de votre code.

1. Utiliser les modules de gestion d'état (OOP)

Plutôt que de laisser les variables globales (comme $nombre_secret et $tentatives_restantes) floating dans l'espace global, il est préférable d'encapsuler la logique dans un paquet (Package) ou une classe Perl. Cela empêche les conflits de noms et rend le code plus modulaire. Si l'on veut évoluer, un objet Perl encapsulant l'état du jeu est la meilleure voie.

2. Modularisation et fonctions spécifiques

Décomposez le code en fonctions claires et testables. Ne mélangez pas la logique de jeu (vérification de la victoire) avec l'I/O (afficher le prompt). Par exemple, créez une fonction get_user_input() dédiée uniquement à la lecture et à la validation des données, et une autre fonction check_guess() pour la logique de comparaison. Chaque fonction doit avoir un unique rôle (Single Responsibility Principle).

3. Utilisation de la gestion des erreurs avec 'Try'

Perl offre des mécanismes avancés pour le traitement des exceptions (similaire au try/catch dans d'autres langages). Au lieu de longs blocs 'if' qui gèrent les erreurs prévisibles, utilisez un constructeur de bloc de gestion des erreurs. Cela rend le code beaucoup plus propre et permet de séparer clairement le flux normal de l'exécution du traitement des pannes. C'est un niveau d'abstraction crucial pour les grands projets.

4. Documentation et commentaires exhaustifs (PerlDoc)

Rédigez des commentaires de module (docblock) et de sous-routines (subroutines). Même si le code est simple, expliquer l'intention derrière chaque bloc de logique (surtout la gestion des limites de boucles) est essentiel pour le futur vous-même et pour les collaborateurs. Utilisez le format de documentation PerlDoc pour standardiser cette documentation.

5. Utilisation des say vs print

Bien que print fonctionne, utiliser la fonction say (qui est un alias de print mais ajoute automatiquement un retour à la ligne) rend le code plus concis et plus idiomatique. C'est une petite touche qui améliore considérablement le style du code Perl.

📌 Points clés à retenir

  • L'utilisation de 'use strict' et 'use warnings' est obligatoire pour garantir la sécurité et la robustesse du code Perl.
  • La structure de boucle 'while' est le mécanisme idéal pour maintenir l'état interactif du jeu jusqu'à la condition de sortie (victoire/défaite).
  • La validation des entrées via des expressions régulières (<code class="language-perl">/^\d+$/</code>) est primordiale pour empêcher toute exécution avec des types de données invalides.
  • La gestion du flux de contrôle avec <code class="language-perl">last</code> et <code class="language-perl">next</code> est essentielle pour un contrôle précis de la progression du jeu.
  • Le module rand() est utilisé pour générer un nombre secret non prédictible, garantissant la rejouabilité et le caractère 'jeu'.
  • Modulariser le code en fonctions distinctes (Input, Validation, Logique) augmente considérablement la maintenabilité du <strong class="expression_cle">jeu de devinette de nombre en Perl</strong>.
  • Le traitement des I/O de console avec <code class="language-perl"><stdin></code> nécessite des techniques spécifiques de lecture (chomp) propres à Perl.
  • L'amélioration d'un tel jeu passe par le passage à une approche orientée objet (encapsulation de l'état du jeu dans une classe Perl).

✅ Conclusion

En conclusion, la création d'un jeu de devinette de nombre en Perl représente bien plus qu'un simple exercice de divertissement ; il est une démonstration parfaite des capacités de Perl à gérer la logique séquentielle, le contrôle de flux complexe et l'interaction utilisateur dans un environnement console. Nous avons parcouru les étapes allant de l'installation des outils (prérequis) à l'implémentation avancée (cas d'usage avancés), en passant par les pièges syntaxiques à éviter (erreurs courantes). L'importance de la validation des données et de la propreté du code, grâce à use strict; use warnings;, ne saurait être soulignée assez.

Pour approfondir vos connaissances, nous vous recommandons vivement de vous plonger dans la Programmation Orientée Objet en Perl. Passer de scripts procéduraux simples à des paquets (packages) Perl complexes est le saut qualitatif qui vous transformera en développeur senior. Consultez la documentation officielle : documentation Perl officielle pour explorer les modules avancés comme IO::Socket et Game::Engine.

Pour un défi pratique, tentez de transformer ce jeu pour qu'il puisse déterminer si le nombre secret est premier (algorithme de test de primalité) au lieu d'être aléatoire. Cela intégrera une nouvelle couche de logique mathématique complexe à votre jeu de devinette de nombre en Perl. Rappelez-vous que la maîtrise d'un langage comme Perl vient avec la pratique régulière. N'ayez pas peur de casser le code pour comprendre comment le réparer. Nous espérons que ce guide exhaustif vous a donné confiance en votre capacité à construire des applications console robustes et ludiques. Lancez-vous, codez, et partagez votre réussite !

2 réflexions sur « jeu de devinette de nombre en Perl : Le guide complet »

  1. Ping : type system Perl Moo : Maîtriser Type::Tiny pour la validation - Perlia, du Perl
  2. Ping : Middleware PSGI Perl : Construire des apps web modernes - Perlia, du Perl

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *