Lolcode 快速指南
Lolcode - 介绍和环境设置
LOLCODE 是一种受互联网上有趣事物启发的深奥编程语言。它旨在测试编程语言设计的边界。
本章将使您熟悉设置 LOLCODE 的本地环境，在 Windows 上安装它，以及在 Tutorialspoint-codingground 上在线执行其脚本。
设置本地环境
LOLCODE 解释器是用 C 语言编写的。它解释在多个平台上用 LOLCODE 语言编写的代码。LOLCODE 解释器称为 lci，代表 LOLCODE 解释器。
请注意，LOLCODE 官方仅支持直接安装 MAC 操作系统的解释器。要在您的操作系统中安装 LOLCODE，您需要按照以下步骤操作：
- 按 Command+Space，输入终端并按回车键
- 在终端应用程序中运行
- $ git clone https://github.com/justinmeza/lci.git
- $ cd lci
- $ cmake.
- $ make && make install
在 Windows 上安装
如果您需要在 Windows 操作系统上安装 LOLCODE，请执行以下步骤：
首先将 MinGW 和 Python 添加到您的环境变量路径中。为此，右键单击我的电脑，选择属性，然后选择高级系统设置。选择环境变量。在此框中，选择PATH变量，然后单击编辑。
现在，将“;C:\MinGW\bin;C:\Python32”添加到该路径的末尾。
接下来，打开命令提示符并使用“cd”命令导航到项目目录，例如。
运行 install.py 脚本。
使用 TutorialsPoint - codingground 在线执行脚本
要轻松快捷地执行您的脚本，请使用 TutorialsPoint 提供的 codingground 平台。为此，请访问以下链接在线执行您的脚本：
https://tutorialspoint.com/execute_lolcode_online.phpLolcode - 语法
LOLCODE 结构是俚语词。下表显示了迄今为止实现的结构的字母顺序列表：
| 序号 | 结构和用法 |
|---|---|
| 1 | BTW 它开始单行注释。 |
| 2 | DOWN <变量>!!<次数> 这对应于 variable = variable - times。请注意，“times”是仅限 wut 的语言扩展。 |
| 3 | GIMMEH <变量> 这表示输入语句。 |
| 4 | GTFO 这类似于其他语言中的break，并提供了一种跳出循环的方法。 |
| 5 | HAI 这对应于其他语言中的main ()函数。它是 LOLCODE 中的程序入口点。 |
| 6 | HEREZ <标签> 这是另一个仅限 wut 的语言扩展，声明一个标签以供 SHOO 使用 |
| 7 | I HAS A <类型> <变量> 这声明了指定类型的变量。 LOLCODE 中有三种内置类型：
请注意，类型是仅限 wut 的语言扩展。 |
| 8 | IM IN YR LOOP 这启动一个无限循环。退出循环的唯一方法是使用 GTFO。对应于其他语言中的 for(;;) |
| 9 | IZ <表达式1> <运算符> <表达式2>?: 条件结构 这类似于其他语言中的 if 运算符。运算符是以下之一：BIGGER THAN、SMALLER THAN、SAEM AS。请注意，末尾的 ? 是可选的。 |
| 10 | KTHX 它结束一个块。对应于} |
| 11 | KTHXBAI 这结束一个程序 |
| 12 | NOWAI 这对应于 else |
| 13 | PURR <表达式> 这在屏幕上打印参数，后跟换行符。它是仅限 wut 的语言扩展。 |
| 14 | RELSE 这对应于else (if) |
| 15 | SHOO 这是另一个仅限 wut 的语言扩展，对应于goto（恐怖！） |
| 16 | UP <变量>!!<次数> 这对应于 variables = variable + times。这里“times”是仅限 wut 的语言扩展。 |
| 17 | VISIBLE <表达式> 这在屏幕上打印参数。请注意，这不会打印换行符。 |
| 18 | YARLY 这表示“真”条件块的开始 |
一些 LOLCODE 俚语示例：
- HAI 是 hi
- KTHXBYE 是 okay, thanks, bye
- BTW 是 by the way
- OBTW 是 oh, by the way
- TLDR 是 too long; didn't read
空白符
在大多数编程语言中，关键字或标记之间可能没有空格。但是，在某些语言中，空格用于区分标记。
逗号
逗号在大多数语言中像换行符关键字一样工作，例如 Java 和 C 中的\n。您可以在 LOLCODE 中在一行中编写许多命令，前提是您使用逗号 (,) 将它们分隔开。
三个点 (…)
三个点 (…) 使您能够通过在行尾包含 (...) 将多行代码组合成单行或单个命令。这使编译器将下一行的内容仅视为上一行的内容。只要每行以三个点结尾，就可以将无限行代码编写在一起作为单个命令。
注释以换行符结束。请注意，lci 忽略注释 (BTW) 后的行延续 (...) 和 (,)。
注释
单行注释写在 BTW 关键字之后。它们可以出现在程序主体中的任何位置：可以位于程序的第一行、程序之间、某些行之间或程序的末尾。
所有这些都是有效的单行注释：
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
在 LOLCODE 中，多行注释写在 OBTW 之后，并以 TLDR 结束。
这是一个有效的多行注释：
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
文件创建
LOLCODE 程序以 HAI 关键字开头，应该以 KTHXBYE 结尾。由于 LOLCODE 使用速记语言，HAI 基本上代表 Hi，KTHXBYE 可以记为“Ok, thanks, bye”。
示例
HAI 1.2 I HAS A NAME VISIBLE "NAME::"! GIMMEH NAME VISIBLE "tutorialsPoint " NAME "!" KTHXBYE
Lolcode - 变量
与任何其他编程语言一样，LOLCODE 允许您定义各种类型的变量。本章将使您熟悉在 LOLCODE 中使用变量。
变量的作用域
变量的作用域是局部于函数或程序块的，即在一个作用域中定义的变量不能在同一程序的任何其他作用域中调用。变量只有在声明后才能访问。
请注意，LOLCODE 中没有变量的全局作用域。
命名约定
变量名通常称为标识符。以下是 LOLCODE 中变量命名的约定：
变量标识符可以全部大写或小写字母（或两者的混合）。
它们只能以字母开头，然后可以后跟其他字母、数字和下划线。
LOLCODE 不允许在命名变量时使用空格、短划线或其他符号。
变量标识符区分大小写。
以下是 LOLCODE 中变量有效和无效名称的一些规则：
名称应始终以字母开头。例如，name、Name 是有效的。
变量名不能以数字开头。例如，2var 是无效的。
变量名不能以特殊字符开头。
变量可以在其名称中的任何位置包含 _ 或数字，但起始索引除外。例如，name2_m 是有效的名称。
以下显示了 LOLCODE 中一些有效名称的示例：
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
上述代码中的所有声明语句都是有效的，并且执行时将产生以下输出：
sh-4.3$ lci main.lo 111.00033 111 1
以下是无效语句及其输出的一些示例：
示例 1
HAI 1.2 I HAS A 2food ITZ "111.00033" KTHXBYE
执行上述代码时，将得到以下输出：
sh-4.3$ lci main.lo Line 2: Expected: identifier; Got: int(2).
示例 2
HAI 1.2 I HAS A _food ITZ "111.00033" KTHXBYE
执行上述代码时，将得到以下输出：
sh-4.3$ lci main.lo Line 2: Unrecognized sequence at: _food ITZ "111.00033".
示例 3
HAI 1.2 I HAS A f$ood ITZ "111.00033" KTHXBYE
执行上述代码时，将得到以下输出：
sh-4.3$ lci main.lo Line 2: Unrecognized sequence at: $ood ITZ "111.00033".
变量的声明和赋值
要声明变量，LOLCODE 提供了一个关键字“I HAS A”，后跟变量名。您可以在下面找到声明变量的语法。
I HAS A VAR BTW VAR is empty now, You can use any name instead of var
要在同一语句中赋值给变量，您可以然后在变量名后跟“ITZ”，然后给出要赋值的值。使用以下语法为变量赋值：
<variable> R <expression>
示例
VAR R "Green" BTW VAR is now a YARN and equals "Green" VAR R 30 BTW VAR is now a NUMBR and equals 30
您还可以同时声明和赋值变量，使用以下语法：
I HAS A VAR ITZ VALUE
示例
I HAS A NAME ITS “TUTORIALS POINT”
示例
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
上述程序显示了变量的声明并打印它们。输出为：
sh- 4.3$ lci main.lo 1 OMG! 5
类型转换
要将一个类型的值转换为另一个类型，我们使用类型转换。将 NUMBAR 转换为 NUMBR 会截断浮点数的小数部分。将 NUMBAR 转换为 YARN（例如通过打印它），会将输出截断为默认的 2 位小数。
示例
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
上述代码行将产生以下输出：
sh-4.3$ lci main.lo 111.00033 111.00033
在 LOLCODE 程序中声明的所有变量都是局部变量，此语言中没有任何变量的全局作用域。
Lolcode - 数据类型
LOLCODE 旨在测试编程语言设计的边界。它是一种受互联网上有趣事物启发的深奥编程语言。本章使您了解 LOLCODE 类型。
类型
目前，LOLCODE 中的变量类型为：
- 字符串 (YARN)
- 整数 (NUMBR)
- 浮点数 (NUMBAR)
- 和布尔值 (TROOF)
- 数组 (BUKKIT)
在 LOLCODE 中，变量类型由编译器动态处理。如果变量没有初始值，则称为未类型化（在 LOLCODE 中称为 NOOB）。
下面显示了在 LOLCODE 中声明和使用不同类型的语法：
创建任何数据类型的变量
I HAS A <VARIABLE> ITZ A <DATA TYPE>
创建变量并为其赋值
I HAS A <VARIABLE> ITZ <EXPRESSION<
为已创建的数据类型赋值
<VARIABLE> R <EXPRESSION>
未类型化 (NOOB)
未类型化数据类型 (称为 NOOB) 无法转换为除 TROOF 数据类型以外的任何其他类型。将 NOOB 隐式转换为 TROOF 会使变量 FAIL。之后，对 NOOB 的任何操作都会导致错误。
未类型化数据类型 (即未初始化且没有任何初始值的类型) 变量的显式转换会导致所有其他类型的零值。
要定义未类型化变量，只需声明一个变量并赋值，如本例所示：
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
运行上述程序时，您将看到以下结果：
sh- 4.3$ lci main.lo ANYVALUE 44
布尔值 (TROOFS)
在 LOLCODE 中，布尔值有两种类型。布尔值通常有两个值——真和假。但是，在 LOLCODE 中，布尔值称为 TROOF，真/假值分别称为 WIN/FAIL。所有未初始化的值，如空字符串 (“”) 或空数组，都将转换为 FAIL。所有其他已初始化的值都计算为 WIN。
示例
HAI 1.2 I HAS A VAR3 ITZ A TROOF VAR3 R "FAIL" VISIBLE VAR3 KTHXBYE
执行上述代码时，您将看到以下输出：
sh-4.3$ lci main.lo FAIL
数值类型 (NUMBR)
在 LOLCODE 中，NUMBR 代表整数。任何数字序列都被视为 NUMBR，除非它在序列中的任何位置都包含小数点。要使任何数字为负数，可以在其前面加上一个连字符 (-)，这表示负数。
示例
HAI 1.2 I HAS A VAR3 ITZ A NUMBR VISIBLE VAR3 KTHXBYE
运行上述代码时，您将看到以下结果：
sh- 4.3$ lci main.lo 0
类似于NUMBR，LOLCODE还有另一种数据类型，它在许多编程语言中表示十进制数或浮点数。在LOLCODE中，NUMBAR是一个包含一个小数点的浮点数。将NUMBAR转换为NUMBR会截断浮点数的小数部分，并将其作为NUMBR返回，没有任何小数。
字符串 (YARN)
在LOLCODE中，包含字符串的值，即字符串字面量(YARN)，应该以双引号("”)开头和结尾。
可以在字符串内写入任何内容，例如空格、逗号、句点、感叹号或任何其他符号。任何单引号缺失的字符串都可能导致错误。冒号在LOLCODE中用作转义字符，冒号后的任何值都具有特殊含义。
:) − 冒号后面的右括号表示换行符(\n)
:> − 冒号后面的右尖括号表示制表符(\t)
:o − 冒号后面的‘o’字符表示响铃(蜂鸣声)(\g)
:" − 冒号后面的“表示字面意义上的双引号(")
:: − 冒号后面的冒号表示字面意义上的单个冒号(:)
示例
HAI 1.2 I HAS A VAR3 ITZ A YARN VAR3 R "XYZ" VISIBLE VAR3 KTHXBYE
上面给出的代码执行后会产生以下输出：
sh- 4.3$ lci main.lo XYZ
BUKKIT
此类型表示数组。它具有命名的槽，可以包含变量或函数。BUKKIT可以按以下方式声明：
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
BUKKIT内的函数也可以使用ME'Z [var]或ME IZ [function name] (YR [argument1] (AN YR [argument2] (AN YR [argument3] ...))) MKAY访问BUKKIT的变量和其他函数。
示例
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
运行上面给出的代码后，您将看到以下输出：
sh- 4.3$ lci main.lo DOGE
Lolcode - 运算符
运算符在对变量执行各种运算中起着重要作用。本章介绍LOLCODE中的各种运算符及其用法。
运算符
数学运算符依赖于前缀表示法，即出现在操作数之前的表示法。当所有运算符都有已知数量的参数或操作数时，不需要分组标记。在运算符没有固定参数或操作数的情况下，运算以MKAY结束。
如果MKAY与语句的结尾重合，则可能不使用MKAY。在这种情况下，应使用EOL关键字。要使用一元数学运算符，请使用以下语法：
<operator> <expression>
可以可选地使用AN关键字分隔参数，并对多个操作数应用单个运算，因此二元运算符表达式具有以下语法：
<operator> <expression1> AN <expression2>
任何包含具有无限多个参数的运算符的表达式都可以用以下语法表示：
<operator> <expression1> [[AN <expression2>] AN <expression3> ...] MKAY
数学运算
以下是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
上述和可以是唯一的表达式，因此数学运算符可以无限嵌套和分组。
如果存在两个NUMBR，则数学运算将参数视为整数运算；但如果任一表达式为NUMBAR，则运算将视为浮点运算。
示例
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
运行上述代码后，将产生以下输出：
sh- 4.3$ lci main.lo 6 2 8 2 0 4 2
重要事项：
请考虑以下与在LOLCODE中使用数学运算符相关的重要事项：
如果表达式中一个或两个参数为YARN，则将其视为NUMBAR。
如果任何参数不能安全地内部转换为数值类型，则会出错。
布尔值
布尔运算符应用于那些可能是真或假的值。作用于TROOF的布尔运算符如下：
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.
请注意，如果上述表达式语法中的
比较
如果要在LOLCODE中比较两个或多个操作数，可以使用以下任何方法：
方法1
可以使用等号运算符比较两个二元操作数。语法如下所示：
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
方法2
可以比较两个值是否为NUMBR类型。请记住，如果任一值为NUMBAR，则将其作为浮点值进行比较。
方法3
还可以使用最小值和最大值运算符进行比较。语法如下所示：
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>
示例
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
KTHXBY
执行给定代码后，您将看到以下输出：
sh- 4.3$ lci main.lo TRUE
值的连接
LOLCODE允许您使用SMOOSH…MKAY运算符显式连接无限多个YARN。对于连接，可以使用AN运算符分隔多个参数。
示例
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
上面给出的代码执行后将产生以下结果：
sh- 4.3$ lci main.lo TRUE ONE MORE TRUE ANOTHER TRUE
类型转换
作用于特定类型的运算符会隐式转换或安全地将一种类型的值转换为另一种类型。如果值不能安全地转换为另一种类型，则会发生错误。
可以使用二元MAEK运算符将表达式的值显式转换为其他类型。MAEK运算符的语法如下：
MAEK <expression> A <type>
其中，
要将变量显式转换为其他类型，可以使用带有MAEK运算符的普通赋值语句，或者可以使用以下赋值语句：
<Any_variable> IS NOW A <type> BTW this code will be equal to <Any_variable> R MAEK <variable> A <type>
示例
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
上述代码将产生以下输出：
sh-4.3$ lci main.lo 111.00033
Lolcode - 输入/输出
本章将解释如何通过LOLCODE终端输入值以及如何将其输出到终端。
终端I/O
可以使用VISIBLE关键字在LOLCODE中打印内容。VISIBLE是一个函数，可以接收无限多个字符作为输入，并通过内部连接并将它们转换为字符串或YARN来一次性打印所有字符。
VISIBLE函数以分隔符结束或终止，该分隔符是行尾或逗号。
输出由编译器自动以回车符终止。如果最终标记以感叹号(!)结尾，则回车符将被此符号覆盖。
VISIBLE <any_expression> [<any_expression> ...][!]
请注意，在LOLCODE中，目前没有定义将某些数据打印到文件的标准。
要从用户处获取一些输入，使用的关键字是GIMMEH。它是一个函数，可以接收任意数量的变量作为输入。它接收YARN作为输入，并将值存储在任何给定的变量中。
GIMMEH <any_variable>
示例
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
运行此代码时，它将要求您输入一个数字，然后自动在下一行打印该数字。运行此代码时，它将打印以下输出：
sh- 4.3$ lci main.lo TYPE SOMETHING AND ENTER 67 67
Lolcode - 语句和流程控制
LOLCODE允许您通过各种语句控制程序的流程。本章解释LOLCODE中可用的不同类型的语句。
表达式语句
在LOLCODE中，没有任何赋值的表达式（即简单地调用数学运算或任何函数）都是合法的语句。表达式求值后，其最终值将放入临时变量IT中。IT的值保留在局部作用域中，并且存在直到下次被表达式替换。
赋值语句
赋值语句用于将任何表达式的输出赋值给给定的变量。它们通常采用以下形式：
<any_variable> <assignment operator> <any expression>
请注意，即使在变量被赋值之前，您也可以在表达式中使用它。
条件语句
If-Then语句
if-then语句是一个作用于IT变量的非常简单的操作。它类似于C和Java等其他编程语言中的if-else语句。
有四个关键字可以应用if-then语句。
- O RLY?
- YA RLY
- NO WAI
- OIC
一般形式为：
<any_expression>
O RLY?
YA RLY
<code to execute if above condition is true>
NO WAI
<code to execute in this block>
OIC
以上所有语句都可以用逗号分隔写在同一行，例如：
BOTH SAEM NAMES AN "Name", O RLY? YA RLY, VISIBLE "My name is ABCD" NO WAI, VISIBLE "Your name is ABCD" OIC
使用if-then语句时，可以在YA RLY和NO WAI块之间可选地使用MEBBE
如果MEBBE后面的
示例
<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
示例
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
Case语句
在LOLCODE中，“WTF？”关键字类似于许多其他语言中的switch。WTF？关键字将IT作为比较的表达式值。要使用WTF，比较块由OMG打开，OMG应该是一个字面量，而不是一个表达式。
请记住，每个字面量必须是唯一的，类似于其他语言中的情况。
OMG块必须以GTFO语句终止。如果OMG块没有以GTFO终止，则将执行下一个OMG块，直到到达GTFO。
如果没有任何字面量求值为真，则默认情况由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
上述代码的输出结果将是：
"E"
EFGH
Lolcode - 循环
循环用于编程语言中多次执行一组语句。例如，如果要打印数字5五次，则无需将VISIBLE “5”语句编写五次，而可以使用单个VISIBLE “5”语句循环运行五次。
简单的循环用IM IN YR
迭代循环具有以下结构：
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>
请注意，在函数体中，可以使用UPPIN（加一）、NERFIN（减一）或任何一元函数。
TIL关键字将表达式计算为TROOF：如果其值为FAIL，则循环再继续一次；如果其值为WIN，则循环执行停止，并在匹配的IM OUTTA YR语句之后继续。
WILE关键字与TIL关键字相反，如果表达式为WIN，则继续执行，否则循环退出。
示例
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
当上述代码在任何LOLCODE编译器或我们的在线编码环境中编译时，这将产生以下输出。
sh- 4.3$ lci main.lo 1 2 3 4 5 6 7 8 9 10
Lolcode - 函数
函数在编程中非常有用，因为它们减少了反复编写代码的时间和精力。编写良好的函数代码具有很高的可重用性。本章解释如何在LOLCODE中编写和使用函数。
函数的定义
函数是一组语句，通过调用该函数一次性执行所有语句。在LOLCODE中，函数的定义以关键字“HOW IZ I”开头，结束关键字是“IF U SAY SO”。
在LOLCODE中编写函数的语法如下：
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
重要事项
定义LOLCODE函数时，请考虑以下重要事项：
在LOLCODE中，函数只能接受一定数量的固定参数作为输入。
参数或变量是成为函数变量的标识符。
LOLCODE中的函数无法访问除作为参数传递给它们的值之外的任何其他值。
从函数返回值
编码中的返回意味着返回某些内容。在编程中，函数可以在执行完成后向程序返回某些值。在LOLCODE中，函数返回的值如下所述：
FOUND YR
在函数块完全执行时返回表达式的值。 -
GTFO不返回值(NOOB)，这类似于C和Java等其他编程语言中的return 0。
如果没有找到其他返回语句，则执行IF U SAY SO，并返回IT变量中的值。
.
调用函数
函数在程序体中定义，稍后调用以执行。接受给定数量参数的函数调用如下所示：
I IZ <function_name> [YR <expression_One> [AN YR <expression_Two> [AN YR <expression_Three> ...]]] MKAY
调用函数时，表达式由函数名后跟函数将接受的参数数量构成。这些参数可以是简单的变量或任何表达式。如果函数接受任何表达式而不是简单值，则在调用函数之前计算表达式的值。
请记住，函数将接受的参数数量应在函数定义中定义。
示例
HAI HOW DUZ I MAINUMBA I HAS A NUMBA GIMMEH NUMBA FOUND YR NUMBA IF U SAY SO VISIBLE MAINUMBA KTHXBYE
运行以上代码时，它会要求输入，然后提交输入后，您将看到与结果相同的输出。例如，如果我们输入 55，它将打印 55。
示例
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
当您运行执行输入操作数乘法的上述函数时，它将打印以下输出：
sh- 4.3$ lci main.lo 6
示例
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
以上代码将产生以下输出：
sh- 4.3$ lci main.lo OBJECT1
Lolcode - 异常处理
异常处理是处理运行时错误的强大机制之一，以便可以维护应用程序的正常流程。LOLCODE 对异常处理的支持不像其他编程语言那样广泛。与其他语言中的 Try-Catch 块类似，LOLCODE 有 PLZ 块。
例如，如果您想打开可能存在也可能不存在的文件，请使用：
PLZ OPEN FILE "filename.TXT"?
AWSUM THX
VISIBLE FILE
O NOES
INVISIBLE "ERROR!"
KTHX
可能导致异常的代码写在 PLZ 块中，异常在 O NOES 块中处理。在这里，INVISIBLE 关键字向调试器发送内部消息。
请注意，由于 LOLCODE 并非定期维护，因此 LOLCODE 异常处理和许多其他功能均不再提供更新。
Lolcode - 更多示例
前面的章节解释了 LOLCODE 的编程。在本章中，您将学习一些示例，让您能够在 LOLCODE 中进行更高级别的编码。
示例 1：计算数字的幂的程序
在此示例中，您将找到计算输入数字的幂的代码。例如，2 的 4 次幂等于 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
以上代码成功运行后将打印以下输出：
sh- 4.3$ lci main.lo 16
示例 2：创建数组的程序
此示例显示了创建包含五个元素的数组的代码，每个元素的值为 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
执行上述代码时，您将看到以下输出：
sh-4.3$ lci main.lo 10 10 10 10 10
示例 3：计算数字阶乘的程序
此程序显示了计算输入数字阶乘的代码。
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
以上程序打印数字 6 的阶乘，您可以看到如下所示的输出：
sh- 4.3$ lci main.lo 720
示例 4：设计计算器的程序
您可以使用 LOLCODE 编程设计一个计算器来执行基本的数学运算。观察以下给出的代码：
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
当我们使用以下输入执行上述程序时：
3 4 +
执行后，上述程序将生成以下输出：
VALUE1 VALUE2 Choose Operation? + - * / 7