Lolcode - Guide rapide

LOLCODE est un langage de programmation ésotérique inspiré des choses amusantes sur Internet. Il est conçu pour tester les limites de la conception du langage de programmation.

Ce chapitre vous familiarisera avec la configuration de l'environnement local pour LOLCODE, son installation sur Windows et l'exécution de son script en ligne sur Tutorialspoint-codingground.

Configuration de l'environnement local

L'interpréteur LOLCODE est écrit en langage C. Il interprète le code écrit en langage LOLCODE sur plusieurs plates-formes. L'interpréteur LOLCODE est connu sous le nom de lci, qui signifie LOLCODE Interpreter.

Veuillez noter que LOLCODE prend officiellement en charge l'installation directe de l'interpréteur pour les systèmes d'exploitation MAC uniquement. Pour installer LOLCODE dans votre système d'exploitation, vous devez suivre les étapes ci-dessous -

Appuyez sur Commande + Espace et tapez Terminal et appuyez sur enter/return clé
Exécuter dans l'application Terminal
$ git clone https://github.com/justinmeza/lci.git
$ cd lci
$ cmake.
$ make && make install

Installation sous Windows

Si vous devez installer LOLCODE sur le système d'exploitation Windows, veuillez suivre ces étapes -

Ajoutez d'abord MinGW et Python au chemin de vos variables d'environnement. Pour ce faire, faites un clic droit surMy Computer, choisir Properties, puis sélectionnez Advanced system settings. Sélectionner Environment Variables. Dans cette boîte, sélectionnez lePATH variable puis cliquez sur Edit.
Maintenant, ajoutez "; C: \ MinGW \ bin; C: \ Python32" à la fin de ce chemin.
Ensuite, ouvrez le Command Prompt et accédez au répertoire du projet à l'aide de la commande "cd", par exemple.
Exécutez le script install.py.

Exécution de script en ligne avec TutorialsPoint - Codingground

Pour exécuter vos scripts facilement et rapidement, utilisez la plate- forme codingground fournie par TutorialsPoint. Pour cela, rendez-vous sur le lien suivant pour exécuter vos scripts en ligne -

https://www.tutorialspoint.com/execute_lolcode_online.php

LOLCODE a une syntaxe différente de celle des autres langages de programmation, cependant, il est plus facile à retenir. Ce chapitre vous donne la syntaxe de base de LOLCODE.

Constructions

Les constructions LOLCODE sont des mots d'argot. Le tableau suivant montre la liste alphabétique des constructions implémentées jusqu'à présent -

Sr.No.	Construction et utilisation
1	BTW Il commence un commentaire sur une seule ligne.
2	DOWN <variable>!!<times> Cela correspond à variable = variable - fois. Notez que "times" est une extension de langage wut-only.
3	GIMMEH <variable> Cela représente l'instruction d'entrée.
4	GTFO Ceci est similaire à break dans d'autres langues et fournit un moyen de sortir d'une boucle.
5	HAI Cela correspond à main ()fonctionner dans d’autres langues. C'est le point d'entrée du programme dans LOLCODE.
6	HEREZ <label> Ceci est une autre extension de langage wut-only et déclare une étiquette à utiliser avec SHOO
sept	I HAS A <type> <variable> Ceci déclare une variable dudit type. Il existe trois types intégrés dans LOLCODE - NUMBAH (entier) DECINUMBAH (double) WORDZ (std :: chaîne) Notez que les types sont une extension de langage wut-only.
8	IM IN YR LOOP Cela démarre une boucle infinie. La seule façon de sortir de la boucle est d'utiliser GTFO. Correspond à pour(;;) dans d'autres langues
9	IZ <expr1> <operator> <expr2>?: Conditional structure Ceci est similaire à l'opérateur if dans d'autres langues. L'opérateur est l'un des: PLUS GRAND QUE, PLUS PETIT QUE, SAEM AS. Notez que le? à la fin est facultatif.
dix	KTHX Cela termine un bloc. Correspond à}
11	KTHXBAI Cela met fin à un programme
12	NOWAI Cela correspond à else
13	PURR <expr> Ceci imprime l'argument à l'écran, suivi d'une nouvelle ligne. C'est une extension de langage wut-only.
14	RELSE Cela correspond à else (if)
15	SHOO Ceci est une autre extension de langage wut-only, qui correspond à goto (l'horreur!)
16	UP <variable>!!<times> Cela correspond à variables = variable + temps. Ici, "times" est une extension de langage uniquement.
17	VISIBLE <expr> Cela imprime l'argument à l'écran. Notez que cela n'imprime pas de nouvelle ligne.
18	YARLY Ceci indique le début du bloc conditionnel "vrai"

Quelques exemples de termes d'argot dans LOLCODE sont -

HAI est salut
KTHXBYE va bien, merci, au revoir
BTW est au fait
OBTW est oh, au fait
TLDR est trop long; n'a pas lu

Espace blanc

Dans la plupart des langages de programmation, les mots clés ou les jetons peuvent ne pas avoir d'espaces entre eux. Cependant, dans certaines langues, des espaces sont utilisés dans les jetons pour les différencier.

Virgule

La virgule se comporte comme un mot-clé de nouvelle ligne dans la plupart des langues, par exemple, \n en Java et C. Vous pouvez écrire de nombreuses commandes sur une seule ligne dans LOLCODE, à condition que vous les sépariez par une virgule (,).

Trois périodes (…)

Les trois points (…) vous permettent de combiner plusieurs lignes de code en une seule ligne ou une seule commande en incluant (...) à la fin de la ligne. Cela permet au compilateur de traiter le contenu de la ligne suivante comme le contenu de la ligne précédente uniquement. Des lignes infinies de code peuvent être écrites ensemble en une seule commande, à condition que chaque ligne se termine par trois points.

Un commentaire se termine par une nouvelle ligne. Veuillez noter que la suite de ligne (...) et (,) après le commentaire (BTW) sont ignorées par le lci.

commentaires

Les commentaires sur une seule ligne sont écrits suivis du mot-clé BTW. Ils peuvent se produire n'importe où dans le corps d'un programme: cela peut être à la première ligne du programme, entre le programme, entre une ligne ou à la fin d'un programme.

Tous ces commentaires sont valides sur une seule ligne -

I HAS A VAL ITZ 19      BTW VAL = 19
I HAS A VAL ITZ 19,   BTW VAL = 19
I HAS A VAL ITZ 14
BTW VAR = 14

Dans LOLCODE, les commentaires sur plusieurs lignes sont écrits suivis de OBTW et se terminent par TLDR.

Ceci est un commentaire multiligne valide -

I HAS A VAL ITZ 51
   OBTW this is a comment
      No it’s a two line comment
      Oops no.. it has many lines here
   TLDR

Création de fichier

Un programme LOLCODE commence par le mot clé HAI et doit se terminer par KTHXBYE. Comme LOLCODE utilise un langage abrégé, HAI signifie essentiellement Salut et KTHXBYE peut être mémorisé comme“Ok, thanks, bye ”.

Exemple

HAI 1.2
I HAS A NAME
VISIBLE "NAME::"!
GIMMEH NAME
VISIBLE "tutorialsPoint " NAME "!"
KTHXBYE

Comme dans tout autre langage de programmation, LOLCODE vous permet de définir des variables de différents types. Ce chapitre vous familiarisera avec l'utilisation des variables dans LOLCODE.

Portée des variables

La portée d'une variable est locale à la fonction ou au bloc de programme, c'est-à-dire qu'une variable définie dans une portée ne peut pas être appelée dans une autre portée du même programme. Les variables ne sont accessibles qu'après avoir été déclarées.

Veuillez noter qu'il n'y a pas de portée globale des variables dans LOLCODE.

Conventions de nommage

Les noms de variables sont généralement appelés identificateurs. Voici quelques-unes des conventions pour nommer les variables dans LOLCODE -

Les identificateurs de variable peuvent être en majuscules ou en minuscules (ou un mélange des deux).
Ils ne peuvent commencer que par une lettre, puis être suivis d'autres lettres, chiffres et traits de soulignement.
LOLCODE n'autorise pas l'utilisation d'espaces, de tirets ou d'autres symboles lors de la dénomination d'une variable.
Les identificateurs de variable sont sensibles à la casse.

Voici quelques règles pour les noms valides et non valides pour les variables dans LOLCODE−

Le nom doit toujours commencer par un alphabet. Par exemple,name, Name sont valides.
Le nom d'une variable ne peut pas commencer par un chiffre. Par exemple,2var est invalide.
Le nom d'une variable ne peut pas commencer par un caractère spécial.
Une variable peut contenir _ ou un chiffre n'importe où dans son nom, sauf à l'index de départ. Par exemple,name2_m est un nom valide.

Quelques exemples de noms valides dans LOLCODE sont présentés ci-dessous -

HAI 1.2
I HAS A food ITZ "111.00033"
I HAS A food2 ITZ "111"
I HAS A fo_od ITZ "1"
VISIBLE food
VISIBLE food2
VISIBLE fo_od
KTHXBYE

Toutes les instructions de déclaration dans le code ci-dessus sont valides et produiront la sortie suivante une fois exécutées -

sh-4.3$ lci main.lo
111.00033
111
1

Quelques exemples d'instructions invalides et leur sortie sont donnés ci-dessous -

Exemple 1

HAI 1.2
I HAS A 2food ITZ "111.00033"
KTHXBYE

Le code ci-dessus donnera la sortie suivante lorsque vous l'exécuterez -

sh-
4.3$ lci main.lo
Line 2: Expected: identifier; Got: int(2).

Exemple 2

HAI 1.2
I HAS A _food ITZ "111.00033"
KTHXBYE

Le code ci-dessus donnera la sortie suivante lorsque vous l'exécuterez -

sh-
4.3$ lci main.lo
Line 2: Unrecognized sequence at: _food ITZ "111.00033".

Exemple 3

HAI 1.2
I HAS A f$ood ITZ "111.00033"
KTHXBYE

Le code ci-dessus donnera la sortie suivante lorsque vous l'exécuterez -

sh-
4.3$ lci main.lo
Line 2: Unrecognized sequence at: $ood ITZ "111.00033".

Déclaration et affectation des variables

À declareune variable, LOLCODE fournit un mot-clé «I HAS A» qui est suivi du nom de la variable. Vous pouvez trouver ci-dessous la syntaxe pour déclarer une variable.

I HAS A VAR BTW VAR is empty now, You can use any name instead of var

À assignla variable une valeur dans la même instruction, vous pouvez ensuite suivre le nom de la variable avec «ITZ» et ensuite donner la valeur que vous souhaitez attribuer. Utilisez la syntaxe suivante pour attribuer une valeur à une variable -

<variable> R <expression>

Exemple

VAR R "Green"         BTW VAR is now a YARN and equals "Green"
VAR R 30              BTW VAR is now a NUMBR and equals 30

Vous pouvez aussi declare et assign variables en même temps en utilisant la syntaxe suivante -

I HAS A VAR ITZ VALUE

Exemple

I HAS A NAME ITS “TUTORIALS POINT”

Exemple

HAI 1.2
BTW this is how we declare variables
I HAS A food
I HAS A bird

BTW this is how we assign variables
food R 1
bird R 5

BTW this is how initialize variables
I HAS A biz ITZ "OMG!"
VISIBLE food
VISIBLE biz
VISIBLE bird
KTHXBYE

Le programme ci-dessus montre la déclaration des variables et les imprime. La sortie est -

sh-
4.3$ lci main.lo
1
OMG!
5

Type Casting

Pour convertir une valeur d'un type en un autre type, nous utilisons la conversion de type. La conversion d'un NUMBAR en NUMBR tronque la partie décimale du nombre à virgule flottante. Le cast d'un NUMBAR en un YARN (en l'imprimant, par exemple), tronque la sortie à 2 décimales par défaut.

Exemple

HAI 1.2
I HAS A food ITZ "111.00033"
VISIBLE food

BTW this is how we do type casting
MAEK food A NUMBAR
VISIBLE food
KTHXBYE

La ligne de code ci-dessus produira la sortie suivante -

sh-4.3$ lci main.lo
111.00033
111.00033

Toutes les variables déclarées dans un programme LOLCODE sont des variables locales et il n'y a pas de portée globale dans ce langage pour aucune variable.

LOLCODE est conçu pour tester les limites de la conception du langage de programmation. C'est un langage de programmation ésotérique inspiré des choses amusantes sur Internet. Ce chapitre vous donne une compréhension des types LOLCODE.

Les types

Actuellement, les types de variables dans LOLCODE sont -

chaînes (YARN)
entiers (NUMBR)
flotteurs (NUMBAR)
et booléens (TROOF)
Tableaux (BUKKIT)

Dans LOLCODE, le type de variable est géré dynamiquement par le compilateur. Si une variable n'a pas de valeur initiale, elle est appelée non typée (appelée NOOB dans LOLCODE).

La syntaxe pour déclarer et utiliser différents types dans LOLCODE est indiquée ci-dessous -

Pour créer une variable de n'importe quel type de données

I HAS A <VARIABLE> ITZ A <DATA TYPE>

Pour créer une variable et lui attribuer une valeur

I HAS A <VARIABLE> ITZ <EXPRESSION<

Pour affecter une valeur à un type de données déjà créé

<VARIABLE> R <EXPRESSION>

Non tapé (NOOB)

Le type de données non typé (connu sous le nom de NOOB) ne peut être converti en aucun autre type sauf en un type de données TROOF. Le transtypage implicite d'un NOOB dans TROOF rend la variable FAIL. Après cela, toute opération sur un NOOB entraîne une erreur.

Les transtypages explicites d'un type de données NOOB (c'est-à-dire les types qui ne sont pas initialisés et n'ont aucune valeur initiale) donnent des valeurs nulles pour tous les autres types.

Pour définir une variable non typée, déclarez simplement une variable et attribuez une valeur comme indiqué dans cet exemple -

HAI 1.2
I HAS A VAR3
VAR3 R "ANYVALUE"
VISIBLE VAR3

BTW Or declare in same line
I HAS A VAR4 ITZ 44
VISIBLE VAR4
KTHXBYE

Lorsque vous exécutez le programme ci-dessus, vous trouverez le résultat suivant -

sh-
4.3$ lci main.lo 
ANYVALUE
44

Booléens (TROUFS)

Dans LOLCODE, les valeurs booléennes sont de deux types. BOOLEAN a généralement deux valeurs: vrai et faux. Mais, dans LOLCODE, le booléen est connu sous le nom de TROOF, et les valeurs vrai / faux sont appelées respectivement WIN / FAIL. Toutes les valeurs non initialisées telles qu'une chaîne vide ("") ou un tableau vide seront toutes converties en FAIL. Toutes les autres valeurs initialisées sont évaluées à WIN.

Exemple

HAI 1.2
I HAS A VAR3 ITZ A TROOF
VAR3 R "FAIL"
   VISIBLE VAR3
KTHXBYE

Vous pouvez voir la sortie suivante lorsque vous exécutez le code ci-dessus -

sh-4.3$ lci main.lo
FAIL

Types numériques (NUMBR)

Dans LOLCODE, un NUMBR représente un entier. Toute séquence de chiffres est considérée comme un NUMBR, sauf si une décimale apparaît n'importe où entre la séquence. Pour rendre un nombre négatif, il peut être précédé d'un tiret (-) qui signifie un nombre négatif.

Exemple

HAI 1.2
I HAS A VAR3 ITZ A NUMBR
   VISIBLE VAR3
KTHXBYE

Le code ci-dessus vous montre le résultat suivant lorsque vous l'exécutez -

sh- 
4.3$ lci main.lo
0

Semblable à NUMBR, LOLCODE a un autre type de données, qui représente une décimale ou un flottant dans de nombreux langages de programmation. Dans LOLCODE, un NUMBAR est un flottant contenant une virgule décimale. La conversion d'un NUMBAR en NUMBR tronque la partie décimale du nombre à virgule flottante et la renvoie sous la forme d'un NUMBR, sans aucune décimale.

Chaînes (YARN)

Dans LOLCODE, la valeur contenant des chaînes, c'est-à-dire des chaînes littérales (YARN) doit commencer et se terminer par des guillemets doubles ("").

Tout peut être écrit à l'intérieur de la chaîne, comme un espace, une virgule, un point, une exclamation ou tout autre symbole. Une chaîne dans laquelle un guillemet simple est manquant peut provoquer une erreur. Les deux points sont utilisés comme caractères d'échappement dans LOLCODE, et toute valeur suivant un signe deux-points a une signification particulière.

:) - Un crochet fermant après un deux-points représente une nouvelle ligne (\ n)
:> - Un crochet de fermeture après un deux-points représente une tabulation (\ t)
:o - Un ‘o’ le caractère suivant un deux-points représente une cloche (bip) (\ g)
:" - Un «après un deux-points représente un guillemet double littéral (")
:: - Un deux-points après un deux-points représente un seul deux-points littéral (:)

Exemple

HAI 1.2
I HAS A VAR3 ITZ A YARN
VAR3 R "XYZ"
   VISIBLE VAR3
KTHXBYE

Le code donné ci-dessus produit la sortie suivante lors de l'exécution -

sh-
4.3$ lci main.lo 
XYZ

BUKKIT

Ce type représente un tableau. Il a des emplacements nommés, qui peuvent contenir des variables ou des fonctions. Un BUKKIT peut être déclaré de la manière suivante -

BTW declaration of the BUKKIT
I HAS A [object] ITZ A BUKKIT BTW creating a variable in a slots
[object] HAS A [var] ITZ [value] BTW creating a function inside the BUKKIT

HOW IZ [object] [function name] (YR [argument1] (AN YR [argument2] (AN YR [argument3] ...)))
[function code]
IF U SAY SO

Une fonction à l'intérieur d'un BUKKIT peut également accéder à des variables et à d'autres fonctions du BUKKIT en utilisant ME'Z [var] ou ME IZ [nom de la fonction] (YR [argument1] (AN YR [argument2] (AN YR [argument3] ... ))) MKAY.

Exemple

HAI 1.2
   I HAS A VAR6 ITZ A BUKKIT
   BTW DECLARING AN ARRAY
   VAR6 HAS A VAR7 ITZ "DOGE"
   
   BTW VAR7 IS A STRING VARIABLE THAT IS INSERTED  INTO ARRAY VAR6
   VISIBLE VAR6'Z VAR7
   BTW GET THE ELEMENT OF ARRAY
KTHXBYE

C'est la sortie que vous trouverez lorsque vous exécuterez le code donné ci-dessus -

sh-
4.3$ lci main.lo 
DOGE

Les opérateurs jouent un rôle important pour effectuer diverses opérations sur les variables. Ce chapitre vous présente différents opérateurs dans LOLCODE et leur utilisation.

Les opérateurs

Les opérateurs mathématiques dépendent d'une notation de préfixe, c'est-à-dire la notation qui précède l'opérande. Lorsque tous les opérateurs ont un nombre connu d'arguments ou d'opérandes, aucun marqueur de regroupement n'est nécessaire. Dans les cas où les opérateurs n'ont pas d'arguments ou d'opérandes fixes, l'opération est fermée avec MKAY.

Un MKAY ne peut pas être utilisé s'il coïncide avec la fin de l'instruction. Dans de tels cas, le mot clé EOL doit être utilisé. Pour utiliser des opérateurs mathématiques unaires, utilisez la syntaxe suivante -

<operator> <expression>

Le mot clé AN peut éventuellement être utilisé pour séparer les arguments et appliquer une seule opération sur plusieurs opérandes, de sorte qu'une expression d'opérateur binaire a la syntaxe suivante -

<operator> <expression1> AN <expression2>

Toute expression contenant un opérateur avec un nombre infini d'arguments peut être exprimée avec la syntaxe suivante -

<operator> <expression1> [[AN <expression2>] AN <expression3> ...] MKAY

Math

Voici les opérations mathématiques de base dans LOLCODE -

SUM OF <a> AN <b>      BTW This is a plus + operator
DIFF OF <a> AN <n>     BTW This is a minus - operator
PRODUKT OF <a> AN <n>  BTW This is a multiply operator *
QUOSHUNT OF <a> AN <n> BTW This is a divide operator
MOD OF <a> AN <n>      BTW This is a modulo operator
BIGGR OF <a> AN <n>    BTW This is a max operator
SMALLR OF <a> AN <n>   BTW This is a min operator

<a> et <b> peuvent chacun être des expressions uniques dans ce qui précède, de sorte que les opérateurs mathématiques peuvent être imbriqués et groupés indéfiniment.

Les mathématiques sont effectuées en considérant les arguments comme des nombres entiers en présence de deux NUMBR, mais si l'une des expressions est NUMBAR, les opérations sont considérées comme des opérations en virgule flottante.

Exemple

HAI 1.2
   I HAS A m ITZ 4
   I HAS A n ITZ 2
VISIBLE SUM OF m AN n      BTW +
VISIBLE DIFF OF m AN n     BTW -
VISIBLE PRODUKT OF m AN n  BTW *
VISIBLE QUOSHUNT OF m AN n BTW /
VISIBLE MOD OF m AN n      BTW modulo
VISIBLE BIGGR OF m AN n    BTW max
VISIBLE SMALLR OF m AN n   BTW min
KTHXBYE

Le code ci-dessus produira la sortie suivante lorsque vous l'exécuterez -

sh-
4.3$ lci main.lo
6
2
8
2
0
4
2

Points importants -

Considérez les points importants suivants liés au travail avec des opérateurs mathématiques dans LOLCODE−

Si l'un ou les deux arguments d'une expression sont YARN, ils sont traités comme des NUMBAR.
Si l'un des arguments ne peut pas être converti en toute sécurité en interne en type numérique, cela échoue avec une erreur

Booléen

Les opérateurs booléens sont appliqués aux valeurs qui peuvent être vraies ou fausses. Les opérateurs booléens travaillant sur les TROOF sont les suivants:

BOTH OF <m> AN <n>             BTW its and operation: WIN if m = WIN and n = WIN
EITHER OF <m> AN <n>           BTW its or operation: FAIL iff m = FAIL, n = FAIL
WON OF <m> AN <n>              BTW its xor operation: FAIL if m = n
NOT <m>                        BTW its an unary negation: WIN if m = FAIL
ALL OF <m> AN <n> ... MKAY     BTW it will take infinite arguments and apply AND
ANY OF <m> AN <n> ... MKAY     BTW it will take infinite arguments and apply OR.

Veuillez noter que <m> et <n> dans la syntaxe d'expression ci-dessus sont automatiquement convertis en valeurs TROOF s'ils ne sont pas déjà des valeurs TROOF.

Comparaison

Lorsque vous souhaitez comparer deux opérandes ou plus dans LOLCODE, vous pouvez le faire dans l'une des méthodes suivantes:

Méthode 1

Vous pouvez comparer deux opérandes binaires à l'aide d'opérateurs d'égalité. La syntaxe est indiquée ci-dessous -

BOTH SAEM <m> AN <n>   BTW this will return WIN if m is equal to n
DIFFRINT <m> AN <n>    BTW this will return WIN if m is not equal to n

Méthode 2

Vous pouvez comparer si les deux valeurs sont de type NUMBR. N'oubliez pas que si l'une des valeurs est NUMBAR, elle est comparée en tant que valeur à virgule flottante.

Méthode 3

Vous pouvez également effectuer une comparaison à l'aide des opérateurs minimum et maximum. La syntaxe est indiquée ci-dessous -

BOTH SAEM <m>   AN BIGGR OF <m> AN <n>

BOTH SAEM <m>  AN SMALLR OF <m> AN <n>
DIFFRINT <m>  AN SMALLR OF <m> AN <n>
DIFFRINT <m> AN BIGGR OF <m> AN <n>

Example

HAI 1.2
I HAS A VAR11 ITZ 7
BOTH SAEM VAR11 SMALLR OF VAR11 AN 8, O RLY?
YA RLY
VISIBLE "TRUE"
NO WAI
VISIBLE "FALSE"
OIC
KTHXBYE

Vous pouvez voir la sortie suivante lorsque vous exécutez le code donné -

sh-
4.3$ lci main.lo

TRUE

Concaténation de valeurs

LOLCODE vous permet de concaténer explicitement un nombre infini de YARN à l'aide de l'opérateur SMOOSH… MKAY. Pour la concaténation, plusieurs arguments peuvent être séparés avec leAN opérateur.

Exemple

HAI 1.2
I HAS A VAR1 ITZ A YARN
VAR1 R "TRUE"

I HAS A VAR2 ITZ A YARN
VAR2 R "ANOTHER TRUE"

I HAS A VAR3 ITZ A YARN
VAR3 R "ONE MORE TRUE"
VISIBLE SMOOSH VAR1 " " VAR3 " " VAR2 MKAY
KTHXBYE

Le code donné ci-dessus produira le résultat suivant lors de l'exécution -

sh-
4.3$ lci main.lo

TRUE ONE MORE TRUE ANOTHER TRUE

Type Casting

Les opérateurs qui travaillent sur des types spécifiques transtypent ou convertissent implicitement les valeurs d'un type en un autre type en toute sécurité. Si la valeur ne peut pas être convertie en toute sécurité en un autre type, cela entraîne une erreur.

La valeur d'une expression peut être explicitement castée ou convertie en un autre type avec l'opérateur MAEK binaire. La syntaxe de l'opérateur MAEK est -

MAEK <expression> A <type>

où, <type> peut être l'un des TROOF, YARN, NUMBR, NUMBAR ou NOOB.

Pour convertir explicitement une variable en un autre type, une instruction d'affectation normale avec l'opérateur MAEK peut être utilisée, ou une instruction d'affectation de conversion peut être utilisée comme suit -

<Any_variable> IS NOW A <type>  BTW this code will be equal to
<Any_variable> R MAEK <variable> A <type>

Exemple

HAI 1.2
I HAS A food ITZ "111.00033"
VISIBLE food

BTW this is how we do type casting
MAEK food A NUMBAR
VISIBLE food
KTHXBYE

Le code ci-dessus produira la sortie suivante -

sh-4.3$ lci main.lo
111.00033
111.00033

Ce chapitre vous explique comment saisir une valeur via le terminal LOLCODE et comment la sortir sur le terminal.

E / S depuis le terminal

Vous pouvez utiliser le mot-clé VISIBLE pour imprimer quelque chose dans LOLCODE. VISIBLE est une fonction qui peut prendre un nombre infini de caractères en entrée, et les imprime tous à la fois en les concaténant en interne et en les convertissant en chaînes ou en YARN.

La fonction VISIBLE se termine ou se termine par un délimiteur, qui est soit une fin de ligne, soit une virgule.

La sortie est automatiquement terminée par le compilateur avec un retour chariot. Si le jeton final se termine par un symbole d'exclamation (!), Le chariot renvoyé est écrasé par ce symbole.

VISIBLE <any_expression> [<any_expression> ...][!]

Veuillez noter que dans LOLCODE, il n'existe actuellement aucune norme définie pour l'impression de certaines données dans un fichier.

Pour prendre des informations de l'utilisateur, le mot-clé utilisé est GIMMEH. C'est une fonction qui peut prendre n'importe quel nombre de variables en entrée. Il prend YARN comme entrée et stocke la valeur dans une variable donnée.

GIMMEH <any_variable>

Exemple

HAI 1.2
   I HAS A VAR ITZ A YARN BTW DECLARE A VARIABLE FOR LATER USE
   VISIBLE "TYPE SOMETHING AND ENTER"
   GIMMEH VAR BTW GET INPUT (STRING) INTO VARIABLE
   VISIBLE VAR
KTHXBYE

Lorsque ce code est exécuté, il vous demandera d'entrer un numéro, puis réimprimera automatiquement le numéro dans la ligne suivante. Lorsque vous exécutez ce code, il imprimera la sortie suivante -

sh-
4.3$ lci main.lo

TYPE SOMETHING AND ENTER
67

67

LOLCODE vous permet de contrôler le flux du programme à travers diverses instructions. Ce chapitre explique les différents types d'instructions disponibles dans LOLCODE.

Déclarations d'expression

Une expression sans aucune affectation, c'est-à-dire appeler simplement une opération mathématique ou une fonction quelconque, est une déclaration légale dans LOLCODE. Une fois l'expression évaluée, sa valeur finale est placée dans la variable temporaire IT. La valeur de IT reste dans la portée locale et existe jusqu'à la prochaine fois qu'elle est remplacée par une expression.

Déclarations d'affectation

Les instructions d'affectation sont utilisées pour affecter la sortie de toute expression à une variable donnée. Ils sont généralement de la forme -

<any_variable> <assignment operator> <any expression>

Veuillez noter que vous pouvez utiliser une variable dans l'expression, avant même qu'elle ne soit affectée.

Expressions conditionnelles

Déclarations If-Then

L'instruction if-then est une opération très simple fonctionnant sur la variable informatique. Elle est similaire aux instructions if – else dans d'autres langages de programmation comme C et Java.

Il existe quatre mots-clés pour appliquer les instructions if – then.

O RLY?
YA RLY
PAS DE WAI
OIC

La forme générale est -

<any_expression>
O RLY?
   YA RLY
      <code to execute if above condition is true>
   NO WAI
      <code to execute in this block>
OIC

Toutes les instructions ci-dessus peuvent être écrites sur la même ligne séparées par des virgules comme -

BOTH SAEM NAMES AN "Name", O RLY?
   YA RLY, VISIBLE "My name is ABCD"
   NO WAI, VISIBLE "Your name is ABCD"
 OIC

Lors de l'utilisation des instructions if-then, un MEBBE optionnel <toute expression> peut être utilisé entre les blocs YA RLY et NO WAI.

Si <toute expression> suivant MEBBE est True (WIN), alors ce bloc est exécuté. Sinon, si cette expression est fausse, le bloc est ignoré jusqu'aux instructions MEBBE, NO WAI ou OIC suivantes.

Exemple

<any expression>
O RLY?
   YA RLY
      <code to be executed if true>
   MEBBE <expression>
      <code to be executed mebbe is true>
   MEBBE <expression>
      <code to be executed mebbe is true>
   NO WAI
      <code to be executed if above are false>
OIC

Exemple

BOTH SAEM NAMES AN "NAME"
O RLY?
   YA RLY, VISIBLE "YOUR NAME IS ABCD"
   MEBBE BOTH SAEM ANIMAL AN "OUR NAME IS ABCD"
   VISIBLE "NO ABCD"
OIC

Déclarations de cas

Dans LOLCODE, le mot clé "WTF?" est similaire au commutateur dans de nombreuses autres langues. Le mot-clé WTF? prend IT comme valeur d'expression pour la comparaison. Pour utiliser WTF, un bloc de comparaison est ouvert par OMG qui doit être un littéral et non une expression.

N'oubliez pas que chaque littéral doit être unique, similaire au cas des autres langues.

Le bloc OMG doit être terminé par une instruction GTFO. Si un bloc OMG n'est pas terminé par un GTFO, le bloc OMG suivant est exécuté jusqu'à ce que GTFO soit atteint.

Si aucun des littéraux n'est évalué comme vrai, alors la casse par défaut est signifiée par OMGWTF.

WTF?
   OMG <any value to compare>
      <code block to execute if expression is satisfied>
   OMG <any value to compare>
      <code block to execute if expression is satisfied>
   OMGWTF
      <code block to execute as a default case>
OIC
NAME, WTF?
   OMG "A"
      VISIBLE "ABCD"
   GTFO
   OMG "E"
      VISIBLE "EFGH"
   GTFO
   OMGWTF
      VISIBLE "ZYXW"
   OIC

Les résultats de sortie du code ci-dessus seront -

"E":

EFGH

Les boucles sont utilisées dans les langages de programmation pour exécuter un ensemble d'instructions plusieurs fois. Par exemple, si vous souhaitez imprimer le chiffre 5 cinq fois, au lieu d'écrire leVISIBLE “5” instruction cinq fois, vous pouvez exécuter une boucle avec un seul VISIBLE “5” déclaration cinq fois.

Les boucles simples sont représentées par IM IN YR <label> et IM OUTTA YR <label>. Les boucles définies de cette manière sont des boucles infinies et elles doivent être terminées par une instruction break GTFO.

Les boucles d'itération ont la structure suivante -

IM IN YR <label> <any_operation> YR <any_variable> [TIL|WILE <expression>]
   <code block to execute inside the loop multiple times>
IM OUTTA YR <label>

Veuillez noter qu'à l'intérieur du corps de la fonction, UPPIN (incrémenter de un), NERFIN (décrémenter de un) ou toute fonction unaire peuvent être utilisés.

Le mot clé TIL calcule l'expression comme un TROOF: s'il est évalué comme FAIL, la boucle continue une fois de plus, s'il est évalué comme WIN, alors l'exécution de la boucle s'arrête et se poursuit après l'instruction IM OUTTA YR correspondante.

Le mot-clé WILE est l'opposé du mot-clé TIL, si l'expression est WIN, l'exécution se poursuit, sinon la boucle se termine.

Exemple

HAI 1.2
I HAS A VAR ITZ 0
IM IN YR LOOPY UPPIN YR VAR TIL BOTH SAEM VAR AN 10
   VISIBLE SUM OF VAR AN 1
IM OUTTA YR LOOPY
KTHXBYE

Lorsque le code ci-dessus est compilé sur n'importe quel compilateur LOLCODE, ou sur notre terrain de codage en ligne, cela produira la sortie suivante.

sh-
4.3$ lci main.lo
1
2
3
4
5
6
7
8
9
10

Les fonctions sont utiles dans la programmation car elles réduisent le temps et les efforts pour écrire le code encore et encore. Un code de fonction bien écrit offre une grande réutilisabilité. Ce chapitre vous explique comment écrire et utiliser des fonctions dans LOLCODE.

Définition d'une fonction

Une fonction est un ensemble d'instructions qui sont exécutées en une seule fois en appelant cette fonction. Dans LOLCODE, la définition d'une fonction commence par le mot-clé «COMMENT IZ I» et le mot-clé de fermeture est «IF U SAY SO».

La syntaxe pour écrire une fonction dans LOLCODE est -

HOW IZ I <function name> [YR <parameter/argument> [AN YR <other _arguments..> …]]
   <code block to execute / Set of statements to execute>
IF U SAY SO

Les points importants

Tenez compte des points importants suivants lorsque vous définissez une fonction LOLCODE -

Dans LOLCODE, la fonction ne peut accepter qu'un certain nombre fixe d'arguments comme entrée.
Les arguments ou paramètres, sont les identifiants qui deviennent une variable de la fonction.
Les fonctions de LOLCODE ne peuvent accéder à aucune autre valeur que les valeurs qui leur sont transmises en tant qu'arguments.

Renvoyer la valeur d'une fonction

Le retour dans le codage signifie quelque chose qui est rendu. En programmation, une fonction peut renvoyer une valeur au programme lorsque son exécution est terminée. Dans LOLCODE, les fonctions renvoient des valeurs variables comme expliqué ci-dessous -

FOUND YR <any_expression> renvoie la valeur de l'expression lorsque le bloc fonction est exécuté complètement.
GTFO ne renvoie aucune valeur (NOOB), ce qui est similaire à return 0 dans d'autres langages de programmation comme C et Java.
Si aucune autre instruction de retour n'est trouvée, alors IF U SAY SO est exécuté et la valeur de la variable IT est renvoyée.

Fonctions d'appel

Une fonction est définie dans le corps du programme et est appelée ultérieurement pour exécution. Une fonction qui accepte un nombre donné d'arguments est appelée comme indiqué ci-dessous -

I IZ <function_name> [YR <expression_One> [AN YR <expression_Two> 
   [AN YR <expression_Three> ...]]] MKAY

Lors de l'appel d'une fonction, l'expression est formée par le nom de la fonction, suivi du nombre d'arguments que la fonction acceptera. Ces arguments peuvent être de simples variables ou n'importe quelle expression. Si une fonction accepte une expression au lieu d'une valeur simple, les valeurs des expressions sont calculées avant l'appel de la fonction.

N'oubliez pas que le nombre d'arguments qu'une fonction acceptera doit être défini dans la définition de la fonction.

Exemple

HAI

HOW DUZ I MAINUMBA
   I HAS A NUMBA
   GIMMEH NUMBA
   FOUND YR NUMBA
IF U SAY SO

VISIBLE MAINUMBA

KTHXBYE

Lorsque vous exécutez le code ci-dessus, il vous demandera une entrée, puis lorsque vous soumettez l'entrée, vous verrez le même résultat. Par exemple, si nous entrons 55, il imprimera 55.

Exemple

HAI 1.2
HOW IZ I MULTIPLY YR FIRSTOPERANT AN YR SECONDOPERANT
   FOUND YR PRODUKT OF FIRSTOPERANT AN SECONDOPERANT
   IF U SAY SO
   VISIBLE I IZ MULTIPLY YR 2 AN YR 3
KTHXBYE

La fonction ci-dessus qui effectue la multiplication des opérandes d'entrée imprimera la sortie suivante lorsque vous l'exécuterez -

sh-
4.3$ lci main.lo

6

Exemple

HAI 1.2
I HAS A STRINGARRAY ITZ A BUKKIT
   STRINGARRAY HAS A VAR17 ITZ "OBJECT1"
   STRINGARRAY HAS A VAR18 ITZ "OBJECT2"
   HOW IZ STRINGARRAY ACCESS YR VARIABLE
      FOUND YR STRINGARRAY'Z SRS VARIABLE
   IF U SAY SO
   I HAS A STRING ITZ "VAR17"
   VISIBLE STRINGARRAY IZ ACCESS YR STRING MKAY
KTHXBYE

La sortie que le code ci-dessus produira est -

sh-
4.3$ lci main.lo 
OBJECT1

La gestion des exceptions est l'un des mécanismes puissants pour gérer les erreurs d'exécution afin que le flux normal de l'application puisse être maintenu. LOLCODE n'a pas beaucoup de support pour la gestion des exceptions comme les autres langages de programmation. Semblable au bloc Try-Catch dans d'autres langues, LOLCODE a le bloc PLZ.

Par exemple, si vous souhaitez ouvrir un fichier qui peut exister ou non, utilisez -

PLZ OPEN FILE "filename.TXT"?
   AWSUM THX
      VISIBLE FILE
      O NOES
   INVISIBLE "ERROR!"
KTHX

Le code qui peut provoquer une exception est écrit dans le bloc PLZ et l'exception est gérée dans le bloc O NOES. Ici, le mot clé INVISIBLE envoie un message interne au débogueur.

Veuillez noter que comme LOLCODE n'est pas mis à jour régulièrement, il n'y a plus de mises à jour disponibles pour la gestion des exceptions LOLCODE et de nombreuses autres fonctionnalités.

Les chapitres précédents vous ont expliqué la programmation en LOLCODE. Dans ce chapitre, vous apprendrez quelques exemples qui vous permettent de coder à un niveau avancé en LOLCODE.

Exemple 1: programme pour calculer la puissance d'un nombre

Dans cet exemple, vous trouverez le code pour calculer la puissance d'un nombre d'entrée. Par exemple, 2 élevé à la puissance 4 est égal à 16.

HAI 1.2
HOW IZ I POWERTWO YR NUM
   BTW RETURN 1 IF 2 TO POWER OF 0
   BOTH SAEM NUM AN 0, O RLY?
   YA RLY, FOUND YR 1
   OIC
  
   BTW CALCULATE 2 TO POWER OF NUM
   I HAS A INDEX ITZ 0
   I HAS A TOTAL ITZ 1
   IM IN YR LOOP UPPIN YR INDEX TIL BOTH SAEM INDEX AN NUM
   TOTAL R PRODUKT OF TOTAL AN 2
   IM OUTTA YR LOOP
  
   FOUND YR TOTAL
   IF U SAY SO
   BTW OUTPUT: 8
   VISIBLE I IZ POWERTWO YR 4 MKAY
KTHXBYE

Le code ci-dessus imprimera la sortie suivante une fois qu'il s'exécutera avec succès -

sh-
4.3$ lci main.lo
16

Exemple 2: programme pour créer un tableau

Cet exemple montre le code pour créer un tableau avec cinq éléments et chaque élément avec la valeur 10.

HAI 1.3
   OBTW
      CREATES A ONE DIMENSIONAL ARRAY WITH N ELEMENTS, EACH IS A 0
   TLDR
	HOW IZ I MAKEMATRIX YR N
      I HAS A MATRIX ITZ A BUKKIT
      IM IN YR LOOP UPPIN YR INDEX TIL BOTH SAEM INDEX N
         MATRIX HAS A SRS INDEX ITZ 10
      IM OUTTA YR LOOP
  
      FOUND YR MATRIX
   IF U SAY SO

      I HAS A N ITZ 5
      I HAS A MATRIX ITZ A BUKKIT
      MATRIX R I IZ MAKEMATRIX YR N MKAY

	   BTW PRINTS THE CONTENTS OF THE ARRAY
      IM IN YR LOOP UPPIN YR INDEX TIL BOTH SAEM INDEX N
         VISIBLE MATRIX'Z SRS INDEX
   IM OUTTA YR LOOP
KTHXBYE

Vous pouvez voir la sortie suivante lorsque vous exécutez le code ci-dessus -

sh-4.3$ lci main.lo
10
10
10
10
10

Exemple 3: programme pour calculer la factorielle d'un nombre

Ce programme affiche le code pour calculer la factorielle d'un nombre d'entrée.

HAI 1.3
   HOW IZ I FACTORIAL YR N
   BOTH SAEM N AN 0
   O RLY?
	   YA RLY, FOUND YR 1
   NO WAI
      FOUND YR PRODUKT OF N AN I IZ FACTORIAL YR DIFF OF N AN 1 
      MKAY
   OIC
   IF U SAY SO

   VISIBLE I IZ FACTORIAL YR 6 MKAY
KTHXBYE

Le programme ci-dessus imprime la factorielle du nombre 6 et vous pouvez voir la sortie comme indiqué ci-dessous -

sh-
4.3$ lci main.lo

720

Exemple 4: programme pour concevoir une calculatrice

Vous pouvez concevoir une calculatrice pour effectuer des opérations mathématiques de base à l'aide de la programmation LOLCODE. Observez le code ci-dessous -

HAI 1.2

   I HAS A V1
   I HAS A V2
   I HAS A CHOICE
   
   VISIBLE "VALUE1"
   GIMMEH V1
   VISIBLE "VALUE2"
   GIMMEH V2VISIBLE "Choose Operation? + - * /"
   GIMMEH CHOICE CHOICE, WTF?
   OMG "+"
      VISIBLE SUM OF V1 AN V2
      
      GTFO

   OMG "-"
      VISIBLE DIFF OF V1 AN V2

      GTFO
   OMG "*"
      VISIBLE PRODUKT OF V1 AN V2
      
      GTFO

   OMG "/"
      VISIBLE QUOSHUNT OF V1 AN V2

      GTFO
   OMGWTF
      VISIBLE "CHOOSE SOME OPERATION"
   OIC

KTHXBYE

Lorsque nous exécutons le programme ci-dessus avec l'entrée suivante -

3
4
+

Lors de l'exécution, le programme ci-dessus générera la sortie suivante -

VALUE1
VALUE2
Choose Operation? + - * /
7