受我启发的语言不是您要寻找的语言！

挑战

选择两种不同的编程语言，然后编写一个程序，将以下行打印到stdout（或等效文件）：

This program errors out in <the current language> :P

然后在两种语言中都产生不同类型的错误。

规则

一些规则来自最初的挑战。

• 在输出中，语言名称应严格遵循：
  • TIO上列出的名称，可以选择不包括版本号和/或实现名称（例如，如果您使用JavaScript (Node.js)其中一种语言，则可以使用JavaScript您的语言名称，但不能使用JS或Javascript。）
  • 如果您选择的语言在TIO上不可用，则在官方网站（或GitHub存储库）上提供全名。
• 这两个程序都不应该接受用户的任何输入。
• 您可以使用两种语言的注释。
• 相同语言的两种不同版本计为不同语言。
  • 如果这样做，程序应输出主要版本号，并且如果在两个不同的次要版本上运行，则还应报告次要版本。
  • 您不应该使用预构建的版本函数（这包括在运行时已经评估过的变量）。
• 只要此标记不包含代码片段（例如，在C 语言中），根据该元共识，两种使用相同语言的不同命令行标记也会计为不同的语言-Dblahblah...。
  • 如果这样做，程序还应该输出使用的标志。
• 除非两个错误都由相同的语义生成（例如“除以零”，“分段错误”或“索引超出范围”），否则将认为这两个错误是不同的。
  • 如果语言的运行时在发生错误后没有退出，而是以某种方式向用户报告该错误，则这是有效的错误。
  • 如果一种语言不能区分错误消息，但是具有导致错误的已知原因列表，则必须指定原因，而不是错误消息。
    一个示例是><>，它只有一个错误消息something smells fishy...，但是esolangs Wiki页面上有错误原因列表。
• 除非通过调用eval()或类似方法生成，否则不允许语法错误。
• 允许通过throw（JS），raise（Python），die（Perl）或类似方式手动投掷某些东西，但是所有这些都被视为一种错误。
• 也允许在2D或golflangs中通过无效命令进行错误（并将其视为一种错误）。

例子

Python和Ruby

• Python：This program errors out in Python :P到stdout，然后是未定义的标识符
• Ruby：This program errors out in Ruby :P到stdout，然后越界索引

C89和C99

• C89：This program errors out in C 89 :P到标准输出，然后除以零
• C99：This program errors out in C 99 :P到标准输出，然后分段错误

请注意，版本号应始终与语言名称用空格分隔。

Python 2.7.9和Python 2.7.10

• Python 2.7.9：This program errors out in Python 2.7.9 :P到stdout，然后在eval上出现语法错误
• Python 2.7.10：This program errors out in Python 2.7.10 :P输出到stdout，然后在dict上出现键错误

Perl和Perl -n

• Perl：This program errors out in Perl :P到stdout，然后无效的时间格式
• Perl -n：This program errors out in Perl -n :P到stdout，然后尝试打开一个不存在的文件

获奖条件

这是code-golf，因此以字节为单位的最短代码获胜。但是，总是鼓励您发布一个有趣或有趣的答案，即使答案不是很短。

Python 2 / Python 3，60个字节

print("This program errors out in Python %d :P"%(3/2*2))*1;a

• Python 2得到了 NameError: name 'a' is not defined
• Python 3得到了 unsupported operand type(s) for *: 'NoneType' and 'int'

Python 2：

• /是整数除法，3/2得到1；int（3/2 * 2）是2。
• print是一个语句，因此第一个语句读为print((...)*1)，这里*1意味着重复一次字符串。
• 第二条语句引用了不存在的变量，这导致了错误。
• 在线尝试！

Python 3：

• '/'是浮点数除法，3/2为1.5；int（3/2 * 2）是3。
• print是一个函数，因此第一条语句显示为(print(...))*1。
• 函数print返回None; 乘法不起作用None x int，因此它报告“不支持的操作数”。
• 在线尝试！

C和C ++，114字节

-13个字节要感谢l4m2！

#include<stdio.h>
main(){auto d=.5;printf("This program errors out in C%s :P",d?"++":"");2[&d]+=1/d;}

C ++中的分段错误，C中的浮点异常。

auto默认为int用C所以(int).5变得0，因此尝试除以它基本上是除以零。

在C ++中1/d为2，将其添加到d并尝试更改该地址的值将引发段错误。

在C ++中尝试！
在C中尝试！

JavaScript + HTML / HTML + JavaScript，160字节

<!--
document.write`This program errors out in JavaScript + HTML :P`()
--><script>document.write`This program errors out in HTML + JavaScript :P`+X</script>

<!--
document.write`This program errors out in JavaScript + HTML :P`()
--><script>document.write`This program errors out in HTML + JavaScript :P`+X</script>

不知道这是否包含两种语言，但这很有趣。

Java 8和C99，172个字节

//\
interface a{static void main(String[]a){System.out.print("This program errors out in Java 8 :P");a[1]=""/*
main(n){{n=puts("This program errors out in C99 :P")/0/**/;}}

根据我对“ abc”和“ cba”挑战的回答。

在Java 8中尝试-导致ArrayIndexOutOfBoundsException：1。
在C中进行尝试-导致浮点异常：未定义除以零。

说明：

//\
interface a{static void main(String[]a){System.out.print("This program errors out in Java 8 :P");a[1]=""/*
main(n){{n=puts("This program errors out in C99 :P")/0/**/;}}

如您在上面的Java高亮代码中所看到的，第一行是由于的注释//，而C代码是由于的注释/* ... */，结果是：

interface a{static void main(String[]a){System.out.print("This program errors out in Java 8 :P");a[1]="";}}

因此它将打印到STDOUT，然后尝试访问第二个程序参数（如果未给出任何参数），因此将产生ArrayIndexOutOfBoundsException。

//\
interface a{static void main(String[]a){System.out.print("This program errors out in Java 8 :P");a[1]=""/*
main(n){{n=puts("This program errors out in C99 :P")/0/**/;}}

不确定如何正确启用C-highlighting，因为会lang-c导致与Java相同的突出显示。但是//\将注释掉下一行，即Java代码，结果是：

main(n){{n=puts("This program errors out in C99 :P")/0;}}

因此，将其发送到STDOUT，然后除以零误差。

爪哇8 空白，439个 431 428 408字节

                         






























 interface a{static void    main(String[]a){System.out.print("This program errors out"+
" in Java 8 :P");a[0]="";}}

在Java 8中尝试-导致ArrayIndexOutOfBoundsException：0。
在空白中尝试-导致用户错误（无法执行Infix Plus）。

说明：

Java 8：

interface a{static void main(String[]a){System.out.print("This program errors out"+
" in Java 8 :P");a[0]="";}}

因此它将打印到STDOUT，然后尝试访问第一个程序参数（如果未给出任何参数），则产生 ArrayIndexOutOfBoundsException。

空格：

[S S T  T   T   T   T   T   N
_Push_-31_P][S S T  T   T   S T S T N
_Push_-53_:][S S T  T   S S T   T   T   T   N
_Push_-79_space][S S T  T   S T S N
_Push_-10_e][S S T  T   T   S S N
_Push_-12_c][S S T  T   T   T   S N
_Push_-14_a][S S S T    N
_Push_1_p][S S S T  S S N
_Push_4_s][S S T    T   S T S N
_Push_-10_e][S S S T    S T N
_Push_5_t][S S T    T   T   S N
_Push_-6_i][S S T   T   T   T   N
_Push_-7_h][S S T   T   T   S S S N
_Push_-24_W][S T    S S T   S T S N
_Copy_0-based_10th_(-79_space)][S S T   T   N
_Push_-1_n][S S T   T   T   S N
_Push_-6_i][S T S S T   S N
_Copy_0-based_2nd_(-79_space)][S S S T  S T N
_Push_5_t][S S S T  T   S N
_Push_6_u][S S S N
_Push_0_o][S T  S S T   T   N
_Copy_0-based_3rd_(-79_space)][S S S T  S S N
_Push_4_s][S S S T  T   N
_Push_3_r][S S S N
_Push_0_o][S S S T  T   N
_Push_3_r][S N
S _Duplicate_top_(3_r)][S S T   T   S T S N
_Push_-10_e][S T    S S T   T   S N
_Copy_0-based_6th_(-79_space)][S S T    T   S N
_Push_-2_m][S S T   T   T   T   S N
_Push_-14_a][S S S T    T   N
_Push_3_r][S S T    T   S S S N
_Push_-8_g][S S S S (_Note_the_additional_S_here)N
_Push_0_o][S S S T  T   N
_Push_3_r][S S S T  N
_Push_1_p][S T  S S T   T   T   N
_Copy_0-based_7th_(-79_space)][S S S T  S S N
_Push_4_s][S S T    T   T   S N
_Push_-6_i][S S T   T   T   T   N
_Push_-7_h][S S T   T   T   S T T   N
_Push_-27_T][N
S S N
_Create_Label_LOOP][S S S T T   S T T   T   T   N
_Push_111][T    S S S _Add][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

字母S（空格），T（制表符）和N（换行符）仅作为突出显示而添加。
[..._some_action]仅作为说明添加。

试试这个突出显示的版本。

空格是一种基于堆栈的语言，它将忽略除空格，制表符和换行符以外的所有内容。这是相同的伪代码程序：

Push all unicode values of "P: ecapsetihW tuo srorre margorp sihT", minus 111
Start LOOP
  Push 111
  Add the top two stack values together
  Print as character
  Go to the next iteration of the LOOP

它会在完成所有值的打印后立即出错，并且在尝试执行添加（TSSS），这需要堆栈上有两个项目。

我已经111使用此Java程序生成了该常数，也将其用于以前在Whitespace中遇到的与ASCII相关的挑战。另外，我使用了一些副本来节省字节。

需要注意的重要一件事是我用来将Java程序放入Whitespace答案中的技巧。让我首先说明如何在空格中推送数字：

S开始时：启用堆栈操作；
S：按数字后跟；
S或T：分别为正或负；
一些S和/或T，后跟一个N：数字为二进制，其中T=1和S=0。

这里有一些例子：

• 将值1推为SSSTN;
• 将值-1推为SSTTN;
• 将值111推送为SSSTTSTTTTN。
• 推0值可以是SSSSN，SSTSN，SSSN，SSTN，SSSSSSSSSSSSN，等。（当您使用SSSN（或SSTN），我们没有指定二进制的一部分，因为它是隐含0之后，我们已经表明了其标志。）

这样就SSSN足以推动该值0（o在这种情况下，用于字母）。但是，要将Java程序放置在这个经过打折的Whitespace程序中，我需要一个额外的空间，因此前两个o用推动SSSN，而第三个用推动SSSSN，因此我们有足够的空间容纳Java程序的语句。

CBM BASIC和6502机器代码（C64），142个 144字节

在意识到语法错误之后不得不添加2个字节....

.prg文件的十六进制转储：

01 08 50 08 00 00 8F 5A 49 52 49 41 A9 17 8D 18 D0 A2 30 BD 30 08 20 D2 FF E8
E0 4B D0 F5 A2 30 BD 05 08 20 D2 FF E8 E0 44 D0 F5 A9 0D 20 D2 FF A2 1A 4C 37
A4 22 36 35 30 32 20 4D 41 43 48 49 4E 45 20 43 4F 44 45 20 3A D0 22 20 20 20
20 20 00 8D 08 01 00 97 35 33 32 37 32 2C 32 33 3A 99 22 D4 48 49 53 20 50 52
4F 47 52 41 4D 20 45 52 52 4F 52 53 20 4F 55 54 20 49 4E 20 C3 C2 CD 2D C2 C1
D3 C9 C3 20 3A D0 22 2C 58 AD 50 00 00 00

在C64的编辑器中列出的CBM BASIC视图：

0 remziriastepgosubinput#new0exp0 dim.clrsavekinput#stepnew0exp<white> dim.clrsavedinput#stepstep
 dim.newl7to"6502 machine code :P"
1 poke53272,23:print"This program errors out in CBM-BASIC :P",x/p

注意：无法在BASIC编辑器中正确输入此程序。甚至不要尝试在BASIC编辑器中编辑该程序，否则它将崩溃。仍然是一个可运行的BASIC程序;）

6502机器码视图：

         01 08                          ; load address

.C:0801  50 08       BVC $080B          ; jump to real start of mc

         ; line number (00 00), REM (8F) and "ziria"
.C:0803  00 00 8F 5A 49 52 49 41

.C:080b  A9 17       LDA #$17
.C:080d  8D 18 D0    STA $D018          ; set upper/lower font
.C:0810  A2 30       LDX #$30
.C:0812  BD 30 08    LDA $0830,X
.C:0815  20 D2 FF    JSR $FFD2          ; print "This program errors ..."
.C:0818  E8          INX
.C:0819  E0 4B       CPX #$4B
.C:081b  D0 F5       BNE $0812
.C:081d  A2 30       LDX #$30
.C:081f  BD 05 08    LDA $0805,X
.C:0822  20 D2 FF    JSR $FFD2          ; print "6502 machine code :P"
.C:0825  E8          INX
.C:0826  E0 44       CPX #$44
.C:0828  D0 F5       BNE $081F
.C:082a  A9 0D       LDA #$0D
.C:082c  20 D2 FF    JSR $FFD2          ; print a newline
.C:082f  A2 1A       LDX #$1A           ; error code for "can't continue"
.C:0831  4C 37 A4    JMP $A437          ; jump to error handling routine

.C:0834  22 ; '"'

         ; "6502 machine code :P"
.C:0835  36 35 30 32 20 4D 41 43 48 49 4E 45 20 43 4F 44 45 20 3A D0

         ; '"', some spaces, and next BASIC line
.C:0849  22 20 20 20 20 20 00 8D 08 01 00 97 35 33 32 37 32 2C 32 33 3A 99 22

         ; "This program errors out in CBM-BASIC :P"
.C:0860  D4 48 49 53 20 50 52 4F 47 52 41 4D 20 45 52 52 4F 52 53 20 4F 55 54
.C:0877  20 49 4E 20 C3 C2 CD 2D C2 C1 D3 C9 C3 20 3A D0

.C:0887  22 2C 58 AD 50 00 00 00

在线演示，键入run以BASIC的形式运行，sys 2049以机器码的形式运行，list以示将其解释为BASIC代码。

以BASIC运行会产生division by zero error in 1一个can't continue error

说明：

文件的前两个字节是.prg低位字节序的加载地址，这里是$0801（十进制2049），它是C64上BASIC程序的起始地址。run在BASIC解释器中启动该程序，同时sys 2049命令是在地址处运行机器代码程序的命令2049。

如您所见，BASIC视图的第一行是一个注释（rem），其中包含“垃圾”和所需的输出字符串的一部分。这是机器代码程序和一些填充字节。您会在此处看到一些“随机”的BASIC命令，因为CBM-BASIC程序将“令牌化”的命令包含为单字节值，并且其中一些值与机器代码中使用的操作码相同。机器代码将第二行代码中存在的字符串重新用于其输出。

基本程序的一行的前两个字节是到下一行的指针$0850。这是经过精心选择的，因为50 08当未设置溢出标志时，也是一条6502分支指令会跳过接下来的8个字节-当作为机器代码执行时，它用于跳转到此“注释”行中间的某个位置。在50这里使用的操作码，所以第二线已经开始0850用于特技工作。这就是为什么您看到一个由5 20个字节（空格字符）填充的序列的原因。机器代码主动跳转到ROM错误处理例程，以给出“无法继续”错误。

BASIC代码非常简单；作为“打印”的第二个参数，两个未初始化的变量（0在CBM BASIC中值为）被除以触发“除以零”错误。

> <>和Foo，42个字节

#o<"This code errors in "p"Foo"'><>'" :P"/

在> <>中尝试！

在Foo中尝试！

Foo "将充分记录文档中的所有内容，并尝试最后将其除以零。它忽略了'><>'。

><>将“ Foo”压入堆栈，但立即使用将其弹出p。在将所有内容打印到堆栈之后#o<当堆栈为空且出现唯一的错误消息时，退出该堆栈，something smells fishy...

C和Python， 126116字节

-10个字节感谢@Bubbler！

#1/*
-print("This program errors out in Python :P")
'''*/
main(c){c=puts("This program errors out in C :P")/0;}//'''

在Python中，print（）为None，因此尝试使其否定是没有意义的，因此Python会引发错误。

在C中，printf（）返回一个int，因此将其除以零会产生一个浮点异常。

在C中尝试！
在Python中尝试！

Attache + Wolfram语言（Mathematica），82个字节

s:="Attache"
s=" Mathematica "
Throw[Print["This program errors out in",s,":P"]-0]

在线尝试Attache！ 在线尝试Mathematica！

这取决于=两种语言中运算符的含义。在Attache中，它比较是否相等，但是在Mathematica中，它执行变量分配。:=用两种语言进行变量赋值。

现在，在Attache中，Print返回打印的字符串数组，并且不能对字符串和整数（即0）进行减法。因此，将引发类型错误。在Mathematica中，Printreturn Null，然后0从中减去就可以了。但是，我们用手动将null抛出Throw，给出了nocatch错误。

Python（2）和QB64，82字节

1#DEFSTR S
s="QB64"
'';s="Python"
print"This program errors out in "+s+" :P"
CLS-1

要测试Python版本，您可以在线尝试！要测试QB64版本，您需要下载QB64。

Python看到了什么

1#DEFSTR S
s="QB64"
'';s="Python"
print"This program errors out in "+s+" :P"
CLS-1

第一行只是裸露的表情 1（无操作），后跟注释。

第二行设置s为字符串"QB64"，但第三行立即将其更改为"Python"。第四行相应地打印消息。

第五行是另一个裸露的表达，但它提出了一个 NameError由于未定义nameCLS。

QB64看到了什么

1#DEFSTR S
s="QB64"
'';s="Python"
print"This program errors out in "+s+" :P"
CLS-1

第一行编号为1#，将名称以S（不区分大小写）开头的每个变量定义为字符串变量。这意味着我们不必使用s$，这将是Python中的语法错误。

第二行设置s为字符串"QB64"。'在QB64中开始注释，因此第三行不执行任何操作。第四行相应地打印消息。

第五行尝试CLS使用参数来（清除屏幕）-1。但由于CLS只接受的参数0，1或者2，这将产生错误Illegal function call。该错误会创建一个对话框，询问用户是否要继续执行或中止操作。从技术上讲，这意味着该错误不是致命的（在这种情况下，您可以选择“继续执行”，并且该程序将结束而不会出现进一步的问题）。但是OP明确允许在错误后可以继续使用的语言，因此QB64的行为应该可以。

Perl 5和JavaScript（Node.js），96字节

eval("printf=console.log");printf("This program errors out in %s :P",("Perl","JavaScript"));$//0

这利用了以下事实：(...)Perl中的一个列表printf将使用的最左边的元素，并且它是JavaScript中的逗号运算符，这将返回最右边的参数。

由于$未在JavaScript中定义，因此在Perl中导致零除错误，并导致ReferenceError 。

在线试用Perl！

在线尝试JavaScript！

八度和MATLAB，67个字节

v=ver;disp(['This program errors out in ' v(1).Name ' :P']);v(--pi)

在线尝试！

注意：该代码假定未安装任何工具箱而安装了MATLAB（或者所安装的任何工具箱的名称都不以字母A到M开头）。

怎么运行的：

该代码使用来获取解释器和工具箱的版本数据ver。Running v(1).Name提取第一个产品的名称，这将返回Octave或MATLAB假设上面的注释为true。

然后，程序将显示所需的字符串，并以Octave或MATLAB按要求完成。

最后我们做v(--pi)。

在Octave中，--是减量运算符。这样，它会尝试先递减，因为变量pi不存在（pi实际上是函数，不是变量）而失败。

This program errors out in Octave :P
error: in x-- or --x, x must be defined first

在MATLAB中，递减运算符不存在。因此，该语句被解释为v(-(-pi))等于just v(pi)。但是pi不是整数，因此不能用于索引v数组，从而产生错误。

This program errors out in MATLAB :P
Subscript indices must either be real positive integers or logicals.

C ++ 14（gcc）/ C ++ 17（gcc），107105字节

#include<cstdio>
int*p,c=*"??/0"/20;int
main(){*p=printf("This program errors out in C++ 1%d :P",4+c)/c;}

在线尝试！（C ++ 14）

在线尝试！（C ++ 17）

假设在全局名称空间中<cstdio>声明printf（除了std），并且基本执行字符集使用ASCII值，在Linux上使用g ++都适用。

这里的基本要点是C ++ 17从语言中消除了三字母组合。

在C ++ 14中，"??/0"包含一个trigraph并等效于"\0"。因此*"??/0"为零，并将c其设置为零。数字4作为参数传递给printf，然后除以c引起不确定的行为。在Linux上，这*p是在图片出现之前发生的，程序得到一个SIGFPE。

在C ++ 17中，"??/0"它恰好是长度为4的字符串。So *"??/0"是'?'或63，并c设置为3。将数字7作为参数传递给printf，这时除以c有效。由于p是名称空间成员，因此它在程序开始时被初始化为零，并且具有空指针值，因此*p未定义行为也是如此。在Linux上，由于该程序尝试修改地址为零的内存，因此该程序将获得一个SIGSEGV。

Perl 5和Perl 6，55个字节

say('This program errors out in Perl ',5-~-1,' :P').a/0

在线尝试Perl 5！（非法除以零）

在线尝试Perl 6！（没有这种方法）

字首 ~是Perl 6中的字符串化，在上面的程序中基本上是no-op。在Perl 5中，按位不将-1转换为0。

. 是Perl 6中的方法调用语法和Perl 5中的串联方法。

C（gcc） / Stax，109字节

AA=~1;
	char* s;main(){*(int*)(printf("%s C :P",s))=0;}char* s=
"This program errors out in";;;/*dp`UGYC\`Q*/

在线尝试！（C（gcc））

在线尝试！（Stax）或运行并调试它！（Stax）

C中的段错误。Stax中的无效操作。我喜欢Stax中实际使用的不是注释的所有内容。

C

这就是C的看法。第一行是无操作。第二行打印带有的消息，printf然后显示由于引起的段错误=0。

AA=~1;
	char* s;main(){*(int*)(printf("%s C :P\n",s))=0;}char* s=
"This program errors out in";;;/*dp`UGYC\`Q*/

萨克斯

每当尝试从空堆栈弹出或偷看时，Stax程序都会终止。这有点棘手，我们必须准备一个不为空的堆栈。AA=~1;在保留C中的有效语句的同时执行此操作。

AA=~1;
AA=       10=10, returns a 1
   ~      Put it on the input stack
    1     Pushes a 1 to main stack (*)
     ;    Peek from the input stack (**)

真正有用的是~，它准备了一个非空的输入堆栈，以便;可以在不退出程序的情况下执行。但是，两者1稍后也会使用主堆栈上。

第二行以制表符开头，并在Stax中开始行注释。

"...";;;/*dp`UGYC\`Q*/
"..."                     "This program errors out in"
     ;;;                  Peek the stack three times so that we have enough operands for the next two operations
        /                 Divide, this consumes one element of the main stack
         *                Multiply, this consumes another element
          d               Discard the result, now the TOS is the string
           p              Pop and print without newline
            `UGYC\`       Compressed string literal for " Stax :P"
                   Q      Print and keep the string as TOS
                    *     Duplicate string specific times
                          Since the element under the top of stack is `1` that was prepared in (**), this does nothing
                     /    Invalid operation error

无效操作试图对/字符串作为TOS（第二操作数）和1（*）中的数字作为第一操作数执行操作，这是无效的。

如果两个操作数被交换，则在Stax中将是有效操作。

果冻和M，39个字节

İ=`ị“¢³ƥ“Ȥ¹»;“ :P”“¢ḅñ⁵ẹḞŀẊịñṙȧṄɱ»;ȮṠṛƓ

在果冻中尝试！

在M中尝试！

这两种语言都适用逆İ于0这导致inf果冻和zoo为M.我不知道为什么zoo代表无穷远M.询问丹尼斯。

重要的区别是果冻的无穷大等于自身，而M的无穷大不等于。因此，果冻和M中的“等于自身”单子=`产量。从这里：10

İ=`ị“¢³ƥ“Ȥ¹»;“ :P”“¢ḅñ⁵ẹḞŀẊịñṙȧṄɱ»;ȮṠṛƓ
İ=`                                      0 in M, 1 in Jelly
    “¢³ƥ“Ȥ¹»                             Pair of compressed strings: [' M',' Jelly']
   ị                                     Index into this list with 0 or 1
            ;“ :P”                       Concatenate with the string ' :P'
                  “¢ḅñ⁵ẹḞŀẊịñṙȧṄɱ»       Compressed string: 'This program errors in'
                                  ;      Prepend this to ' Jelly/M :P'
                                   Ȯ     Print the string and return it
                                    Ṡ    Sign. M errors with a string as input and terminates
                                         Jelly returns a list of Nones
                                     ṛ   Right argument. This prevents the list of Nones from being printed
                                      Ɠ  Read a single line from input. Since input is not allowed, this produces an EOFError

果冻的错误是 EOFError: EOF when reading a line。

M的错误是TypeError: '>' not supported between instances of 'str' and 'int'。

Foo / CJam，51 50字节

"This program errors out in ""Foo"/'C'J'a'm" :P"Li

这在Foo中以零除错误退出，NumberFormatException在CJam中以a 退出。

前往CJam：

• 字符串文字（在引号之间）将自身压入堆栈。程序终止时，堆栈中的项目将自动打印而无需分隔符。
• /尝试This program errors out in 在子字符串上拆分字符串Foo。由于字符串不包含子字符串，因此将生成包含原始字符串的单例数组，其显示方式完全相同。
• 'x 是用于的字符文字 x，其打印方式与一个字符的字符串相同。这样，我们可以为Foo忽略的CJam推送数据（我还没有弄清楚如何使循环不在Foo中执行）。
• Li尝试将空字符串转换为整数，这将失败。堆栈中的所有内容均已打印。

致：

• 字符串文字（在引号之间）会自行打印。
• /尝试将当前单元格除以顶部堆栈元素（这是一个隐式0）。出于某些原因，Foot中除以零的错误并不是致命的，因此这只会打印出消息

  Only Chuck Norris can divide by zero.

  到STDERR并继续前进。
• 无法识别的字符（'C'J'a'm和Li）将被忽略。

蟒和Lua中，111 110 102 98 95 85个字节

x="This program errors out in ",#[[
print(x[0]+"Python :P")
a#]]z=#print(x.."Lua :P")

错误：Python 3：

Traceback (most recent call last):
  File ".code.tio", line 3, in <module>
    a#]]z=#print(x.."Lua :P")
NameError: name 'a' is not defined

卢阿：

lua: .code.tio:3: attempt to get length of a nil value
stack traceback:
    .code.tio:3: in main chunk
    [C]: in ?

明显不同。

滥用多重差异：

• <var>=<a>,<b>,... 在Python中创建一个元组，但在Lua中创建一个参数列表，仅从中获取第一个成员。
• #在Python中开始注释，但在Lua中是length运算符。Python的额外道具，允许元组以逗号结尾。
• [[...]]是Lua的多行字符串语法，这意味着它甚至没有看到Python的print函数；这是必要的，因为Lua ..用于字符串连接，而不是+。
• 看到a，未定义的变量后发生Python错误；a之后z=#print(x.."Lua :P")。只#print(x.."Lua :P")为Lua 使用不起作用，因为这会在甚至执行代码之前引发错误。

编辑：

• 无需"".join在Python中使用，-1字节
• 制作x两种语言的字符串，并Python在打印功能中放入字符串文字，-8个字节
• 使用#[[]]比#""和短--[[]]，-4个字节
• 无需使用 #1用作表键，-3个字节
• Jo King做到了，-9个字节
• print(x.."Lua :P")显然，以作品的回报价值为限；-1字节

Java和C＃242 235

/**\u002f/*/using System;/**/class G{public static void/**\u002fmain/*/Main/**/(String[]a){String s="This program errors out in ";/**\u002fSystem.out.print(s+"Java :P");/*/Console.Write(s+"C# :P")/**/;s=/**\u002f(1/0)+""/*/a[-1]/**/;}}

滥用Java和C＃之间的不同转义处理（在Java中而不是c＃中解析代码之前先解析转义代码）作为一种预处理程序，这就是\u0027魔术的工作，剩下的就是一些“切换注释”

编辑：由于@KevinCruijssen的指针，打了8个字节

编辑：固定规则derp

AutoHotkey的 / C＃，155个 133 128 122字节

语法高亮比我能更好地解释它：

C＃ RuntimeBinderException：'无法调用非委托类型'

;dynamic
i="This program errors out in " ;Console.Write(i+"c# :P");i();/*
i:=SubStr(i,2,27)
send %i%AutoHotkey :P
Throw */

AutoHotkey错误：引发了异常。

;dynamic
i="This program errors out in " ;Console.Write(i+"c# :P");i();/*
i:=SubStr(i,2,27)
send %i%AutoHotkey :P
Throw */

编辑：

1. 删除了一个变量
2. -5字节归功于牛奶

PHP 7+ / JavaScript，90 89字节

它使用两种具有非常相似的语法的语言，从而可以用两种语言编写此代码。

语言分离是通过JavaScript中不存在的属性来完成的：PHP在JavaScript中认为[]（空数组）是虚假的值，而它是真实的（因为它是一个对象，而对象始终是真实的，即使new Boolean(false)）。

$X='This program errors out in %s :P';([]?console.log($X,'JavaScript'):printf($X,PHP))();

执行：

将重点关注以下一段代码：([]?console.log($X,'JavaScript'):printf($X,PHP))();。

字符串归属在两种语言中均相同。

该代码使用“三元运算符”（Javascript，PHP），这两种语言的工作方式基本相同。

Java脚本

Javascript将运行该console.log($X,'JavaScript')片段，并返回undefined。

稍后，当您尝试执行时(...)()，您将获得一个Uncaught TypeError: (intermediate value)(intermediate value)(intermediate value) is not a function（在Google Chrome中）。

的PHP

PHP将执行该程序printf($X,PHP)。

在PHP中，该printf函数返回output的长度。

PHP具有一个有趣的功能：它可以执行名称存储在变量中的函数（或者，自PHP7起，作为表达式的结果），这可以防止语法错误。

然后，PHP将尝试运行名称为表达式结果[]? ... :printf($X,PHP)（即number 33）的函数。
But that interesting functionality has a caveat: only accepts strings (duh!).

这会导致Fatal error: Function name must be a string，因为33是int。

感谢Shieru Asakoto为我节省了1个字节！

Perl 5和C，95个字节

//;$_='
main(){puts(puts("This program errors out in C :P"));}//';/T.*n /;print$&,"perl :P";die

//; 在perl中基本上是NOP，在C中是注释。

因此，C程序实际上是：

main(){puts(puts("This program errors out in C :P"));}

它将打印所需的字符串，然后尝试运行puts(32)。从技术上讲，这是C语言中未定义的行为，但会在TIO和我可以访问的每个系统上造成分段错误。

perl程序将整个C程序视为一个字符串，使用正则表达式/T.*n /进行匹配This program errors out in，然后打印和perl :P。die导致程序因错误而崩溃Died at script_name line 2。

If you don't like that as an error, 1/0 is the same length and crashes with an Illegal division by zero error. I just like die more ;)

Try it online! (C)

Try it online! (Perl)

VBScript, JScript, 72 bytes

x="VB"
'';x='J'
WScript.echo("This program errors out in "+x+"Script")
y

VBScript will print "Microsoft VBScript runtime error: Type mismatch: 'y'"
JScript will print "Microsoft JScript runtime error: 'y' is undefined"

JavaScript & Python 3, 105 91 bytes

Errors by NameError: name 'console' is not defined in Python 3

a="This program errors out in %s :P"
1//2;print(a%"Python 3")
console.log(a,"JavaScript")()

Try it online!

... and by TypeError: console.log(...) is not a function in JavaScript.

a="This program errors out in %s :P"
1//2;print(a%"Python 3")
console.log(a,"JavaScript")()

Try it online!

Java (JDK)/JavaScript (Node.js), 154 bytes

class P{P(){var s="This program errors out in ";try{System.out.printf("%sJava :P",s);}finally{if(1!='1'){var a=0/0;}throw new Error(s+"JavaScript :P");}}}

Try it online! (Java)

Try it online! (JavaScript)

Output in Java:

This program errors out in Java :P
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at P.(Main.java:1)

Output in JavaScript (to stderr):

Error: This program errors out in JavaScript :P
    at P (/home/runner/.code.tio:1:185)

This takes advantage of JavaScript's weak typing (1=='1') to detect the language, and the same keywords in Java and JavaScript (var,class), and the similar error constructors (new Error()) to make the polyglot.

PowerShell v6 and PowerShell v2, 73 bytes

"This errors out in PowerShell v$($PSVersionTable.PSVersion) :P"
1-shl1/0

Try it online!

This will throw a parsing error on v2 because -shl was introduced in v3. v3+ will then be able to correctly shift the value before attempting to divide it by 0, conveniently throwing a division-by-zero error. Both versions have the $PSVersionTable hashmap which contains the PSVersion field

C(gcc) on Linux/C(gcc) on Mac (160)

#include <sys/utsname.h>
main(){struct utsname n;float g;uname(&n);printf("This program errors out in C(gcc) on %s :P\n",n.sysname);g=1/(int)gamma(1);abort();}

Untested on Mac; basically, John Cook pointed out (in his blog) that POSIX doesn't define gamma; Linux uses the log of the gamma function (log(gamma(1)) will return 0 which will trigger a floating point exception); OSX uses the "true" gamma function, (which is officially called tgamma per POSIX); this returns 1 which will then hit the abort statement; I tried to get it to throw a different floating point error (e.g. sqrt(-1) but I'm forgetting how to make that throw an error vs just return zero)

Perl, Bash (78 bytes)

printf "This program errors out in ";eval 'echo Bash :P'||print"Perl :P
";
a()

Output in Perl:

This program errors out in Perl :P
Undefined subroutine &main::a called at /tmp/perlbash line 3.

Output in Bash:

This program errors out in Bash :P
/tmp/perlbash: line 4: syntax error: unexpected end of file

(Note that Bash is indeed displaying the line 4 error, despite the fact that line 3 does not end with a line feed...)

C and ECPP, 112 bytes

#ifdef ECPP
#replace "C" "ECPP"
#endif
main(){puts("This program errors out in " "C" " :P");raise(strlen("C"));}

• Try it online! (C) Throws error 1, Hangup.
• Try it online! (ECPP) Throws error 4, Illegal instruction.

C (gcc) and Haskell, 135 bytes

char/*x=0-- */*
s="This program errors out in ";
int main(){--s;*s=printf("%sC :P",s+1);}//-}=0;main=mapM print[s++"Haskell :P",tail""]

Try it online (С)! Try it online (Haskell)!

The result is achieved by interweaving the comments, the C version being essentially this:

char * s = "This program errors out in ";
int main ()
{
   --s;
   *s = printf ("%sC :P", s + 1);
}

(Failure is achieved by writing before the beginning of the string).

Haskell version, on the other hand, reduces to the following:

char /* x = 0 -- a useless operator (/*) taking two arguments
s = "This program errors out in ";
int main () = 0 -- a useless function int taking two arguments
main = mapM print [s ++ "Haskell :P", tail ""]

(Failure is achieved by taking tail of an empty list)