Un petit langage de programmation, avec les mots de l'Europano
Europano Code est un langage simple pour écrire de petits programmes et même des pages interactives. Ses mots viennent de l'Europano. Tu écris ton programme, tu le lances pour ouvrir une page de résultat, ou tu le décodes en français pour comprendre ce qu'il dit.
On écrit une instruction par ligne. Une ligne qui commence par # est un commentaire : elle est ignorée, elle sert juste à expliquer.
# ceci est un commentaire
pil "saluto, mundo!"
En cliquant sur Lancer, une page s'ouvre et affiche : saluto, mundo!
Le bouton Décoder en français traduit ton programme en phrases claires, pour vérifier ce qu'il fait.
Ces mots ajoutent des choses sur la page de résultat :
titro met un grand titre. pil affiche une ligne de texte.
titro "Mi pajo" pil "Bonjour ! Voici ma page."
kolor change la couleur du texte qui suit. kolor "defaut" revient au normal.
kolor "rouge" pil "Texte rouge" kolor "bleu" pil "Texte bleu" kolor "defaut"
Couleurs : rouge, bleu, vert, jaune, orange, violet, rose, gris, noir, or, blanc (ou un code couleur).
punto ajoute un point de liste (à puce). lino trace une ligne de séparation. imajo affiche une image depuis un lien.
punto "premier point" punto "deuxieme point" lino imajo "https://exemple.com/image.png"
Il y a trois sortes de valeurs :
Les nombres. En mots : nul un du tri kar kin ses set ot nov dek (de 0 à 10), plus san (100) et mil (1000). Ou en chiffres. Pour les autres nombres, on calcule.
pil dek # 10 pil dek + du # 12 pil 42 # en chiffres aussi
Le texte s'écrit entre guillemets : "comme ceci".
Vrai et faux : i veut dire vrai, u veut dire faux.
Une variable garde une valeur sous un nom. On écrit nom = valeur.
aje = dek + ot # aje vaut 18 nom = "Ana" pil "saluto, " + nom # colle le texte avec +
Affiche : saluto, Ana. Avec les nombres, on peut aussi faire + - * / % (le reste d'une division).
Pour comparer deux valeurs : plu (plus grand que), men (plus petit que), egal (est égal à). Le résultat est vrai ou faux.
Pour combiner : e (et), o (ou), no (non).
pil dek plu kin # vrai (10 plus grand que 5) pil i e no u # vrai et non-faux : vrai
si fait quelque chose seulement si une condition est vraie. senon donne ce qu'on fait sinon. Le bloc va entre accolades { }.
aje = dek + ot
si aje plu dek {
pil "ti es gran"
} senon {
pil "ti es jun"
}
Comme aje (18) est plus grand que 10, affiche : ti es gran.
repete N répète un bloc N fois.
n = un
repete kin {
pil n
n = n + un
}
Affiche 1, 2, 3, 4, 5.
tanke répète tant qu'une condition reste vraie.
n = un
tanke n men kin {
pil n
n = n + un
}
Affiche 1, 2, 3, 4 (s'arrête quand n n'est plus plus petit que 5).
Pour créer une vraie page interactive : entro nom "label" ajoute un champ de saisie, et ce que la personne tape est rangé dans nom. buto "label" { ... } ajoute un bouton qui exécute son bloc quand on clique.
titro "Aditar"
entro a "premier nombre"
entro b "deuxieme nombre"
buto "kalkular" {
pil a + b
}
La page montre deux cases et un bouton. On tape deux nombres, on clique, et le résultat s'affiche.
Une fonction est un morceau de code qu'on écrit une fois et qu'on réutilise. On la définit avec fonzo, on renvoie une valeur avec redon, et on l'utilise en écrivant son nom suivi de parenthèses.
fonzo karo(x) {
redon x * x
}
pil karo(tri) # 9
pil karo(kin) # 25
Une fonction peut aussi juste afficher des choses, et on peut l'appeler plusieurs fois :
fonzo saluti(nom) {
pil "saluto, " + nom + "!"
}
saluti("Ana")
saluti("Leo")
Une fonction peut même s'appeler elle-même (récursivité), par exemple pour une factorielle :
fonzo fak(n) {
si n men du {
redon un
}
redon n * fak(n - un)
}
pil fak(kin) # 120
Des fonctions toutes prêtes. Tu peux aussi utiliser des fonctions déjà fournies : hazar(n) donne un nombre au hasard de 1 à n (parfait pour les jeux), racine(x) la racine carrée, aretond(x) arrondit, min(a, b) et max(a, b) le plus petit et le plus grand, abs(x) la valeur absolue, longo(t) la longueur d'un texte.
titro "Lansa le de"
buto "lansi" {
pil "ti faris : " + hazar(ses)
}
Un dé : à chaque clic, un nombre au hasard de 1 à 6.
Parler à l'IA. Ce langage n'est pas figé : il peut dialoguer avec une intelligence artificielle, et grandir par l'échange. demandi "question" pose une question à l'IA, et la réponse s'affiche sur la page. Dans l'atelier, un Assistant IA peut aussi écrire un programme à partir de ta description. (Ces fonctions marchent lorsque la page est ouverte dans Claude.)
titro "Demandi a la IA" demandi "raconte une courte blague"
Si quelque chose ne va pas, le programme l'explique avec le numéro de la ligne. Par exemple, si tu utilises une variable qui n'existe pas, tu verras : Erreur (ligne 2) : variable inconnue « x ». Corrige la ligne indiquée, et relance.
Construire la page | |
| titro "..." | un grand titre |
| pil X | afficher une ligne de texte |
| kolor "rouge" | colorer le texte qui suit (defaut = normal) |
| punto "..." | un point de liste (à puce) |
| lino | une ligne de séparation |
| imajo "lien" | afficher une image |
| entro nom "label" | un champ de saisie rangé dans « nom » |
| buto "label" { … } | un bouton qui exécute le bloc au clic |
Variables et calcul | |
| nom = X | donner la valeur X à « nom » |
| + - * / % | additionner, soustraire, multiplier, diviser, reste |
Comparer et combiner | |
| plu men egal | plus grand / plus petit / égal |
| e o no | et / ou / non |
| i u | vrai / faux |
Conditions et boucles | |
| si COND { … } senon { … } | si la condition est vraie, sinon |
| repete N { … } | répéter N fois |
| tanke COND { … } | répéter tant que vrai |
Fonctions | |
| fonzo f(a, b) { … } | définir une fonction réutilisable |
| redon X | rendre (renvoyer) une valeur |
| f(...) | utiliser la fonction |
| hazar(n) | un nombre au hasard de 1 à n |
| racine(x) aretond(x) | racine carrée / arrondir |
| min(a,b) max(a,b) abs(x) longo(t) | min / max / valeur absolue / longueur |
| demandi "question" | poser une question à l'IA (dans Claude) |
Nombres et notes | |
| nul … dek | de 0 à 10 (san = 100, mil = 1000) |
| # | commentaire jusqu'à la fin de la ligne |