Lolcode - 快速指南

Lolcode - 简介和环境设置

LOLCODE 是一种深奥的编程语言，其灵感来自互联网上的有趣事物。它旨在测试编程语言设计的边界。

本章将让您熟悉设置 LOLCODE 的本地环境、在 Windows 上安装它以及在Tutorialspoint-codingground 在线执行其脚本。

设置本地环境

LOLCODE 解释器是用 C 语言编写的。它可以在多个平台上解释用 LOLCODE 语言编写的代码。LOLCODE 解释器称为 lci，代表 LOLCODE 解释器。

请注意，LOLCODE 官方仅支持直接安装 MAC 操作系统的解释器。要在您的操作系统中安装 LOLCODE，您需要按照以下步骤操作 -

  • 按 Command+空格键，然后输入Terminal，然后按Enter/Return键
  • 在终端应用程序中运行
  • $ git 克隆https://github.com/justinmeza/lci.git
  • $ CD LCI
  • $ cmake.
  • $ make && 进行安装

在 Windows 上安装

如果您需要在 Windows 操作系统上安装 LOLCODE，请执行以下步骤 -

  • 首先将 MinGW 和 Python 添加到环境变量路径中。为此，请右键单击“我的电脑”，选择“属性”，然后选择“高级系统设置”。选择环境变量。在此框中，选择PATH变量，然后单击“编辑”。

  • 现在，将“;C:\MinGW\bin;C:\Python32”添加到该路径的末尾。

  • 接下来，打开命令提示符并使用“cd”命令导航到项目目录。

  • 运行脚本 install.py。

使用TutorialsPoint 在线执行脚本 -codingground

要轻松快速地执行脚本，请使用TutorialsPoint 提供的codingground平台。为此，请访问以下链接在线执行脚本 -

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

Lolcode - 语法

LOLCODE 结构是俚语。下表显示了迄今为止实现的结构的字母顺序列表 -

先生。 构造与使用
1

顺便提一句

它开始单行注释。
2

向下<变量>!!<次>

这对应于变量=变量-时间。请注意，“times”是仅 wut 的语言扩展。
3

GIMMEH <变量>

这代表输入语句。
4

GTFO

这与其他语言中的break类似，提供了一种跳出循环的方法。
5

医院感染

这对应于其他语言中的main()函数。它是LOLCODE 中的程序入口点。
6

这里<标签>

这是另一种仅限 wut 的语言扩展，并声明一个与 SHOO 一起使用的标签
7

我有一个 <类型> <变量>

这声明了该类型的变量。

LOLCODE 中有三种内置类型 -

  • 努巴赫 (int)
  • 德西努巴（双）
  • WORDZ（std::字符串）

请注意，类型是仅 wut 的语言扩展。
8

我在你的循环中

这将开始无限循环。退出循环的唯一方法是使用 GTFO。相当于其他语言中的for (;;)
9

IZ <expr1> <运算符> <expr2>?：条件结构

这类似于其他语言中的 if 运算符。运算符是以下之一：BIGGER THAN、SMALLER THAN、SAEM AS。请注意，？最后是可选的。
10

韩国THX

它结束了一个块。对应于}
11

KTHXBAI

这样就结束了一个程序
12

诺威

这对应于其他
13

Grunt声<表达式>

这会在屏幕上打印参数，后跟换行符。它是一个仅限 wut 的语言扩展。
14

瑞尔赛

这对应于else (if)
15

舒

这是另一种仅限 wut 的语言扩展，对应于goto（恐怖！）
16

UP <变量>!!<次>

这对应于变量=变量+时间。这里的“times”是一个仅限于wut的语言扩展。
17 号

可见<表达式>

这会在屏幕上打印参数。请注意，这不会打印换行符。
18

雅利

这表示“true”条件块的开始

LOLCODE 中俚语的一些例子是 -

  • 海伊很嗨
  • KTHXBYE 没关系，谢谢，再见
  • 顺便说一句
  • OBTW 是哦，顺便说一句
  • TLDR 太长；没读过

空白

在大多数编程语言中，关键字或标记之间可能没有空格。然而，在某些语言中，标记中使用空格来区分它们。

逗号

在大多数语言中，逗号的作用类似于换行符关键字，例如Java 和 C 中的\n。在 LOLCODE 中，您可以在一行中编写许多命令，前提是使用逗号 (,) 分隔它们。

三个时期（…）

三个句点 (...) 使您能够通过在行末尾包含 (...) 将多行代码组合成一行或单个命令。这使得编译器仅将下一行的内容视为上一行的内容。可以将无限行代码一起编写为单个命令，只要每行以三个句点结束即可。

注释以换行符结束。请注意，注释 (BTW) 后面的续行符 (...) 和 (,) 会被 lci 忽略。

评论

单行注释后面跟着 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 中的变量类型是 -

  • 字符串（纱线）
  • 整数 (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 会使变量失败。此后，对 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

当你运行上面的程序时，你会发现以下结果 -

嘘-
4.3$ lci main.lo
任意值
44

布尔值 (TROOFS)

在LOLCODE中，布尔值有两种类型。BOOLEAN 通常有两个值 - true 和 false。但是，在 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 返回，不带任何小数。

绳子（纱线）

在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 可以通过以下方式声明 -

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] ... ）））MKAY。

例子

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 与语句结尾一致，则不能使用它。在这种情况下，应使用 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

上面的 <a> 和 <b> 都可以是唯一的表达式，因此数学运算符可以无限地嵌套和分组。

在存在两个 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.

请注意，上面表达式语法中的 <m> 和 <n> 如果还不是 TROOF 值，则会自动转换为 TROOF 值。

比较

当您想在 LOLCODE 中比较两个或多个操作数时，可以使用以下任意方法来执行此操作 -

方法一

您可以使用相等运算符比较两个二进制操作数。语法如下所示 -

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

您可以比较这两个值是否都是 NUMBRs 类型。请记住，如果其中一个值是 NUMBAR，那么它们将作为浮点值进行比较。

方法三

您还可以使用最小值和最大值运算符执行比较。语法如下所示 -

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>

其中，<type> 可以是 TROOF、YARN、NUMBR、NUMBAR 或 NOOB 之一。

要将变量显式转换为其他类型，可以使用带有 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 语句是对 IT 变量进行的非常简单的操作。它类似于 C 和 Java 等其他编程语言中的 if−else 语句。

有四个关键字可应用 if-then 语句。

  • 哦，RLY？
  • 雅丽
  • 没有围
  • 伊斯兰会议组织

一般形式是 -

<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 后面的 <任意表达式> 为 True (WIN)，则执行该块。否则，如果该表达式为假，则跳过该块，直到下一个 MEBBE、NO WAI 或 OIC 语句。

例子

<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

案例陈述

在 LOLCODE 中，关键字“WTF？” 与许多其他语言中的 switch 类似。关键字 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 - 循环

循环在编程语言中用于多次执行一组语句。例如，如果要打印数字 5 五次，则可以使用单个VISIBLE “5”语句运行循环五次，而不是编写五次VISIBLE “5”语句。

简单循环用 IM IN YR <label> 和 IM OUTTA YR <label> 表示。以这种方式定义的循环是无限循环，应使用 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（加一）、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 <any_expression>返回功能块执行完毕后表达式的值。

  • GTFO不返回任何值 (NOOB)，这类似于C 和 Java 等其他编程语言中的返回 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