CoddyRun

Le langage CoddyRun

La référence complète du pseudo-code : chaque mot-clé, chaque structure et chaque fonction intégrée, avec des exemples prêts à copier dans l'éditeur.

18
Chapitres
FR
Syntaxe native
0
Prérequis
Mots-clés
Tous les mots réservés du langage CoddyRun
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 CoddyRun 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éentableauenregistrementdateheuretoile

CoddyRun dispose de 8 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
affichedemandechoisirappuyerdansdéboguer
Conditions
sialorssinonfin siselonfin selon
Boucles
tant quefin tant querépètefoisfin répètepourde àpasfin pourcontinuearrete

CoddyRun 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 CoddyRun, 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
x est un nombre vaut 1.5Déclaration et initialisation en une seule ligne

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' / "Bonjour"Texte entre '...' - "..."
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
Exemple Tableau
t est un tableau t[1] vaut 10 t[1] soustrait 1 // 9 affiche t[1] t[1] ajoute 1 affiche t[1] // 10

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
Classes
Définir un modèle nommé regroupant plusieurs champs typés

Qu'est-ce qu'une classe ?

Une classe est un modèle qui regroupe sous un même nom plusieurs informations différentes, appelées champs. Chaque champ possède son propre type (nombre, texte, booléen…). Une fois la classe définie, on accède à ses champs directement par leur nom, avec la notation nom_de_classe.champ.
La classe est proche de l'enregistrement : elle sert à représenter un objet du monde réel (un joueur, un produit, un point…) en réunissant toutes ses caractéristiques au même endroit. La différence est que les champs sont déclarés à l'avance, avec leur type, dans le bloc classe … fin classe. Cela rend la structure de l'objet claire et lisible dès le début du programme.
Définir une classe
Une classe commence par classe suivi de son nom et de deux-points, puis liste ses champs (un par ligne), et se termine par fin classe.
classe joueur: nom est un texte score est un nombre vie est un nombre fin classe
Accéder aux champs
Après la définition, chaque champ s'utilise comme une variable, en le préfixant du nom de la classe et d'un point. On peut lui affecter une valeur, la lire, ou la modifier avec les raccourcis numériques (ajoute, soustrait…).
joueur.nom vaut 'Alice' joueur.score vaut 100 joueur.score ajoute 50 affiche joueur.nom + ' : ' + joueur.score // Alice : 150
Classe ou enregistrement ?
Les deux regroupent plusieurs informations sous un même nom. La différence est surtout pédagogique : avec l'enregistrement, les champs apparaissent au fur et à mesure des affectations ; avec la classe, on décrit d'abord le modèle complet (tous les champs et leurs types), puis on le remplit. La classe est donc utile pour poser clairement la structure d'un objet avant de l'utiliser.
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>
constante nom 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

CoddyRun 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)

Formater une date
d est une date d vaut aujourd_hui() affiche format_date(d, 'jj/mm/aaaa') // 31/05/2026 affiche format_date(d, 'jjjj j mmmm aaaa') // dimanche 31 mai 2026 affiche format_date(d, 'jjj jj mmm') // dim. 31 mai affiche format_date(d, 'aa') // 26 affiche format_date('31/05/2026', 'aaaa-mm-jj') // 2026-05-31 // j : jour du mois (sans zéro) // jj : jour du mois sur 2 chiffres // jjj : jour de la semaine abrégé // jjjj : jour de la semaine en entier // mm : mois sur 2 chiffres // mmm : mois abrégé // mmmm : mois en entier // aa : année sur 2 chiffres // aaaa : année sur 4 chiffres
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
Exemple d'utilisation de l'instruction demander
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
menu est un tableau choix est un nombre menu ajoute 'Option 1' menu ajoute 'Option 2' menu ajoute 'Option 3' choisir menu dans choix
Boîte de dialogue de l'instruction choisir
appuyer — attend que l'utilisateur appuie sur une touche
action est un nombre appuyer ['z', 's', 'd', 'q'] dans action si action = 1 alors affiche 'Avancer' sinon si action = 2 alors affiche 'Reculer' sinon si action = 3 alors affiche 'Droite' sinon si action = 4 alors affiche 'Gauche' fin si
Exemple d'utilisation de l'instruction appuyer
cliquer — attendre un clic sur la toile
La toile doit avoir été affichée avec affiche avant l'appel. Le programme se met alors en pause jusqu'au clic, puis range les coordonnées du point cliqué dans deux variables de type nombre : l'abscisse x, puis l'ordonnée y. L'origine (0, 0) est le coin haut-gauche de la toile.
maToile est une toile
x, y est un nombre
cliquer maToile dans x, yAttend un clic et récupère sa position

Combiné à la fonction clique, qui teste si un point tombe dans une zone, cliquer permet de fabriquer de véritables boutons : il suffit d'utiliser les mêmes valeurs pour dessiner la forme et pour tester la zone.

maToile est une toile x, y est un nombre dimension(maToile, 300, 200) remplir(maToile, #0D1117) // mêmes valeurs pour le dessin et pour le test rectangle(maToile, 40, 80, 100, 45, #1976D2) label(maToile, 60, 108, 'Jouer', #FFFFFF, 16) affiche maToile cliquer maToile dans x, y si clique(x, y, 40, 80, 100, 45) alors affiche 'Tu as cliqué sur le bouton !' sinon affiche 'Raté, à côté du bouton.' fin si
Exemple d'utilisation de l'instruction cliquer
interagir — attendre un clic ou une touche

interagir réunit cliquer et appuyer en une seule instruction : le premier événement qui arrive — un clic sur la toile ou une touche de la liste — débloque le programme. C'est l'instruction de base pour écrire un jeu qui se pilote à la souris comme au clavier.

Les trois variables doivent être des nombres.
Clic sur la toile : action vaut 0, et x, y reçoivent les coordonnées du clic.
Touche pressée : action vaut le numéro de la touche (1 pour la première de la liste, 2 pour la deuxième…), et x, y valent -1.
interagir maToile, ['z', 's', 'd', 'q'] dans action, x, yClic ou touche
maToile est une toile action, x, y est un nombre dimension(maToile, 300, 200) remplir(maToile, #1E2430) affiche maToile interagir maToile, ['z', 's', 'd', 'q'] dans action, x, y si action = 0 alors affiche 'Clic en ' + x + ' ; ' + y sinon affiche 'Touche numéro ' + action fin si

Placée dans une boucle, cette instruction forme la boucle de jeu : on redessine la toile, on l'affiche, on attend l'action du joueur, puis on recommence.

maToile est une toile action, x, y est un nombre posX, posY est un nombre posX vaut 150 posY vaut 100 dimension(maToile, 300, 200) répète 20 fois effacer(maToile) cercle(maToile, posX, posY, 10, #FFD60A) remplir(maToile, #1E2430) affiche maToile interagir maToile, ['z', 's', 'd', 'q'] dans action, x, y selon action cas 0 : // clic : on téléporte le cercle posX vaut x posY vaut y cas 1 : posY vaut posY - 10 cas 2 : posY vaut posY + 10 cas 3 : posX vaut posX + 10 cas 4 : posX vaut posX - 10 fin selon fin répète
Exemple d'utilisation de l'instruction interagir
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 CoddyRun, = 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. CoddyRun 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 CoddyRun, 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).

// 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é

Dictionnaire
Collection de valeurs accessibles par clé (paires clé → valeur)
Un dictionnaire est une variable qui associe des clés à des valeurs. Contrairement au tableau, où l'on accède aux éléments par un index numérique, ici chaque valeur est retrouvée grâce à sa clé (par exemple un texte comme 'nom'). Les dictionnaires sont dynamiques : on peut ajouter, modifier ou supprimer des clés à tout moment.
Opérations de base
Dico est un dictionnaireCréer un dictionnaire vide
Dico vaut ['nom': 'Jean', 'age': 25]Initialiser avec des paires clé → valeur
affiche Dico['nom']Lire une valeur par sa clé
Dico['ville'] ajoute 'Paris'Ajouter une nouvelle clé
Dico['age'] vaut 26Modifier la valeur d'une clé existante
Dico supprime 'nom'Supprimer une clé
affiche longueur(Dico)Nombre de clés du dictionnaire
affiche contient(Dico, 'ville')Tester l'existence d'une clé (vrai / faux)
clés(Dico)Récupérer la liste des clés
Créer et lire un dictionnaire

On déclare un dictionnaire, puis on l'initialise avec des paires 'clé' : valeur. Chaque valeur se lit ensuite grâce à sa clé, placée entre crochets.

Dico est un dictionnaire Dico vaut ['nom': 'Jean', 'age': 25] // Lire une valeur par clé affiche Dico['nom'] // Jean affiche Dico['age'] // 25
Ajouter, modifier et supprimer une clé

On peut faire évoluer le dictionnaire à tout moment : ajouter une nouvelle clé avec ajoute, changer une valeur avec vaut, ou retirer une clé avec supprime.

// Ajouter / modifier une clé Dico['ville'] ajoute 'Paris' Dico['age'] vaut 26 // Supprimer une clé Dico supprime 'nom' // Nombre de clés affiche longueur(Dico) // 2 // Tester l'existence d'une clé affiche contient(Dico, 'ville') // vrai
Parcourir les clés d'un dictionnaire

La fonction cles retourne un tableau contenant toutes les clés du dictionnaire. On peut alors le parcourir avec une boucle pour pour accéder à chaque paire clé → valeur.

Liste est un tableau Liste vaut clés(Dico) pour i de 0 à longueur(Liste) - 1 affiche Liste[i] + ' = ' + Dico[Liste[i]] fin pour
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 CoddyRun, 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 CoddyRun, 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
Processus
Une tâche de fond qui s'exécute en parallèle du programme principal
Un processus est un bloc de code qui tourne en parallèle du programme principal, comme une tâche de fond. On le démarre par un simple appel — MonProcessus() — qui rend la main immédiatement : le programme continue son chemin pendant que le processus travaille. C'est l'outil idéal pour animer une toile toute seule, faire avancer une horloge ou mettre à jour des variables en arrière-plan, sans bloquer le dialogue avec l'utilisateur.
Définition & démarrage

La définition ressemble à celle d'une procédure : processus suivi d'un nom, puis fin processus. Le processus partage les variables du programme, il peut donc lire et modifier ce qui a été déclaré avant lui.

processus Compteur() n est un nombre n vaut 0 tant que vrai n ajoute 1 affiche n pause 500 fin tant que fin processus Compteur()
Le rythme : pause

Dans la boucle d'un processus, pause donne son rythme à l'animation et rend la main au programme principal. Une pause 100 correspond à dix images par seconde. La durée est exprimée en millisecondes (1000 = une seconde) et ramenée entre 60 et 3000 ms.

pause 60Le plus rapide autorisé
pause 100Dix images par seconde, fluide pour une animation
pause 500Deux fois par seconde
pause 1000Une fois par seconde, rythme d'une horloge
Dans le programme principal, pause attend en laissant vivre le processus et active l'affichage progressif : ce qui a été affiché avant la pause apparaît tout de suite.

Animer une toile pendant que le programme écoute le clavier

C'est l'usage le plus courant : le processus redessine la toile en boucle, pendant que le programme principal attend une touche. Quand le processus redessine avec affiche, l'image est remplacée en place, donc cliquer et interagir restent actifs dans le programme principal.

t est une toile dimension(t, 300, 200) x est un nombre x vaut 0 processus Balle() tant que vrai x ajoute 5 si x > 300 alors x vaut 0 fin si effacer(t) cercle(t, x, 100, 10, #ffd43b) affiche t pause 100 fin tant que fin processus Balle() action est un nombre tant que vrai appuyer ['e'] dans action terminer fin tant que

Suspendre & reprendre

suspendre met le processus en pause : il ne s'exécute plus mais garde sa position et ses variables. reprendre le relance exactement là où il s'était arrêté. Le nom entre les parenthèses est facultatif, puisqu'il n'y a qu'un processus par programme.

processus Horloge() tant que vrai affiche maintenant() pause 1000 fin tant que fin processus Horloge() nom est un texte suspendre Horloge() demande 'Ton prénom ?' dans nom reprendre Horloge() affiche 'Bonjour ' + nom
suspendre et reprendre restent sans effet si aucun processus n'est en cours ou s'il n'est pas suspendu. Pour redémarrer un processus terminé, il suffit de l'appeler à nouveau.
Les règles à connaître
Un seul processus par programme
Un appel lancé pendant qu'il tourne déjà est simplement ignoré : le processus ne démarre jamais deux fois.
Aucun dialogue avec l'utilisateur
demande, choisir, appuyer, cliquer et interagir y sont interdits : seul le programme principal parle à l'utilisateur.
Toujours une pause dans la boucle
Sans pause, le processus monopolise le programme. C'est elle qui lui donne son rythme et laisse le programme principal travailler.
Fin du programme
Le programme attend la fin du processus avant de se terminer. terminer ou le bouton Stop coupent tout immédiatement.

Récapitulatif des mots-clés
processus Nom()Ouvre la définition du processus
fin processusFerme la définition
Nom()Démarre le processus et rend la main aussitôt
pause 100Donne son rythme à la boucle (60 à 3000 ms)
suspendre Nom()Met le processus en pause sans perdre son état
reprendre Nom()Le relance là où il s'était arrêté
terminerArrête le programme et le processus
processusfin processuspausesuspendrereprendre
Fonctions intégrées
Disponibles sans déclaration, directement dans vos expressions
CoddyRun 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.
évaluer(expression) math
Évaluer une expression mathématique donnée sous forme de texte et retourne le résultat numérique.
arcsinus(radians) math
Retourne l'arc sinus de x : l'angle (en radians) dont le sinus vaut x.
arccosinus(radians) math
Retourne l'arc cosinus de x : l'angle (en radians) dont le cosinus vaut x.
radians(angle) math
Convertit un angle exprimé en degrés en radians.
hypoténuse(a, b) math
Retourne la longueur de l'hypoténuse d'un triangle rectangle de côtés a et b.
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.
supprimer(position, texte) texte
Supprime le caractère situé à une position donnée dans un texte.
uid() texte
Génère un identifiant unique aléatoire.
compter_mots(texte) texte
Retourne le nombre de mots d'un texte.
similaire(t1, t2, seuil) texte
Compare deux textes et retourne vrai s'ils se ressemblent suffisamment.
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.
assembler(t1, t2) tableau
Regroupe plusieurs tableaux élément par élément.
Dictionnaire
clés(dictionnaire) Dictionnaire
Retourne un tableau contenant toutes les clés du dictionnaire.
longueur(dictionnaire) Dictionnaire
Retourne le nombre de clés que contient le dictionnaire.
contient(clé) Dictionnaire
Vérifie si une clé existe dans le dictionnaire.
fusionner(dict1, dict2) Dictionnaire
Fusionne deux dictionnaires en un nouveau.
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).
seconde_de(heure) Heure
Retourne la partie secondes d'une variable heure (0 à 59).
ajouter_heures(heure, n) Heure
Ajoute (ou soustrait si négatif) un nombre d'heures à une heure.
ajouter_minutes(heure, n) Heure
Ajoute (ou soustrait si négatif) un nombre de minutes à une heure.
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, .csv, .svg ou d'une page web. importer('C:\monfichier.csv') / importer('https://coddyrun.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')
ouvrir(fichier) Fichier
ouvrir : Ouvre un fichier, un dossier ou une URL avec l'application par défaut du système.
liste_fichiers(dossier, extention, tableau) Fichier
Liste les fichiers d'un dossier et remplit un tableau avec leurs chemins complets.
paramètre(section, clé, valeur) / paramètre(section, clé)Fichier
Enregistre et relit des paramètres conservés d'une exécution.
Dessins
dimension(toile, largeur, hauteur) Dessin
Définit la largeur et la hauteur d'une toile.
remplir(toile, couleur) Dessin
Remplit toute la toile avec une couleur.
contour(toile, couleur, épaisseur) Dessin
Active un contour (une bordure) appliqué à toutes les formes pleines dessinées ensuite sur la toile.
dégradé(toile, [Couleur, Couleur, p3, ...] / tableau) Dessin
Remplit toute la toile avec un dégradé horizontal (de gauche à droite) entre plusieurs couleurs.
rectangle(toile, x1, y1, x2, y2, couleur) Dessin
Dessine un rectangle plein sur la toile.
rectangle arrondi(toile, x1, y1, x2, y2, rayon, couleur) Dessin
Dessine un rectangle aux coins arrondis sur la toile.
cercle(toile, cx, cy, rayon, couleur) Dessin
Dessine un cercle plein sur la toile.
ligne(toile, x1, y1, x2, y2, couleur, épaisseur) Dessin
Trace une ligne entre deux points sur la toile.
pixel(toile, x, y, couleur) Dessin
Colore un seul pixel de la toile.
label(toile, x, y, texte, couleur, taille , angle) Dessin
Écrit un texte sur la toile.
polygone(toile, [p1, p2, p3, ...] / tableau, couleur) Dessin
Dessine un polygone plein en reliant une suite de points.
arc(toile, cx1, cy1, cx2, cy2, angle, couleur) Dessin
Dessine un secteur de disque (une part de camembert).
grille(toile, pas, couleur) Dessin
Trace un quadrillage sur toute la toile.
ellipse(toile, cx, cy, rx, ry, couleur) Dessin
Dessine une ellipse pleine sur la toile.
courbe(toile, [p1, p2, p3, ...] / tableau, couleur) Dessin
Trace une courbe en reliant une suite de points par des segments.
histogramme(toile, [n1, n2, n3, ...] / tableau, couleur) Dessin
Dessine un histogramme (diagramme en barres) sur la toile.
label_largeur(texte, taille) Dessin
Renvoie la largeur estimée en pixels d'un texte affiché avec label.
label_hauteur(taille) Dessin
Renvoie la hauteur estimée en pixels d'une ligne de texte affichée avec label.
effacer(toile) Dessin
Efface tout le contenu dessiné sur un toile.
icône(toile, x, y, icône, couleur, taille) Dessin
Dessine une icône (glyph) sur une toile à partir d'un code hexadécimal Unicode.
svg(toile, x, y, source 'c:\img.svg' / variable image, largeur, hauteur) Dessin
Dessine une image vectorielle sur une toile.
animation(tableau, millisecondes, répétition) Dessin
Anime une suite d'images de toile stockées dans un tableau.
enregistrer(fichier) Dessin
Enregistre une toile dans un fichier .svg sur le disque.
clique(x, y, x_coin, y_coin, largeur, hauteur) Dessin
Vérifie si un point (x, y), obtenu après un clic (cliquer), se situe dans une zone de la toile.
flèche(toile, tableau, couleur, epaisseur, pointe) Dessin
Dessine une flèche, une ligne terminée par une pointe au dernier point.
triangle(toile, x1, y1, x2, y2, x3, y3, couleur) Dessin
Dessine un triangle plein à partir de ses 3 sommets.
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 texte 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.
vers_date(texte) util
Convertit un texte au format jj/mm/aaaa en une valeur de type date.
vers_heure(texte) util
Convertit un texte au format hh:mm:ss en une valeur de type heure.
vers_type(type, texte) util
Convertit une valeur vers le type demandé.
vers_hexadécimal(valeur, préfixe) util
Convertit un nombre entier en sa représentation hexadécimale (base 16).
vers_décimal(valeur, base) util
Convertit un texte écrit en binaire (base 2), octal (base 8) ou hexadécimal (base 16) en sa valeur décimale.
rgb(rouge, vert, bleu) util
Construit une couleur hexadécimale #RRGGBB à partir de trois composantes numériques : rouge, vert et bleu.
chrono() util
Retourne le temps courant en millisecondes (haute résolution).
tls(teinte, luminosité, saturation) util
Construit une couleur hexadécimale #RRGGBB à partir de la teinte, de la saturation et de la luminosité.
rgba(rouge, vert, bleu, alpha) util
Construit une couleur hexadécimale #RRGGBBAA à partir de trois composantes de couleur (rouge, vert, bleu, chacune entre 0 et 255) et d'un canal alpha de transparence.
Erreurs courantes
Comprendre les messages d'erreur et comment les corriger
Les erreurs font partie intégrante de l'apprentissage de la programmation. CoddyRun 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.
Toutes les erreurs
Référence exhaustive des messages de l'interpréteur, classés par thème
Le chapitre précédent présente les erreurs les plus fréquentes. Celui-ci recense l'ensemble des messages que CoddyRun peut afficher, regroupés par thème. Les parties variables d'un message (nom de variable, nom de fonction, valeur, numéro de ligne) sont notées : seul le texte fixe permet de retrouver l'erreur dans ce tableau. Chaque message indique toujours la ligne concernée — c'est par elle qu'il faut commencer.
Les familles d'erreurs

Les erreurs de CoddyRun se répartissent en 15 familles. Les premières sont détectées à la lecture du programme, les suivantes pendant son exécution.

Syntaxe & structure du programme

Ces erreurs sont levées par l'analyseur avant même l'exécution : une ligne est mal formée, un mot-clé manque ou un délimiteur n'est pas fermé.

Message d'erreur Cause probable Solution
Instruction inattendue : "…" La ligne commence par un jeton qui n'est pas une instruction valide. Vérifier l'orthographe du mot-clé (affiche, si, pour…) et les accents.
Instruction inconnue après "x" Après un nom de variable, CoddyRun attend est, vaut, ajoute, soustrait ou supprime. Compléter l'instruction, par exemple x vaut 10.
Expression attendue, obtenu : "…" Un opérande manque : opérateur en fin de ligne, virgule en trop, parenthèse ouverte suivie de rien. Compléter l'expression ou supprimer l'opérateur orphelin.
Élément attendu : …, mais trouvé : … L'analyseur attendait un jeton précis (mot-clé, virgule, parenthèse) et en a trouvé un autre. Comparer la ligne avec la syntaxe de référence du chapitre concerné.
")" attendu Une parenthèse ouvrante n'a jamais été refermée. Compter les parenthèses ; chaque ( a besoin de son ).
Crochet fermant "]" attendu dans le tableau Un littéral tableau [1, 2, 3] n'est pas refermé. Ajouter le ] manquant et vérifier les virgules entre les éléments.
Crochet fermant "]" attendu dans le dictionnaire Un littéral dictionnaire ['clé': valeur] n'est pas refermé. Ajouter le ] final.
Crochet fermant "]" attendu après ":" (dictionnaire vide) Le dictionnaire vide s'écrit exactement [:]. Écrire d vaut [:] sans rien entre : et ].
Identifiant attendu après "," Dans une déclaration multiple x, y, z est un nombre, une virgule n'est pas suivie d'un nom. Supprimer la virgule en trop ou ajouter le nom manquant.
Après "x, y", seule la forme "x, y est ..." est supportée Une liste de variables séparées par des virgules ne peut servir qu'à une déclaration. Affecter chaque variable sur sa propre ligne.
Nom attendu après "…" Un mot-clé de définition (fonction, procédure, processus, classe) n'est pas suivi d'un nom. Donner un nom valide, commençant par une lettre.
Nom de champ attendu après "." Le point d'accès à un champ n'est suivi d'aucun identifiant. Écrire personne.nom, jamais personne. seul.
Définition "…" sans fin correspondante Une fonction, procédure ou un processus n'a pas son mot-clé de fermeture. Ajouter fin fonction, fin procédure ou fin processus.
Ligne %d: instruction invalide sur champ "x.y" Après x.champ, seuls vaut, ajoute et soustrait sont acceptés. Utiliser une de ces trois formes.
Nombre attendu après "#" Un littéral caractère #65 ou #$41 est incomplet. Faire suivre le # d'un code décimal ou hexadécimal.
Erreur interne: pop global interdit Anomalie de l'interpréteur : une portée globale a tenté d'être libérée. Ce cas ne doit pas se produire ; signaler le programme qui le déclenche.
Variables, types et constantes

CoddyRun est typé : une variable garde le type reçu à la déclaration. La plupart des erreurs ci-dessous viennent d'une affectation qui change ce type.

Message d'erreur Cause probable Solution
Variable inconnue : "x" La variable est lue avant d'avoir été déclarée, ou son nom est mal orthographié. Déclarer la variable avant usage : x est un nombre.
"x" existe déjà comme variable Le nom est déjà pris par une variable ou une constante de la même portée. Choisir un autre nom, ou supprimer la seconde déclaration.
Type inconnu : "…" Le mot placé après est un / est une n'est pas un type reconnu. Utiliser nombre, texte, booléen, tableau, dictionnaire, enregistrement, date, heure ou toile.
Déclaration de type …, impossible d'affecter un … La déclaration et la valeur initiale ne sont pas du même type. Aligner le type déclaré sur la valeur, ou convertir la valeur.
"x" est déclaré de type …, impossible d'affecter un … Affectation d'une valeur d'un autre type que celui déclaré. Convertir avec convertir_nombre(), convertir_texte() ou vers_type().
"x" est de type …, impossible d'affecter un … Même situation, détectée au moment de l'exécution. Vérifier le type renvoyé par l'expression de droite avec type_de().
"x" est de type nombre, impossible d'ajouter un … ajoute sur un nombre exige une valeur numérique. Convertir la valeur avant : x ajoute convertir_nombre(v).
"x" est de type …, "soustrait" réservé aux nombres soustrait n'existe que pour les nombres. Pour un texte, utiliser retirer() ; pour un tableau, supprime.
Impossible de soustraire un … à un nombre La valeur soustraite n'est pas un nombre. Convertir la valeur, ou corriger l'expression.
"ajoute" non supporté sur le type … ajoute ne fonctionne que sur nombre, texte et tableau. Utiliser vaut pour les autres types.
"x" est une constante : modification interdite Une constante ne peut être affectée qu'une fois, à sa définition. Transformer en variable, ou supprimer la réaffectation.
Constante attend un identifiant constante n'est pas suivi d'un nom valide. Écrire constante TVA vaut 20.
Constante déjà définie : "…" Deux constantes portent le même nom. Renommer l'une des deux.
Nom de variable interdit : "…" est un mot réservé Le nom choisi est un mot-clé du langage. Choisir un autre nom (par exemple pour_total au lieu de pour).
Nom de variable interdit : "…" est un nom de type Le nom choisi est un nom de type (nombre, texte, tableau…). Choisir un nom différent du type.
Nom de variable interdit : "…" est une fonction native Le nom entre en collision avec une fonction intégrée. Renommer la variable ; la liste complète est au chapitre Fonctions intégrées.
Nom de variable interdit : "…" est déjà une fonction ou une procédure Une fonction ou procédure du programme porte déjà ce nom. Renommer la variable ou le sous-programme.
défaut : type non pris en charge défaut() ne connaît pas de valeur par défaut pour ce type. L'appeler sur un nombre, un texte, un booléen, un tableau ou un dictionnaire.
Nombres et calculs

Les nombres CoddyRun sont des flottants double précision : ils restent exacts jusqu'à 253. Au-delà, ou en cas d'opération impossible, l'exécution s'arrête plutôt que de produire un résultat faux.

Message d'erreur Cause probable Solution
Division par zéro Le diviseur d'une division vaut 0. Tester avant : si b <> 0 alors.
Modulo par zéro a mod 0 n'a pas de sens. Vérifier que le second opérande n'est pas nul.
Dépassement numérique : la valeur dépasse le maximum représentable Le résultat sort des bornes des nombres flottants. Réduire l'ordre de grandeur du calcul (éviter les puissances et factorielles trop grandes).
Résultat numérique indéfini (NaN) Opération mathématiquement indéfinie (0/0, ∞−∞…). Contrôler les valeurs d'entrée avant le calcul.
Nombre invalide ou hors limites : "…" Un littéral numérique est mal écrit ou trop grand. Corriger l'écriture du nombre (pas d'espace, point décimal).
Nombre trop grand : "…" Le littéral dépasse ce que le langage peut stocker. Utiliser une valeur plus petite, ou un texte si le nombre sert d'identifiant.
Nombre trop grand : "…" dépasse 2^53 Au-delà de 9 007 199 254 740 992, les entiers ne sont plus exacts. Rester sous cette limite, ou manipuler la valeur sous forme de texte.
Nombre trop grand : au-delà de 9 007 199 254 740 992 (2^53), les nombres ne sont plus exacts Résultat de calcul dépassant la précision entière garantie. Revoir l'algorithme pour limiter la croissance des valeurs.
Nombre hexadécimal invalide : … Un littéral $… contient un caractère hors de 0-9 A-F. N'utiliser que des chiffres hexadécimaux valides.
Conversion en nombre impossible La valeur fournie ne représente pas un nombre. Vérifier le texte source, ou tester avec est_nombre().
arcsinus(x) : x doit être compris entre -1 et 1 L'arc sinus n'est défini que sur [-1 ; 1]. Borner la valeur avec limiter(x, -1, 1).
arccosinus(x) : x doit être compris entre -1 et 1 L'arc cosinus n'est défini que sur [-1 ; 1]. Borner la valeur avant l'appel.
tangente(x) : valeur indéfinie (cos = 0) La tangente diverge quand le cosinus s'annule (90°, 270°…). Éviter ces angles ou tester le cosinus avant.
logarithme(x) : x doit être strictement positif Le logarithme de 0 ou d'un nombre négatif n'existe pas. Tester x > 0 avant l'appel.
factorielle : n doit être >= 0 La factorielle n'est pas définie pour un nombre négatif. Passer un entier positif ou nul.
factorielle : n doit être un entier Un nombre à virgule a été fourni. Arrondir d'abord avec arrondi().
factorielle : n trop grand (max 170) Au-delà de 170!, le résultat dépasse les limites numériques. Rester sous 170.
pgcd : les deux arguments doivent être des entiers Le PGCD ne s'applique qu'à des entiers. Arrondir les deux valeurs avant l'appel.
decimal(x, n) : n doit être >= 0 Le nombre de décimales demandé est négatif. Passer 0 ou plus.
decimal(x, n) : n trop grand (max 15) Au-delà de 15 décimales, l'affichage n'a plus de sens. Réduire n.
pourcentage : le total ne peut pas être zéro Le calcul d'un pourcentage divise par le total. Vérifier que le total est non nul avant l'appel.
hasard(n) ou hasard(min,max) Le nombre d'arguments fourni à hasard() n'est ni 1 ni 2. Utiliser une des deux formes documentées.
intervalle : plage trop grande (maximum 1 000 000 éléments) L'intervalle demandé générerait un tableau démesuré. Réduire l'écart entre début et fin.
Textes, couleurs et expressions

Les textes se concatènent avec + ; toute autre opération arithmétique est refusée. Les fonctions de recherche et de mise en forme valident en plus leurs bornes.

Message d'erreur Cause probable Solution
Soustraction de textes impossible 'a' - 'b' n'existe pas. Pour enlever un fragment, utiliser retirer(texte, motif).
code: texte vide code() a reçu une chaîne vide. Vérifier que le texte contient au moins un caractère.
Code ASCII invalide Le code fourni ne correspond à aucun caractère. Rester dans l'intervalle autorisé.
caractère: code hors limites (…). Intervalle autorisé: 0..65535 caractère() n'accepte qu'un code sur 16 bits. Borner la valeur entre 0 et 65535.
U+… : code Unicode hors limites (max U+10FFFF) Le point de code dépasse le maximum Unicode. Utiliser un point de code valide.
repeter_texte: n trop grand (max 10000) Répétition démesurée, protection contre la saturation mémoire. Réduire le nombre de répétitions.
supprimer: position hors limites (…). Intervalle autorisé: 1..… La position demandée n'existe pas dans le texte. Contrôler avec longueur(texte). Les positions commencent à 1.
position(motif, chaine) ou position(motif, chaine, depart) Nombre d'arguments incorrect. Utiliser la forme à 2 ou à 3 arguments.
expression : le motif ne peut pas être vide L'expression régulière fournie est une chaîne vide. Fournir un motif non vide.
expression : motif invalide "…" (…) L'expression régulière est mal formée. Vérifier les parenthèses, crochets et échappements du motif.
expression : trop de correspondances (motif trop général ?) Le motif capture un nombre excessif de résultats. Rendre le motif plus précis.
similaire : le seuil doit être compris entre 0 et 1 Le seuil de similarité est une proportion. Passer une valeur entre 0 et 1 (par exemple 0.8).
hasardtexte attend au moins un argument Aucune source de caractères n'a été fournie. Passer au moins une longueur ou un jeu de caractères.
html : balise <…> non autorisée. Balises permises : h1 à h6, a, img, ul, ol, li, strong, em. html() n'accepte qu'une liste blanche de balises. Remplacer la balise par une balise autorisée.
couleur : valeur invalide "…". Utilisez #RRGGBB, #RRGGBBAA (avec transparence) ou #0 pour reset. Le code couleur n'est pas un hexadécimal reconnu. Écrire la couleur au format #RRGGBB, ou passer par rgb().
Couleur invalide : "…". Utilisez un code hexadécimal #RRGGBB, #RRGGBBAA (avec transparence), #RGB ou #RGBA. Même cause, lors d'un dessin sur toile. Corriger le code couleur ou utiliser rgba() / tls().
couleur ne peut pas être appliquée à du html(). Utilisez html() pour la mise en forme, ou couleur() sur du texte simple. Les deux fonctions de mise en forme sont exclusives. Choisir l'une ou l'autre pour un même affichage.
rgb : chaque composante doit être comprise entre 0 et 255 Une composante rouge, verte ou bleue sort des bornes. Borner avec limiter(v, 0, 255).
rgba : R, V, B doivent être compris entre 0 et 255 Même cause pour la variante avec transparence. Corriger les trois composantes.
rgba : l'alpha doit être compris entre 0 (transparent) et 1 (opaque) Le canal alpha est une proportion, pas un nombre sur 255. Passer une valeur entre 0 et 1.
tls : la teinte doit être comprise entre 0 et 360 La teinte est un angle en degrés. Ramener la valeur dans [0 ; 360].
tls : la saturation doit être comprise entre 0 et 100 Saturation exprimée en pourcentage. Passer une valeur entre 0 et 100.
tls : la luminosité doit être comprise entre 0 et 100 Luminosité exprimée en pourcentage. Passer une valeur entre 0 et 100.
Tableaux

Les index commencent à 0 et doivent toujours exister avant d'être lus. Beaucoup de fonctions intégrées exigent explicitement un tableau en premier argument.

Message d'erreur Cause probable Solution
"x" n'est pas un tableau Notation t[i], ajoute ou fonction de tableau utilisée sur une autre variable. Déclarer x est un tableau.
"x" n'est pas un tableau ni un texte L'indexation x[i] ne s'applique qu'aux tableaux et aux textes. Vérifier le type avec type_de(x).
Index hors limites : t[5] L'index demandé dépasse la taille du tableau. Contrôler longueur(t) ; le dernier index vaut longueur(t) - 1.
Index négatif interdit Un index calculé est devenu négatif. Tester l'index avant l'accès, ou utiliser limiter().
Tableau vide Suppression ou lecture dans un tableau sans élément. Vérifier longueur(t) > 0.
Tableau vide : "x" Même cause, avec le nom de la variable concernée. Remplir le tableau avant de le parcourir.
premier: tableau vide premier() sur un tableau sans élément. Tester la longueur avant l'appel.
dernier: tableau vide dernier() sur un tableau sans élément. Tester la longueur avant l'appel.
premier attend un tableau L'argument n'est pas un tableau. Passer une variable déclarée comme tableau.
dernier attend un tableau L'argument n'est pas un tableau. Passer une variable déclarée comme tableau.
melanger attend un tableau melanger() ne s'applique qu'aux tableaux. Convertir ou corriger l'argument.
liste_tableau attend un tableau L'argument fourni n'est pas un tableau. Passer un tableau initialisé.
supprime attend un nom de tableau supprime doit porter sur une variable tableau ou dictionnaire. Écrire t supprime 2.
vide attend un nom de tableau vide doit porter sur un nom de tableau. Écrire vide t.
taille(tableau, n) : le premier argument doit être un tableau Argument de mauvais type. Passer un tableau en premier.
taille(tableau, n) : n doit être >= 0 Taille cible négative. Passer 0 ou plus.
trier : le premier argument doit être un tableau Tri demandé sur autre chose qu'un tableau. Corriger l'argument.
index_de : le premier argument doit être un tableau Recherche d'index sur un type non indexable. Pour un texte, utiliser position().
joindre : le premier argument doit être un tableau joindre() assemble les éléments d'un tableau. Passer un tableau et un séparateur texte.
somme : l'argument doit être un tableau Argument de mauvais type. Passer un tableau de nombres.
moyenne : l'argument doit être un tableau Argument de mauvais type. Passer un tableau de nombres.
moyenne : le tableau est vide La moyenne d'un ensemble vide n'existe pas. Tester la longueur avant l'appel.
médiane : l'argument doit être un tableau Argument de mauvais type. Passer un tableau de nombres.
médiane : le tableau ne doit pas être vide Pas de valeur centrale dans un tableau vide. Tester la longueur avant l'appel.
unique : l'argument doit être un tableau Argument de mauvais type. Passer un tableau.
assembler : tous les arguments doivent être des tableaux Un des arguments n'est pas un tableau. Vérifier chaque argument avec type_de().
fusionner : le premier argument doit être un tableau Fusion de tableaux avec un premier argument d'un autre type. Passer deux tableaux, ou deux dictionnaires.
fusionner : le second argument doit être un tableau Le premier argument est un tableau, pas le second. Les deux arguments doivent être du même genre.
longueur attend un texte, un tableau ou un dictionnaire longueur() ne s'applique qu'à ces trois types. Corriger l'argument.
contient attend un texte, un tableau ou un dictionnaire en premier argument Recherche d'appartenance sur un type non supporté. Corriger le premier argument.
est_vide : attend un texte, un tableau, un enregistrement ou un dictionnaire est_vide() n'a pas de sens sur un nombre ou un booléen. Comparer directement à 0 ou à faux dans ce cas.
Dictionnaires

Un dictionnaire associe une clé texte à une valeur. La clé doit exister avant toute lecture.

Message d'erreur Cause probable Solution
Clé de dictionnaire invalide : la clé doit être un texte Une clé numérique ou booléenne a été utilisée. Convertir la clé : d[convertir_texte(i)].
Clé inconnue : "…" Lecture d'une clé absente du dictionnaire. Tester avec contient(d, 'clé') avant de lire.
Clé inconnue : d['ville'] Suppression ou lecture d'une clé qui n'existe pas. Vérifier les clés disponibles avec cles(d).
Dictionnaire vide : "d" Opération nécessitant au moins une entrée. Ajouter des entrées avant : d['clé'] vaut.
Après d[...] on attend "vaut" ou "ajouter" Après un accès indexé sur dictionnaire, seuls ces deux mots-clés sont acceptés. Écrire d['clé'] vaut valeur.
cles : l'argument doit être un dictionnaire cles() appelée sur autre chose. Passer un dictionnaire.
fusionner : le premier argument doit être un dictionnaire Mélange de types dans une fusion. Fusionner deux dictionnaires entre eux.
fusionner : le second argument doit être un dictionnaire Le premier argument est un dictionnaire, pas le second. Aligner les deux types.
Enregistrements, classes et champs

Un champ doit être créé par une affectation avant d'être lu. Les types de champ sont figés une fois le champ créé.

Message d'erreur Cause probable Solution
"x" n'est pas un enregistrement Accès x.champ sur une variable d'un autre type. Déclarer x est un enregistrement.
"x" n'est pas un objet ni un enregistrement Accès par point sur une valeur qui n'est ni une instance de classe ni un enregistrement. Vérifier le type avec type_de(x).
Champ inconnu : "nom" Le champ n'a jamais été créé. Créer le champ d'abord : x.nom vaut 'Alice', ou tester avec existe().
Enregistrement vide : "x" Opération demandée sur un enregistrement sans aucun champ. Ajouter au moins un champ.
"x.champ" est de type …, impossible d'affecter un … Le champ change de type entre deux affectations. Conserver le type initial, ou convertir la valeur.
"x.champ" est de type nombre, impossible d'ajouter un … ajoute sur un champ numérique avec une valeur non numérique. Convertir avant d'ajouter.
"x.champ" est de type …, "soustrait" réservé aux nombres soustrait sur un champ non numérique. N'utiliser soustrait que sur des champs nombre.
champs: argument doit être un enregistrement champs() liste les champs d'un enregistrement. Passer un enregistrement.
existe: premier argument doit être un enregistrement Test d'existence de champ sur un autre type. Pour un dictionnaire, utiliser contient().
supprime_champ: premier argument doit être un enregistrement Suppression de champ sur un autre type. Passer un enregistrement.
Conditions, boucles et contrôle de flux

Les boucles sont protégées par une limite d'itérations : au-delà, CoddyRun considère qu'il s'agit d'une boucle infinie et interrompt le programme.

Message d'erreur Cause probable Solution
"pas" ne peut pas être 0 Une boucle pour avec un pas nul ne progresse jamais. Utiliser un pas non nul : positif pour monter, négatif pour descendre.
"pour" attend un identifiant Le mot-clé pour n'est pas suivi d'un nom de variable. Écrire pour i de 1 à 10.
La boucle "…" dépasse … itérations (probable boucle infinie). La condition de sortie n'est jamais satisfaite. Vérifier que la variable testée est bien modifiée dans le corps de la boucle.
"répète … fois" dépasse la limite de … itérations. Le nombre de répétitions demandé est trop grand. Réduire le nombre, ou restructurer l'algorithme.
"arrete" ne peut être utilisé qu'à l'intérieur d'une boucle arrete placé hors d'une boucle. Le déplacer dans un pour, tant que ou répète.
"continue" ne peut être utilisé qu'à l'intérieur d'une boucle continue placé hors d'une boucle. Même correction.
Fonctions, procédures et processus

Les sous-programmes vérifient leur nom, le nombre de paramètres et l'unicité des noms au moment de l'appel.

Message d'erreur Cause probable Solution
Fonction/procédure inconnue : "f" Le nom appelé n'existe ni dans le programme, ni parmi les fonctions intégrées. Vérifier l'orthographe, et que la définition précède l'appel.
"f" : 2 paramètre(s) attendu(s), 1 fourni(s) Le nombre d'arguments ne correspond pas à la signature. Comparer l'appel à la ligne fonction f(...).
Paramètre en double : "x" Deux paramètres portent le même nom dans une définition. Renommer l'un des deux.
Nom de paramètre interdit : "…" est un mot réservé Un paramètre porte le nom d'un mot-clé. Choisir un autre nom.
Nom de paramètre interdit : "…" est un nom de type Un paramètre porte un nom de type. Choisir un autre nom.
Nom de paramètre interdit : "…" est une fonction native Collision avec une fonction intégrée. Renommer le paramètre.
Nom de paramètre interdit : "…" est déjà une fonction ou une procédure Collision avec un sous-programme du fichier. Renommer le paramètre.
retourne attend une expression retourne est seul sur sa ligne. Indiquer la valeur renvoyée : retourne total.
appelle attend un nom de procédure appelle n'est pas suivi d'un nom valide. Écrire appelle maProcedure(…).
Un seul processus est autorisé par programme : « … » est déjà défini, « … » ne peut pas être ajouté. Deux blocs processus dans le même fichier. Fusionner les deux en un seul processus.
Entrées utilisateur : demande, choisir, appuyer, cliquer, interagir

Ces instructions stockent leur résultat dans une variable existante, dont le type doit correspondre à ce qui est reçu.

Message d'erreur Cause probable Solution
demande "texte" attend le mot-clé "dans" La destination du résultat n'est pas indiquée. Écrire demande 'Ton nom ?' dans nom.
demande sur tableau non supporté : "t" Une saisie ne peut pas remplir directement un tableau. Lire dans une variable simple, puis t ajoute valeur.
demande sur enregistrement non supporté : "x" Une saisie ne peut pas remplir directement un enregistrement. Lire champ par champ.
choisir attend une liste entre crochets, ex : choisir ['A', 'B'] dans x, ou un tableau Les options ne sont ni un littéral entre crochets ni un tableau. Fournir une des deux formes.
choisir attend au moins une option La liste d'options est absente. Proposer au moins un choix.
choisir : le tableau d'options est vide Le tableau passé ne contient aucun élément. Le remplir avant l'appel.
choisir : crochet fermant "]" attendu La liste d'options n'est pas refermée. Ajouter le ].
choisir attend le mot-clé "dans" La variable de destination n'est pas indiquée. Écrire choisir [...] dans x.
choisir ... dans attend un nom de variable Après dans, il faut un identifiant. Indiquer une variable déjà déclarée.
choisir : la variable "x" doit être de type nombre choisir renvoie l'indice de l'option retenue. Déclarer x est un nombre.
choisir : la variable "x" doit être déclarée comme un nombre (ex : x est un nombre) La variable de destination n'est pas déclarée. La déclarer avant l'instruction.
appuyer attend une liste de touches entre crochets, ex : appuyer ['z', 's', 'd', 'q'] dans action La liste de touches est mal formée. Utiliser la forme documentée.
appuyer attend au moins une touche Aucune touche n'est surveillée. Indiquer au moins une touche.
appuyer : crochet fermant "]" attendu La liste de touches n'est pas refermée. Ajouter le ].
appuyer attend le mot-clé "dans" La variable de destination manque. Écrire appuyer [...] dans action.
appuyer ... dans attend un nom de variable Après dans, il faut un identifiant. Indiquer une variable déclarée.
appuyer : la variable "x" doit être de type nombre L'indice de la touche pressée est un nombre. Déclarer la variable comme nombre.
appuyer : la variable "x" doit être déclarée comme un nombre (ex : x est un nombre) Variable de destination non déclarée. La déclarer avant.
cliquer attend le mot-clé "dans", ex : cliquer maToile dans x, y La syntaxe attendue n'est pas respectée. Suivre l'exemple donné dans le message.
cliquer ... dans attend des noms de variables, ex : cliquer maToile dans x, y Il faut deux variables : abscisse et ordonnée. Déclarer x et y comme nombres.
cliquer : virgule attendue entre les variables (x, y) La virgule séparant les deux variables manque. Écrire dans x, y.
cliquer : la variable "x" doit être de type nombre Les coordonnées sont des nombres. Déclarer les deux variables comme nombres.
cliquer : la variable "x" doit être déclarée comme un nombre (ex : x est un nombre) Variable non déclarée. La déclarer avant l'instruction.
cliquer n'accepte pas de délai, ex : cliquer maToile dans x, y Un argument supplémentaire a été ajouté. Supprimer le délai.
interagir attend une virgule puis une liste de touches, ex : interagir maToile, ['z', 's'] dans action, x, y La toile et la liste de touches doivent être séparées par une virgule. Suivre l'exemple du message.
interagir attend une liste de touches entre crochets Liste de touches mal formée. Encadrer les touches par des crochets.
interagir attend au moins une touche Aucune touche surveillée. Indiquer au moins une touche.
interagir : crochet fermant "]" attendu Liste non refermée. Ajouter le ].
interagir attend le mot-clé "dans", ex : ... dans action, x, y Les variables de destination manquent. Ajouter dans action, x, y.
interagir ... dans attend des noms de variables Trois variables sont attendues après dans. Déclarer action, x et y.
interagir : virgule attendue entre les variables (action, x, y) Une virgule manque entre les destinations. Séparer les trois variables par des virgules.
interagir : la variable "x" doit être de type nombre Les trois destinations sont numériques. Déclarer chacune comme nombre.
interagir : la variable "x" doit être déclarée comme un nombre (ex : x est un nombre) Variable non déclarée. La déclarer avant.
Dates et heures

Les fonctions de date acceptent une valeur date ou un texte au format reconnu ; celles d'heure une valeur heure ou un texte. Les messages ci-dessous se déclinent pour chaque fonction concernée.

Message d'erreur Cause probable Solution
… : date invalide Le texte fourni ne correspond à aucune date lisible. Concerne année_de, mois_de, jour_de, jour_semaine, semaine_de, ajouter_jours, ajouter_mois, ajouter_années, format_date, vers_date. Utiliser le format documenté au chapitre Date & Heure, ou convertir_date().
… : attend une date ou un texte L'argument est d'un type incompatible (nombre, booléen, tableau…). Passer une variable date ou un texte.
… : le premier argument doit être une date ou un texte Même cause pour les fonctions à plusieurs arguments. Corriger le premier argument.
… : heure invalide Texte d'heure non reconnu. Concerne heure_de, minute_de, seconde_de, ajouter_heures, ajouter_minutes, vers_heure. Respecter le format hh:mm:ss.
… : attend une heure ou un texte Argument d'un type incompatible. Passer une variable heure ou un texte.
… : le premier argument doit être une heure ou un texte Même cause pour les fonctions à plusieurs arguments. Corriger le premier argument.
jours_entre: date invalide (argument 1) La première date n'est pas lisible. Corriger ou convertir cette date.
jours_entre: date invalide (argument 2) La seconde date n'est pas lisible. Corriger ou convertir cette date.
jours_entre: le premier argument doit être une date ou un texte Type incompatible en première position. Passer une date ou un texte.
jours_entre: le second argument doit être une date ou un texte Type incompatible en seconde position. Passer une date ou un texte.
est_bissextile : attend une année ou une date L'argument n'est ni un nombre d'année ni une date. Passer 2026 ou une variable date.
est_bissextile : année hors limites (1 à 9999) L'année demandée sort du calendrier supporté. Rester entre 1 et 9999.
format_date : le motif ne doit pas être vide Aucun motif de formatage fourni. Passer un motif, par exemple 'jj/mm/aaaa'.
format_date : motif invalide "…" Le motif contient des symboles non reconnus. Se référer au tableau des motifs du chapitre Date & Heure.
Toile, dessin et animation

Toutes les fonctions de dessin attendent une toile en premier argument et vérifient leurs bornes (tailles, angles, nombre de points).

Message d'erreur Cause probable Solution
toile : dimensions invalides (1 a 1000) La toile créée est trop petite ou trop grande. Choisir une largeur et une hauteur entre 1 et 1000.
dimension : taille 1 a 1000 Redimensionnement hors bornes. Rester dans l'intervalle autorisé.
… : le 1er argument doit etre une toile Une fonction de dessin a reçu autre chose qu'une toile. Créer la toile avec t est une toile et la passer en premier.
… : toile introuvable La toile référencée n'existe plus (variable écrasée ou hors portée). Conserver la toile dans une variable accessible.
contour : l'épaisseur doit être comprise entre 1 et 100 Épaisseur de trait hors bornes. Passer une valeur entre 1 et 100.
grille : le pas doit être >= 1 Un pas nul ou négatif produirait une infinité de lignes. Passer un pas d'au moins 1.
grille : pas trop petit (trop de lignes) Le pas génère plus de lignes que la toile ne peut en contenir. Augmenter le pas.
pixel : trop d'elements sur la toile (max 1 000 000) Limite de complexité du dessin atteinte. Dessiner des formes plutôt que des pixels un à un, ou effacer la toile.
courbe : le tableau doit contenir au moins 2 points (paires x,y) Une courbe a besoin de deux points minimum. Fournir au moins quatre valeurs (x1, y1, x2, y2).
courbe(toile, x1, y1, x2, y2, ... [, couleur]) : au moins 2 points (paires x,y) Coordonnées incomplètes en appel direct. Compléter les paires de coordonnées.
polygone(toile, x1, y1, ... [, couleur]) : au moins 3 points (paires x,y) Un polygone exige trois sommets. Ajouter les points manquants.
fleche(toile, x1, y1, x2, y2, ...) : au moins 2 points (paires x,y) Une flèche relie au moins deux points. Compléter les coordonnées.
histogramme : le tableau est vide Aucune valeur à représenter. Remplir le tableau avant l'appel.
degrade : il faut au moins 2 couleurs Un dégradé a besoin d'une couleur de départ et d'arrivée. Fournir au moins deux couleurs.
degrade : le 2e argument doit etre un tableau de couleurs Le second argument n'est pas un tableau. Écrire par exemple degrade(toile, ['#3f87a6', '#f69d3c']).
label : la taille doit être comprise entre 1 et 100 Taille de texte hors bornes. Passer une valeur entre 1 et 100.
label : l'angle doit être compris entre -180 et 180 Rotation du texte hors bornes. Ramener l'angle dans cet intervalle.
label_hauteur : la taille doit être comprise entre 1 et 100 Taille hors bornes. Corriger la taille.
label_largeur : la taille doit être comprise entre 1 et 100 Taille hors bornes. Corriger la taille.
icone : la taille doit être comprise entre 1 et 400 Taille d'icône hors bornes. Passer une valeur entre 1 et 400.
icone : point de code Unicode invalide "…" (ex. $E735) Le code d'icône n'est pas au format attendu. Utiliser la notation hexadécimale $E735.
icone : point de code Unicode hors limites Le point de code dépasse le maximum Unicode. Choisir un code valide.
clique(x, y, x_coin, y_coin, largeur, hauteur) pour une zone rectangulaire, ou clique(x, y, cx, cy, rayon) pour une zone circulaire Le nombre d'arguments ne correspond à aucune des deux formes. Choisir la forme rectangulaire (6 arguments) ou circulaire (5 arguments).
animation : le 1er argument doit être un tableau de toiles L'animation s'alimente d'un tableau d'images. Construire un tableau et y ajouter les toiles une à une.
animation : le tableau ne contient aucune image Le tableau d'images est vide. Ajouter au moins une toile avant de lancer l'animation.
animation : l'élément … n'est pas une toile Un élément du tableau n'est pas une image. Vérifier ce que contient le tableau.
svg : le fichier doit être un ".svg" (reçu "…") Extension de fichier non autorisée. Fournir un fichier .svg.
svg : fichier introuvable "…" Le chemin ne pointe vers aucun fichier. Vérifier le chemin, absolu ou relatif au programme.
svg : impossible de lire "…" (…) Le fichier existe mais n'est pas lisible. Vérifier les droits d'accès.
svg : "…" ne contient pas de balise <svg> Le contenu n'est pas un SVG valide. Ouvrir le fichier pour vérifier son contenu.
svg : image vide La source ne contient aucun élément dessinable. Utiliser une image non vide.
svg : la largeur et la hauteur doivent être supérieures à 0 Dimensions d'incrustation nulles ou négatives. Passer des dimensions positives.
svg : le 4e argument doit être une toile, une image ou un chemin de fichier Source d'incrustation d'un type non supporté. Passer une toile, une image importée ou un chemin.
svg : une toile ne peut pas s'incruster elle-même Incrustation récursive détectée. Utiliser une seconde toile comme source.
enregistrer : le chemin est vide Aucun chemin de sortie fourni. Indiquer un chemin de fichier.
enregistrer : seuls les fichiers .svg sont autorisés (obtenu : "…") Une toile ne s'enregistre qu'au format SVG. Terminer le chemin par .svg.
enregistrer : le dossier destination n'existe pas : "…" Le dossier de sortie est introuvable. Créer le dossier, ou corriger le chemin.
enregistrer : impossible d'écrire dans "…" : … Écriture refusée par le système. Vérifier les droits d'écriture et que le fichier n'est pas ouvert ailleurs.
Fichiers, paramètres et réseau

Pour des raisons de sécurité, la lecture et l'écriture sont limitées à quelques extensions, les dossiers doivent exister, et seules les URL https:// sont acceptées.

Message d'erreur Cause probable Solution
importer : seuls les fichiers .txt et .csv sont autorisés (obtenu : "…") Extension non autorisée en lecture. Convertir le fichier en .txt ou .csv.
importer : fichier introuvable : "…" Le chemin ne correspond à aucun fichier. Vérifier le chemin et le nom exact, accents compris.
importer : fichier trop volumineux (… octets, maximum 1 Mo) La taille dépasse la limite de sécurité. Découper le fichier ou n'en lire qu'une partie.
importer : contenu URL trop volumineux (… octets, maximum 1 Mo) Même limite appliquée au contenu distant. Utiliser une ressource plus légère.
importer : les URLs non sécurisées (http://) ne sont pas autorisées. Utilisez https:// à la place. Seul HTTPS est accepté. Remplacer http:// par https://.
importer : impossible de récupérer l'URL "…" : … Échec réseau (hors ligne, domaine injoignable, certificat). Vérifier la connexion et l'adresse.
importer : l'URL "…" a retourné le code HTTP … Le serveur a répondu par une erreur (404, 403, 500…). Vérifier que l'adresse est publique et valide.
importer : "…" ne contient pas de balise <svg> Le contenu importé n'est pas un SVG. Vérifier la ressource visée.
sauvegarder : seuls les fichiers .txt et .csv sont autorisés (obtenu : "…") Extension non autorisée en écriture. Choisir .txt ou .csv.
sauvegarder : le dossier destination n'existe pas : "…" Le dossier de sortie est introuvable. Créer le dossier au préalable.
sauvegarder : impossible d'écrire dans "…" : … Écriture refusée (droits, fichier verrouillé). Vérifier les permissions.
ajouter_ligne : seuls les fichiers .txt et .csv sont autorisés (obtenu : "…") Extension non autorisée. Choisir .txt ou .csv.
ajouter_ligne : le dossier destination n'existe pas : "…" Dossier introuvable. Corriger le chemin.
ajouter_ligne : impossible d'écrire dans "…" : … Écriture refusée. Vérifier les droits et la disponibilité du fichier.
fichier_existe : seuls les fichiers .txt et .csv sont autorisés (obtenu : "…") Le test d'existence est limité à ces extensions. Tester un fichier .txt ou .csv.
liste_fichiers : le dossier "…" n'existe pas Le dossier à lister est introuvable. Vérifier le chemin.
liste_fichiers : lecture de "…" impossible : … Le dossier existe mais n'est pas lisible. Vérifier les droits d'accès.
liste_fichiers : le 3e argument doit être un tableau Le résultat doit être stocké dans un tableau. Déclarer t est un tableau et le passer en 3e position.
liste_fichiers : le tableau n'est pas initialisé Le tableau de destination n'a jamais été créé. Le déclarer avant l'appel.
télécharger : URL invalide "…" L'adresse n'est pas une URL exploitable. Fournir une adresse complète commençant par https://.
télécharger : les URLs non sécurisées (http://) ne sont pas autorisées. Utilisez https:// à la place. Seul HTTPS est accepté. Remplacer le protocole.
télécharger : l'URL "…" a retourné le code HTTP … Réponse d'erreur du serveur. Vérifier que la ressource est accessible publiquement.
télécharger : impossible de récupérer "…" : … Échec réseau. Vérifier la connexion.
télécharger : impossible de déterminer le nom du fichier depuis "…" L'URL ne se termine pas par un nom de fichier. Utiliser une URL pointant directement le fichier.
télécharger : type de fichier non autorisé "…". Extensions acceptées : jpg, jpeg, png, gif, svg, webp, bmp, ico, txt, csv, html Extension hors de la liste blanche. Télécharger un format autorisé.
télécharger : fichier trop volumineux (… octets, maximum 1 Mo) Taille au-delà de la limite. Choisir une ressource plus petite.
télécharger : le dossier destination n'existe pas : "…" Dossier de réception introuvable. Créer le dossier avant.
télécharger : impossible d'écrire "…" : … Écriture refusée sur le disque. Vérifier les droits du dossier.
ouvrir : le chemin est vide Aucune cible fournie. Indiquer un fichier, un dossier ou une URL.
ouvrir : fichier ou dossier introuvable : "…" La cible n'existe pas. Vérifier le chemin.
ouvrir : les URLs non sécurisées (http://) ne sont pas autorisées. Utilisez https:// à la place. Seul HTTPS est accepté. Remplacer le protocole.
ouvrir : impossible d'ouvrir "…" (code …) Le système a refusé l'ouverture. Vérifier qu'une application est associée à ce type de fichier.
paramètre(section, clé) pour lire une valeur, paramètre(section, clé, valeur) pour l'enregistrer Nombre d'arguments incorrect. Utiliser la forme à 2 arguments pour lire, à 3 pour écrire.
paramètre : la section "…" n'existe pas dans … Lecture d'une section absente du fichier de paramètres. L'écrire d'abord, ou vérifier son orthographe.
paramètre : la clé "…" n'existe pas dans la section "…" Lecture d'une clé absente. L'enregistrer avant de la lire.
paramètre : le nom de … ne peut pas être vide Nom de section ou de clé vide. Fournir un nom non vide.
paramètre : le nom de … est trop long (… caractères, max …) Nom au-delà de la longueur autorisée. Raccourcir le nom.
paramètre : le nom de … ne peut pas contenir "[", "]", "=" ni de retour à la ligne Ces caractères sont réservés au format du fichier. Les retirer du nom.
paramètre : le texte est trop long (… caractères, max …) Valeur au-delà de la longueur autorisée. Stocker la donnée dans un fichier à part.
paramètre : le texte ne peut pas contenir de retour à la ligne Une valeur doit tenir sur une seule ligne. Remplacer les sauts de ligne par un séparateur.
paramètre : seuls un nombre, un texte ou un booléen peuvent être enregistrés Type non sérialisable (tableau, enregistrement, toile…). Convertir en texte avant d'enregistrer.
paramètre : impossible d'ouvrir "…" : … Fichier de paramètres illisible. Vérifier les droits d'accès.
paramètre : impossible d'écrire dans "…" : … Fichier de paramètres non modifiable. Vérifier les droits d'écriture.
Conversions et évaluation d'expressions

Les conversions explicites échouent proprement plutôt que de renvoyer une valeur approximative.

Message d'erreur Cause probable Solution
convertir_nombre: texte non convertible en nombre Le texte contient des caractères non numériques. Nettoyer le texte, ou tester avec est_nombre().
convertir_nombre: type non convertible Le type source n'a pas d'équivalent numérique. Convertir d'abord en texte.
vers_type : type cible inconnu "…" (attendu : nombre, texte, date ou heure) Le type demandé n'est pas supporté par cette fonction. Utiliser un des quatre types listés.
vers_type : "…" n'est pas convertible en nombre La valeur source n'a pas de lecture numérique. Vérifier la valeur d'origine.
vers_type : "…" n'est pas une date valide Texte non reconnu comme date. Respecter le format documenté.
vers_type : "…" n'est pas une heure valide Texte non reconnu comme heure. Respecter le format hh:mm:ss.
vers_type : conversion vers nombre impossible pour ce type Le type source ne peut pas devenir un nombre. Passer par un texte intermédiaire.
vers_type : conversion vers date impossible pour ce type Le type source ne peut pas devenir une date. Passer par un texte au bon format.
vers_type : conversion vers heure impossible pour ce type Le type source ne peut pas devenir une heure. Passer par un texte au bon format.
vers_decimal : base invalide (2, 8 ou 16 seulement) Seules ces trois bases sont gérées. Passer 2, 8 ou 16.
vers_decimal : texte vide Aucun chiffre à convertir. Fournir un texte non vide.
vers_decimal : caractere invalide "…" Un caractère n'appartient pas à la base indiquée. Nettoyer le texte source.
vers_decimal : chiffre "…" invalide en base … Le chiffre dépasse la base (par exemple 9 en base 8). Corriger la valeur ou la base.
vers_hexadecimal : largeur trop grande (max 16) Le remplissage demandé dépasse la limite. Passer une largeur inférieure ou égale à 16.
valuer : caractère non autorisé "…" (seuls ( ) + - * / , et 0..9 sont permis) valuer() n'évalue que de l'arithmétique simple. Retirer les lettres et symboles non autorisés.
valuer : caractère inattendu "…" Symbole mal placé dans l'expression. Vérifier l'écriture de l'expression.
valuer : nombre invalide "…" Un nombre est mal formé (deux points décimaux, par exemple). Corriger le nombre.
valuer : expression incomplète L'expression se termine sur un opérateur. Compléter l'expression.
valuer : parenthèse fermante manquante Parenthèses déséquilibrées. Ajouter la parenthèse manquante.
valuer : division par zéro L'expression évaluée divise par zéro. Corriger l'expression.
Nombre d'arguments des fonctions intégrées

Chaque fonction intégrée contrôle le nombre d'arguments reçus et affiche sa propre signature quand le compte n'y est pas. Ces messages suivent toujours l'une des quatre formes ci-dessous : le texte entre parenthèses est la syntaxe correcte à recopier.

Forme du message Signification Solution
longueur(x) attend 1 argument La fonction exige exactement ce nombre d'arguments. Recopier la signature affichée entre parenthèses.
décrément(x[, n]) attend 1 ou 2 arguments Les crochets signalent un argument facultatif. Fournir le minimum, et l'option seulement si nécessaire.
assembler(tableau1, tableau2, ...) attend au moins 2 tableaux La fonction accepte un nombre variable d'arguments, avec un minimum. Ajouter les arguments manquants.
rectangle(toile, x, y, largeur, hauteur [, couleur]) : 5 ou 6 arguments Forme employée par les fonctions de dessin : signature complète puis nombres admis. Compter les arguments par rapport à la signature affichée.
maintenant() ne prend aucun argument La fonction s'appelle sans rien entre les parenthèses. Écrire maintenant() sans argument.
Toutes ces erreurs sont interceptables : entoure le code sensible d'un bloc essayerattraperfin essayer pour afficher un message adapté au lieu d'interrompre le programme. Voir le chapitre Gestion des erreurs.
Trois réflexes avant de modifier quoi que ce soit : lire le numéro de ligne, lire le type mentionné dans le message, puis vérifier la déclaration de la variable concernée. La plupart des erreurs se corrigent en une ligne.
Note de fin
CoddyRun 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.