EduCode
EduCode

EduCode

Environnement pédagogique, référence du langage, philosophie du projet et informations sur le développeur — tout en un seul endroit. Ce guide vous accompagne de vos premiers pas jusqu'aux programmes avancés.

100%
Pédagogique
FR
Langage natif
0
Prérequis
Télécharger EduCode
Obtenez la dernière version stable gratuitement
EduCode

Version actuelle v1.0 Stable

EduCode — Environnement pédagogique

Fonctionne sans installation supplémentaire
Compatible Windows : 10, 11
Licence éducative : 100% gratuit
Télécharger EduCode v1.0
EduCode
À propos d'EduCode
Présentation, philosophie, architecture et informations générales
Présentation générale
Ce qu'est EduCode et à qui il s'adresse
Vue d'ensemble

EduCode est un environnement logiciel éducatif conçu pour faciliter l'apprentissage de la programmation, de l'algorithmique et de la logique informatique. Il fonctionne directement dans le navigateur, sans aucune installation, et propose un langage de programmation entièrement en français.

Il a été pensé dès l'origine comme un outil pédagogique, accessible, clair et progressif, destiné aussi bien aux débutants complets qu'aux apprenants plus avancés souhaitant consolider leur compréhension des concepts fondamentaux, aux enseignants cherchant un support de cours, et aux formateurs en reconversion professionnelle.

Contrairement aux environnements de développement classiques (VS Code, PyCharm, etc.), EduCode n'expose pas de complexité technique inutile. Pas de configuration, pas de dépendances, pas d'environnement virtuel à gérer : on ouvre, on écrit, on exécute.

EduCode met l'accent sur la compréhension plutôt que sur la syntaxe brute, et sur le raisonnement logique plutôt que sur la performance ou la vitesse d'exécution. L'objectif n'est pas de produire un code le plus court possible, mais de comprendre ce que chaque instruction fait.
Ce qu'EduCode est
Un langage pédagogique en français
Les mots-clés sont des mots français naturels : affiche, si … alors, tant que…
Un éditeur intégré avec console
Écrivez, exécutez et observez les résultats immédiatement dans la même interface.
Un outil d'exploration pas à pas
Le log pédagogique montre chaque instruction exécutée dans l'ordre, pour comprendre le déroulement réel du programme.
Un environnement zéro-config
Aucune installation, aucun compte requis. Accessible depuis n'importe quel navigateur moderne.
Ce qu'EduCode n'est pas
Un langage de production
EduCode n'est pas destiné à construire des applications réelles. C'est un tremplin vers Python, JavaScript, etc.
Un IDE professionnel
Pas de débogueur avancé, pas de gestion de projets multifichiers — la simplicité est intentionnelle.
Un cours de programmation
EduCode est l'environnement ; le contenu pédagogique est apporté par l'enseignant ou le formateur.
Un outil payant ou limité
Toutes les fonctionnalités sont disponibles gratuitement, sans restriction ni version "premium".
Philosophie du projet
Principe fondateur
"Apprendre à coder, c'est avant tout apprendre à penser."

Cette phrase résume toute la démarche d'EduCode. Quand on débute, les plus grandes difficultés ne sont pas de comprendre un algorithme — elles viennent des obstacles syntaxiques, des messages d'erreur cryptiques, des configurations à mettre en place. EduCode cherche à faire disparaître cette friction pour que l'apprenant puisse se concentrer sur l'essentiel : la logique.

Chaque choix de conception — la syntaxe en français, l'indentation automatique, les messages d'erreur clairs, le log pas à pas — vise à réduire la charge cognitive et à maintenir l'attention sur le raisonnement algorithmique plutôt que sur les détails d'implémentation.

Lisibilité
Le code EduCode se lit comme du texte naturel. si age >= 18 alors affiche 'Majeur' fin si — même quelqu'un qui n'a jamais programmé comprend ce que ça fait.
Compréhension avant performance
L'exécution pas à pas permet de voir exactement quelle ligne s'exécute, dans quel ordre, et avec quelles valeurs. C'est plus instructif qu'un simple résultat final.
Charge cognitive réduite
Pas de points-virgules obligatoires, pas d'accolades imbriquées, pas de types complexes à déclarer explicitement. La grammaire du langage est volontairement minimaliste pour réduire les sources d'erreur involontaires.
Progressivité
EduCode accompagne l'apprenant du programme "Bonjour monde" jusqu'aux algorithmes de tri, en passant par les fonctions récursives. Le même outil sert à chaque étape de l'apprentissage.
Un langage pédagogique dédié
Conçu en français, pour penser en français
Le langage EduCode est un pseudo-code exécutable. Il ressemble volontairement à ce qu'un professeur écrirait au tableau pour expliquer un algorithme — sauf qu'il peut être lancé directement dans l'éditeur. Cette proximité entre le raisonnement naturel et le code exécutable est au cœur de la démarche pédagogique.
Mots-clés du langage
si … alorssinonfin si tant que …pour … de … à … affichedemande fonctionprocédureretourne répète … foistableauajoute
Pourquoi des mots-clés en français ?

Les langages de programmation comme Python ou JavaScript utilisent des mots-clés anglais (if, while, for…). Pour un apprenant francophone qui ne maîtrise pas encore l'anglais, ce double effort — comprendre la logique et mémoriser des termes étrangers — peut décourager.

En EduCode, les mots-clés correspondent directement aux concepts : tant que signifie littéralement "tant que la condition est vraie, répète". Aucune traduction mentale n'est nécessaire : on pense, et on code.

Ce que le langage évite intentionnellement
Symboles cryptiques
Pas de {} pour délimiter les blocs, pas de ; obligatoires en fin de ligne, pas de == vs = pour la comparaison. En EduCode, = compare toujours, et vaut affecte.
Règles syntaxiques ambiguës
Chaque structure a un début et une fin explicites : si … alors … fin si, pour … fin pour. Il n'y a jamais de doute sur ce qui appartient à quel bloc.
Erreurs de typage cachées
Les types sont déclarés explicitement (x est un nombre), ce qui aide à comprendre ce que contient chaque variable et prévient les conversions implicites surprenantes.
Gestion de mémoire complexe
Pas de pointeurs, pas d'allocation manuelle, pas de garbage collector à comprendre. Les variables se créent naturellement et sont gérées automatiquement.
Un éditeur pensé pour l'apprentissage
Interface intégrée : édition, exécution et console dans la même fenêtre
L'éditeur EduCode est une interface tout-en-un : on écrit son programme à gauche, on clique sur "Exécuter", et les résultats apparaissent immédiatement dans la console à droite. Pas besoin d'un terminal séparé ni d'une configuration quelconque. Cette boucle courte entre écriture et résultat est essentielle pour l'apprentissage par essai-erreur.
Fonctionnalités de l'éditeur
Coloration syntaxique adaptée
Les mots-clés, les chaînes de texte, les nombres, les commentaires et les fonctions sont colorés différemment. Cette mise en évidence visuelle aide à repérer rapidement la structure du programme et à détecter les fautes de frappe (un mot-clé mal orthographié ne sera pas coloré).
Numérotation des lignes en temps réel
Chaque ligne est numérotée, ce qui facilite la navigation dans les programmes plus longs et permet aux messages d'erreur de pointer précisément vers la ligne problématique.
Affichage de la position du curseur
La ligne et la colonne du curseur sont affichées en permanence. Un détail qui simplifie considérablement la localisation des erreurs signalées par l'interpréteur.
Indentation automatique intelligente
Quand on passe à la ligne après un si … alors ou un pour, l'indentation est ajoutée automatiquement. Cela renforce dès le départ les bonnes habitudes de présentation du code — un code bien indenté est un code qu'on peut relire facilement.
Console intégrée
Les sorties du programme (résultats des affiche), les messages système, les erreurs d'exécution et le message de fin sont tous affichés dans la console. Les erreurs incluent la ligne concernée pour faciliter le débogage.
Comptage de caractères
La taille du programme est suivie en temps réel — utile pour les enseignants qui veulent fixer des contraintes de longueur sur des exercices.
La console ne se contente pas d'afficher les résultats : elle signale explicitement le début et la fin de l'exécution, ce qui aide l'apprenant à distinguer ce qui vient de son programme de ce qui vient du système.
Mode interactif & Exécution pas à pas
Visualiser l'exécution pour mieux comprendre
EduCode propose deux outils complémentaires pour aller au-delà du simple "j'exécute et je vois le résultat" : la saisie interactive pendant l'exécution, et le log pédagogique qui trace chaque instruction. Ensemble, ils transforment l'exécution d'un programme en une expérience d'apprentissage active.
Entrées utilisateur interactives

Quand le programme rencontre une instruction demande, une fenêtre de saisie s'ouvre sans bloquer l'interface. L'utilisateur tape sa valeur, et l'exécution reprend. Cela permet de créer des programmes qui dialoguent avec l'utilisateur — une étape fondamentale pour comprendre la notion d'interaction homme-machine.

Le type de la variable cible détermine la conversion automatique : si x est un nombre, la saisie sera automatiquement convertie en nombre, éliminant une source fréquente de bugs pour les débutants.

Log pédagogique pas à pas

Le mode log affiche dans la console chaque instruction au moment où elle est exécutée, avec sa valeur. On voit ainsi concrètement comment les variables évoluent, comment les boucles itèrent, et quelles branches d'un si sont prises.

C'est un outil précieux pour les élèves en difficulté — au lieu de dire "je ne comprends pas pourquoi ça ne marche pas", ils peuvent suivre l'exécution ligne par ligne et identifier exactement à quel moment le comportement diverge de leurs attentes. C'est aussi idéal pour les démonstrations en classe.

Architecture technique
Comment EduCode fonctionne sous le capot
EduCode repose sur une architecture en couches strictement séparées : le serveur local gère l'accès et les routes, le moteur d'interprétation analyse et exécute le code EduCode, et l'interface web présente tout cela de manière réactive. Cette séparation garantit que chaque couche peut évoluer indépendamment.
Stack applicative
01
Serveur local intégré (HTTP)
Point d'entrée de l'application. Gère les routes, l'authentification et le chargement conditionnel des ressources. Fonctionne en local sur votre machine — aucune donnée n'est envoyée vers un serveur distant.
02
Moteur d'exécution EduCode
Interpréteur du langage pédagogique. Il effectue un pré-scan du code pour enregistrer toutes les fonctions et procédures avant l'exécution, puis interprète les instructions ligne par ligne. Gère également la génération du log pédagogique pas à pas.
03
Interface web moderne & réactive
Éditeur de code avec coloration syntaxique, console d'affichage, gestion des entrées interactives et indicateurs visuels (position du curseur, compteur de caractères). Se met à jour en temps réel sans rechargement de page.
04
Séparation stricte des couches
Authentification, logique applicative et interface utilisateur sont totalement indépendantes. Cette architecture garantit la sécurité (la logique n'est chargée qu'après authentification) et la maintenabilité du projet.
Sécurité & Contrôle d'accès
Protéger l'environnement, même en contexte local
Même si EduCode fonctionne en local, un mécanisme d'authentification protège l'accès à l'éditeur. Cela permet à un enseignant de déployer EduCode sur un réseau de classe et de contrôler qui peut y accéder, sans risquer que des élèves accèdent à la logique applicative via les outils de développement du navigateur.
Protection par mot de passe
Accès à l'éditeur contrôlé
L'éditeur n'est accessible qu'après une authentification préalable. Un utilisateur non authentifié voit une page de connexion et ne peut pas accéder aux fonctionnalités de l'application.
Chargement conditionnel de la logique
Le moteur d'exécution et la logique applicative ne sont transmis au navigateur qu'après une authentification réussie. Cela évite l'exposition du code source à des utilisateurs non autorisés, même via les outils réseau du navigateur.
Cohérence côté serveur
La vérification des droits d'accès est effectuée côté serveur, pas seulement côté client. Cette approche est robuste même si le JavaScript de la page est manipulé par un utilisateur averti.
Un outil adapté à l'enseignement
De la salle de classe à l'auto-apprentissage
EduCode a été conçu en gardant à l'esprit les contraintes réelles de l'enseignement : des élèves aux niveaux très différents, des séances de durée limitée, des machines pas toujours récentes, et des enseignants qui ne sont pas toujours des développeurs. Tout doit fonctionner immédiatement, sans friction technique.
Publics cibles
Enseignement scolaire
Collège, lycée — cours d'algorithmique, NSI (Numérique et Sciences Informatiques), SNT. EduCode permet d'illustrer concrètement les notions du programme officiel (variables, boucles, fonctions, tableaux) sans se perdre dans les subtilités d'un langage de production.
Formation professionnelle
Ateliers d'initiation, reconversion professionnelle, montée en compétences. EduCode offre un point d'entrée doux dans la programmation, sans que les stagiaires aient besoin de maîtriser un environnement de développement complexe dès la première session.
Auto-apprentissage
Parcours guidé, progressif, sans prérequis technique ni linguistique. Idéal pour les curieux qui veulent comprendre "comment ça marche" sans se lancer directement dans un langage comme Python ou JavaScript.
Formateurs et enseignants
Environnement stable et prévisible, prise en main rapide, focus total sur la pédagogie. Le log pas à pas est particulièrement utile pour les démonstrations en classe — on peut projeter l'exécution et commenter chaque étape.
Gratuit
Une conviction, pas un modèle économique
Accès libre & sans condition

EduCode est et restera totalement gratuit. Il a été créé par conviction, pas pour en faire un business. Il est mis à disposition librement pour tous — élèves, enseignants, formateurs, curieux — sans condition, sans abonnement, sans version "premium" qui cacherait des fonctionnalités derrière un paywall.

L'accès à l'éducation et aux outils pédagogiques de qualité ne devrait pas être une question de budget. EduCode part de ce principe et s'y tient.

Tu peux le partager, l'utiliser en classe, l'enseigner, l'intégrer dans tes supports de cours — c'est même tout ce qui est souhaité. Plus EduCode est utilisé, plus il remplit son rôle.
Interdiction de vente
EduCode ne peut pas être vendu ni revendu
Le projet est protégé. Aucune intégration dans un produit commercial n'est autorisée sans accord explicite du développeur. La gratuité est une condition non négociable de l'utilisation.
Aucune exploitation commerciale
Monétiser EduCode, le faire payer à des élèves ou à des institutions, ou l'intégrer dans une offre payante sans accord préalable : interdit. Le projet est un cadeau à la communauté éducative, pas une opportunité commerciale.
Le développeur
À propos de l'auteur

Je m'appelle Grégory.P, et j'ai créé EduCode.

J'étais convaincu que les outils existants posaient trop souvent plus de problèmes qu'ils n'en résolvaient : syntaxes intimidantes pour les débutants, interfaces surchargées de fonctionnalités inutiles pour l'apprentissage, messages d'erreur incompréhensibles, configurations à rallonge avant de pouvoir écrire la première ligne. Alors j'ai décidé de construire quelque chose de différent, depuis zéro, avec une seule obsession : la clarté au service de la compréhension.

EduCode est le fruit de cette conviction. Chaque fonctionnalité, chaque mot-clé, chaque message d'erreur a été pensé du point de vue de l'apprenant — pas du développeur expérimenté.

EduCode, c'est ma réponse à cette frustration. Un environnement où l'on pense avant de coder, où l'erreur est normale et formatrice, et où comprendre compte infiniment plus que performer.
Mises à jour & Versions
Version actuelle
1.0
Version stable
Première version officielle
C'est la toute première release d'EduCode. Elle inclut l'éditeur complet, la console, le moteur d'exécution, le log pédagogique pas à pas, le mode interactif avec saisie utilisateur, et l'ensemble des fonctions intégrées documentées dans ce guide.
Historique des versions
v1.0 Actuelle
Lancement initial — éditeur avec coloration syntaxique, console intégrée, moteur d'exécution complet, log pédagogique pas à pas, mode interactif (saisie utilisateur), toutes les structures de contrôle (si, pour, tant que, répète), fonctions, procédures, tableaux, et bibliothèque de fonctions intégrées.
EduCode est en développement actif. De nouvelles fonctionnalités et améliorations sont prévues dans les versions futures. Si vous avez des suggestions ou rencontrez des problèmes, n'hésitez pas à les signaler.
Conclusion
EduCode est bien plus qu'un simple éditeur de code :
c'est un outil d'apprentissage, un support pédagogique,
et un compagnon de découverte de la programmation.

Il place l'utilisateur au cœur du processus d'apprentissage, en rendant le code compréhensible, l'exécution visible et la logique accessible à tous. EduCode incarne une vision humanisée et pédagogique de la programmation, où comprendre est plus important que coder vite, et où apprendre est une expérience progressive, claire et motivante. Bonne exploration !

Démarrage rapide
Ton premier programme en 3 étapes
Ton premier programme en 3 étapes
01
Ouvre l'éditeur
La zone de texte à gauche est ton éditeur de code. Tu peux y taper directement ton programme EduCode.
02
Écris ton code
Par exemple, tape affiche 'Bonjour !' pour afficher un message dans la console.
03
Exécute le programme
Clique sur le bouton Exécuter. Le résultat s'affiche dans la console à droite.
Interface
Présentation des zones de l'application
Éditeur
Zone de saisieTape ton code ici. La coloration syntaxique met en valeur mots-clés, chaînes, nombres et commentaires.
Numéros de ligneActivables dans les options. Facilitent le repérage des erreurs.
AutocomplétionUne liste de suggestions s'affiche pendant la frappe.
Formater le codeLe bouton Formater réindente automatiquement ton programme pour le rendre plus lisible.
Console
Résultats d'exécutionTout ce qu'affiche ton programme avec affiche apparaît ici.
Entrée interactiveQuand le programme utilise demande, une barre de saisie apparaît en bas de la console.
Messages d'erreurLes erreurs s'affichent en rouge avec le numéro de ligne concernée pour t'aider à les corriger.
Barre d'outils
ExécuterLance le programme
FormaterRéindente le code
OuvrirCharge un fichier .educode
EnregistrerTélécharge le fichier .educode
EffacerVide l'éditeur
Mots-clés
Tous les mots réservés du langage EduCode
Les mots-clés sont les mots réservés du langage — on ne peut pas les utiliser comme noms de variables. Ils forment la grammaire d'EduCode et couvrent tout ce dont on a besoin pour écrire des programmes complets : déclarer et modifier des variables, interagir avec l'utilisateur, prendre des décisions, répéter des actions, et organiser son code en sous-programmes.
Déclaration & affectation
estununevautconstante

Ces mots servent à créer des variables et leur assigner des valeurs. x est un nombre déclare la variable, x vaut 42 l'affecte. Les deux peuvent être écrits séparément ou ensemble.

Types
nombretextebooléentableauenregistrementdateheure

EduCode dispose de 7 types fondamentaux. Le type détermine la valeur par défaut et les opérations disponibles : on peut additionner des nombres, concaténer des textes, tester des booléens, et parcourir des tableaux.

Entrée / Sortie
affichedemandedans
Conditions
sialorssinonfin siselonfin selon
Boucles
tant quefin tant querépètefoisfin répètepourdeàpasfin pourcontinuearrete

EduCode propose trois structures de répétition pour couvrir tous les cas : pour quand on connaît le nombre d'itérations, tant que quand on répète sous condition, et répète … fois pour les répétitions simples à nombre fixe.

Fonctions & procédures
fonctionretournefin fonctionprocédureappellefin procédure
Tableaux
ajoutesupprimevide
Opérateurs logiques & Booléens
etounonvraifaux
Variables
Déclarer, affecter et manipuler les 4 types du langage

Qu'est-ce qu'une variable ?

Une variable est une boîte nommée qui stocke une valeur en mémoire. On lui donne un nom, un type, et une valeur initiale. Plus tard dans le programme, on peut lire sa valeur, la modifier, ou l'utiliser dans des calculs. En EduCode, on déclare une variable avec la syntaxe x est un type, et on lui assigne une valeur avec x vaut valeur.

Pourquoi déclarer le type ? Déclarer explicitement le type (nombre, texte, booléen, tableau) a deux avantages pédagogiques : cela force l'apprenant à réfléchir à la nature de sa donnée, et cela permet à l'interpréteur de faire des conversions automatiques cohérentes (par exemple lors d'une saisie utilisateur).
Déclaration
x est un nombre0 par défaut
x est un texte'' par défaut
x est un booléenfaux par défaut
x est un tableau[] par défaut
x est un enregistrementVariable regrouper
x est une datejj/mm/aaaa
x est une heurehh:mm:ss
x, y est un nombreDéclarer plusieurs variables

Quand plusieurs variables ont le même type, il est plus simple et plus lisible de les déclarer sur une seule ligne.

Affectation
x vaut 42Nombre entier
x vaut 3.14Nombre décimal (le point comme séparateur)
x vaut 'Bonjour'Texte entre apostrophes
x vaut vraiBooléen positif
x vaut fauxBooléen négatif
x vaut y + 1Résultat d'une expression
Raccourcis numériques

Ces raccourcis permettent de modifier une variable numérique sans réécrire son nom des deux côtés.

x ajoute 10x = x + 10
x soustrait 5x = x − 5
x vaut x * 2x = x × 2
x vaut x / 4x = x ÷ 4
Portée & règles importantes
// Le langage est insensible à la casse
Age = age = AGEIdentiques pour l'interpréteur
// Création implicite possible
x vaut 5Crée x si non déclaré
// Variables locales dans les fonctions
// Les paramètres et variables déclarées à l'intérieur
// d'une fonction n'existent pas à l'extérieur
Qu'est-ce qu'un enregistrement ?

Un enregistrement est une variable qui peut regrouper plusieurs informations différentes sous un même nom.

Contrairement : à un nombre (une seule valeur), à un texte (une seule chaîne), à un tableau (plusieurs valeurs du même type),

un enregistrement permet de stocker plusieurs champs, chacun pouvant représenter une information différente.

On utilise un enregistrement pour représenter un objet du monde réel : un élève (nom, note, âge…), un point (x, y), un produit (prix, quantité, nom)

Exemple
élève est un enregistrement élève.nom vaut 'Alice' élève.note vaut 15 affiche élève.nom affiche élève.note
Utilisation dans les calculs et conditions
si élève.note >= 10 alors affiche 'Admis' sinon affiche 'Refusé' fin si
Constante
Déclarer, affecter et manipuler les constantes

Qu'est-ce qu'une constante ?

Une constante est un nom associé à une valeur qui ne peut jamais changer.

Contrairement à une variable, une constante est immuable : sa valeur est fixée une fois pour toutes, toute tentative de modification provoque une erreur.
Les constantes servent à représenter : des valeurs fixes (ex : π, une limite, un message), des paramètres importants du programme, des données que l'on ne veut pas modifier par erreur.
Déclarer une constante
nom est une constante vaut <expression>
Exemples
pi est une constante vaut 3.14159
max est une constante vaut 100
message est une constante vaut 'Bonjour'
Utiliser une constante
affiche pi
affiche max
affiche message
Entrée / Sortie
Afficher des résultats et lire des données saisies par l'utilisateur
L'interaction avec l'utilisateur est au cœur de tout programme interactif. affiche envoie une valeur vers la console, demande attend une saisie clavier. Ces deux instructions permettent de créer des programmes qui posent des questions, calculent, et répondent — le cycle fondamental de tout logiciel interactif.
affiche — écrire dans la console

Affiche peut prendre n'importe quelle valeur ou expression. Texte, nombre, variable, calcul — tout est accepté. Pour afficher plusieurs éléments sur une ligne, on les concatène avec +.

affiche 'Bonjour monde'Texte littéral
affiche xValeur d'une variable
affiche 2 + 2Expression calculée → 4
affiche 'x = ' + xConcaténation texte + variable
affiche t[0]Premier élément d'un tableau
demande — lire une saisie utilisateur
La variable doit être déclarée avant demande. Son type détermine la conversion automatique de la saisie : si c'est un nombre, la chaîne tapée est convertie en nombre; si c'est un texte, elle reste telle quelle.
x est un nombre
demande xAttend un nombre (sans message)
demande 'Entrez un nombre' dans xAvec message d'invite
n est un texte
demande 'Votre prénom ?' dans nSaisie de texte
Commentaires — documenter son code

Un commentaire commence par // et s'étend jusqu'à la fin de la ligne. Il est totalement ignoré lors de l'exécution. Les commentaires servent à expliquer le code — aux autres, mais surtout à soi-même quand on relit un programme plus tard. C'est une bonne habitude à prendre dès le début.

// Ceci est un commentaire — ignoré à l'exécution
affiche x // peut aussi suivre une instruction
Instruction terminer

terminer permet d'arrêter immédiatement le programme.

Quand l'instruction terminer est exécutée : le programme s'arrête, aucune autre instruction n'est exécutée, on sort définitivement du programme.

pour i de 1 a 10 si i = 5 alors terminer fin si affiche i fin pour affiche 'Ce message ne sera jamais affiché'
Instruction essayer / attraper

Dans un programme, certaines instructions peuvent provoquer des erreurs : division par zéro, variable inconnue, mauvais type de valeur, accès hors limites dans un tableau.

Par défaut, une erreur arrête le programme immédiatement.

La structure essayer / attraper permet de prévoir ces erreurs et de réagir proprement, sans faire planter tout le programme.

essayer affiche 10 / 0 affiche 'ce texte ne sera jamais affiché' attraper affiche 'Une erreur est survenue' fin essayer affiche 'Le programme continue'

Récupérer le message d'erreur

essayer affiche x attraper erreur affiche 'Erreur détectée : ' + erreur fin essayer

essayer peut être imbriqué

Chaque essayer gère ses propres erreurs. essayer essayer affiche 10 / 0 attraper e1 affiche 'Erreur interne' fin essayer attraper e2 affiche 'Erreur externe' fin essayer

Exercice

Ex. 1 Calculatrice interactive
Demandez deux nombres, affichez leur somme, différence et produit
Déclarez a et b comme nombres. Utilisez demande avec un message pour les lire. Calculez et affichez sur trois lignes séparées : leur somme, leur différence et leur produit, avec un label clair (ex : "Somme : 15").
Opérateurs
Arithmétiques, comparaisons, logiques et priorités
Les opérateurs permettent de calculer (arithmétiques), comparer (relationnels) et combiner des conditions (logiques). Il est important de comprendre leur priorité : certains opérateurs s'évaluent avant d'autres, tout comme en mathématiques (la multiplication avant l'addition). En cas de doute, on peut toujours utiliser des parenthèses pour forcer l'ordre d'évaluation.
+
Addition / ConcaténationPour les nombres : 3 + 4 = 7. Pour les textes : 'Bon' + 'jour' = 'Bonjour'
-
SoustractionUniquement entre nombres. Erreur si appliqué à des textes.
*
MultiplicationNombre × Nombre uniquement
/
DivisionRésultat décimal. Provoque une erreur si le diviseur est 0.
mod
Modulo (reste de division)8 mod 3 = 2. Aussi écrit %. Très utile pour tester la parité (n mod 2 = 0) ou créer des cycles.
=
Égalité (comparaison)Retourne vrai ou faux. En EduCode, = compare — pour affecter, on utilise le mot-clé vaut.
<>
Différent deVrai si les deux valeurs sont différentes
< >
Inférieur / Supérieur strictComparaison stricte : 5 < 5 est faux, 4 < 5 est vrai
<= >=
Inférieur ou égal / Supérieur ou égalComparaison inclusive : 5 <= 5 est vrai
et
ET logiqueVrai uniquement si les deux conditions sont vraies simultanément
ou
OU logiqueVrai si au moins l'une des conditions est vraie
non
Négation logiqueInverse un booléen : non vrai = faux, non (x > 5) = (x <= 5)
Priorité des opérateurs (du plus fort au plus faible)

Quand une expression contient plusieurs opérateurs, ils ne sont pas évalués de gauche à droite : certains ont une priorité plus élevée. Voici l'ordre, du plus prioritaire au moins prioritaire :

1. nonNégation unaire — évalué en premier
2. * / modMultiplication, division, modulo
3. + -Addition, soustraction (et concaténation de textes)
4. = <> < > <= >=Comparaisons
5. etET logique
6. ouOU logique — le moins prioritaire
// En cas de doute, utilisez des parenthèses : (a + b) * c
Conditions
Prendre des décisions avec si / sinon / fin si
Une structure conditionnelle permet au programme de prendre des décisions en fonction d'une condition. Si la condition est vraie, on exécute un bloc d'instructions ; sinon, on en exécute éventuellement un autre. C'est le mécanisme fondamental qui donne au programme un comportement différent selon les données.
si … alors … fin si — la forme simple

Exécute le bloc seulement si la condition est vraie. Si elle est fausse, rien ne se passe et l'exécution continue après fin si.

si age >= 18 alors affiche 'Vous êtes majeur.' fin si
si … sinon … fin si — deux branches

L'une des deux branches est toujours exécutée. Si la condition est vraie → bloc alors ; sinon → bloc sinon. Les deux branches s'excluent mutuellement.

si x mod 2 = 0 alors affiche 'pair' sinon affiche 'impair' fin si
si imbriqués — plusieurs cas

On peut imbriquer des structures si pour traiter plus de deux cas. Chaque si doit avoir son propre fin si. L'indentation aide à visualiser quelle fin si ferme quel si.

si note >= 16 alors affiche 'Très bien' sinon si note >= 12 alors affiche 'Bien' sinon affiche 'À améliorer' fin si fin si
Conditions composées avec et / ou / non

On peut combiner plusieurs conditions dans un même si avec et (les deux doivent être vraies), ou (au moins l'une doit être vraie), et non (inverse la condition). Les parenthèses aident à lever toute ambiguïté.

si x > 0 et x < 10 alors affiche 'entre 0 et 10 (exclus)' fin si si non (age >= 18) alors affiche 'mineur' fin si
Structure SELON / CAS

La structure selon permet de choisir une action parmi plusieurs possibilités, en fonction de la valeur d'une variable ou d'une expression.

note est un nombre note vaut 10 selon note // je regarde la valeur cas 20 : affiche 'Parfait' cas 10 : // je compare avec une valeur précise affiche 'Moyen' sinon selon : // aucun cas ne correspond affiche 'À améliorer' fin selon // la structure est terminée
Boucles
Répéter des instructions avec pour, tant que et répète
Une boucle permet d'exécuter plusieurs fois le même bloc d'instructions sans le réécrire. C'est l'un des concepts les plus puissants de la programmation : grâce aux boucles, un programme de 10 lignes peut effectuer des millions d'opérations. EduCode propose trois structures adaptées à différents contextes.
pour … de … à … fin pour — nombre d'itérations connu

Utilisez pour quand vous savez à l'avance combien de fois la boucle doit s'exécuter. La variable de contrôle (i) prend automatiquement les valeurs de départ à fin, de 1 en 1 par défaut. Le mot-clé pas permet de changer l'incrément — y compris en négatif pour parcourir à rebours.

// Affiche 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 pour i de 1 à 10 affiche i fin pour // Pas personnalisé : affiche 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 pour i de 0 à 20 pas 2 affiche i fin pour // Boucle décroissante pour i de 5 à 1 pas -1 affiche i fin pour
Le pas ne peut pas être 0 — cela provoquerait une boucle infinie. Pour parcourir à rebours, utilisez un pas négatif : pas -1.
tant que … fin tant que — condition de continuation

Utilisez tant que quand le nombre d'itérations n'est pas connu à l'avance — par exemple, répéter jusqu'à ce que l'utilisateur saisisse une valeur correcte, ou jusqu'à ce qu'un compteur atteigne un certain seuil.

x est un nombre x vaut 1 tant que x <= 100 affiche x x ajoute 1 fin tant que
Assurez-vous que la condition finit par devenir fausse ! Oublier de modifier la variable de condition à l'intérieur de la boucle provoque une boucle infinie qui bloque le programme.
répète … fois … fin répète — nombre fixe, sans variable

La forme la plus simple : répéter exactement N fois, sans avoir besoin d'une variable de contrôle. Idéale pour les actions répétitives simples (afficher un message N fois, dessiner une figure, etc.).

répète 5 fois affiche 'tic' fin répète
Boucles imbriquées

On peut placer une boucle à l'intérieur d'une autre. Pour chaque itération de la boucle extérieure, la boucle intérieure s'exécute entièrement. C'est la base des algorithmes sur des structures à deux dimensions (tableaux 2D, tables de multiplication, matrices).

// Table de multiplication complète pour i de 1 à 5 pour j de 1 à 5 affiche i + ' × ' + j + ' = ' + (i * j) fin pour fin pour
continue — passer à l'itération suivante

continue sert à ignorer le reste de la boucle pour l'itération en cours et à passer directement à l'itération suivante.

Explication : quand i = 3, le programme rencontre continue il saute l'affichage il passe directement à i = 4 pour i de 1 a 5 si i = 3 alors continue fin si affiche i fin pour
La boucle ne s'arrête pas, elle continue, mais sans exécuter les lignes suivantes.
À retenir pour continue : continue ne sort pas de la boucle il saute seulement le reste de l'itération actuelle, il est utile pour ignorer certains cas.
arrête — sortir de la boucle

arrête sert à arrêter complètement la boucle en cours.

Explication : quand i = 4, la condition est vraie arrête met fin à la boucle les valeurs 5 à 10 ne sont jamais exécutées pour i de 1 a 10 affiche i si i = 4 alors arrête fin si fin pour
Une fois arrête exécuté : la boucle se termine immédiatement, le programme continue après la boucle
À retenir pour arrête : arrête sort définitivement de la boucle, les instructions suivantes dans la boucle ne sont plus exécutées, il sert à mettre fin à une répétition quand une condition est remplie.
Tableaux
Listes dynamiques à index numérique (l'index commence à 0)
Un tableau est une variable qui contient plusieurs valeurs, accessibles par leur position (index). En EduCode, les tableaux sont dynamiques : on peut y ajouter ou supprimer des éléments à tout moment. L'index commence à 0 (le premier élément est t[0], le deuxième t[1], etc.) — une convention universelle dans la quasi-totalité des langages de programmation.
Opérations de base
t est un tableauCréer un tableau vide []
t ajoute 42Ajouter 42 en fin de tableau
t[0] vaut 99Modifier l'élément à l'index 0
affiche t[0]Lire la valeur à l'index 0
t supprime 2Supprimer l'élément à l'index 2
vide tVider entièrement le tableau
Parcourir un tableau avec une boucle

Le pattern classique pour accéder à chaque élément d'un tableau : une boucle pour allant de 0 à longueur(t) - 1. La fonction longueur retourne le nombre d'éléments, donc le dernier index valide est toujours longueur - 1.

t est un tableau t ajoute 10 t ajoute 20 t ajoute 30 pour i de 0 à longueur(t) - 1 affiche 't[' + i + '] = ' + t[i] fin pour
Extension automatique par affectation directe

Affecter directement une valeur à un index inexistant étend automatiquement le tableau. Les éléments intermédiaires sont initialisés à une chaîne vide. Cela peut être pratique, mais peut aussi provoquer des surprises si on n'y prend pas garde.

t est un tableau t[5] vaut 'saut' affiche longueur(t) // → 6 // t[0] à t[4] contiennent '' (texte vide)
Fonctions
Sous-programmes qui calculent et retournent une valeur
Une fonction est un bloc de code nommé qui prend des paramètres en entrée, effectue un traitement, et retourne une valeur. Les fonctions permettent de découper un programme en sous-problèmes, de réutiliser du code sans le réécrire, et de rendre les programmes plus lisibles et plus faciles à déboguer. En EduCode, les fonctions peuvent être définies n'importe où — le moteur les pré-scanne toutes avant de commencer l'exécution.
Définition & appel
fonction addition(a, b) retourne a + b fin fonction // Appel : le résultat est stocké dans r r est un nombre r vaut addition(3, 7) affiche r // → 10 // On peut aussi appeler directement dans affiche affiche addition(100, 200) // → 300
Fonctions avec conditions

Une fonction peut contenir n'importe quelle structure du langage. Ici, deux branches de retour : l'une si a > b, l'autre sinon. La première instruction retourne rencontrée arrête l'exécution de la fonction.

fonction maximum(a, b) si a > b alors retourne a sinon retourne b fin si fin fonction affiche maximum(8, 13) // → 13
Fonctions récursives

Une fonction peut s'appeler elle-même — c'est la récursivité. C'est un concept avancé mais très élégant pour certains problèmes. La clé est toujours le cas de base : une condition qui arrête la récursion (ici n <= 1), sans laquelle la fonction s'appellerait infiniment.

fonction factorielle(n) si n <= 1 alors retourne 1 // cas de base fin si retourne n * factorielle(n - 1) // appel récursif fin fonction affiche factorielle(5) // → 120 (5×4×3×2×1)
Les fonctions peuvent être définies n'importe où dans le fichier (avant ou après leur premier appel). Le pré-scan de l'interpréteur les enregistre toutes avant de commencer l'exécution — cette souplesse évite d'avoir à s'interroger sur l'ordre de déclaration.
Procédures
Sous-programmes qui effectuent des actions sans retourner de valeur
Une procédure ressemble à une fonction, mais elle n'a pas de valeur de retour. Elle effectue des actions (afficher, modifier un tableau, interagir avec l'utilisateur) sans produire de résultat qu'on peut utiliser dans une expression. En EduCode, les procédures se définissent avec procédure et s'appellent avec appelle.
Définition & appel
procédure saluer(prenom) affiche 'Bonjour ' + prenom + ' !' fin procédure appelle saluer('Alice') // → Bonjour Alice ! appelle saluer('Bob') // → Bonjour Bob !
Différences fonction / procédure

Le choix entre fonction et procédure dépend du besoin : si on veut un résultat réutilisable (dans un calcul, une condition, un affichage), on utilise une fonction. Si on veut effectuer une action sans s'attendre à un résultat (afficher, remplir un tableau, etc.), on utilise une procédure.

Critère Fonction Procédure
Mot-clé début fonction procédure
Mot-clé fin fin fonction fin procédure
Retourne une valeur Oui (retourne) Non
Utilisable dans expression Oui : x vaut f(3) Non
Mode d'appel Direct ou avec appelle Obligatoirement avec appelle
Fonctions intégrées
Disponibles sans déclaration, directement dans vos expressions
EduCode fournit une bibliothèque de fonctions prêtes à l'emploi couvrant les opérations mathématiques courantes, la manipulation de texte, les opérations sur les tableaux, la date/heure et quelques utilitaires de conversion. Toutes ces fonctions s'utilisent comme n'importe quelle autre : racine(9) retourne 3, longueur('bonjour') retourne 7, etc.
Mathématiques
racine(x) math
Racine carrée de x. Retourne un nombre décimal si x n'est pas un carré parfait. racine(9) → 3, racine(2) → 1.414…
absolue(x) math
Valeur absolue : supprime le signe négatif. absolue(-5) → 5, absolue(3) → 3. Utile pour calculer des distances.
arrondi(x) math
Arrondi à l'entier le plus proche (règle standard : .5 arrondit vers le haut). arrondi(3.7) → 4, arrondi(3.2) → 3
hasard(n) math
Entier aléatoire entre 0 et n inclus. Chaque appel peut donner un résultat différent — utile pour les jeux et simulations.
hasard(min, max) math
Entier aléatoire entre min et max inclus. hasard(1, 6) simule un lancer de dé à 6 faces.
minimum(a, b) math
Retourne le plus petit des deux arguments. Équivalent à écrire un si a < b alors retourne a sinon retourne b.
maximum(a, b) math
Retourne le plus grand des deux arguments.
puissance(a, b) math
Calcule a à la puissance b (aᵇ).
Texte
longueur(texte) texte
Nombre de caractères dans le texte. Les espaces et la ponctuation comptent. longueur('abc') → 3, longueur('bonjour monde') → 13
majuscules(texte) texte
Convertit tous les caractères en majuscules. majuscules('bonjour') → 'BONJOUR'. Utile pour comparer des chaînes sans tenir compte de la casse.
minuscules(texte) texte
Convertit tous les caractères en minuscules. minuscules('BONJOUR') → 'bonjour'.
inverser(texte) texte
Inverse l'ordre des caractères. inverser('abc') → 'cba'. Utile pour détecter les palindromes.
contient(texte, mot) texte
Cherche si mot apparaît dans texte, sans tenir compte de la casse. Retourne vrai ou faux.
remplacer(texte, ancien, nouveau) texte
Remplace toutes les occurrences de ancien par nouveau dans le texte. Retourne le texte modifié (n'altère pas l'original).
supprime_espace(texte) texte
Supprime les espaces en début et en fin de texte (trim). Indispensable pour nettoyer les saisies utilisateur avant de les comparer.
repeter_texte(texte, n) texte
Répète le texte n fois (maximum 10 000). repeter_texte('*', 5) → '*****'. Idéal pour dessiner des formes dans la console.
hasardtexte(v1, v2, …) texte
Retourne aléatoirement l'un des arguments fournis. hasardtexte('Pierre', 'Feuille', 'Ciseaux') simule un choix aléatoire.
commence_par(texte, prefixe) texte
Vérifie si un texte commence par un certain mot ou groupe de caractères. commence_par('Bonjour', 'Bon') // vrai
termine_par(texte, suffixe) texte
Vérifie si un texte se termine par un certain mot ou groupe de caractères. termine_par('Bonjour', 'Bon') // faux
compter(texte, motif) texte
Compte combien de fois un motif apparaît dans un texte. compter('banana', 'a') // 3
copier(texte, debut, longueur) texte
Copier extrait une partie d'un texte. copier('bonjour', 4, 4) // 'jour'
caractère(65) texte
convertit un code ASCII en caractère. caractère(65) // A
code('A') texte
convertit un code ASCII en caractère. code('A') // 65
Tableaux
longueur(tableau) tableau
Nombre d'éléments dans le tableau. Aussi accessible via taille(). Un tableau vide a une longueur de 0.
premier(tableau) tableau
Retourne le premier élément (index 0). Équivalent à t[0] mais plus lisible. Provoque une erreur si le tableau est vide — vérifiez avec longueur(t) > 0 avant.
dernier(tableau) tableau
Retourne le dernier élément. Équivalent à t[longueur(t) - 1] mais plus concis. Provoque une erreur si le tableau est vide.
melanger(tableau) tableau
Mélange les éléments en place de façon aléatoire (algorithme Fisher-Yates). Le tableau original est modifié. Utile pour les jeux de cartes, les quizz à ordre aléatoire, etc.
contient(tableau, valeur) tableau
Vérifie si la valeur est présente dans le tableau. Retourne vrai ou faux. Plus simple qu'une boucle de recherche manuelle.
liste_tableau(tableau) tableau
Affiche chaque élément sous la forme [0] = val. Très pratique pour déboguer l'état d'un tableau sans écrire une boucle d'affichage.
découper(texte, séparateur) tableau
Permet de couper un texte en plusieurs morceaux à chaque fois qu'on rencontre un séparateur. mots vaut découper('pomme,poire,banane', ',')
Enregistrement
existe(enregistrement, champ) Enregistrement
Vérifier si un champ existe dans un enregistrement.
champs(enregistrement) Enregistrement
Affiche la liste des champs contenus dans un enregistrement.
supprime_champ(enregistrement, champ) Enregistrement
Supprimer un champ précis d’un enregistrement.
Date & Heure
aujourd_hui() date
Date actuelle au format jj/mm/aaaa. Retourne une date
maintenant() date
Heure actuelle au format hh:mm:ss. Retourne une heure
jours_entre(d1, d2) date
Renvoie le nombre de jours entre deux dates.
Utilitaires
est_nombre(x) util
Vrai si x est de type nombre, ou si c'est une chaîne de texte qui peut être convertie en nombre (ex : '42'). Utile pour valider les saisies utilisateur avant de faire des calculs.
est_texte(x) util
Vrai si x est de type texte. Permet de vérifier le type d'une valeur avant de lui appliquer des opérations spécifiques.
est_booleen(x) util
Vrai si x contient une valeur booléenne (vrai ou faux), Faux dans tous les autres cas (nombre, texte, tableau…)
convertir_texte(x) util
Convertit n'importe quelle valeur en texte. convertir_texte(42) → '42'. Nécessaire pour concaténer un nombre avec du texte dans certains contextes.
convertir_nombre(x) util
Convertit une valeur en nombre. convertir_nombre('3.14') → 3.14. Provoque une erreur si la conversion est impossible.
convertir_date(x) util
Convertit une valeur date en texte. convertir_date(x)
convertir_heure(x) util
Convertit une valeur heure en texte. convertir_heure(x)
type_de(x) util
Indique le type d'une valeur. Valeur retournée : nombre, texte, booléen, tableau
limiter(s, min, max) util
Force une valeur à rester dans un intervalle. score vaut 120 → score vaut limiter(score, 0, 100)
sialors(condition, 'a', 'b') util
Renvoie a si condition est vraie, sinon b. sialors(vrai, 'oui', 'non')
Erreurs courantes
Comprendre les messages d'erreur et comment les corriger
Les erreurs font partie intégrante de l'apprentissage de la programmation. EduCode fournit des messages d'erreur en français, aussi clairs que possible, pour aider à identifier rapidement ce qui ne va pas. Le tableau ci-dessous recense les erreurs les plus fréquentes, leur cause et la correction à apporter.
Message d'erreur Cause probable Solution
Variable inconnue : "x" Variable utilisée avant d'être déclarée Ajouter x est un nombre (ou texte, booléen, tableau) avant la première utilisation
Variable déjà déclarée : "x" La variable a déjà été déclarée auparavant Supprimer la redéclaration.
Division par zéro a / 0 ou a mod 0 — le diviseur vaut 0 Vérifier le diviseur avec un si avant de diviser : si b <> 0 alors …
Index hors limites : t[5] Accès à un index qui n'existe pas dans le tableau Vérifier avec longueur(t) que l'index est valide avant d'y accéder
"x" n'est pas un tableau Utilisation de la notation t[i] sur une variable qui n'est pas un tableau Déclarer la variable avec x est un tableau
fin si manquant Un si n'a pas de fin si correspondant Vérifier que chaque si imbriqué est bien fermé par son propre fin si
pas ne peut pas être 0 Boucle pour avec un incrément (pas) égal à 0 Utiliser un pas non nul — positif pour aller en avant, négatif pour aller en arrière
"f" : 2 paramètre(s) attendu(s) Nombre d'arguments incorrect lors de l'appel d'une fonction Vérifier la signature de la fonction et passer le bon nombre d'arguments
Soustraction de textes impossible 'a' - 'b' n'est pas supporté Seul l'opérateur + est valable pour les textes (concaténation)
premier/dernier : tableau vide Appel de premier() ou dernier() sur un tableau sans éléments Vérifier longueur(t) > 0 avant d'appeler ces fonctions
la boucle "tant que" dépasse la limite d'itérations Boucle infinie détectée Vérifier que la condition évolue à chaque itération
Champ inconnu : "nom" Le champ demandé n’existe pas dans l’enregistrement Créer le champ avant de le lire : x.nom vaut …
"x" n'est pas un enregistrement Accès à un champ (x.nom) sur une variable non enregistrement Déclarer la variable comme enregistrement : x est un enregistrement
"x" est une constante : modification interdite Tentative de modification d’une constante Supprimer l’affectation ou utiliser une variable à la place
Quand vous obtenez une erreur, lisez-la attentivement avant de modifier le code. Le message indique la ligne concernée — commencez par regarder cette ligne et ses lignes voisines. 90% des erreurs se résolvent en lisant le message correctement.
Exemples complets
Programmes prêts à l'emploi combinant plusieurs fonctionnalités
Ces exemples sont conçus pour être copiés et exécutés directement dans l'éditeur. Chacun illustre une combinaison de fonctionnalités différente. Lisez le code avant de l'exécuter, essayez de prédire le résultat, puis vérifiez. Modifiez-les ensuite pour mieux les comprendre.
Bonjour monde

Le programme traditionnel de tout débutant. Montre comment utiliser affiche avec du texte littéral.

affiche 'Bonjour le monde !' affiche 'Bienvenue dans EduCode.'
Pair ou impair

Utilisation de l'opérateur mod et d'une structure conditionnelle à deux branches.

n est un nombre n vaut 7 si n mod 2 = 0 alors affiche 'Pair' sinon affiche 'Impair' fin si
Tableau dynamique

Création, remplissage et parcours d'un tableau avec longueur.

t est un tableau t ajoute 10 t ajoute 20 t ajoute 30 affiche 'Taille : ' + longueur(t) pour i de 0 à longueur(t) - 1 affiche t[i] fin pour
Suite de Fibonacci

Illustre l'utilisation d'une variable temporaire pour permuter deux valeurs — un pattern courant en algorithmique.

x est un nombre b est un nombre temp est un nombre x vaut 0 b vaut 1 affiche x affiche b répète 8 fois temp vaut x + b x vaut b b vaut temp affiche b fin répète
Table de multiplication (saisie)

Combine saisie utilisateur, boucle pour et concaténation de texte pour produire un affichage formaté.

n est un nombre demande 'Quelle table ? (1-10)' dans n affiche '--- Table de ' + n + ' ---' pour i de 1 à 10 affiche n + ' × ' + i + ' = ' + n * i fin pour
Calcul de moyenne (saisie)

Programme interactif complet : boucle de saisie, accumulation dans une variable, calcul final. Montre comment utiliser convertir_texte pour construire un message d'invite dynamique.

somme est un nombre note est un nombre i est un nombre titre est un texte somme vaut 0 pour i de 1 à 5 titre vaut 'Note ' + convertir_texte(i) demande titre dans note somme vaut somme + note fin pour affiche 'Moyenne = ' + (somme / 5)
Procédures & Encadrement

Exemple de composition de procédures : encadre appelle ligne. Illustre comment découper un programme en sous-tâches réutilisables.

procédure ligne(car) affiche repeter_texte(car, 12) fin procédure procédure encadre(texte) appelle ligne('═') affiche ' ' + texte appelle ligne('═') fin procédure appelle encadre('Bienvenue !') appelle encadre('EduCode')
Saisie utilisateur + Conditions

Programme interactif qui combine saisie de différents types (texte et nombre) et structure conditionnelle. Un bon exercice d'introduction pour les débutants.

prenom est un texte age est un nombre demande 'Quel est ton prénom ?' dans prenom demande 'Quel est ton âge ?' dans age affiche 'Bonjour, ' + prenom + ' !' si age >= 18 alors affiche 'Tu es majeur.' sinon affiche 'Tu es mineur. Il te reste ' + (18 - age) + ' an(s).' fin si
Tri à bulles

L'un des algorithmes de tri les plus pédagogiques. Combine procédure, boucles imbriquées, accès aux tableaux par index, et échange de valeurs via variable temporaire.

procédure tri_bulles(t) n est un nombre n vaut longueur(t) pour i de 0 à n - 2 pour j de 0 à n - i - 2 si t[j] > t[j + 1] alors tmp est un nombre tmp vaut t[j] t[j] vaut t[j + 1] t[j + 1] vaut tmp fin si fin pour fin pour fin procédure nombres est un tableau nombres ajoute 5 nombres ajoute 2 nombres ajoute 8 nombres ajoute 1 appelle tri_bulles(nombres) affiche nombres // → [1, 2, 5, 8]
Générateur de mots de passe

Boucles, concaténation texte, hasard, copier, longueur.

alphabet est un texte alphabet vaut 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#' fonction caractere_aleatoire() // position aléatoire 1..longueur i est un nombre i vaut hasard(longueur(alphabet) - 1) + 1 retourne copier(alphabet, i, 1) fin fonction mdp est un texte mdp vaut '' n est un nombre n vaut 12 pour k de 1 a n mdp vaut mdp + caractere_aleatoire() fin pour affiche 'Mot de passe : ' + mdp
Quizz

Programme de quiz à 5 questions avec score final. Utilise une fonction utilitaire normalise pour comparer les réponses sans tenir compte des espaces ni de la casse — une bonne pratique pour la robustesse.

score est un nombre rep est un texte score vaut 0 // Normalise : supprime espaces + met en minuscules fonction normalise(t) retourne supprime_espace(minuscules(t)) fin fonction demande 'Capitale de la France ?' dans rep si normalise(rep) = 'paris' alors score vaut score + 1 fin si demande 'Combien font 7 + 5 ?' dans rep si normalise(rep) = '12' alors score vaut score + 1 fin si demande 'Mot-clé pour afficher ?' dans rep si normalise(rep) = 'affiche' alors score vaut score + 1 fin si affiche 'Score : ' + convertir_texte(score) + ' / 3' si score = 3 alors affiche '🏆 Parfait !' sinon affiche 'Continue à t\'entraîner !' fin si
Pyramide (1, 3, 5, … étoiles)
// i servira de compteur pour la boucle (ligne courante) i est un nombre // variable texte qui contiendra les espaces pour centrer les étoiles espaces est un texte // boucle de 1 à 5 pour créer une pyramide de hauteur 5 pour i de 1 a 5 // crée (5 - i) espaces pour centrer la ligne espaces vaut repeter_texte(' ', 5 - i) // affiche les espaces puis (2 * i - 1) étoiles pour former la pyramide affiche espaces + repeter_texte('*', 2 * i - 1) fin pour
Convertir un entier en hexadécimal
n est un nombre hexa est un texte reste est un nombre chiffre est un texte demande 'Entier à convertir (>= 0) : ' dans n si n = 0 alors affiche '0' sinon hexa vaut '' tant que n > 0 reste vaut n mod 16 selon reste cas 0: chiffre vaut '0' cas 1: chiffre vaut '1' cas 2: chiffre vaut '2' cas 3: chiffre vaut '3' cas 4: chiffre vaut '4' cas 5: chiffre vaut '5' cas 6: chiffre vaut '6' cas 7: chiffre vaut '7' cas 8: chiffre vaut '8' cas 9: chiffre vaut '9' cas 10: chiffre vaut 'A' cas 11: chiffre vaut 'B' cas 12: chiffre vaut 'C' cas 13: chiffre vaut 'D' cas 14: chiffre vaut 'E' cas 15: chiffre vaut 'F' fin selon hexa vaut chiffre + hexa n vaut (n - reste) / 16 fin tant que affiche hexa fin si
Conversion en chiffres romains
n est un nombre res est un texte demande 'Entrer un nombre (1 à 3999) : ' dans n si n < 1 ou n > 3999 alors affiche 'Erreur : nombre hors limites' terminer fin si res vaut '' // ───── milliers ───── tant que n >= 1000 res vaut res + 'M' n vaut n - 1000 fin tant que // ───── centaines ───── si n >= 900 alors res vaut res + 'CM' n vaut n - 900 sinon si n >= 500 alors res vaut res + 'D' n vaut n - 500 tant que n >= 100 res vaut res + 'C' n vaut n - 100 fin tant que sinon si n >= 400 alors res vaut res + 'CD' n vaut n - 400 sinon tant que n >= 100 res vaut res + 'C' n vaut n - 100 fin tant que fin si fin si fin si // ───── dizaines ───── si n >= 90 alors res vaut res + 'XC' n vaut n - 90 sinon si n >= 50 alors res vaut res + 'L' n vaut n - 50 tant que n >= 10 res vaut res + 'X' n vaut n - 10 fin tant que sinon si n >= 40 alors res vaut res + 'XL' n vaut n - 40 sinon tant que n >= 10 res vaut res + 'X' n vaut n - 10 fin tant que fin si fin si fin si // ───── unités ───── si n = 9 alors res vaut res + 'IX' sinon si n >= 5 alors res vaut res + 'V' n vaut n - 5 tant que n > 0 res vaut res + 'I' n vaut n - 1 fin tant que sinon si n = 4 alors res vaut res + 'IV' sinon tant que n > 0 res vaut res + 'I' n vaut n - 1 fin tant que fin si fin si fin si affiche 'Chiffre romain : ' + res
Conversion chiffres en lettres
n est un nombre reste est un nombre cent est un nombre diz est un nombre uni est un nombre res est un texte part est un texte // ── Fonction : mot pour 0..9 fonction mot_unite(x) selon x cas 0: retourne 'zéro' cas 1: retourne 'un' cas 2: retourne 'deux' cas 3: retourne 'trois' cas 4: retourne 'quatre' cas 5: retourne 'cinq' cas 6: retourne 'six' cas 7: retourne 'sept' cas 8: retourne 'huit' cas 9: retourne 'neuf' fin selon retourne '' // sécurité fin fonction // ── Fonction : mot pour 0..19 fonction mot_0_19(x) selon x cas 0: retourne 'zéro' cas 1: retourne 'un' cas 2: retourne 'deux' cas 3: retourne 'trois' cas 4: retourne 'quatre' cas 5: retourne 'cinq' cas 6: retourne 'six' cas 7: retourne 'sept' cas 8: retourne 'huit' cas 9: retourne 'neuf' cas 10: retourne 'dix' cas 11: retourne 'onze' cas 12: retourne 'douze' cas 13: retourne 'treize' cas 14: retourne 'quatorze' cas 15: retourne 'quinze' cas 16: retourne 'seize' cas 17: retourne 'dix-sept' cas 18: retourne 'dix-huit' cas 19: retourne 'dix-neuf' fin selon retourne '' // sécurité fin fonction // ── Procédure : ajoute une partie au résultat avec des tirets procédure ajouter(p) si res = '' alors res vaut p sinon res vaut res + '-' + p fin si fin procédure // ── Lecture demande 'Entrer un nombre (0 à 999) : ' dans n affiche convertir_nombre(n) // ── Validation simple si n < 0 ou n > 999 alors affiche 'Erreur : hors limite' terminer fin si // ── Cas 0 direct si n = 0 alors affiche 'zéro' terminer fin si res vaut '' // 1) Centaines cent vaut (n - (n mod 100)) / 100 reste vaut n mod 100 si cent > 0 alors si cent = 1 alors appelle ajouter('cent') sinon // ex: deux-cent, trois-cent, ... part vaut mot_unite(cent) + '-cent' appelle ajouter(part) fin si fin si // 2) Reste (0..99) si reste = 0 alors affiche res terminer fin si // 0..19 si reste < 20 alors appelle ajouter(mot_0_19(reste)) affiche res terminer fin si // 20..99 diz vaut (reste - (reste mod 10)) / 10 uni vaut reste mod 10 // Base de dizaine (sans gérer encore 70/90) selon diz cas 2: part vaut 'vingt' cas 3: part vaut 'trente' cas 4: part vaut 'quarante' cas 5: part vaut 'cinquante' cas 6: part vaut 'soixante' cas 7: part vaut 'soixante' // 70..79 = 60 + (10..19) cas 8: part vaut 'quatre-vingt' cas 9: part vaut 'quatre-vingt' // 90..99 = 80 + (10..19) fin selon // Cas 70 et 90 : on transforme l’unité en 10..19 si diz = 7 ou diz = 9 alors uni vaut uni + 10 fin si // Si on est dans 20..69 et unité = 1, on peut faire "vingt-et-un", etc. // Cas du "et-un" (21, 31, 41, 51, 61) si uni = 1 alors si diz >= 2 et diz <= 6 alors appelle ajouter(part + '-et-un') affiche res terminer fin si fin si // Unité = 0 : ex 20, 30, 40, 80... si uni = 0 alors appelle ajouter(part) affiche res terminer fin si // Unité 1..9 (cas normal hors 70/90) si uni < 10 alors appelle ajouter(part + '-' + mot_unite(uni)) affiche res terminer fin si // Unité 10..19 (70/90, ou 71..79 / 91..99) appelle ajouter(part + '-' + mot_0_19(uni)) affiche res
Jeu du morpoin avec bot
// Joueur X : humain // Joueur O : bot grille est un tableau i est un nombre ligne est un nombre colonne est un nombre joueur est un texte tour est un nombre gagne est un booléen // Initialisation i vaut 0 tant que i < 9 grille ajoute ' ' i vaut i + 1 fin tant que joueur vaut 'X' tour vaut 0 gagne vaut faux // Affichage procédure afficher_grille affiche grille[0] + ' | ' + grille[1] + ' | ' + grille[2] affiche '---------' affiche grille[3] + ' | ' + grille[4] + ' | ' + grille[5] affiche '---------' affiche grille[6] + ' | ' + grille[7] + ' | ' + grille[8] fin procédure // Victoire ───── fonction victoire(j) si grille[0] = j et grille[1] = j et grille[2] = j alors retourne vrai fin si si grille[3] = j et grille[4] = j et grille[5] = j alors retourne vrai fin si si grille[6] = j et grille[7] = j et grille[8] = j alors retourne vrai fin si si grille[0] = j et grille[3] = j et grille[6] = j alors retourne vrai fin si si grille[1] = j et grille[4] = j et grille[7] = j alors retourne vrai fin si si grille[2] = j et grille[5] = j et grille[8] = j alors retourne vrai fin si si grille[0] = j et grille[4] = j et grille[8] = j alors retourne vrai fin si si grille[2] = j et grille[4] = j et grille[6] = j alors retourne vrai fin si retourne faux fin fonction // Bot : joue une seule case fonction bot_joue() i vaut 0 tant que i < 9 si grille[i] = ' ' alors grille[i] vaut 'O' retourne vrai fin si i vaut i + 1 fin tant que retourne faux fin fonction // Boucle principale tant que tour < 9 et gagne = faux appelle afficher_grille si joueur = 'X' alors affiche 'Joueur X (ligne 1-3, colonne 1-3)' demande 'Ligne : ' dans ligne demande 'Colonne : ' dans colonne ligne vaut ligne - 1 colonne vaut colonne - 1 i vaut ligne * 3 + colonne si i < 0 ou i > 8 alors affiche 'Position invalide' sinon si grille[i] <> ' ' alors affiche 'Case déjà occupée' sinon grille[i] vaut 'X' tour vaut tour + 1 si victoire('X') alors appelle afficher_grille affiche '🎉 Joueur X a gagné !' gagne vaut vrai sinon joueur vaut 'O' fin si fin si fin si sinon affiche '🤖 Le bot joue...' si bot_joue() alors tour vaut tour + 1 si victoire('O') alors appelle afficher_grille affiche '🤖 Le bot a gagné !' gagne vaut vrai sinon joueur vaut 'X' fin si sinon // sécurité tour vaut 9 fin si fin si fin tant que si gagne = faux alors appelle afficher_grille affiche 'Match nul 🤝' fin si
Lancer de dé
face est un nombre face vaut hasard(1, 6) selon face cas 1: affiche '+-----+' affiche '| |' affiche '| o |' affiche '| |' affiche '+-----+' cas 2: affiche '+-----+' affiche '| o |' affiche '| |' affiche '| o |' affiche '+-----+' cas 3: affiche '+-----+' affiche '| o |' affiche '| o |' affiche '| o |' affiche '+-----+' cas 4: affiche '+-----+' affiche '| o o |' affiche '| |' affiche '| o o |' affiche '+-----+' cas 5: affiche '+-----+' affiche '| o o |' affiche '| o |' affiche '| o o |' affiche '+-----+' cas 6: affiche '+-----+' affiche '| o o |' affiche '| o o |' affiche '| o o |' affiche '+-----+' fin selon
Escape Game
// ---------- ÉTAT DU JEU ---------- lieu est un nombre lieu vaut 0 // 0 = cellule, 1 = bureau, 2 = couloir, 3 = sortie inventaire est un tableau cle_pris est un booléen porte_ouverte est un booléen code_trouve est un booléen cle_pris vaut faux porte_ouverte vaut faux code_trouve vaut faux // ---------- OUTILS ---------- fonction a_objet(obj) retourne contient(inventaire, obj) fin fonction procédure ajouter_objet(obj) si a_objet(obj) = faux alors inventaire ajoute obj affiche 'Objet ajouté : ' + obj fin si fin procédure procédure afficher_inventaire() affiche 'Inventaire :' si longueur(inventaire) = 0 alors affiche '(vide)' sinon pour i de 0 a longueur(inventaire) - 1 affiche '- ' + inventaire[i] fin pour fin si fin procédure // ---------- SCÈNES ---------- procédure scene_cellule() affiche '' affiche 'Tu es enfermé dans une cellule.' affiche '1: Examiner la porte' affiche '2: Regarder sous le lit' affiche '3: Inventaire' choix est un nombre demande 'Ton choix (1, 2 ou 3)' dans choix selon choix cas 1 : si cle_pris alors porte_ouverte vaut vrai affiche 'Tu ouvres la porte avec la clé.' lieu vaut 2 sinon affiche 'La porte est verrouillée.' fin si cas 2 : si cle_pris = faux alors affiche 'Tu trouves une petite clé.' cle_pris vaut vrai appelle ajouter_objet('clé') sinon affiche 'Il n''y a plus rien.' fin si cas 3 : appelle afficher_inventaire() sinon selon : affiche 'Choix invalide.' fin selon fin procédure procédure scene_bureau() affiche '' affiche 'Tu es dans un bureau abandonné.' affiche '1: Fouiller le bureau' affiche '2: Lire un papier' affiche '3: Retourner au couloir' choix est un nombre demande 'Ton choix (1, 2 ou 3)' dans choix selon choix cas 1 : affiche 'Tu ne trouves rien d'+ caractère(39) +'utile.' cas 2 : si code_trouve = faux alors affiche 'Le papier indique : CODE = 1234' code_trouve vaut vrai appelle ajouter_objet('code') sinon affiche 'Tu connais déjà le code.' fin si cas 3 : lieu vaut 2 sinon selon : affiche 'Choix invalide.' fin selon fin procédure procédure scene_couloir() affiche '' affiche 'Tu es dans le couloir.' affiche '1: Aller au bureau' affiche '2: Aller à la sortie' affiche '3: Inventaire' choix est un nombre demande 'Ton choix (1, 2 ou 3)' dans choix selon choix cas 1 : lieu vaut 1 cas 2 : lieu vaut 3 cas 3 : appelle afficher_inventaire() sinon selon : affiche 'Choix invalide.' fin selon fin procédure procédure scene_sortie() affiche '' affiche 'Une porte blindée bloque la sortie.' affiche '1: Entrer un code' affiche '2: Retourner au couloir' choix est un nombre demande 'Ton choix (1 ou 2)' dans choix selon choix cas 1 : si code_trouve alors affiche 'TU ES LIBRE !' arrete sinon affiche 'Tu ne connais pas le code.' fin si cas 2 : lieu vaut 2 sinon selon : affiche 'Choix invalide.' fin selon fin procédure // ---------- BOUCLE PRINCIPALE ---------- tant que vrai selon lieu cas 0 : appelle scene_cellule() cas 1 : appelle scene_bureau() cas 2 : appelle scene_couloir() cas 3 : appelle scene_sortie() sinon selon : affiche 'Erreur inconnue.' arrete fin selon fin tant que
Interpréteur
EduCode — Suite de tests de validation globale

Ce programme est un script de test complet destiné à vérifier le bon fonctionnement d’un langage pédagogique EduCode (syntaxe proche du français). Il exécute une grande série d’assertions (assert) organisées par sections afin de valider, de bout en bout, que l’interpréteur gère correctement :


- I/O, demande (nombre, texte)

- Variables, types et valeurs par défaut (nombre, texte, booléen)

- Constantes

- Opérateurs arithmétiques, de comparaison et logiques (priorités, parenthèses, négation…)

- Manipulations de texte (concaténation, longueur, maj/min, découpage, remplacement, …)

- Structures de contrôle : si/sinon, selon/cas

- Boucles : tant que, répète … fois, pour + gestion de arrete et continue

- Tableaux (ajout, suppression, accès, tri à bulles)

- Enregistrements (champs, existence, suppression de champ)

- Fonctions et procédures (retour de valeur, récursivité : factorielle / fibonacci, effets de bord)

- Fonctions intégrées (racine, absolue, arrondi, minimum/maximum, conversions, type_de…)

- Gestion d’erreurs avec essayer/attraper (division par zéro, variable inconnue, index hors limites…)

- Arrêt du programme avec terminer (vérifie que rien ne s’exécute après)

Script de test complet
// ============================================================ // SCRIPT DE TEST GLOBAL — EduCode // ============================================================ // ───────────────────────────────────────────── // 0. UTILITAIRE : procédure d'assertion // ───────────────────────────────────────────── procédure assert(label, obtenu, attendu) si obtenu = attendu alors affiche '[OK] ' + label sinon affiche '[FAIL] ' + label + ' — obtenu: ' + obtenu + ' attendu: ' + attendu fin si fin procédure procédure section(titre) affiche '' affiche '=== ' + titre + ' ===' fin procédure // ───────────────────────────────────────────── // 1. I/O — DEMANDE // ───────────────────────────────────────────── appelle section('1. I/O demande') n_io est un nombre demande 'Tape 7' dans n_io appelle assert('I/O nombre', convertir_texte(n_io), '7') t_io est un texte demande 'Tape Alice' dans t_io appelle assert('I/O texte', t_io, 'Alice') // ───────────────────────────────────────────── // 2. VARIABLES & TYPES // ───────────────────────────────────────────── appelle section('2. Variables & Types') n est un nombre appelle assert('nombre défaut', convertir_texte(n), '0') t est un texte appelle assert('texte défaut', t, '') b est un booléen appelle assert('booléen défaut', convertir_texte(b), 'faux') n vaut 42 appelle assert('affectation nombre', convertir_texte(n), '42') t vaut 'Bonjour' appelle assert('affectation texte', t, 'Bonjour') b vaut vrai appelle assert('affectation booléen', convertir_texte(b), 'vrai') // Déclaration multiple x, y, z est un nombre x vaut 1 y vaut 2 z vaut 3 appelle assert('décl. multiple x', convertir_texte(x), '1') appelle assert('décl. multiple y', convertir_texte(y), '2') appelle assert('décl. multiple z', convertir_texte(z), '3') // ───────────────────────────────────────────── // 3. CONSTANTES // ───────────────────────────────────────────── appelle section('3. Constantes') PI est une constante vaut 3.14159 appelle assert('constante PI (approx)', convertir_texte(absolue(PI - 3.14159) < 0.000001), 'vrai') // Tentative de modification (doit lever une erreur) essayer PI vaut 9999 attraper errC affiche '[OK] constante protégée : ' + errC fin essayer // ───────────────────────────────────────────── // 4. OPÉRATEURS ARITHMÉTIQUES // ───────────────────────────────────────────── appelle section('4. Opérateurs arithmétiques') appelle assert('addition', convertir_texte(3 + 4), '7') appelle assert('soustraction', convertir_texte(10 - 3), '7') appelle assert('multiplication', convertir_texte(6 * 7), '42') appelle assert('division', convertir_texte(15 / 2), '7,5') appelle assert('modulo', convertir_texte(17 mod 5), '2') appelle assert('priorité', convertir_texte(2 + 3 * 4), '14') appelle assert('parenthèses', convertir_texte((2 + 3) * 4), '20') appelle assert('négatif unaire', convertir_texte(-5 + 2), '-3') // Division par zéro => erreur essayer r est un nombre r vaut 1 / 0 affiche '[FAIL] division par zéro non détectée' attraper errDiv affiche '[OK] division par zéro attrapée' fin essayer // ───────────────────────────────────────────── // 5. OPÉRATEURS DE COMPARAISON & LOGIQUE // ───────────────────────────────────────────── appelle section('5. Comparaisons & logique') appelle assert('égal vrai', convertir_texte(5 = 5), 'vrai') appelle assert('égal faux', convertir_texte(5 = 6), 'faux') appelle assert('différent', convertir_texte(5 <> 6), 'vrai') appelle assert('inférieur', convertir_texte(3 < 5), 'vrai') appelle assert('supérieur', convertir_texte(5 > 3), 'vrai') appelle assert('inf ou égal', convertir_texte(5 <= 5), 'vrai') appelle assert('sup ou égal', convertir_texte(6 >= 5), 'vrai') appelle assert('et vrai', convertir_texte(vrai et vrai), 'vrai') appelle assert('et faux', convertir_texte(vrai et faux), 'faux') appelle assert('ou vrai', convertir_texte(faux ou vrai), 'vrai') appelle assert('ou faux', convertir_texte(faux ou faux), 'faux') appelle assert('non vrai', convertir_texte(non vrai), 'faux') appelle assert('non faux', convertir_texte(non faux), 'vrai') appelle assert('combo logique', convertir_texte(vrai et (non faux)), 'vrai') // ───────────────────────────────────────────── // 6. TEXTE — CONCATÉNATION & OPÉRATIONS // ───────────────────────────────────────────── appelle section('6. Texte & concaténation') s est un texte s vaut 'Hello' + ', ' + 'World!' appelle assert('concat', s, 'Hello, World!') s ajoute ' Oui' appelle assert('ajoute texte', s, 'Hello, World! Oui') appelle assert('longueur', convertir_texte(longueur('Bonjour')), '7') appelle assert('majuscules', majuscules('abc'), 'ABC') appelle assert('minuscules', minuscules('ABC'), 'abc') appelle assert('contient vrai', convertir_texte(contient('Bonjour', 'jour')), 'vrai') appelle assert('contient faux', convertir_texte(contient('Bonjour', 'xyz')), 'faux') appelle assert('remplacer', remplacer('aababab', 'ab', 'X'), 'aXXX') appelle assert('inverser', inverser('abc'), 'cba') appelle assert('supprime_espace', supprime_espace(' ok '), 'ok') appelle assert('repeter_texte', repeter_texte('ha', 3), 'hahaha') appelle assert('commence_par', convertir_texte(commence_par('Bonjour', 'Bon')), 'vrai') appelle assert('termine_par', convertir_texte(termine_par('Bonjour', 'jour')), 'vrai') appelle assert('compter', convertir_texte(compter('abababab', 'ab')), '4') appelle assert('copier', copier('Bonjour', 2, 3), 'onj') appelle assert('position', convertir_texte(position('jour', 'Bonjour')), '4') appelle assert('code A', convertir_texte(code('A')), '65') appelle assert('caractère 65', caractère(65), 'A') tab est un tableau tab ajoute 'alpha' tab ajoute 'beta' tab ajoute 'gamma' parties est un tableau parties vaut découper('un;deux;trois', ';') appelle assert('découper nb', convertir_texte(longueur(parties)), '3') appelle assert('découper [0]', parties[0], 'un') appelle assert('découper [2]', parties[2], 'trois') // ───────────────────────────────────────────── // 7. CONDITION SI / SINON // ───────────────────────────────────────────── appelle section('7. Condition SI / SINON') age est un nombre age vaut 20 si age >= 18 alors appelle assert('si vrai', 'majeur', 'majeur') sinon appelle assert('si vrai', 'mineur', 'majeur') fin si si age < 18 alors appelle assert('si faux', 'mineur', 'majeur') sinon appelle assert('si faux', 'majeur', 'majeur') fin si // SI imbriqués note est un nombre note vaut 15 mention est un texte si note >= 16 alors mention vaut 'Très bien' sinon si note >= 14 alors mention vaut 'Bien' sinon si note >= 10 alors mention vaut 'Passable' sinon mention vaut 'Échec' fin si fin si fin si appelle assert('si imbriqué', mention, 'Bien') // ───────────────────────────────────────────── // 8. SELON / CAS // ───────────────────────────────────────────── appelle section('8. Selon / Cas') jour est un nombre jour vaut 3 nomJour est un texte selon jour cas 1: nomJour vaut 'Lundi' cas 2: nomJour vaut 'Mardi' cas 3: nomJour vaut 'Mercredi' cas 4: nomJour vaut 'Jeudi' sinon selon: nomJour vaut 'Autre' fin selon appelle assert('selon cas 3', nomJour, 'Mercredi') jour vaut 7 selon jour cas 1: nomJour vaut 'Lundi' sinon selon: nomJour vaut 'Weekend' fin selon appelle assert('selon sinon', nomJour, 'Weekend') // ───────────────────────────────────────────── // 9. BOUCLE TANT QUE // ───────────────────────────────────────────── appelle section('9. Boucle TANT QUE') compteur est un nombre compteur vaut 0 somme est un nombre somme vaut 0 tant que compteur < 5 somme ajoute compteur compteur ajoute 1 fin tant que appelle assert('tant que somme 0..4', convertir_texte(somme), '10') // Avec ARRETE compteur vaut 0 resultat est un texte resultat vaut '' tant que vrai si compteur >= 3 alors arrete fin si resultat ajoute convertir_texte(compteur) compteur ajoute 1 fin tant que appelle assert('tant que + arrete', resultat, '012') // Avec CONTINUE compteur vaut 0 resultat vaut '' tant que compteur < 6 compteur ajoute 1 si compteur mod 2 = 0 alors continue fin si resultat ajoute convertir_texte(compteur) fin tant que appelle assert('tant que + continue (impairs)', resultat, '135') // ───────────────────────────────────────────── // 10. BOUCLE RÉPÈTE ... FOIS // ───────────────────────────────────────────── appelle section('10. Boucle RÉPÈTE ... FOIS') acc est un texte acc vaut '' répète 5 fois acc ajoute '*' fin répète appelle assert('répète 5 fois', acc, '*****') // RÉPÈTE avec ARRETE acc vaut '' repetitions est un nombre repetitions vaut 0 répète 10 fois repetitions ajoute 1 si repetitions > 4 alors arrete fin si acc ajoute 'X' fin répète appelle assert('répète arrete', acc, 'XXXX') // RÉPÈTE avec CONTINUE acc vaut '' idx est un nombre idx vaut 0 répète 6 fois idx ajoute 1 si idx mod 2 = 1 alors continue fin si acc ajoute convertir_texte(idx) fin répète appelle assert('répète continue (pairs)', acc, '246') // ───────────────────────────────────────────── // 11. BOUCLE POUR // ───────────────────────────────────────────── appelle section('11. Boucle POUR') total est un nombre total vaut 0 pour i de 1 à 5 total ajoute i fin pour appelle assert('pour somme 1..5', convertir_texte(total), '15') // Pas négatif seq est un texte seq vaut '' pour k de 5 à 1 pas -1 seq ajoute convertir_texte(k) fin pour appelle assert('pour décroissant', seq, '54321') // Pas personnalisé seq vaut '' pour p de 0 à 10 pas 2 seq ajoute convertir_texte(p) fin pour appelle assert('pour pas=2', seq, '0246810') // POUR avec ARRETE et CONTINUE seq vaut '' pour q de 1 à 10 si q > 6 alors arrete fin si si q mod 3 = 0 alors continue fin si seq ajoute convertir_texte(q) fin pour appelle assert('pour arrete+continue', seq, '1245') // ───────────────────────────────────────────── // 12. TABLEAUX // ───────────────────────────────────────────── appelle section('12. Tableaux') fruits est un tableau fruits ajoute 'pomme' fruits ajoute 'banane' fruits ajoute 'cerise' appelle assert('tableau longueur', convertir_texte(longueur(fruits)), '3') appelle assert('tableau [0]', fruits[0], 'pomme') appelle assert('tableau [2]', fruits[2], 'cerise') fruits[1] vaut 'mangue' appelle assert('tableau[1] modif', fruits[1], 'mangue') appelle assert('premier', premier(fruits), 'pomme') appelle assert('dernier', dernier(fruits), 'cerise') appelle assert('contient tableau vrai', convertir_texte(contient(fruits, 'mangue')), 'vrai') appelle assert('contient tableau faux', convertir_texte(contient(fruits, 'kiwi')), 'faux') // Suppression fruits supprime 1 appelle assert('après supprime', convertir_texte(longueur(fruits)), '2') appelle assert('après supprime [1]', fruits[1], 'cerise') // Vide vide fruits appelle assert('vide tableau', convertir_texte(longueur(fruits)), '0') // Tableau numérique + tri nums est un tableau nums ajoute 5 nums ajoute 1 nums ajoute 4 nums ajoute 2 nums ajoute 3 // Tri à bulles taille est un nombre taille vaut longueur(nums) tmp est un nombre pass est un nombre borne est un nombre jj est un nombre pass vaut 0 tant que pass < taille - 1 borne vaut taille - 2 - pass jj vaut 0 tant que jj <= borne si nums[jj] > nums[jj + 1] alors tmp vaut nums[jj] nums[jj] vaut nums[jj + 1] nums[jj + 1] vaut tmp fin si jj ajoute 1 fin tant que pass ajoute 1 fin tant que appelle assert('tri bulles [0]', convertir_texte(nums[0]), '1') appelle assert('tri bulles [4]', convertir_texte(nums[4]), '5') // ───────────────────────────────────────────── // 13. ENREGISTREMENTS // ───────────────────────────────────────────── appelle section('13. Enregistrements') personne est un enregistrement personne.nom vaut 'Alice' personne.age vaut 30 personne.actif vaut vrai appelle assert('enreg nom', personne.nom, 'Alice') appelle assert('enreg age', convertir_texte(personne.age), '30') appelle assert('enreg actif', convertir_texte(personne.actif), 'vrai') personne.age ajoute 1 appelle assert('enreg ajoute', convertir_texte(personne.age), '31') personne.age soustrait 5 appelle assert('enreg soustrait', convertir_texte(personne.age), '26') appelle assert('existe champ vrai', convertir_texte(existe(personne, 'nom')), 'vrai') appelle assert('existe champ faux', convertir_texte(existe(personne, 'email')), 'faux') ok est un booléen ok vaut supprime_champ(personne, 'actif') appelle assert('supprime_champ ok', convertir_texte(ok), 'vrai') appelle assert('existe après supprime', convertir_texte(existe(personne, 'actif')), 'faux') // ───────────────────────────────────────────── // 14. FONCTIONS // ───────────────────────────────────────────── appelle section('14. Fonctions') fonction carre(n) retourne n * n fin fonction appelle assert('carre(5)', convertir_texte(carre(5)), '25') appelle assert('carre(0)', convertir_texte(carre(0)), '0') fonction factorielle(n) si n <= 1 alors retourne 1 fin si retourne n * factorielle(n - 1) fin fonction appelle assert('facto(1)', convertir_texte(factorielle(1)), '1') appelle assert('facto(5)', convertir_texte(factorielle(5)), '120') fonction fibonacci(n) si n <= 0 alors retourne 0 fin si si n = 1 alors retourne 1 fin si retourne fibonacci(n - 1) + fibonacci(n - 2) fin fonction appelle assert('fib(0)', convertir_texte(fibonacci(0)), '0') appelle assert('fib(1)', convertir_texte(fibonacci(1)), '1') appelle assert('fib(10)', convertir_texte(fibonacci(10)), '55') fonction maximum_local(v, b, c) res est un nombre res vaut v si b > res alors res vaut b fin si si c > res alors res vaut c fin si retourne res fin fonction appelle assert('max3(3,9,5)', convertir_texte(maximum_local(3, 9, 5)), '9') // Fonction retournant un texte fonction saluer(prenom) retourne 'Bonjour ' + prenom + ' !' fin fonction appelle assert('saluer', saluer('Bob'), 'Bonjour Bob !') // ───────────────────────────────────────────── // 15. PROCÉDURES // ───────────────────────────────────────────── appelle section('15. Procédures') // La procédure assert (définie en haut) est déjà testée // On teste ici la portée des variables compteur_global est un nombre compteur_global vaut 0 procédure incrementer(valeur) compteur_global ajoute valeur fin procédure appelle incrementer(5) appelle incrementer(3) appelle assert('procédure effet de bord', convertir_texte(compteur_global), '8') // ───────────────────────────────────────────── // 16. FONCTIONS INTÉGRÉES // ───────────────────────────────────────────── appelle section('16. Fonctions intégrées') appelle assert('racine(9)', convertir_texte(racine(9)), '3') appelle assert('absolue(-7)', convertir_texte(absolue(-7)), '7') appelle assert('arrondi(3.7)', convertir_texte(arrondi(3.7)), '4') appelle assert('puissance(2,10)',convertir_texte(puissance(2,10)), '1024') appelle assert('minimum(3,8)', convertir_texte(minimum(3, 8)), '3') appelle assert('maximum(3,8)', convertir_texte(maximum(3, 8)), '8') appelle assert('limiter ok', convertir_texte(limiter(5,1,10)), '5') appelle assert('limiter min', convertir_texte(limiter(-5,1,10)),'1') appelle assert('limiter max', convertir_texte(limiter(15,1,10)),'10') appelle assert('est_nombre vrai', convertir_texte(est_nombre(42)), 'vrai') appelle assert('est_nombre texte', convertir_texte(est_nombre('3.14')), 'vrai') appelle assert('est_nombre faux', convertir_texte(est_nombre('abc')), 'faux') appelle assert('est_texte vrai', convertir_texte(est_texte('ok')), 'vrai') appelle assert('est_texte faux', convertir_texte(est_texte(42)), 'faux') appelle assert('est_booleen vrai', convertir_texte(est_booleen(vrai)), 'vrai') appelle assert('type_de nombre', type_de(42), 'nombre') appelle assert('type_de texte', type_de('coucou'), 'texte') appelle assert('type_de booléen', type_de(vrai), 'booléen') tmpArr est un tableau tmpArr ajoute 'a' appelle assert('type_de tableau', type_de(tmpArr), 'tableau') tmpRec est un enregistrement tmpRec.x vaut 1 appelle assert('type_de enreg', type_de(tmpRec), 'enregistrement') appelle assert('convertir_texte', convertir_texte(123), '123') appelle assert('convertir_nombre', convertir_texte(convertir_nombre('3,14')), '3,14') appelle assert('sialors vrai', sialors(vrai, 'oui', 'non'), 'oui') appelle assert('sialors faux', sialors(faux, 'oui', 'non'), 'non') // ───────────────────────────────────────────── // 17. GESTION D'ERREURS (ESSAYER / ATTRAPER) // ───────────────────────────────────────────── appelle section('17. Essayer / Attraper') // Variable inconnue essayer v est un texte v vaut inconnue_xyz affiche '[FAIL] variable inconnue non détectée' attraper e1 affiche '[OK] variable inconnue attrapée : ' + e1 fin essayer // Index hors limites essayer arr2 est un tableau arr2 ajoute 'a' lu est un texte lu vaut arr2[99] affiche '[FAIL] index hors limites non détecté' attraper e2 affiche '[OK] index hors limites attrapé' fin essayer // Essayer sans erreur : le bloc attraper ne s'exécute pas flag est un texte flag vaut 'avant' essayer flag vaut 'dans_essai' attraper e3 flag vaut 'attrapé' fin essayer appelle assert('essayer sans erreur', flag, 'dans_essai') // Essayer imbriqués essayer essayer x2 est un nombre x2 vaut 1 / 0 affiche '[FAIL] imbriqué sans catch' attraper ei affiche '[OK] essayer imbriqué : ' + ei fin essayer attraper eOuter affiche '[FAIL] leakage vers outer' fin essayer // ───────────────────────────────────────────── // 18. CONDITIONS AVANCÉES // ───────────────────────────────────────────── appelle section('18. Conditions avancées') // Variables locales à cette section cx est un nombre cb est un nombre cc est un nombre ct est un texte cu est un texte cok est un booléen ctab est un tableau ci est un nombre cx vaut 1 cb vaut 2 cc vaut 3 ct vaut 'bonjour' cu vaut 'bonjour' cok vaut vrai ci vaut 0 ctab ajoute 1 ctab ajoute 2 ctab ajoute 3 ctab ajoute 1 // --- Nombres : égalité simple si cx = 1 alors affiche '[OK] T01 cx = 1' sinon affiche '[FAIL] T01 cx = 1' fin si // --- et chaîné : cx < cb < cc si cx < cb et cb < cc alors affiche '[OK] T02 cx < cb et cb < cc' sinon affiche '[FAIL] T02' fin si // --- triple et si cx = 1 et cb = 2 et cc = 3 alors affiche '[OK] T03 triple et' sinon affiche '[FAIL] T03' fin si // --- quadruple et avec inégalité si cx = 1 et cb = 2 et cc = 3 et cb > cx alors affiche '[OK] T04 quadruple et' sinon affiche '[FAIL] T04' fin si // --- ou : premier faux, second vrai si cx = 0 ou cb = 2 alors affiche '[OK] T05 ou (premier faux)' sinon affiche '[FAIL] T05' fin si // --- ou triple : seul le troisième vrai si cx = 0 ou cb = 0 ou cc = 3 alors affiche '[OK] T06 ou triple' sinon affiche '[FAIL] T06' fin si // --- non simple si non cx = 2 alors affiche '[OK] T07 non cx=2' sinon affiche '[FAIL] T07' fin si // --- non d'un ou (De Morgan) si non (cx = 2 ou cb = 3) alors affiche '[OK] T08 non(cx=2 ou cb=3)' sinon affiche '[FAIL] T08' fin si // --- textes : égalité entre deux variables si ct = cu alors affiche '[OK] T09 ct = cu' sinon affiche '[FAIL] T09' fin si // --- textes : égalité variable + littéral, double et si ct = 'bonjour' et cu = 'bonjour' alors affiche '[OK] T10 textes et' sinon affiche '[FAIL] T10' fin si // --- booléen seul dans le si si cok alors affiche '[OK] T11 si cok' sinon affiche '[FAIL] T11' fin si // --- booléen + condition nombre si cok et cx = 1 alors affiche '[OK] T12 cok et cx=1' sinon affiche '[FAIL] T12' fin si // --- tableau : accès par littéral si ctab[0] = 1 alors affiche '[OK] T13 ctab[0]=1' sinon affiche '[FAIL] T13' fin si // --- tableau : double accès si ctab[0] = 1 et ctab[1] = 2 alors affiche '[OK] T14 ctab[0] et ctab[1]' sinon affiche '[FAIL] T14' fin si // --- tableau : triple accès si ctab[0] = 1 et ctab[1] = 2 et ctab[2] = 3 alors affiche '[OK] T15 ctab triple' sinon affiche '[FAIL] T15' fin si // --- tableau + variable index si ctab[ci] = 1 alors affiche '[OK] T16 ctab[ci]' sinon affiche '[FAIL] T16' fin si // --- tableau + index calculé ci+1 si ctab[ci] = 1 et ctab[ci + 1] = 2 alors affiche '[OK] T17 ctab[ci] et ctab[ci+1]' sinon affiche '[FAIL] T17' fin si // --- tableau + triple index calculé si ctab[ci] = 1 et ctab[ci + 1] = 2 et ctab[ci + 2] = 3 alors affiche '[OK] T18 ctab triple index calculé' sinon affiche '[FAIL] T18' fin si // --- fonction retournant booléen dans si fonction est_un(v) si v = 1 alors retourne vrai fin si retourne faux fin fonction si est_un(cx) alors affiche '[OK] T19 est_un(cx)' sinon affiche '[FAIL] T19' fin si // --- deux appels de fonction dans le si si est_un(cx) et est_un(ctab[0]) alors affiche '[OK] T20 est_un(cx) et est_un(ctab[0])' sinon affiche '[FAIL] T20' fin si // --- fonction + non dans le si si est_un(cx) et est_un(ctab[0]) et non est_un(cb) alors affiche '[OK] T21 est_un + non est_un' sinon affiche '[FAIL] T21' fin si // --- fonction multi-paramètres comparant des éléments de tableau fonction tous_egaux(v, w, zz) si v = w et w = zz alors retourne vrai fin si retourne faux fin fonction // ctab[0]=1, ctab[3]=1, cx=1 : tous egaux si tous_egaux(ctab[0], ctab[3], cx) alors affiche '[OK] T22 tous_egaux tableau+variable' sinon affiche '[FAIL] T22' fin si // --- sinon : vérification via assert appelle assert('T23 sinon', convertir_texte(cx = 0), 'faux') // --- T24 : ou — premier vrai, second faux vv est un nombre si cx = 1 ou cc = 9 alors affiche '[OK] T24 ou court-circuit vrai' sinon affiche '[FAIL] T24' fin si // --- T25 : ou — tous faux si cx = 99 ou cc = 99 alors affiche '[FAIL] T25' sinon affiche '[OK] T25 ou tout faux' fin si // --- T26 : non + et — résultat faux car les deux membres sont vrais si non (cx = 1 et cb = 2) alors affiche '[FAIL] T26' sinon affiche '[OK] T26 non(et) = faux' fin si // --- T27 : non + ou — résultat vrai car les deux membres sont faux si non (cx = 99 ou cb = 99) alors affiche '[OK] T27 non(ou) = vrai' sinon affiche '[FAIL] T27' fin si // --- T28 : expression arithmétique dans condition // (cx+cb)*cc = (1+2)*3 = 9 si (cx + cb) * cc = 9 alors affiche '[OK] T28 expr arithm dans cond' sinon affiche '[FAIL] T28' fin si // --- T29 : comparaison lexicographique texte < si 'abc' < 'abd' alors affiche '[OK] T29 texte <' sinon affiche '[FAIL] T29' fin si // --- T30 : comparaison lexicographique texte > si 'z' > 'a' alors affiche '[OK] T30 texte >' sinon affiche '[FAIL] T30' fin si // --- T31 : comparaison texte <> si 'abc' <> 'ABC' alors affiche '[OK] T31 texte <>' sinon affiche '[FAIL] T31' fin si // --- T32 : booléen composé vrai — triple et si cx = 1 et cb = 2 et cc = 3 alors affiche '[OK] T32 booléen composé vrai' sinon affiche '[FAIL] T32' fin si // --- T33 : booléen composé faux — second membre faux si cx = 1 et cb = 99 alors affiche '[FAIL] T33' sinon affiche '[OK] T33 booléen composé faux' fin si // --- si imbriqué 3 niveaux avec conditions mixtes res_imb est un texte res_imb vaut 'rien' si cx = 1 alors si cb = 2 alors si cc = 3 alors res_imb vaut 'triple' fin si fin si fin si appelle assert('T34 si imbriqué 3 niveaux', res_imb, 'triple') // --- cascade sinon : seule la 3e branche est vraie res_imb vaut 'rien' si cx = 99 alors res_imb vaut 'branche1' sinon si cb = 99 alors res_imb vaut 'branche2' sinon si cc = 3 alors res_imb vaut 'branche3' sinon res_imb vaut 'branche4' fin si fin si fin si appelle assert('T35 cascade sinon', res_imb, 'branche3') // --- condition ou dans tant que : filtre sur tableau acc_cond est un nombre acc_cond vaut 0 ci vaut 0 tant que ci < longueur(ctab) si ctab[ci] = 1 ou ctab[ci] = 3 alors acc_cond ajoute ctab[ci] fin si ci ajoute 1 fin tant que // ctab=[1,2,3,1] : garde 1,3,1 => somme=5 appelle assert('T36 cond ou dans tant que', convertir_texte(acc_cond), '5') // --- condition et dans pour : filtre intervalle acc_cond vaut 0 pour fi de 0 à longueur(ctab) - 1 si ctab[fi] >= 2 et ctab[fi] <= 3 alors acc_cond ajoute ctab[fi] fin si fin pour // ctab=[1,2,3,1] : garde 2,3 => somme=5 appelle assert('T37 cond et dans pour', convertir_texte(acc_cond), '5') // --- fonction booléenne dans pour fonction est_pair(n) si n mod 2 = 0 alors retourne vrai fin si retourne faux fin fonction acc_cond vaut 0 pour fi de 1 à 10 si est_pair(fi) alors acc_cond ajoute fi fin si fin pour // 2+4+6+8+10 = 30 appelle assert('T38 fn bool dans pour', convertir_texte(acc_cond), '30') // --- selon + condition après selon niv est un nombre niv vaut 2 label_niv est un texte selon niv cas 1: label_niv vaut 'bas' cas 2: label_niv vaut 'moyen' cas 3: label_niv vaut 'haut' sinon selon: label_niv vaut 'inconnu' fin selon si label_niv = 'moyen' et niv >= 2 alors affiche '[OK] T39 selon + si après' sinon affiche '[FAIL] T39' fin si // --- essayer avec condition sur le message d'erreur essayer val_err est un nombre val_err vaut 10 / 0 attraper emsg si contient(emsg, 'zéro') alors affiche '[OK] T40 catch + contient' sinon affiche '[FAIL] T40 message inattendu : ' + emsg fin si fin essayer // ───────────────────────────────────────────── // 19. TERMINER (sortie anticipée) // ───────────────────────────────────────────── appelle section('19. Instruction TERMINER') affiche '[OK] avant terminer' terminer // Ce qui suit ne doit jamais s'afficher affiche '[FAIL] code après terminer exécuté !'
Contact & Suggestions
Une question, un bug, une idée d'amélioration ? Écrivez-nous.
Envoyer un message
Informations
Développeur
Grégory.P — Créateur et mainteneur d'EduCode
Support — support@educode-academie.fr
Délai de réponse
Les messages sont traités sous 2 à 5 jours ouvrés selon le volume reçu.
Bugs critiques
Précisez les étapes pour reproduire le problème — cela accélère considérablement le diagnostic.
Votre retour est précieux. EduCode s'améliore grâce aux utilisateurs — enseignants, formateurs, apprenants. Toutes les suggestions sont lues et considérées.