Lolcode - 快速指南
Introduction and Environment Setup
LOLCODE是一种深奥的编程语言，受到互联网上有趣事物的启发。 它旨在测试编程语言设计的界限。
本章将使您熟悉为LOLCODE设置本地环境，在Windows上安装以及在IoWiki-codingground.在线执行其脚本IoWiki-codingground.
设置本地环境
LOLCODE解释器是用C语言编写的。 它解释了在多个平台上用LOLCODE语言编写的代码。 LOLCODE解释器称为lci，代表LOLCODE解释器。
请注意，LOLCODE官方支持仅为MAC操作系统直接安装解释器。 要在您的操作系统中安装LOLCODE，您需要按照以下步骤操作 -
- 按Command + Space，键入Terminal ，然后按enter/return键
- 在终端应用程序中运行
- $ git clone https://github.com/justinmeza/lci.git
- $ cd lci
- $ cmake。
- $ make && make install
Installation on Windows
如果您需要在Windows操作系统上安装LOLCODE，请执行以下步骤 -
首先将MinGW和Python添加到环境变量路径中。 为此，请右键单击“ My Computer,选择“ Properties,然后选择“ Advanced system settings. 选择Environment Variables 。 在此框中，选择PATH变量，然后单击“ Edit 。
现在，将“; C:\MinGW\bin; C:\Python32”添加到该路径的末尾。
接下来，打开Command Prompt并使用“cd”命令导航到项目目录。
运行脚本install.py。
使用IoWiki执行脚本在线 - 编码
要轻松快速地执行脚本，请使用IoWiki提供的codingground平台。 为此，请转到以下链接以在线执行脚本 -
https://www.iowiki.com/execute_lolcode_online.phpLolcode - Syntax
与其他编程语言相比，LOLCODE具有不同的语法，但是，它更容易记住。 本章为您提供LOLCODE的基本语法。
构造(Constructs)
LOLCODE结构是俚语。 下表显示了到目前为止实施的按字母顺序排列的构造列表 -
| Sr.No. | 构造与使用 |
|---|---|
| 1 | BTW 它开始一行评论。 |
| 2 | DOWN 《variable》!!《times》 这对应于variable = variable - times。 请注意，“时间”是仅限于语言的语言扩展。 |
| 3 | GIMMEH 《variable》 这表示输入语句。 |
| 4 | GTFO 这与其他语言中的break类似，并提供了一种突破循环的方法。 |
| 5 | HAI 这对应于其他语言中的main ()函数。 它是LOLCODE中的程序入口点。 |
| 6 | HEREZ 《label》 这是另一个仅限于语言的语言扩展，并声明了一个与SHOO一起使用的标签 |
| 7 | I HAS A 《type》 《variable》 这声明了所述类型的变量。 LOLCODE中有三种内置类型 -
请注意，类型是仅限于语言的语言扩展。 |
| 8 | IM IN YR LOOP 这开始了一个无限循环。 退出循环的唯一方法是使用GTFO。 对应于(;;)在其他语言中 |
| 9 | IZ 《expr1》 《operator》 《expr2》?: Conditional structure 这类似于其他语言的if运算符。 运算符是以下之一:比较小，比SAEM AS更大。 请注意？ 最后是可选的。 |
| 10 | KTHX 它结束了一个块。 对应} |
| 11 | KTHXBAI 这结束了一个程序 |
| 12 | NOWAI 这对应于其他 |
| 13 | PURR 《expr》 这将在屏幕上打印参数，然后是换行符。 这是一种仅限于语言的语言扩展。 |
| 14 | RELSE 这对应于else (if) |
| 15 | SHOO 这是另一个仅限语言的语言扩展，对应于goto （恐怖！） |
| 16 | UP 《variable》!!《times》 这对应于variables = variable + times。 这里“时代”是一种仅限于语言的语言扩展。 |
| 17 | VISIBLE 《expr》 这将在屏幕上打印参数。 请注意，这不会打印换行符。 |
| 18 | YARLY 这表示“真实”条件块的开始 |
LOLCODE中的俚语术语的一些例子是 -
- HAI is hi
- KTHXBYE没关系，谢谢，再见
- BTW顺便说一下
- OBTW是哦，顺便说一句
- TLDR太长了; 没看过
Whitespace
在大多数编程语言中，关键字或标记之间可能没有空格。 但是，在某些语言中，标记中使用空格来区分它们。
Comma
逗号在大多数语言中的行为类似于换行符关键字，例如，在Java和C中的\n 。您可以在LOLCODE中的单行中编写许多命令，前提是您使用逗号（，）分隔它们。
Three Periods (…)
这三个句点（...）使您可以通过在行尾包含（...）将多行代码组合成一行或一个命令。 这使得编译器将下一行的内容视为仅前一行的内容。 无限行代码可以作为单个命令一起写入，只要每行以三个句点结束即可。
评论由换行符终止。 请注意，lci忽略注释（BTW）后的行继续（...）和（，）。
注释 (Comments)
写入单行注释后跟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 ” 。
例子 (Example)
HAI 1.2
I HAS A NAME
VISIBLE "NAME::"!
GIMMEH NAME
VISIBLE "iowiki " NAME "!"
KTHXBYE
Lolcode - Variables
与任何其他编程语言一样，LOLCODE允许您定义各种类型的变量。 本章将使您熟悉在LOLCODE中使用变量。
变量范围
变量的作用域是函数或程序块的本地，即在同一程序的任何其他作用域中不能调用在一个作用域中定义的变量。 变量只有在声明后才能访问。
请注意，LOLCODE中没有全局变量范围。
命名约定
变量名称通常称为标识符。 以下是在LOLCODE中命名变量的一些约定 -
变量标识符可以是所有CAPITAL或小写字母（或两者的混合）。
它们只能以字母开头，然后可以跟随其他字母，数字和下划线。
在命名变量时，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 (Example 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 (Example 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 (Example 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".
变量的声明和赋值
要declare变量，LOLCODE提供关键字“I HAS A”，后跟变量名称。 您可以在下面找到声明变量的语法。
I HAS A VAR BTW VAR is empty now, You can use any name instead of var
要在同一语句中为变量assign ，可以使用“ITZ”跟随变量名，然后给出要分配的值。 使用以下语法为变量赋值 -
<variable> R <expression>
例子 (Example)
VAR R "Green" BTW VAR is now a YARN and equals "Green"
VAR R 30 BTW VAR is now a NUMBR and equals 30
您还可以使用以下语法同时declare和assign变量 -
I HAS A VAR ITZ VALUE
例子 (Example)
I HAS A NAME ITS “TUTORIALS POINT”
例子 (Example)
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位小数。
例子 (Example)
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 - Types
LOLCODE旨在测试编程语言设计的界限。 它是一种深奥的编程语言，受到互联网上有趣事物的启发。 本章将帮助您了解LOLCODE类型。
类型 (Types)
目前，LOLCODE中的变量类型是 -
- 字符串（YARN）
- integers (NUMBR)
- floats (NUMBAR)
- and booleans (TROOF)
- Arrays (BUKKIT)
在LOLCODE中，变量类型由编译器动态处理。 如果变量没有初始值，则称为无类型（在LOLCODE中称为NOOB）。
在LOLCODE中声明和使用不同类型的语法如下所示 -
创建任何数据类型的变量
I HAS A <VARIABLE> ITZ A <DATA TYPE>
创建变量并为其赋值
I HAS A <VARIABLE> ITZ <EXPRESSION<
为已创建的数据类型分配值
<VARIABLE> R <EXPRESSION>
Untyped (NOOB)
无类型数据类型（称为NOOB）不能转换为除TROOF数据类型之外的任何其他类型。 将NOOB隐式转换为TROOF使变量成为FAIL。 之后，对NOOB的任何操作都会导致错误。
对于所有其他类型，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
Booleans (TROOFS)
在LOLCODE中，布尔值有两种类型。 BOOLEAN通常有两个值 - true和false。 但是，在LOLCODE中，布尔值称为TROOF，而真/假值分别称为WIN/FAIL。 所有未初始化的值（如空字符串（“”）或空数组都将转换为FAIL。 所有其他初始化值评估为WIN。
例子 (Example)
HAI 1.2
I HAS A VAR3 ITZ A TROOF
VAR3 R "FAIL"
VISIBLE VAR3
KTHXBYE
执行上述代码时，您可以看到以下输出 -
sh-4.3$ lci main.lo
FAIL
Numerical Types (NUMBR)
在LOLCODE中，NUMBR代表整数。 任何数字序列都被视为NUMBR，除非它在序列之间的任何位置出现小数。 要使任何数字为负数，可以在前面加一个连字符（ - ）表示负数。
例子 (Example)
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返回，不带任何小数。
Strings (YARN)
在LOLCODE中，包含字符串的值，即字符串文字（YARN）应以双引号（“”）开头和结尾。
任何东西都可以写在字符串中，如空格，逗号，句号，感叹号或任何其他符号。 缺少任何单引号的字符串可能会导致错误。 冒号在LOLCODE中用作转义字符，冒号后的任何值都具有特殊含义。
:) - 冒号后的右括号表示换行符（\ n）
:》 - 冒号后面的结束尖括号代表一个标签（\ t）
:o - 冒号后面的'o'字符代表铃声（嘟嘟声）（\ g）
:" - 冒号后面的一个”表示文字双引号（“）
:: - 冒号后面的冒号代表单个字面冒号（:)
例子 (Example)
HAI 1.2
I HAS A VAR3 ITZ A YARN
VAR3 R "XYZ"
VISIBLE VAR3
KTHXBYE
上面给出的代码在执行时产生以下输出 -
sh-
4.3$ lci main.lo
XYZ
BUKKIT
此类型表示一个数组。 它命名了slot，它可以包含变量或函数。 可以通过以下方式声明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 [函数名]（YR [argument1]（AN YR [argument2]（AN YR [argument3] ...）来访问BUKKIT的变量和其他函数。 ）））MKAY。
例子 (Example)
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 - Operators
运算符在对变量执行各种操作方面发挥着重要作用。 本章为您介绍LOLCODE中的各种运算符及其用法。
运算符 (Operators)
数学运算符依赖于前缀表示法，即操作数之前的符号。 当所有运算符都具有已知数量的参数或操作数时，则不需要分组标记。 如果运算符没有固定的参数或操作数，则使用MKAY关闭操作。
如果MKAY与语句的结尾一致，则不能使用MKAY。 在这种情况下，应使用EOL关键字。 要使用一元数学运算符，请使用以下语法 -
<operator> <expression>
AN关键字可以选择用于分隔参数，并对多个操作数应用单个操作，因此二元运算符表达式具有以下语法 -
<operator> <expression1> AN <expression2>
包含具有无限数量参数的运算符的任何表达式都可以使用以下语法表示 -
<operator> <expression1> [[AN <expression2>] AN <expression3> ...] MKAY
Math
以下是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，则操作被视为浮点运算。
例子 (Example)
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。
如果任何参数无法在内部安全地转换为数字类型，则它将失败并显示错误
Boolean
布尔运算符应用于可能为true或false的值。 在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.
请注意，如果上面的表达式语法中的
比较(Comparison)
如果要在LOLCODE中比较两个或多个操作数，可以使用以下任何方法执行此操作 -
Method 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
Method 2
您可以比较两个值是否为NUMBR类型。 请记住，如果其中任何一个值为NUMBAR，则将它们作为浮点值进行比较。
方法3 (Method 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>
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
执行给定代码时，您可以看到以下输出 -
sh-
4.3$ lci main.lo
TRUE
连接价值观
LOLCODE允许您使用SMOOSH ... MKAY运算符显式连接无限数量的YARN。 对于连接，可以使用AN运算符分隔多个参数。
例子 (Example)
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>
例子 (Example)
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 - Input/Output
本章将向您介绍如何通过LOLCODE终端输入值以及如何将其输出到终端。
来自终端的I/O.
您可以使用关键字VISIBLE在LOLCODE中打印内容。 VISIBLE是一个函数，它可以将无限数量的字符作为输入，并通过内部连接将它们全部打印出来，并将它们转换为字符串或YARN。
VISIBLE函数以分隔符结束或终止，分隔符是行尾或逗号。
编译器使用回车符自动终止输出。 如果最终令牌以感叹号（！）终止，则返回的回车将被此符号覆盖。
VISIBLE <any_expression> [<any_expression> ...][!]
请注意，在LOLCODE中，目前没有用于将某些数据打印到文件的定义标准。
要从用户那里获取一些输入，使用的关键字是GIMMEH。 它是一个可以将任意数量的变量作为输入的函数。 它将YARN作为输入并将值存储在任何给定变量中。
GIMMEH <any_variable>
例子 (Example)
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 - Statements and Flow Control
LOLCODE允许您通过各种语句控制程序流。 本章介绍LOLCODE中可用的不同类型的语句。
表达陈述
没有任何赋值的表达式，即简单地调用数学运算或任何函数，是LOLCODE中的一个合法声明。 评估表达式后，将其最终值放在临时变量IT中。 IT的值保留在本地范围内，并且在下次用表达式替换之前一直存在。
作业声明
赋值语句用于将任何表达式的输出分配给给定变量。 它们通常是以下形式 -
<any_variable> <assignment operator> <any expression>
请注意，即使在分配变量之前，您也可以在表达式中使用变量。
条件陈述
If-Then Statements
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之后的
例子 (Example)
<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
例子 (Example)
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？' 类似于许多其他语言中的开关。 关键字WTF？ 将IT作为比较的表达值。 要使用WTF，OMG打开一个比较块，它应该是文字，而不是表达式。
请记住，每个文字必须是唯一的，类似于其他语言的情况。
OMG块必须由GTFO语句终止。 如果OMG块未被GTFO终止，则执行下一个OMG块直到达到GTFO。
如果没有任何文字计算为true，则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 - Loops
循环在编程语言中用于多次执行一组语句。 例如，如果要打印数字5五次，那么可以运行一个带有单个VISIBLE “5”语句的循环五次，而不是写五次VISIBLE “5”语句。
简单循环用IM IN YR 以这种方式定义的循环是无限循环，它们应该以GTFO break语句终止。
迭代循环具有以下结构 -
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（递增1），NERFIN（递减1）或任何一元函数。
TIL关键字将表达式计算为TROOF:如果它计算为FAIL，则循环再次继续，如果它评估为WIN，则循环执行停止，并在匹配的IM OUTTA YR语句之后继续。
WILE关键字与TIL关键字相反，如果表达式为WIN，则继续执行，否则循环退出。
例子 (Example)
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 《any_expression》在完全执行功能块时返回表达式的值。
GTFO没有返回值（NOOB），类似于其他编程语言（如C和Java）中的return 0 。
如果未找到其他返回语句，则执行IF U SAY SO并返回IT变量中的值。
Calling 函数
函数在程序体中定义，稍后调用以执行。 接受给定数量的参数的函数被调用，如下所示 -
I IZ <function_name> [YR <expression_One> [AN YR <expression_Two>
[AN YR <expression_Three> ...]]] MKAY
在调用函数时，表达式由函数名称形成，后跟函数将接受的参数数量。 这些参数可以是简单变量或任何表达式。 如果函数接受任何表达式而不是简单值，则在调用函数之前计算表达式的值。
请记住，函数将接受的参数个数应该在函数的定义中定义。
例子 (Example)
HAI
HOW DUZ I MAINUMBA
I HAS A NUMBA
GIMMEH NUMBA
FOUND YR NUMBA
IF U SAY SO
VISIBLE MAINUMBA
KTHXBYE
当您运行上面的代码时，它会要求输入，然后当您提交输入时，您将看到与结果相同的内容。 例如，如果我们输入55，它将打印55。
例子 (Example)
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
例子 (Example)
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 - Exception Handling
异常处理是处理运行时错误的强大机制之一，以便可以维护应用程序的正常流程。 与其他编程语言一样，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 - Some More Examples
前面的章节向您解释了LOLCODE中的编程。 在本章中，您将学习一些示例，这些示例允许您在LOLCODE中进行高级编码。
示例1:计算数字幂的程序
在此示例中，您将找到用于计算输入数字功效的代码。 例如，升至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
