EduCode
EduCode

EduCode

EduCode est un environnement logiciel éducatif conçu pour faciliter l'apprentissage de la programmation, de l'algorithmique et de la logique informatique.

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

Version actuelle v1.8 Stable

EduCode — Environnement pédagogique

Fonctionne sans installation supplémentaire
Compatible Windows : 10, 11
Application : 100% API Localhost
Licence éducative : 100% gratuit
Application : Version portable
Taille de l'application : 6,05 Mo
Nom du fichier : EduCode.zip
Taille du fichier zip : 2,39 Mo
🚀 programmeurs en herbe ont téléchargé EduCode !
Pour des raisons de sécurité, évitez tout téléchargement d'EduCode depuis des sources non officielles.
Avant de démarrer, pensez à consulter le "Guide de démarrage" : il explique les prérequis et les étapes de lancement du serveur, puis comment accéder à votre l’interface.
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.
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 — 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.
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 par cookie HttpOnly, logique applicative et interface utilisateur sont totalement indépendantes. La logique n'est transmise au navigateur qu'après validation du cookie de session côté serveur — jamais côté client.
Guide de démarrage
EduCode

Prérequis

- Le port 8080 est disponible sur votre machine (personnalisable via "EduCode.exe --port=XXXX")

- Un navigateur web moderne est installé (Chrome, Firefox, Edge)

EduCode fonctionne entièrement en local sur 127.0.0.1 (localhost)

Créer un Launcher avec PowerShell

1) Ouvrez le Bloc-notes (touche Win + R, tapez notepad, puis Entrée)

2) Copiez le contenu ci-dessous et collez-le dans le Bloc-notes

# EduCode Launcher $EduCodePath = Join-Path $PSScriptRoot "EduCode.exe" if (-not (Test-Path $EduCodePath)) { Write-Error "EduCode.exe introuvable dans : $PSScriptRoot" exit 1 } Start-Process -FilePath $EduCodePath -ArgumentList "--start", "--port=8080", "--session=60", "--stopping=3"

--start : Démarre automatiquement le serveur et ouvre le navigateur dès le lancement d'EduCode.

--port=8080 : Définit le port sur lequel le serveur HTTP local sera démarré.

--session=60 : Définit la durée d'inactivité (en minutes) au-delà de laquelle le serveur s'arrête automatiquement.

--stopping=3 : Définit la durée maximale d'exécution d'un programme interprété (en minutes).


3) Cliquez sur Fichier → Enregistrer sous...

4) Dans le champ "Type de fichier", sélectionnez Tous les fichiers

5) Nommez le fichier "Launcher EduCode.ps1"

6) Placez-le dans le même dossier que EduCode.exe

7) Cliquez sur Enregistrer

Pour l'exécuter, faites un clic droit sur le fichier "Launcher EduCode.ps1" et choisissez Exécuter avec PowerShell.


Si Windows bloque l'exécution du script, lance cette commande une seule fois dans PowerShell en administrateur :

Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSigned

EduCode

Démarrage du serveur
01
Étape 1 — Lancer EduCode
Lancez l’application EduCode.exe.
02
Étape 2 — Démarrer le serveur
Cliquez sur le bouton « Démarrer le serveur ».
Le serveur démarre et affiche dans la console :
# Serveur démarré sur http://localhost:8080
# Session token généré
Un token de session cryptographique est généré automatiquement à chaque démarrage.
03
Étape 3 — Accéder à l'interface
Cliquez sur le bouton « Go ! EduCode » pour ouvrir l'interface dans votre navigateur.

Messages d'erreur courants
Port déjà utilisé : Un autre service occupe le port 8080
Fermez le service en conflit ou relancez EduCode avec un autre port via --port=XXXX
Session expirée : Le navigateur affiche "Session expirée ou invalide"
Cliquez à nouveau sur « Go ! EduCode » dans l'application pour ouvrir une nouvelle session authentifiée.
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.
Protection par session authentifiée
Accès à l'éditeur contrôlé
L'éditeur n'est accessible qu'après une authentification automatique par token. L'utilisateur clique sur « Go ! EduCode » — le navigateur reçoit un cookie de session sécurisé et est redirigé vers l'interface. Aucune saisie manuelle n'est requise.
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.

Sécurité intégrée

EduCode embarque plusieurs mécanismes de sécurité actifs en permanence :

Réseau local uniquementServeur lié à 127.0.0.1 — inaccessible depuis l'extérieur
Token de session cryptographique256 bits, généré via BCryptGenRandom à chaque démarrage
Cookie HttpOnly + SameSite=StrictToken jamais exposé au JavaScript, protégé contre le CSRF
Authentification automatiqueLe token transite une seule fois dans l'URL, puis est remplacé par le cookie
Comparaison temps constantProtection contre les attaques par timing sur la vérification du token
Taille des donnéesCorps des requêtes limité à 512 Ko
Auto-déconnexionArrêt automatique après 30 minutes d'inactivité
Session expirée après 1 heureLe cookie de session expire automatiquement après 60 minutes

Auto-déconnexion

Le serveur s'arrête automatiquement après 30 minutes sans activité (aucune requête reçue).

Un message s'affiche dans la console :

# Inactivité détectée : Déconnexion automatique - Arrêt du serveur.

Pour reprendre, cliquez à nouveau sur « Démarrer le serveur ».


Console / Journal

La console affiche en temps réel les événements du serveur.

Les préfixes indiquent la nature du message :

# Événement système (démarrage, sécurité, inactivité…)

$ Activité HTTP (requête, réponse, ressource servie…)


EduCode
Aide interactive
Découvrez l’Aide interactive
L’Aide interactive est un guide intégré qui fournit des explications claires et des exemples de code en un instant. Conçue pour accompagner l’apprentissage et le développement, elle permet à l’utilisateur de rechercher une commande ou un concept, d’afficher une fiche explicative.

EduCode

EduCode

Astuce : Double-cliquez sur un mot dans l’éditeur pour afficher la fiche correspondante.
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.
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.
Contact & Suggestions
Une question, un bug, une idée d'amélioration ?

EduCode est un projet solo et indépendant. Il n'y a pas d'équipe support, pas de ticket system — juste un développeur attentif aux retours de la communauté. Si tu as trouvé un bug, une suggestion d'amélioration ou simplement envie d'échanger sur le projet, voici comment me joindre.

E-mail
Moyen de contact privilégié — réponse sous 48h en général.
Toutes les idées sont lues et prises en compte pour les versions futures.
Recommandé

EduCode est un projet gratuit par conviction. Si tu l'utilises en classe ou en formation, un simple retour — ce qui fonctionne, ce qui manque — est la meilleure façon de contribuer à son amélioration. Merci.
Mises à jour & Versions
Version actuelle
1.8
Version stable
Version actuelle
Cette mise à jour renforce la stabilité de l’interpréteur, clarifie l’expérience de débogage et enrichit EduCode d’un large ensemble de nouvelles fonctions prêtes à l’emploi.

Historique des versions
v1.0 Obsolète
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.
v1.1 Obsolète
Cette mise à jour consolide les fonctionnalités existantes, améliore la stabilité du système et prépare le terrain pour les prochaines évolutions majeures du projet.

Nouvelles fonctionnalités
- Partager votre programme en image : exportez votre travail au format image pour le partager facilement.
- Partager le résultat en image : exportez également le résultat de votre programme sous forme d’image.
- Importer du code : chargez rapidement un fichier de code existant dans l’éditeur (ex. : Bibliothèque EduCode).

Nouvelles options
- Auto-complétion : activez ou désactivez l’aide à la saisie selon vos préférences.
- Mode sombre : une interface plus confortable pour les longues sessions, notamment en environnement peu lumineux.

Améliorations & optimisations
- Optimisation des ressources de l’interface EduCode
- Mise à jour de l’interface graphique web
- Corrections de bugs mineurs pour plus de stabilité
- Optimisation des explications pas à pas : les logs sont désormais ignorés au-delà de 1000 lignes

Serveur EduCode
- Affichage du temps de traitement pour chaque programme interprété
- Blocage des exécutions multi-instances du serveur EduCode (prévention des lancements simultanés)
v1.2 Obsolète
Cette mise à jour apporte de nouvelles fonctionnalités, des améliorations d’interface et plusieurs optimisations afin d’offrir une expérience plus fluide et plus agréable.

Améliorations & optimisations
- Amélioration et optimisation des performances de l’interface EduCode
- Amélioration significative des performances de l’interpréteur EduCode.
- Amélioration et correction du système de recherche des mises à jour de l’application.

Sécurité & serveur
- Renforcement de la sécurité : l’interface est désormais accessible uniquement en Localhost (100 %).
- Suppression du mot de passe au profit d’une authentification automatique par session sécurisée.
- Possibilité de personnaliser le port du serveur via un paramètre de lancement (exemple : EduCode.exe --port=9090)

Langage & exécution
- Ajout d’une nouvelle action : « Arrêter l’exécution »
- Ajout d’une nouvelle condition au langage : sinon si ... alors

Interface & aide
- Intégration d’un nouveau module dans l’interface : « Bibliothèque EduCode »
- Amélioration de l’aide avec l’intégration de nouveaux contenus et modules.
v1.3 Obsolète
Cette mise à jour apporte de nouvelles fonctionnalités pédagogiques, des améliorations de l’interpréteur et plusieurs évolutions techniques visant à rendre EduCode plus expressif, plus lisible et plus agréable à utiliser.

Nouvelles fonctionnalités
Lecture du code
- EduCode intègre désormais une fonctionnalité de lecture explicative du code.
- Cette fonction analyse le programme ligne par ligne et le reformule en langage naturel, afin d’en faciliter la compréhension.
Compteur de session en temps réel
- Ajout d'un compteur de session en temps réel dans la barre d'état.

Sécurité & serveur
Personnalisation de la durée de session
- Il est désormais possible de définir la durée de session (en minutes) via un paramètre de lancement. (exemple : EduCode.exe --session=60)
Démarrage automatique
- Ajout de la commande --start : démarre automatiquement le serveur et ouvre le navigateur au lancement de l'application.

Langage & exécution
Tableaux multi-dimensionnels
- EduCode prend désormais en charge l’accès et l’affectation multi-dimensionnels dans les tableaux.
Ce qui est nouveau :
// Lecture d’un élément 2D affiche t[0][1] // Affectation d’un élément 2D t[0][1] vaut 99
Cette évolution permet :
- l’enseignement des matrices
- les boucles imbriquées
- les algorithmes 2D (tableaux, grilles, cartes, etc.)

Codes ASCII dans les expressions
- Ajout du support des codes ASCII dans les expressions.
- Un code de la forme #nombre est interprété comme un caractère texte.
affiche 'jusqu' + #39 + 'au plus profond des astres'

Nouvelle fonction : taille
- Cette fonction permet de définir ou modifier la taille d’un tableau.
- Il agit directement sur le tableau passé en paramètre et ajuste dynamiquement le nombre d’éléments.
taille(tableau, n)
Comportement :
Si "n" est supérieur à la taille actuelle :
- le tableau est agrandi
- de nouvelles cases sont créées avec une valeur par défaut
Si "n" est inférieur :
- les éléments excédentaires en fin de tableau sont supprimés
- si le tableau est vide, il est automatiquement initialisé

Valeurs hexadécimales
- Ajout du support des valeurs hexadécimales pour l’écriture des nombres.
- Un nombre précédé du symbole $ est interprété en base 16 et automatiquement converti en décimal lors de l’exécution.
x vaut $FF affiche x - $FF // 0
v1.4 Obsolète
Cette mise à jour apporte de nouvelles fonctionnalités pédagogiques, des améliorations de l’interpréteur et plusieurs évolutions techniques visant à rendre EduCode plus expressif, plus lisible et plus agréable à utiliser.

Fiabilité renforcée
- Sauvegarde automatique à l’expiration de session : le code est désormais exporté en .educode, évitant toute perte de travail.
Personnalisation du timeout d'exécution
- Arrêt automatique des interprétations longues : toute exécution dépassant x minutes est stoppée pour prévenir des calculs excessifs.
- Il est désormais possible de définir la durée maximale d'exécution d'un programme interprété (en minutes) via un paramètre de lancement. (exemple : EduCode.exe --stopping=5)

Langage plus clair et plus cohérent
- Correction d’un bug où # et autres caractères spéciaux étaient mal interprétés dans les chaînes de caractères.
- Correction de l’indentation des instructions sinon si, désormais alignées correctement avec le si initial.
- Amélioration du formatage du code : Correction des espaces avant les commentaires //, Réduction automatique des lignes vides consécutives.

Nouveautés pédagogiques
Instruction SELON / CAS multi-valeurs
- Possibilité de regrouper plusieurs valeurs dans un même cas à l’aide de virgules.
selon x cas 1, 2, 3, 4 : affiche 'ok' fin selon

Instruction SELON / CAS avec plages de valeurs
- Possibilité d’utiliser des plages de valeurs dans un cas grâce au mot‑clé a (ou à).
selon x cas 1 a 4 : affiche 'x est compris entre 1 et 4' cas 6, 8 a 10 : affiche 'autre plage' sinon selon : affiche 'hors plage' fin selon

Nouvelles fonctions intégrées
- Mathématiques : décimal, sinus, cosinus, tangente, logarithme, pi
- Texte : majuscule_initiale
- Tableaux : joindre
- Logique : pair, impair

Ajout d'un menu contextuel (clic droit) dans l'éditeur de code
- Couper
- Copier
- Coller
- Tout sélectionner
- Formater le code
v1.5 Obsolète
Cette mise à jour a été pensée pour améliorer l’expérience au quotidien, tout en ouvrant la voie à des outils plus professionnels comme les points d’arrêt, l’analyseur syntaxique et l’optimiseur de code.

Corrections
- Lors du chargement d’un fichier, la barre de défilement de l’éditeur se repositionne désormais correctement en haut.
- En mode retour à la ligne, les mots ne sont plus coupés au milieu d’une ligne.

Nouveautés
Menu contextuel :
- Rechercher : lance une recherche à partir du mot sélectionné dans l’éditeur.
- Basculer en commentaire : commente/décommente la ligne où se trouve le curseur.
- Emojis : ouvre un sélecteur d’emojis.

Coloration syntaxique : prise en charge des littéraux numériques, y compris les valeurs hexadécimales.
Mode plein écran : permet d’étendre l’éditeur en plein écran en masquant la console.
Structure du programme : affiche la liste de toutes les fonctions et procédures déclarées dans le programme.

Options
- Suppression du système de LOG pédagogique (explication pas à pas).

Nouvelles fonctionnalités
- Points d’arrêt
- Analyseur syntaxique
- Optimiseur de code
v1.6 Obsolète
Cette mise à jour consolide les fonctionnalités existantes, améliore la stabilité du système et prépare le terrain pour les prochaines évolutions majeures du projet.

Corrections
- Correction de la fonction intégrée décimal(x, 2) - plus de valeur incohérente du type 16288,9500000000007
- Correction de la procédure tri_insertion de la bibliothèque EduCode.

Nouveautés
Menu contextuel :
- Enregistrer la sélection : enregistrer uniquement la portion de code sélectionnée dans un fichier *.educode.

Interpréteur
- Amélioration de la vitesse de traitement.
- Optimisation générale des performances.

Interface
- Ajout d’un message de confirmation avant la suppression de l’éditeur.
- Ajout d’un message de confirmation avant l’ouverture d’un programme si l’éditeur n’est pas vide.
- Mise à jour et optimisation des fonctions et procédures de la bibliothèque EduCode.
- Mise à jour des emojis : actualisation et enrichissement de la liste des emojis.

Nouvelles fonctions intégrées
Tableaux
- trier : tri d’un tableau en ordre croissant ou décroissant.
- unique : suppression des doublons
Texte
- chiffres : récupére uniquement les caractères numériques présents dans un texte.
- lettres : récupérer uniquement les caractères alphabétiques présents dans un texte.
- normaliser : supprime les accents et caractères spéciaux d'un texte en les remplaçant par leur équivalent ASCII.
- importer : lecture du contenu d’un fichier txt ou csv.

Syntaxe
- Prise en charge des apostrophes doublées dans les chaînes de caractères : il suffit désormais de doubler l’apostrophe pour l’afficher.
affiche 'C''est l''été !'
v1.7 Obsolète
Cette mise à jour affine l'expérience utilisateur, renforce la robustesse de l'interpréteur et pose les bases solides des fonctionnalités à venir.

Amélioration & Nouvelles fonctions intégrées
- importer : Prise en charge des URLs (https://) — extraction du contenu d'une page web directement depuis le code.
- expression : Recherche d'un motif (expression régulière) au sein d'un texte.

Interface
Contrôle de l'exécution via les numéros de ligne :
- Clic simple → Ligne ignorée : la ligne est sautée lors de l'exécution.
- Double-clic → Point d'arrêt : l'exécution se met en pause juste avant cette ligne.

Bouton « Agrandir la console » : redimensionnez la console en un clic.
Fermeture automatique des symboles : les paires [] et () se complètent automatiquement à la saisie.
Lecture du code : fonctionnalité améliorée.
Menu contextuel : intégration d'une palette de couleurs.

Interpréteur
- Nouveau mot-clé couleur() : permet de modifier la couleur du texte affiché dans la console.
- Commentaires multilignes : prise en charge des blocs de commentaires délimités par { }.
v1.8 Actuelle
Cette mise à jour renforce la stabilité de l’interpréteur, clarifie l’expérience de débogage et enrichit EduCode d’un large ensemble de nouvelles fonctions prêtes à l’emploi.

Corrections
- Conversion ASCII réparée : #39 et autres codes renvoient à nouveau le bon caractère.
- Correction de l'alignement du curseur avec l'option retour à la ligne activée.
- Divers ajustements et améliorations de l’interface.

Nouveau mot-clé
- déboguer : Un mot-clé dédié pour afficher des messages de diagnostic sans polluer le résultat principal.
- choisir : Affiche une liste d'options cliquables dans la console.

Nouvelle option : Card de débogage
- Active ou désactive l’affichage d’une card regroupant tous les messages envoyés via déboguer.

Nouvelles fonctions intégrées
Fichier
- sauvegarder : écrit un texte dans un fichier .txt ou .csv.
- fichier_existe : vérifie l’existence d’un fichier.
- ajouter_ligne : ajoute une ligne à la fin d’un fichier sans l’effacer.
- télécharger : télécharge un fichier depuis une URL HTTPS et le sauvegarde localement.
Texte
- retirer : supprime toutes les occurrences d’un motif.
- uid : génère un identifiant unique aléatoire.
- compter_mots : compte le nombre de mots dans un texte.
- Mathématiques
- pourcentage : Retourne le % que représente valeur sur total.
- arrondi_supérieur : Retourne le plus petit entier supérieur ou égal à x (plafond).
- arrondi_inférieur : Retourne le plus grand entier inférieur ou égal à x (plancher).
- signe : Retourne 1 si le nombre est positif, -1 s'il est négatif, 0 s'il est nul.
- factorielle : Retourne la factorielle d'un entier positif (n! = 1 × 2 × … × n).
- pgcd : Retourne le plus grand commun diviseur (PGCD) de deux entiers.
Tableaux
- somme : Retourne la somme de tous les éléments d'un tableau de nombres.
- moyenne : Retourne la moyenne de tous les éléments d'un tableau de nombres.
- fusionner : Retourne un nouveau tableau contenant tous les éléments de deux tableaux mis bout à bout.
- médiane : Retourne la médiane d'un tableau de nombres (valeur centrale).
- index_de : Cherche une valeur dans un tableau et retourne sa position (0 si absente).
- intervalle : Génère un tableau d'entiers consécutifs de début à fin inclus.
Utilitaires
- est_vide : Retourne vrai si le texte, le tableau ou l'enregistrement est vide.
- défaut : Retourne la valeur par défaut correspondant au type de la variable.
Date & Heure
- jour_semaine : Retourne le numéro du jour dans la semaine (norme ISO).
- année_de : Retourne l'année d'une date sous forme de nombre.
- mois_de : Retourne le numéro du mois d'une date (1 à 12).
- jour_de : Retourne le numéro du jour dans le mois d'une date (1 à 31).
- heure_de : Retourne la partie heures d'une variable heure (0 à 23).
- minute_de : Retourne la partie minutes d'une variable heure (0 à 59).
- ajouter_jours : Ajoute (ou soustrait si négatif) un nombre de jours à une date.
- format_date : Affiche une date selon un motif personnalisé (jj, mm, aaaa, hh, nn, ss).
- semaine_de : Retourne le numéro de la semaine dans l'année (norme ISO 8601).
- est_bissextile : Retourne vrai si l'année est bissextile.
- ajouter_mois : Ajoute (ou soustrait si négatif) un nombre de mois à une date.
- ajouter_annees : Ajoute (ou soustrait si négatif) un nombre d'années à une date.

Amélioration interface
- La zone de saisie a été entièrement repensée. Les interactions utilisateur se font désormais directement dans la console, offrant une expérience plus naturelle et conforme au fonctionnement d’un terminal réel.
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 : support@educode-academie.fr

Les mises à jour sont vérifiées automatiquement au lancement d’EduCode.
Si une nouvelle mise à jour est disponible, la console t’indiquera qu’une nouvelle version est proposée.
Cette mise à jour n’est pas obligatoire, mais elle est recommandée, car elle peut inclure des corrections de bugs, des améliorations de performances et de nouvelles fonctionnalités.

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 de l’interface
Présentation de l’interface - EduCode

L’interface d’EduCode a été conçue pour offrir un environnement de programmation simple, clair et intuitif, adapté aussi bien aux débutants qu’aux utilisateurs plus avancés.

Elle se compose principalement de deux zones distinctes : un éditeur de code à gauche et une console d’exécution à droite, permettant de coder et de visualiser immédiatement les résultats.

L’éditeur propose des fonctionnalités essentielles telles que la numérotation des lignes, le formatage automatique, l’ouverture et l’enregistrement de fichiers, ainsi qu’un bouton d’exécution rapide. Une barre d’informations affiche en temps réel la position du curseur et le nombre de caractères, facilitant l’écriture du code.

La console permet d’afficher les résultats du programme, de vider l’affichage et d’interagir avec l’utilisateur grâce à la saisie de données. Un système d’options personnalisables permet d’ajuster l’affichage (taille de police, retour à la ligne, animations) afin d’améliorer le confort d’utilisation.

Dans son ensemble, EduCode propose une interface moderne, ergonomique et pensée pour apprendre le code en toute simplicité.


EduCode

É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
Arrêter l'exécutionStoppe le programme
Analyser la syntaxeContrôle la syntaxe
Formater le codeRéindente le code
Optimiser le codeOptimise le code
OuvrirCharge un fichier .educode
Importer du codeAjout d'un bloc de code à partir d'un fichier
EnregistrerTélécharge le fichier .educode
EffacerVide l'éditeur
Couleurs dans la console
Changer la couleur du texte affiché avec couleur()
EduCode

Le mot-clé couleur permet de changer la couleur du texte qui suit dans la console. Il s'utilise comme une instruction, avant les affiche concernés. La couleur reste active jusqu'à ce qu'elle soit explicitement réinitialisée avec couleur(#0).
Syntaxe
couleur(#RRGGBB)Définit la couleur du texte (format hexadécimal)
couleur(#0)Réinitialise la couleur par défaut de la console
Le format attendu est #RRGGBB — six caractères hexadécimaux précédés du symbole #, comme en CSS. Exemple : #FF0000 pour le rouge, #00CC88 pour le vert. Toute autre valeur provoque une erreur d'exécution.

EduCode

Bonnes pratiques
Toujours réinitialiser après usage
Après avoir coloré un message, appelez couleur(#0) pour revenir à la couleur normale. Sans cela, tous les affichages suivants hériteront de la couleur active.
Utiliser des constantes pour les couleurs
Si vous utilisez souvent les mêmes couleurs, déclarez-les en constantes pour éviter les fautes de frappe et rendre le code plus lisible.
Couleur depuis une variable
Cela permet de choisir la couleur dynamiquement selon l'état du programme.
Exemple avancé — constantes et couleurs dynamiques
// Déclaration des couleurs comme constantes ROUGE est une constante vaut #E05555 VERT est une constante vaut #00CC88 RESET est une constante vaut #0 n est un nombre demande 'Entrez votre note (0-20) : ' dans n si n >= 10 alors couleur(VERT) affiche '✓ Admis avec ' + n + '/20' sinon couleur(ROUGE) affiche '✗ Refusé avec ' + n + '/20' fin si couleur(RESET)
Emojis
Intégrer des emojis directement dans le code
EduCode

Les emojis peuvent être insérés directement dans n'importe quelle chaîne de caractères — dans un affiche, une variable de type texte, un message d'invite demande, ou une valeur de tableau.
Exemples
msg est un texte msg vaut '✅ Validé' affiche msg affiche '❌ Erreur détectée' affiche '⚠️ Attention : vérifiez la saisie' affiche '🎉 Bravo, tu as réussi !'
Dans l'éditeur EduCode, le menu contextuel (clic droit) propose un sélecteur d'emojis pour les insérer facilement sans avoir à les copier-coller depuis une source externe.
Points d'arrêt
Contrôlez l'exécution directement depuis les numéros de ligne
EduCode

Utilisation
Clic simple → Ligne ignorée
La ligne est sautée à l'exécution — utile pour désactiver temporairement une instruction sans la supprimer.
Double-clic → Point d'arrêt
L'exécution s'arrête juste avant cette ligne — utile pour inspecter l'état du programme à un moment précis.
Cliquez à nouveau sur le numéro de ligne pour retirer le marqueur et rétablir l'exécution normale.
Déboguer
Déboguer un programme
EduCode

Déboguer

Déboguer sert à afficher des messages de diagnostic pendant l'exécution.

La particularité par rapport à affiche : les messages ne se mélangent pas à la sortie normale du programme.

Ils sont collectés et regroupés dans une card distincte affichée à la fin, ce qui garde le résultat principal lisible.

À quoi ça sert. Suivre l’évolution d’une variable à différents moments, vérifier qu’une boucle s’exécute bien le nombre de fois prévu, ou repérer l’endroit précis où un calcul commence à dévier, tout cela sans encombrer la sortie finale du programme.

C’est un excellent réflexe pédagogique : comme il s’agit d’une instrumentation provisoire, on supprime ou on désactive ces éléments de débogage une fois le problème résolu, contrairement aux affichages destinés à faire partie du résultat final.


EduCode

Card de débogage

Card de débogage - Active ou désactive l'affichage de la card regroupant les messages déboguer.

Quand l'option est activée, tous les messages produits par l'instruction déboguer sont collectés pendant l'exécution puis affichés dans une card distincte à la fin du programme, sans se mélanger au résultat principal.

Quand elle est désactivée, les instructions déboguer sont ignorées et aucune card n'apparaît, pratique pour exécuter le programme « proprement » sans avoir à retirer les déboguer du code.

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
affichedemandechoisirdansdéboguer
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
Gestion des exceptions
essayerattraperfin essayer
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 $FFNombre hexadécimal ($)
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
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
min est une constante vaut 3.14
max est une constante vaut 100
message est une constante vaut 'Bonjour'
Utiliser une constante
affiche min
affiche max
affiche message
Date & Heure
Déclaration, affectation et affichage
Formats de référence

EduCode utilise des formats standards pour les dates et les heures :

jj/mm/aaaaFormat date : 25/12/2024
hh:mm:ssFormat heure : 14:30:00
Le format jj/mm/aaaa est le format européen (jour/mois/année), cohérent avec l'usage scolaire français.

Exemple de base
d est une date h est une heure d vaut aujourd_hui() h vaut maintenant() affiche 'Nous sommes le : ' + convertir_date(d) affiche 'Il est : ' + convertir_heure(h)
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, et choisir propose des options à sélectionner d'un simple clic. Ces 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
EduCode
choisir — proposer des options cliquables
Contrairement à demande, l'utilisateur sélectionne d'un simple clic. Les options s'affichent comme des liens cliquables dans la console, et le numéro de l'option choisie (1 pour la première, 2 pour la deuxième…) est stocké dans la variable. La variable doit être déclarée comme un nombre.
x est un nombre choisir ['Option 1', 'Option 2', 'Option 3'] dans x selon x cas 1 : affiche 'Option 1' cas 2 : affiche 'Option 2' cas 3 : affiche 'Option 3' fin selon
EduCode
Commentaires — documenter son code

Un commentaire commence par // et s'étend jusqu'à la fin de la ligne.

Pour les commentaires sur plusieurs lignes, on utilise les accolades { } : tout ce qui se trouve entre elles est 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
{
Ceci est un commentaire
sur plusieurs lignes
}
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é'
Gestion des erreurs
Anticiper et intercepter les erreurs d'exécution sans interrompre le programme
Dans un programme, certaines instructions peuvent provoquer des erreurs : division par zéro, variable inconnue, 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 situations et de réagir proprement, sans faire planter tout le programme.
Structure de base

Le bloc essayer contient le code à risque. Si une erreur survient, l'exécution saute immédiatement dans le bloc attraper — les instructions suivantes du bloc essayer sont ignorées. Après le bloc attraper, le programme reprend normalement.

essayer affiche 10 / 0 affiche 'ce texte ne sera jamais affiché' attraper affiche 'Une erreur est survenue' fin essayer affiche 'Le programme continue'
Le programme ne plante pas : après le bloc attraper, l'exécution reprend à la ligne suivant fin essayer.

Récupérer le message d'erreur

En nommant une variable après attraper, on peut lire le message d'erreur exact et l'afficher ou le traiter dans le programme.

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

Essayer imbriqué

Les blocs essayer peuvent être imbriqués. Chaque niveau gère ses propres erreurs indépendamment — une erreur dans le bloc interne ne remonte pas au bloc externe si elle est attrapée.

essayer essayer affiche 10 / 0 attraper e1 affiche 'Erreur interne : ' + e1 fin essayer attraper e2 affiche 'Erreur externe : ' + e2 fin essayer
Si l'erreur interne est attrapée par le premier attraper, le bloc attraper externe ne s'exécute pas.

Cas d'usage typiques
Division par zéro
Protéger un calcul dont le diviseur vient d'une saisie utilisateur et pourrait valoir 0.
Accès à une variable inconnue
Tenter d'accéder à une variable qui n'a pas encore été déclarée ou initialisée.
Index hors limites
Accéder à un index de tableau qui n'existe pas (ex : t[10] sur un tableau de 3 éléments).
Conversion impossible
Appeler convertir_nombre('abc') sur un texte qui ne peut pas être converti en nombre.
essayer / attraper ne doit pas servir à masquer des erreurs de logique. Si une erreur survient souvent au même endroit, mieux vaut corriger la cause avec une condition (si) plutôt que de simplement l'ignorer avec attraper.
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
si age < 12 alors afficher('Tu es un enfant') sinon si age < 18 alors afficher('Tu es un adolescent') sinon afficher('Tu es un adulte') 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 18 // je regarde la valeur selon note cas 18, 19, 20 : affiche 'Parfait' // je compare avec une valeur précise cas 10 : affiche 'Moyen' // aucun cas ne correspond sinon selon : affiche 'À améliorer' // la structure est terminée fin selon
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)
Tableau à 2 dimensions

Un tableau à 2 dimensions (souvent appelé "grille" ou "matrice") est un tableau qui contient d’autres tableaux.

- Chaque élément du tableau principal représente une ligne

- Chaque ligne est un tableau qui contient plusieurs cases (colonnes)

Important :

- L’index commence à 0 (premier élément = t[0]).

- Pour parcourir un tableau, on utilise souvent une boucle de 0 à longueur(t) - 1.

Pour une grille 2D, on utilise généralement deux boucles imbriquées (lignes puis colonnes).

// Exemple 1 // Exemple : Grille 3×3 (tableau de tableaux) grille est un tableau // Construction des 3 lignes l0 est un tableau l0 ajoute 1 l0 ajoute 2 l0 ajoute 3 grille ajoute l0 l1 est un tableau l1 ajoute 4 l1 ajoute 5 l1 ajoute 6 grille ajoute l1 l2 est un tableau l2 ajoute 7 l2 ajoute 8 l2 ajoute 9 grille ajoute l2 // Lecture d'une case (ligne 2, colonne 1) ligne est un tableau ligne vaut grille[2] affiche 'Case (2,1) = ' + ligne[1] // Parcours complet (double boucle) pour i de 0 à longueur(grille) - 1 ligne vaut grille[i] pour j de 0 à longueur(ligne) - 1 affiche 'grille[' + i + '][' + j + '] = ' + ligne[j] fin pour fin pour
// Exemple 2 // Création d’un tableau (matrice) t est un tableau // Dimensions lignes vaut 3 colonnes vaut 4 // Remplissage de la matrice avec deux boucles imbriquées pour i de 0 à lignes - 1 pour j de 0 à colonnes - 1 t[i][j] vaut i * 10 + j fin pour fin pour // Affichage de la matrice affiche 'Contenu de la matrice :' pour i de 0 à lignes - 1 pour j de 0 à colonnes - 1 affiche 't[' + i + '][' + j + '] = ' + t[i][j] fin pour fin pour
Définir dynamiquement la taille d’un tableau

La fonction taille permet de définir ou modifier dynamiquement la taille d’un tableau.

t est un tableau taille(t, 5) t[0] vaut 10 t[4] vaut 99 affiche 'Taille de t = ' + longueur(t) affiche 't[4] = ' + t[4] taille(t, 2) affiche 'Taille de t = ' + longueur(t) affiche 't[0] = ' + t[0]

si n est supérieur à la taille actuelle :

- le tableau est agrandi

- les nouvelles cases reçoivent une valeur par défaut

si n est inférieur :

- les éléments excédentaires en fin de tableau sont supprimés

- si le tableau est vide, il est automatiquement initialisé

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(xa, xb) retourne xa + xb 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(xa, xb) si xa > xb alors retourne xa sinon retourne xb 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(prénom) affiche 'Bonjour ' + prénom + ' !' 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ᵇ).
décimal(x, n) math
Arrondir un nombre à n décimales. décimal(3.14159265358979, 2) → 3.14
sinus(x) math
Retourne le sinus de x (en radians). sinus(3.14159)
cosinus(x) math
Retourne le cosinus de x (en radians). cosinus(3.14159)
tangente(x) math
Retourne la tangente de x (en radians), erreur si cosinus(x) = 0 tangente(45 * pi / 180)
logarithme(x) math
Retourne le logarithme naturel (base e) de x, x doit être > 0 logarithme(2.71828) → ≈ 1
pi() math
Retourne la valeur de π (3.14159265358979). pi() → 3.14159265358979
pair(n) math
Retourne vrai si le nombre est pair. pair(7) → faux
impair(n) math
Retourne vrai si le nombre est impair. impair(3) → vrai
pourcentage(n1, n2) math
Retourne le % que représente valeur sur total.
arrondi_supérieur(n) math
Retourne le plus petit entier supérieur ou égal à x (plafond).
arrondi_inférieur(n) math
Retourne le plus grand entier inférieur ou égal à x (plancher).
signe(n) math
Retourne 1 si le nombre est positif, -1 s'il est négatif, 0 s'il est nul.
factorielle(n) math
Retourne la factorielle d'un entier positif (n! = 1 × 2 × … × n).
pgcd(n1, n2) math
Retourne le plus grand commun diviseur (PGCD) de deux entiers.
Texte
longueur(texte) texte
Nombre de caractères dans le texte. Les espaces et la ponctuation comptent. longueur('abc')3, longueur('bonjour monde')13
majuscule_initiale(texte) texte
Met la première lettre en majuscule. majuscule_initiale('bonjour')'Bonjour'. de la casse.
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
position(motif, texte) texte
Position sert à chercher un motif (un mot, une lettre, un morceau de texte) à l’intérieur d’une chaîne, et à renvoyer l’endroit (la position) où ce motif commence. position('jour', texte) // texte = bonjour → 4
insertion(texte, position, morceau) texte
Ajoute un texte à l’intérieur d’une chaîne, à une position donnée. insertion('jour', 1, Bon) // Bonjour
chiffres(texte) texte
Récupére uniquement les caractères numériques présents dans un texte. chiffres('23ABC10') // 2310
lettres(texte) texte
Récupérer uniquement les caractères alphabétiques présents dans un texte. lettres('23ABC10') // ABC
normaliser(texte) texte
Supprime les accents et caractères spéciaux d'un texte en les remplaçant par leur équivalent ASCII. affiche normaliser('éàü') // eau
expression(motif, texte) texte
Recherche un motif (expression régulière) dans un texte. expression('\w+@\w+\.\w+', texte)
retirer(texte, motif) texte
Supprime toutes les occurrences d'un motif.
uid() texte
Génère un identifiant unique aléatoire.
compter_mots(texte) texte
Retourne le nombre de mots d'un texte.
Tableaux
longueur(tableau) tableau
Retourne le nombre d'éléments dans le tableau.
taille(tableau, n) tableau
Permet de définir ou modifier dynamiquement la taille d’un tableau. taille(t, 2)
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.
mélanger(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', ',')
joindre(tableau, séparateur) tableau
Assemble les éléments d'un tableau en un texte. affiche joindre(t, ', ')
trier(tableau) tableau
Trie les éléments d'un tableau par ordre croissant (par défaut). trier(t) // Ordre décroissant : trier(t, 'desc')
unique(tableau) tableau
Retourne un nouveau tableau sans doublons. unique(t)
somme(tableau) tableau
Retourne la somme de tous les éléments d'un tableau de nombres.
moyenne(tableau) tableau
Retourne la moyenne de tous les éléments d'un tableau de nombres.
fusionner(t1, t2) tableau
Retourne un nouveau tableau contenant tous les éléments de deux tableaux mis bout à bout.
médiane(tableau) tableau
Retourne la médiane d'un tableau de nombres (valeur centrale).
index_de(tableau) tableau
Cherche une valeur dans un tableau et retourne sa position (0 si absente).
intervalle(n1, n2) tableau
Génère un tableau d'entiers consécutifs du début à fin inclus.
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() Heure
Date actuelle au format jj/mm/aaaa. Retourne une date
hier() Date
Renvoie la date d’hier, c’est-à-dire la veille de la date d’aujourd’hui.
demain() Date
Renvoie la date de demain, c’est-à-dire le lendemain de la date d’aujourd’hui.
maintenant() Heure
Heure actuelle au format hh:mm:ss. Retourne une heure
jours_entre(date1, date2) Date
Renvoie le nombre de jours entre deux dates.
jour_semaine(date) Date
Retourne le numéro du jour dans la semaine (norme ISO).
année_de(date) Date
Retourne l'année d'une date sous forme de nombre.
mois_de(date) Date
Retourne le numéro du mois d'une date (1 à 12).
jour_de(date) Date
Retourne le numéro du jour dans le mois d'une date (1 à 31).
heure_de(heure) Heure
Retourne la partie heures d'une variable heure (0 à 23).
minute_de(heure) Heure
Retourne la partie minutes d'une variable heure (0 à 59).
ajouter_jours(date, n) Date
Retourne la partie minutes d'une variable heure (0 à 59).
format_date(date, motif) Date
Affiche une date selon un motif personnalisé (jj, mm, aaaa, hh, nn, ss).
semaine_de(date) Date
Retourne le numéro de la semaine dans l'année (norme ISO 8601).
est_bissextile(date) Date
Retourne vrai si l'année est bissextile.
ajouter_mois(date, n) Date
Ajoute (ou soustrait si négatif) un nombre de mois à une date.
ajouter_annees(date, n) Date
Ajoute (ou soustrait si négatif) un nombre d'années à une date.
Fichier
importer(fichier/url) Fichier
Lecture du contenu d'un fichier .txt ou .csv, ou d'une page web. importer('C:\monfichier.csv') / importer('https://educode-academie.fr/')
sauvegarder(fichier, texte) Fichier
Écrit un texte dans un fichier .txt ou .csv sur le disque. sauvegarder('C:\monfichier.txt', 'Bonjour monde !')
fichier_existe(fichier) Fichier
Vérifie si un fichier .txt ou .csv existe sur le disque. fichier_existe('C:\monfichier.txt')
ajouter_ligne(fichier, texte) Fichier
Ajoute une ligne à la fin d'un fichier .txt ou .csv sans effacer son contenu. ajouter_ligne('C:\log.txt', 'Démarrage du programme')
télécharger(url, répertoire) Fichier
Télécharge un fichier depuis une URL https:// et le sauvegarde dans un dossier local. télécharger('https://exemple.fr/img1.png', 'C:\Images')
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, enregistrement, date, heure
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')
incrément(x, n) util
Renvoie une nouvelle valeur correspondant à : (x + n) Elle permet donc d’augmenter une valeur numérique. x vaut incrément(x, 1)
décrément(x, n) util
Renvoie une nouvelle valeur correspondant à : (x - n) Elle permet donc de diminuer une valeur numérique. x vaut décrément(x, 1)
est_vide(x) util
Retourne vrai si le texte, le tableau ou l'enregistrement est vide.
défaut(x) util
Retourne la valeur par défaut correspondant au type de la variable.
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.
Interpréteur
Fonctionnement de l’interpréteur EduCode – point important à connaître

L’interpréteur EduCode fonctionne de manière déterministe et contrôlée : à chaque interaction avec l’utilisateur (instruction demande), le programme est ré‑exécuté depuis le début avec les nouvelles entrées fournies.

Ce comportement est volontaire et permet : de garantir une exécution propre et cohérente, de simplifier la gestion des entrées utilisateur, d’assurer une pédagogie claire, étape par étape.


Attention à l’utilisation de la fonction hasard

- La fonction hasard (ou hasardTexte) génère une valeur aléatoire à chaque exécution du programme.


Conséquence importante :

- si hasard est utilisé avant ou au moment d’une instruction demande, sa valeur sera recalculée lorsque le programme redémarre après la saisie utilisateur.

- Cela peut donner l’impression que le résultat « change tout seul », une valeur aléatoire n’est pas conservée, ou que le programme se comporte de manière imprévisible.

En réalité, le comportement est logique : le programme repart du début, donc hasard est rappelé.

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, b, 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, i, note 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.

prénom est un texte age est un nombre demande 'Quel est ton prénom ?' dans prenom demande 'Quel est ton âge ?' dans age affiche 'Bonjour, ' + prénom + ' !' 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' + caractère(39) + '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, reste est un nombre hexa, 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, reste, cent, diz, uni est un nombre res, 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, ligne, colonne, tour est un nombre joueur est un texte 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, 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
Note de fin
EduCode est un outil d’apprentissage : avance par petites étapes, teste souvent, et privilégie toujours la compréhension à la vitesse. Si tu bloques, simplifie ton programme, puis recommence.

Bonne exploration — et surtout : amuse-toi à comprendre !
Comprendre d’abord. Coder ensuite. Progresser toujours.
Licence
Conditions d'usage
EduCode est un projet indépendant, développé et maintenu par une seule personne, mis à disposition gratuitement de la communauté éducative. Les conditions ci-dessous définissent ce que vous pouvez faire avec EduCode, et ce qui est interdit sans accord préalable.
Statut juridique

EduCode est un logiciel propriétaire à usage éducatif gratuit. Il n'est pas open source : le code source n'est pas distribué et ne peut pas être copié, modifié ou redistribué sous quelque forme que ce soit sans autorisation écrite de l'auteur.

Le fait qu'EduCode soit gratuit ne signifie pas qu'il est libre de droits. Gratuité et liberté d'exploitation sont deux choses distinctes.


✓ Ce qui est autorisé
Usage pédagogique
Utiliser EduCode en classe, en formation, en atelier ou en auto-apprentissage, sans limitation de durée ni de nombre d'apprenants.
Déploiement en réseau scolaire
Installer et faire tourner EduCode sur un réseau d'établissement ou d'organisme de formation, pour les élèves et les enseignants.
Partage du lien ou du fichier
Partager EduCode à des collègues, élèves ou formateurs dans un cadre éducatif non commercial, à condition de ne pas modifier le logiciel.
Création de supports pédagogiques
Rédiger des cours, exercices, tutoriels ou évaluations qui s'appuient sur EduCode et son langage, pour un usage non commercial.
Mention dans des publications
Citer EduCode dans un mémoire, un article académique ou une présentation, en mentionnant l'auteur et la source.
✕ Ce qui est interdit
Vente ou revente
Vendre EduCode, le faire payer à des élèves ou à des institutions, ou facturer son accès sous quelque forme que ce soit.
Intégration commerciale
Intégrer EduCode dans un produit ou service payant, une plateforme e-learning commerciale, ou toute offre générant des revenus directs ou indirects.
Modification et redistribution
Modifier, décompiler, désassembler ou créer des œuvres dérivées à partir d'EduCode, puis redistribuer le résultat, avec ou sans modification.
Suppression des mentions d'auteur
Retirer, masquer ou modifier les mentions de l'auteur, les crédits ou toute référence à l'origine du logiciel dans l'interface ou la documentation.
Usage à des fins malveillantes
Exécuter du code nuisible, ou dans tout contexte contraire aux lois en vigueur.

EduCode est gratuit par conviction. Cette licence protège cet engagement : personne ne devrait pouvoir monétiser un outil conçu pour rendre l'éducation accessible à tous.