最奇怪的语言特征

Question

在您看来,您遇到的最令人惊讶,奇怪,奇怪或真正的"WTF"语言功能是什么？

每个答案只能有一个功能.

Answer 1

在C中,数组可以像这样索引:

a[10]

这很常见.

然而,鲜为人知的形式(确实有效!)是:

10[a]

这意味着与上述相同.

Answer 2

在JavaScript中:

 '5' + 3 gives '53'

而

 '5' - 3 gives 2

Answer 3

在JavaScript中,以下构造

return
{
    id : 1234,
    title : 'Tony the Pony'
};

返回undefined是一个语法错误,因为在换行符后插入了偷偷的分号分号return.以下工作正如您所期望的那样:

return {
    id : 1234,
    title : 'Tony the Pony'
};

更糟糕的是,这个也适用(至少在Chrome中):

return /*
*/{
    id : 1234,
    title : 'Tony the Pony'
};

这是同一问题的变体,不会产生语法错误,只是默默地失败:

return
    2 + 2;

Answer 4

JavaScript真值表:

''        ==   '0'           // false
0         ==   ''            // true
0         ==   '0'           // true
false     ==   'false'       // false
false     ==   '0'           // true
false     ==   undefined     // false
false     ==   null          // false
null      ==   undefined     // true
" \t\r\n" ==   0             // true

资料来源:Doug Crockford

Answer 5

C和C++中的Trigraphs.

int main() {
   printf("LOL??!");
}

这将打印LOL|,因为三字符??!被转换为|.

Answer 6

有趣的自动装箱和Java中的整数缓存:

Integer foo = 1000;
Integer bar = 1000;

foo <= bar; // true
foo >= bar; // true
foo == bar; // false

//However, if the values of foo and bar are between 127 and -128 (inclusive)
//the behaviour changes:

Integer foo = 42;
Integer bar = 42;

foo <= bar; // true
foo >= bar; // true
foo == bar; // true

说明

快速浏览Java源代码将会出现以下内容:

/**
 * Returns a <tt>Integer</tt> instance representing the specified
 * <tt>int</tt> value.
 * If a new <tt>Integer</tt> instance is not required, this method
 * should generally be used in preference to the constructor
 * {@link #Integer(int)}, as this method is likely to yield
 * significantly better space and time performance by caching
 * frequently requested values.
 *
 * @param  i an <code>int</code> value.
 * @return a <tt>Integer</tt> instance representing <tt>i</tt>.
 * @since  1.5
 */
public static Integer valueOf(int i) {
    if (i >= -128 && i <= IntegerCache.high)
        return IntegerCache.cache[i + 128];
    else
        return new Integer(i);
}

注意: 除非由属性IntegerCache.high设置,127否则默认为.

自动装箱会发生什么,除非明确创建foo = new Integer(42),否则foo和bar都会从缓存中检索相同的整数对象:例如,因此在比较引用相等时,它们将为true而不是false.比较Integer值的正确方法是使用.equals;

Answer 7

引用Neil Fraser(看看那页的末尾),

try {
    return true;
} finally {
    return false;
}

(在Java中,但在JavaScript和Python中的行为显然是相同的).结果留给读者练习.

编辑:只要我们在这个问题上,也要考虑这个问题:

try {
    throw new AssertionError();
} finally {
    return false;
}

Answer 8

APL(除了ALL之外),能够在一行中编写任何程序.

例如康威在APL中的生命游戏:

替代文字http://catpad.net/michael/APLLife.gif

如果那条线不是WTF,那么什么都没有!

这是一个视频

Answer 9

的奇怪的事情C++模板可用于,通过最好的证明"多维模拟字面",其使用模板来计算的"拉伸"的形状的区域.以下代码是3x3矩形的有效C++

#include"analogliterals.hpp"
using namespace analog_literals::symbols;

          unsigned int c = ( o-----o
                             |     !
                             !     !
                             !     !
                             o-----o ).area;

或者,3D立方体的另一个例子:

  assert( ( o-------------o
            |L             \
            | L             \
            |  L             \
            |   o-------------o
            |   !             !
            !   !             !
            o   |             !
             L  |             !
              L |             !
               L|             !
                o-------------o ).volume == ( o-------------o
                                              |             !
                                              !             !
                                              !             !
                                              o-------------o ).area * int(I-------------I) );

Answer 10

Perl的许多内置变量:

• $#- 不是评论!
• $0,$$和$?- 就像shell变量一样
• $?,$&和$'- 奇怪的匹配变量
• $"和$,- list-和output-field-separator的奇怪变量
• $!- 像errno一个数字,但strerror(errno)作为一个字符串
• $_- 在隐形变量,总是习惯从来没见过
• $#_ - 最后一个子程序参数的索引号...也许
• @_ - 当前函数的(非)名称......也许
• $@ - 最后提出的异常
• %:: - 符号表
• $:,$^,$~,$-,和$=-是与输出格式
• $.和$%- 输入行号,输出页码
• $/和$\- 输入和输出记录分隔符
• $| - 输出缓冲控制器
• $[- 将阵列基础从0基础更改为基于1基于42基础:WHEEE!
• $}- 什么都没有,奇怪的是!
• $<,$>,$(,$)-真实和有效的UID和GID
• @ISA - 当前包的直接超类的名称
• $^T - epoch秒中的脚本启动时间
• $^O - 当前的操作系统名称
• $^V - 这是什么版本的Perl

那些来自的地方还有很多.阅读完整的列表在这里.

Answer 11

PHP在字符串中处理数值.有关完整详细信息,请参阅此前一个不同问题的答案,但简而言之:

"01a4" != "001a4"

如果您有两个包含不同字符数的字符串,则它们不能被视为相等.前导零是重要的,因为这些是字符串而不是数字.

"01e4" == "001e4"

PHP不喜欢字符串.它正在寻找任何可以找到将你的价值观视为数字的借口.稍微更改这些字符串中的十六进制字符,突然PHP决定这些字符串不再是字符串,它们是科学记数法中的数字(PHP并不关心您使用引号)并且它们是等效的,因为数字会忽略前导零.为了强调这一点,您会发现PHP也会评估"01e4" == "10000"为true,因为这些是具有等效值的数字.这是记录在案的行为,它不是很明智.

Answer 12

JavaScript八进制转换'功能'是一个很好的了解:

parseInt('06') // 6
parseInt('07') // 7
parseInt('08') // 0
parseInt('09') // 0
parseInt('10') // 10

更多细节在这里.

Answer 13

让我们对试图取消保留字的所有语言(例如PL/I)进行投票.

还有什么地方可以合法地写下这样有趣的表达:

IF IF THEN THEN = ELSE ELSE ELSE = THEN

(IF,THEN,ELSE是变量名)

要么

IF IF THEN THEN ELSE ELSE

(IF是一个变量,THEN和ELSE分别表示子程序)

Answer 14

Duff的装置在C!

在C中,可以使用switch语句交换do/while.这是使用此方法的memcpy的示例:

void duff_memcpy( char* to, char* from, size_t count ) {
    size_t n = (count+7)/8;
    switch( count%8 ) {
    case 0: do{ *to++ = *from++;
    case 7:     *to++ = *from++;
    case 6:     *to++ = *from++;
    case 5:     *to++ = *from++;
    case 4:     *to++ = *from++;
    case 3:     *to++ = *from++;
    case 2:     *to++ = *from++;
    case 1:     *to++ = *from++;
            }while(--n>0);
    }
}

Answer 15

Algol按名称传递(使用C语法说明):

int a[3] = { 1, 2, 3 };
int i = 1;

void f(int j)
{
    int k;
    k = j;  // k = 2
    i = 0;
    k = j;  // k = 1 (!?!)    
}

int main()
{
    f(a[i]);
}

Answer 16

在Python中:

>>> x=5
>>> 1<x<10
True
>>> 1<x<3
False

不是WTF,而是一个有用的功能.

Answer 17

在Java中:

int[] numbers() {
  return null;
}

可以写成:

int numbers() [] {
  return null;
}

Answer 18

INTERCAL可能是最奇怪的语言功能的最佳纲要.我个人最喜欢的是COMEFROM声明,它几乎与GOTO相反.

COMEFROM与GOTO大致相反,因为它可以将执行状态从代码中的任意点转换为COMEFROM语句.发生状态转移的代码中的点通常作为COMEFROM的参数给出.传输是在指定传输点的指令之前还是之后发生,取决于所使用的语言.根据所使用的语言,引用相同出发点的多个COMEFROM可能无效,是非确定性的,以某种定义的优先级执行,或者甚至引起并行或以其他方式并发执行,如在线程间隔中所见."COMEFROM x"语句的一个简单示例是标签x(它不需要物理上位于其对应的COMEFROM附近的任何位置),充当"陷阱门".当代码执行到达标签时,控件将传递给COMEFROM之后的语句.这样做的主要目的是使调试(并理解程序的控制流程)非常困难,因为标签附近没有迹象表明控件会神秘地跳转到程序的另一个点.

Answer 19

不是一个语言功能,而是一个实现缺陷:一些早期的Fortran编译器通过使用常量池实现了常量.所有参数均通过引用传递.如果你调用了一个函数,例如

f(1)

编译器会将常量池中常量1的地址传递给函数.如果为函数中的参数指定了值,则可以在程序中全局更改值(在本例中为值1).引起一些头部刮伤.

Answer 20

不知道它是否可以被认为是一种语言特性,但是,在C++中,几乎所有与模板相关的编译器错误都会为全世界的许多C++程序员每天提供相当数量的WTF :)

Answer 21

C的许多名称空间:

typedef int i;

void foo()
{
    struct i {i i;} i;
    i: i.i = 3;
    printf( "%i\n", i.i);
}

或者使用字符:

typedef char c;

void foo()
{
    struct c {c c;} c;
    c: c.c = 'c';
    printf( "%c\n", c.c);
}

Answer 22

我会说Python的整个空白是我最强大的WTF功能.确实,你或多或少习惯了一段时间后现代编辑人员可以轻松应对,但即使在过去一年大部分时间进行python开发之后,我仍然相信这是一个坏主意.我已经阅读了它背后的所有推理但老实说,它妨碍了我的工作效率.不是很多,但它仍然是马鞍下的毛刺.

编辑:根据评论判断,有些人似乎认为我不喜欢缩进我的代码.这是一个不正确的评估.无论语言是什么以及我是否被迫,我总是缩进我的代码.我不喜欢的是缩进定义了一行代码块.我更喜欢明确的分隔符.除了其他原因之外,我发现明确的分隔符可以更轻松地剪切和粘贴代码.

例如,如果我有一个块缩进4个空格并将其粘贴到缩进8个空格的块的末尾,我的编辑器(所有编辑器？)不知道粘贴的代码是属于8空间块还是外部块.OTOH,如果我有明确的分隔符,很明显代码属于哪个块以及它应该如何(重新)缩进 - 它通过智能地查找块分隔符来实现.

编辑2:一些提供评论的人似乎认为这是我讨厌的一个功能,或者我认为这使得python成为一种糟糕的语言.再次,不是真的.虽然我不喜欢这么多,但这不是重点.问题是关于最奇怪的语言特征,我认为这很奇怪,因为它是非常非常少(但> 0)种语言使用的东西.

Answer 23

我对此有点挣扎:

1;

在perl中,模块需要返回真实的东西.

Answer 24

我很惊讶没有人提到Visual Basic的7循环结构.

For i As Integer = 1 to 10 ... Next
While True ... End While
Do While True ... Loop
Do Until True ... Loop
Do ... Loop While True
Do ... Loop Until True
While True ... Wend

因为坚持!在有条件的正面的方式太复杂!

Answer 25

对于那些不知道的人来说,bc是一种"任意精确计算器语言",我经常使用它进行快速计算,特别是当涉及的数字很大时($提示):

$ bc -lq
12^345
20774466823273785598434446955827049735727869127052322369317059031795\
19704325276892191015329301807037794598378537132233994613616420526484\
93077727371807711237016056649272805971389591721704273857856298577322\
13812114239610682963085721433938547031679267799296826048444696211521\
30457090778409728703018428147734622401526422774317612081074841839507\
864189781700150115308454681772032

bc很长一段时间以来一直是标准的Unix命令.

现在为"WTF功能".这来自man bc(强调我的):

退出:当读取quit语句时,无论在哪里找到退出语句,都会终止bc处理器. 例如,"if(0 == 1)quit"将导致bc终止.

halt:halt语句(扩展名)是一个执行语句,它导致bc处理器仅在执行时退出. 例如,"if(0 == 1)halt"不会导致bc终止,因为没有执行暂停.

Answer 26

我总是想知道为什么最简单的程序是:

class HelloWorldApp {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

而它可能是:

print "Hello World!"

也许这首先是吓唬计算机科学的学生......

Answer 27

JavaScript是面向对象的,对吧？因此,对文字字符串和数字运行方法应该有效.喜欢"hello".toUpperCase()和3.toString().原来第二个是语法错误,为什么？因为解析器期望一个点后面跟一个数字作为浮点文字.那不是WTF,WTF是你只需要添加另一个点来使其工作:

3..toString()

原因是文字3.被解释为3.0,并且3.0.toString()工作正常.

Answer 28

在JavaScript中:

2 == [2]

// Even stranger
2 == [[[2]]]

// And down-right nutty
var a = { "abc" : 1 };
a[[[["abc"]]]] === a["abc"]; // this is also true

幸运的是,stackoverflow.com的善良的人向我解释了整个事情: 为什么在JavaScript中2 == [2]？

Answer 29

我最讨厌的功能是任何包含条件逻辑的配置文件语法.这种事情在Java世界中很普遍(Ant,Maven等等.你知道你是谁!).

您最终只能使用ac**p语言进行编程,调试有限且编辑器支持有限.

如果您的配置中需要逻辑,那么使用真实语言编写配置的"Pythonic"方法要好得多.

Answer 30

powerbasic(www.powerbasic.com)包含编译器指令:

# BLOAT {bloatsize}

这会增加编译后的可执行文件的大小<bloatsize>.如果创建可执行文件的人不喜欢生成的可执行文件的小尺寸,则将其放入编译器中.它使得EXE看起来更大,可以与臃肿的编程语言竞争:)

Answer 31

在PHP中,函数名称不区分大小写.这可能会让您认为php中的所有标识符都不区分大小写.再猜.变量区分大小写.WTF.

function add($a, $b)
{
    return $a + $b;
}

$foo = add(1, 2);
$Foo = Add(3, 4);

echo "foo is $foo"; // outputs foo is 3
echo "Foo is $Foo"; // outputs Foo is 7

Answer 32

在上下文中连续使用两个冒号时,我一直非常喜欢抛出的PHP错误:

解析错误:语法错误,第3行的/path/to/file/error.php中的意外T_PAAMAYIM_NEKUDOTAYIM

我第一次遇到这个时,我完全糊涂了.

Answer 33

在C.

a[i++] = i;

它编译,但它很少做你认为它应该做的事情.优化变化导致产生截然不同的结果.它在不同的平台上运行方式不同.

然而,编译器对它非常满意.

Answer 34

Python 2.x

>>>True = False
>>>True
False

你真的可以让这个人变得疯狂.

Answer 35

Oracle有几个SQL WTF问题.

1. Oracle将空字符串视为null.

2. 在"<>"比较中处理空值.

   create table wtf (key number primary key, animal varchar2(10));    
   insert into wtf values (1,'dog');
   insert into wtf values (2,'');
   insert into wtf values (3,'cat');    
   select * from wtf where animal <> 'cat';
   

返回的唯一行是(1,'dog')行.

Answer 36

Java有一本关于它们的完整的书.

预订http://www.javapuzzlers.com/lg-puzzlers-cropped.jpg

Java Puzzlers

Answer 37

在JavaScript中,void它不是关键字,它不是类型声明,也不是变量名,它也不是函数,也不是对象.void是一个前缀操作,类似-,--,++,和!.您可以将其作为任何表达式的前缀,该表达式将计算为未定义.

它经常用于bookmarklet和内联事件处理程序,如在这个有点频繁的例子中:

<a href="javascript:void(0)">do nothing</a>

它在这个例子中使用的方式使它看起来像一个函数调用,当它真的只是一个过于聪明的方式来获得原始undefined值.大多数人并不真正理解voidJavaScript中的真实本质,这可能导致许多令人讨厌的错误和奇怪的意外事情发生.

不幸的是,我认为void运算符是获得undefinedJavaScript值的唯一真正有保证的方法,因为在另一个答案中指出,未定义的是一个可以重新分配的变量名,并且{}.a可以通过Object.prototype.a = 'foo'

更新:我想到了另一种生成方式undefined:

(function(){}())

呃,虽然有点冗长,但回归"未定义"的目的却更为明显.

Answer 38

Perl有yada yada运算符(...).

Perl 6遗产的所谓"yada yada"操作符是标记未实现代码的快捷方式:

if ($condition) { ... }

是相同的

if ($condition) { die "not yet implemented" }

Answer 39

在fortran(肯定是77,也许在95中),未通知的变量和以Ithrough 开头的参数N("in"组)将是INTEGER,而所有其他未声明的变量和参数将是REAL(source).结合"在某些情况下可选的空格"导致了最着名的错误之一.

正如Fred Webb alt.folklore.computers在1990年所说:

我的1963年夏季曾在美国宇航局我工作中的小组正在做的任务控制中心的计算机系统和程序的前期工作.我的办公室伙伴负责测试在水星飞行期间使用的轨道计算程序.通过它运行一些已知答案的测试数据,他得到的答案很接近,但不够准确.因此,他开始在算法中寻找数值问题,检查以确保他的测试数据真的正确等等.

经过几周没有结果,他发现了一个DO 声明,形式如下:

DO 10 I=1.10

编译器(正确地)将此语句解释为:

DO10I = 1.10

程序员明确意图:

DO 10 I = 1, 10

更改.到,程序后,结果正确到所需的准确度.显然,该计划的答案对于亚轨道水星飞行来说已经"足够好"了,所以没有人怀疑有虫子,直到他们试图获得更高的准确度,期待后来的轨道和月球飞行.据我所知,这个特殊的错误从未被指责为太空飞行的任何实际失败,但这里的其他细节似乎足够接近我确信这一事件是DO故事的来源.

我认为这是一个很大的WTF如果DO 10 I被视为DO10I,而反过来,因为隐式声明被认为是类型REAL.这是一个很棒的故事.

Answer 40

我最喜欢的小C++语法技巧是你可以将URL(有一些限制)直接放入代码中:

int main( int argc, char *argv[] )
{
    int i=10;

    http://www.stackoverflow.com
    return 1;
}

编译得很好.

语法突出显示有点破坏了笑话,但它仍然很有趣.

Answer 41

我不敢声称XML是一种编程语言,但它不是我们的心脏吗？:-)

在我看来,XML中最奇怪的特性是以下是一个格式良好的文档:

<_....>
</_....>

这是允许连续点的NT-Name的词汇定义.

Answer 42

继承Ruby中的随机类:

class RandomSubclass < [Array, Hash, String, Fixnum, Float, TrueClass].sample
   ...
end

(首次见于Ruby的隐藏功能)

Answer 43

令我惊讶的是,您可以通过修改其@ISA数组来更改Perl中的类的继承链.

package Employee;
our @ISA = qw(Person);
# somwhere far far away in a package long ago
@Employee::ISA = qw(Shape); 
# Now all Employee objects no longer inherit from 'Person' but from 'Shape'

Answer 44

我喜欢JavaScript这样的事情:

var futureDate = new Date(2010,77,154);
alert(futureDate);

从2010年第0个月的第0天起,即2016年11月1日,结果为77个月和154天

Answer 45

在ruby/python/c中,您可以像这样连接字符串:

a = "foo" "bar"
print a # => "foobar"

Answer 46

在JavaScript中,undefined是一个全局变量,其默认值是原始值undefined.您可以更改以下值undefined:

var a = {};
a.b === undefined; // true because property b is not set
undefined = 42;
a.b === undefined; // false

由于其可变性undefined,通常最好通过typeof以下方式检查undefined-ness :

var a = {};
typeof a.b == "undefined"; // always true

Answer 47

在Forth中,任何不包含空格的东西都可以是一个标识符(包含空格的东西需要一些工作).解析器首先检查是否定义了东西,在这种情况下它被称为一个单词,如果没有,则检查它是否是一个数字.没有关键字.

无论如何,这意味着可以重新定义一个数字来表示其他内容:

: 0 1 ;

它创建的字 0,组成1,无论是在这个被执行的时间.反过来,它可能导致以下结果:

0 0 + .
2 Ok

另一方面,定义可以接管解析器本身 - 这是由注释单词完成的.这意味着Forth程序实际上可以在中途成为完全不同语言的程序.而且,事实上,这是Forth中推荐的编程方式:首先编写要解决问题的语言,然后解决问题.

Answer 48

我在1977年左右将"格式"函数添加到Lisp,之后"printf"甚至存在(我从与Unix相同的来源复制:Multics).它开始时天真无邪,但充满了功能后的功能.当Guy Steele进行迭代和相关功能时,事情就失控了,这些功能已被Common Lisp X3J13 ANSI标准所接受.以下示例可以在Common Lisp the Language,第2版的第22.3.3节中的表22-8中找到:

(defun print-xapping (xapping stream depth)
  (declare (ignore depth))
  (format stream
      "~:[{~;[~]~:{~S~:[->~S~;~*~]~:^ ~}~:[~; ~]~ ~{~S->~^ ~}~:[~; ~]~[~*~;->~S~;->~*~]~:[}~;]~]"
      (xectorp xapping)
      (do ((vp (xectorp xapping))
           (sp (finite-part-is-xetp xapping))
           (d (xapping-domain xapping) (cdr d))
           (r (xapping-range xapping) (cdr r))
           (z '() (cons (list (if vp (car r) (car d)) (or vp sp) (car r)) z)))
          ((null d) (reverse z)))
      (and (xapping-domain xapping)
           (or (xapping-exceptions xapping)
           (xapping-infinite xapping)))
      (xapping-exceptions xapping)
      (and (xapping-exceptions xapping)
           (xapping-infinite xapping))
      (ecase (xapping-infinite xapping)
        ((nil) 0)
        (:constant 1)
        (:universal 2))
      (xapping-default xapping)
      (xectorp xapping)))

Answer 49

流行性腮腺炎.有很多WTF功能,我选了一个,if声明.(请注意,我正在使用下面相当冗长的编码风格来容纳那些不懂语言的人;真正的MUMPS代码通常对于不熟悉的人来说更难以理解.)

if x>10 do myTag(x)    ; in MUMPS "tag" means procedure/function
else  do otherTag(x)

这类似于Java中的说法:

if (x > 10) {
  myMethod(x);
} else {
  otherMethod(x);
}

除了在MUMPS中,else语句在语法上不是if块的一部分,它是一个单独的语句,通过检查内置变量来工作$TEST.每次执行if语句时,它都会设置$TEST为语句的结果if.该else语句实际上意味着"如果$TEST为false 则执行其余行,否则跳到下一行".

这意味着如果x大于10并且因此第一行被调用myTag,并且myTag包含if语句,那么行为else不取决于if它上面的行而是最后if评估的内部myTag!由于这个"功能",MUMPS编码员通常会教这样编写以上代码是安全的:

if x>10 do myTag(x) if 1
else  do otherTag(x)

的if 1在第一行的末尾确保$TEST之前控制进行到下一行正确设置.(顺便说一句,这里的间距必须是这样的,else在所有其他位置之后有两个空格和一个空格.间距是奇数,但是一旦你理解了模式,它至少是非常正交的.)

Answer 50

nullsANSI SQL中的三值逻辑.

Answer 51

Python的一切有趣的副作用 - 实际上是一个参考:

>>> a = [[1]] * 7
>>> a
[[1], [1], [1], [1], [1], [1], [1]]
>>> a[0][0] = 2
>>> a
[[2], [2], [2], [2], [2], [2], [2]]

Answer 52

在JavaScript中,您可以使用双位否定(~~n)替换Math.floor(n)(如果n是正数)或parseInt(n, 10)(即使n是负数).n|n并n&n始终产生相同的结果~~n.

var n = Math.PI;
n; // 3.141592653589793
Math.floor(n); // 3
parseInt(n, 10); // 3
~~n; // 3
n|n; // 3
n&n; // 3

// ~~n works as a replacement for parseInt() with negative numbers…
~~(-n); // -3
(-n)|(-n); // -3
(-n)&(-n); // -3
parseInt(-n, 10); // -3
// …although it doesn’t replace Math.floor() for negative numbers
Math.floor(-n); // -4

单个按位取反(~)计算-(parseInt(n, 10) + 1),因此将返回两个按位否定-(-(parseInt(n, 10) + 1) + 1).

更新: 这是一个jsPerf测试用例,比较这些替代方案的性能.

Answer 53

这不是一个奇怪的功能,但从类型安全的角度来看真的很烦人:C#中的数组协方差.

class Foo { }
class Bar : Foo { }
class Baz : Foo { }

Foo[] foo = new Bar[1];
foo[0] = new Baz(); // Oh snap!

我相信,这是从Java继承的(双关语).

Answer 54

我在C中最喜欢的怪异是5 ["Hello World"],但由于那已经发布了,我最近的最喜欢的怪异是Windows版本结构初始化黑客攻击:

void someWindowsFunction() {
    BITMAPINFOHEADER header = {sizeof header};

    /* do stuff with header */
}

那一条细微的线条完成了以下工作:

1. 声明BITMAPINFOHEADER结构
2. 简洁地设置结构的"大小"成员,而不用硬编码大小常量(因为许多Window结构,包括BITMAPINFOHEADER,遵循将结构的大小指定为第一个成员的惯例}
3. 声明结构的版本(因为许多Windows结构,包括BITMAPINFOHEADER,按照声明的大小标识它们的版本,遵循结构定义仅附加的约定)
4. 清除结构的所有其他成员(结构未完全初始化时的C标准行为).

Answer 55

Java的; 使所有对象实例都是互斥体.

Answer 56

在PHP中,我们可以做到:

System.out.print("hello");

Answer 57

在JavaScript中:

alert(111111111111111111111) // alerts 111111111111111110000

这对于我在JSON中来回传递的一些64位密钥非常有害.

Answer 58

else在Python的for循环中.

从Python文档:

for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print n, 'equals', x, '*', n/x
            break
    else:
        # loop fell through without finding a factor
        print n, 'is a prime number'

输出:

2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

Answer 59

一些早期的动态语言(包括,如果我没记错的话,Perl的早期版本)还没有弄清楚什么是好动力和什么是坏动力.所以有些人允许这样做:

1 = 2;

在该声明之后,以下情况将成立:

if(1 + 1 == 4)

Answer 60

在Python中,函数参数的"编译时间"(或声明时间)评估可能会令人困惑:

def append(v, l = []):
    l.append(v)
    return l


print append(1)
print append(2)

>>> [1]
>>> [1,2]

意图可能是:

def append(v, l = None):
    if l is None:
        l = []
    l.append(v)
    return l

print append(1)
print append(2)

>>> [1]
>>> [2]

此行为对于缓存等内容非常有用,但它可能很危险.

奖励功能:具有可变内容的元组:

a = (1,2,[3])
a[2][:] = [4] # OK
a[2] = [2] # crashes

Answer 61

在PHP中,字符串与函数指针一样好:

$x = "foo";
function foo(){ echo "wtf"; }
$x(); # "wtf"

不幸的是,这不起作用:

"foo"();

Answer 62

在Scala中,没有运算符,只有方法.所以a + b - c实际上是一样的a.+(b).-(c).在此,它等于Smalltalk.但是,与Smalltalk不同,优先考虑.规则基于第一个字符,因此被称为假设的方法*+优先于被调用的方法+*.例外,任何结束的方法=都具有相同的优先级==- 意义!!和!=(非假设方法)具有不同的优先级.

所有ASCII字母的优先级最低,但所有非ASCII(unicode)字符的优先级最高.因此,如果您编写了一个is比较两个整数的方法,那么2 + 2 is 1 + 3将编译并成为真.如果你用葡萄牙语写它é,那么2 + 2 é 1 + 3会导致错误,因为它会看到它2 + (2 é 1) + 3.

并且,为了使Scala中的运算符的WTF更加完善,所有以方式结束的方法:都是右关联而不是左关联.这意味着1 :: 2 :: Nil相当于Nil.::(2).::(1)而不是1.::(2).::(Nil).

Answer 63

在JavaScript中,方法的结果可以取决于放置样式括号.这是K&R样式,其中大括号放在方法签名之后和return语句之后:

var foo = function() {
  return {
    key: 'value'
  };
}

foo() // returns an object here

现在,如果我将此代码格式化为Allman样式,其中大括号总是放在一个新行上,结果是不同的:

var foo = function()
{
  return
  {
    key: 'value'
  };
}

foo() // returns undefined here

怎么会？在JavaScript中,如果您不自己动手,语言会在每行的末尾自动分号.那么最后一个代码片段真正发生的是:

var foo = function()
{
  return; // here's actually a semicolon, automatically set by JavaScript!
  {
    key: 'value'
  };
}

因此,如果您调用foo(),方法中的第一个语句将是一个return语句,它将返回undefined并且不会执行其他后续语句.

Answer 64

其他奇怪的事情:

在C++中,重写虚方法会隐藏该方法的所有其他重载.在Java中,这不会发生.这非常烦人.示例:http://codepad.org/uhvl1nJp

在C++中,如果基类具有公共虚方法foo()且子类具有私有方法foo(),则此私有方法将覆盖另一个私有方法!这样,只需将子类对象指针强制转换为超类对象指针,就可以调用类外的私有方法.这应该是不可能的:它违反了封装.不应将新方法视为旧方法的覆盖.示例:http://codepad.org/LUGSNPdh

在PHP中,您可以定义函数来接受类型化参数(例如,作为某个接口/类的子类的对象),令人讨厌的是,在这种情况下,您不能使用NULL作为实际参数值.示例:http://codepad.org/FphVRZ3S

Answer 65

我最喜欢的C++之一是"公共抽象混凝土内联析构函数":

class AbstractBase {
public:
    virtual ~AbstractBase() = 0 {}; // PACID!

    virtual void someFunc() = 0;
    virtual void anotherFunc() = 0;
};

我从Scott Meyers的Effective C++中偷走了这个.看到一个纯虚拟(通常意味着"抽象")和内联实现的方法看起来有点奇怪,但它是我发现的最好和最简洁的方法,以确保对象被多态破坏.

Answer 66

大约20年前,当我上次涉足MUMPS时,这些实现有一些奇怪的局限性.虽然主机MUMPS变得越来越流行,但MUMPS传统上是一种自托管语言:计算机语言,操作系统和数据库在一个包中.

MUMPS主要是关于它的数据库.本质上,一个巨大的多维哈希表,由一个B*树支持,可以非常快速地访问.语言和数据库之间也没有任何障碍:如果你想在那里存储某些东西,你只需在变量前加上一个符号,表明它将被保存到后备存储中.

另一方面,文件系统几乎不存在,对它的支持甚至更少.关于唯一可以做的是将程序从文件加载到内存中,并将内存中的任何内容发送回文件.并且在加载之前最好清除缓冲区,否则它会与先前的任何东西混合在一起.

因此,考虑到它的自托管性质和极端恶劣的文件系统,人们可能想知道这些程序是如何编辑的.事实上,编辑器本身是用MUMPS编写的 - 那么编辑器如何将程序存储在内存中而不用自己编写？

好吧,诀窍是能够将变量的内容作为源代码执行.然后,编辑器将自身加载到变量中,在其中执行,清除内存,然后在内存中加载,保存和编辑文件,始终从变量执行.

添加到这一事实,即所有的命令可以缩短为他们的第一个字母(除在Z命令,缩短为两个字母,这主要是处理文件系统),以及好奇心喜欢的事实,IF(I)设置一个变量,然后经咨询ELSE(E) - 当然,可以通过任何干预I或程序本身来覆盖.第二个想法,我认为整个语言都是WTF.然而,它有一个奇怪的吸引力.

Answer 67

在Ruby中,0在条件表达式中的计算结果为true.

Answer 68

在类C语言(包括C本身)中,您可以使用"向下转到"运算符:

for (x = 20; x --> 0;) {
    print x;
}

这将打印从19到0的数字.

Answer 69

绝对最差的WTF必须是Cobol改变的GOTO.

语法非常简单:"ALTER label1 TO GOTO label2",但调试运行时意大利面条的结果令人难以置信.

Answer 70

"Piet是由David Morgan-Mar设计的一种深奥的编程语言,其程序是看起来像抽象艺术的位图."

打印Piet的Piet程序

Answer 71

好吧,这个也是我最喜欢的很难找到的bug ...处理以零作为八进制数开头的整数.这导致了一个只在早上8到10之间显示的错误:

有一次,我帮助构建了一个自动回归测试,以便在晚上通过cron执行.它几乎适用于20人团队中的每个人 - 期望一个开发人员每隔一段时间抱怨自动测试失败,但是当手动运行时,一切正常.甚至一旦这可以手动复制.

好吧,原因是,我们根据date命令的输出对统计数据进行了一些计算(在bash中),这只是从早上8点到9点59分失败,因为我们将小时值读作" 08"(这是一个非法的八进制值,而"01" - "07"是有效的八进制值,从"10"开始,所有内容都被视为十进制)...

Answer 72

JavaScript日期充满了WTF.

var d = new Date("1/1/2001");

var wtfyear = d.getYear(); // 101 (the year - 1900)
// to get the *actual* year, use d.getFullYear()

var wtfmonth = d.getMonth(); // 0
// months are 0-based!

Answer 73

作为NHibernate的狂热爱好者,当我听到becomeSmalltalk 时,我感到非常激动......

a become: b

它实际上将a对象更改为b,这使得编写延迟初始化代理变得微不足道,因为对a的所有引用现在将引用b.很简约!

我认为它有资格作为一种奇怪的语言特征,因为没有其他语言具备我的知识能力.

Answer 74

在FoxPro中,如果我没记错的话,每个命令都可以缩写为4个字符,其他一切都被忽略,所以READ,READY,READINESS都是一样的 - 无论前4个字符被忽略之后是什么.向我解释它的人很喜欢这个功能,但我觉得它很令人毛骨悚然.

Answer 75

Common Lisp的format功能可以选择将数字打印为罗马数字.

在INTERCAL中,这是您将获得的唯一输出形式.

Answer 76

在C中,sizeof运算符不评估其参数.这允许人们编写看起来错误但正确的代码.例如,malloc()给定一个类型的惯用方法T是:

#include <stdlib.h>

T *data = NULL;
data = malloc(sizeof *data);

在这里,*data在sizeof运算符中不进行评估(data是NULL,如果进行了评估,则会发生坏事!).

无论如何,这允许人们为新手编写令人惊讶的代码.请注意,正确思想中的任何人都不会真正这样做:

#include <stdio.h>

int main()
{   
    int x = 1;
    size_t sz = sizeof(x++);
    printf("%d\n", x);
    return 0;
}   

这不打印1,2因为x永远不会增加.

对于一些真正的乐趣/困惑sizeof:

#include <stdio.h>
int main(void)
{
    char a[] = "Hello";
    size_t s1 = sizeof a;
    size_t s2 = sizeof ("Hi", a);
    printf("%zu %zu\n", s1, s2);
    return 0;
}

(只有当人们对数组,指针和运算符感到困惑时才会产生混淆.)

Answer 77

可能已经说过了(也许这对某些人来说不是那么奇怪)但我认为这很酷:

在Javascript中,声明函数接受的参数只是程序员的便利.通过函数调用传递的所有变量都可以通过关键字"arguments"访问.所以以下会警告"世界":

<script type="text/javascript">

function blah(){
alert(arguments[1]);
}

blah("hello", "world");

</script> 

请注意,虽然看起来这些参数可能存储在一个数组中(因为您可以以与数组元素大致相同的方式访问对象属性),但它们不是. arguments是一个Object,而不是一个数组(因此,它们是使用数字索引存储的Object属性),如下例所示(从Crockford的补救JavaScript页面获取的typeOf函数):

argumentsExample = function(){
    console.log(typeOf(arguments));

    anArray = [];
    console.log(typeOf(anArray));

    anObject = {};
    console.log(typeOf(anObject));
}

function typeOf(value) {
    var s = typeof value;
    if (s === 'object') {
        if (value) {
            if (typeof value.length === 'number' &&
                    !(value.propertyIsEnumerable('length')) &&
                    typeof value.splice === 'function') {
                s = 'array';
            }
        } else {
            s = 'null';
        }
    }
    return s;
}

argumentsExample("a", "b");

Answer 78

Java缓存整数对象实例,范围从-128到127.如果您不知道这一点,可能会出现以下情况.

Integer.valueOf(127) == Integer.valueOf(127); // true, same instance
Integer.valueOf(128) == Integer.valueOf(128); // false, two different instances

Answer 79

在我看来,能够在C#中输出范围内的枚举是非常奇怪的.想象一下这个枚举:

enum Colour
{
    Red = 1,
    Green = 2,
    Blue = 3
}

现在,如果你写:

Colour eco;
eco = (Colour)17;

编译器认为没问题.还有运行时.

有关详细信息,请参见此处

Answer 80

我很惊讶没有人提到大多数类似C语言的真正丑陋的switch-case实现

switch (someInt) {
    case 1:
    case 2: System.out.println("Forgot a break, idiot!");
    case 3: System.out.println("Now you're doing the wrong thing and maybe need hours to find the missing break muahahahaha");
            break;
    default: System.out.println("This should never happen -,-");        
}

好处是新语言得到了正确的实施.

Answer 81

x = x + 1

当我是初学者时,这很难消化,现在功能语言不使用它,这更难!

如果你没有看到这是怎么奇怪:考虑等号的声明断言,而不是分配动作,因为你使用的基本代数做的,那么这是说"零等于一个"的等价物.

Answer 82

Perl的:

可以编写一个完全由标点符号组成的程序.

这怎么可以工作？!

Answer 83

_{好的,既然问题将处于间歇模式,我将加入"乐趣"}

Go(又名Issue9)使用大写字母表示可见性:

• 如果您用大写字母命名,它将具有公共访问权限.

• 如果你使用小写,它将受到包保护:

包装外可见:

func Print(v ...) { 
}

包装外不可见

func print( v ... ) {
}

您可以在此原始答案中找到更多信息.

Answer 84

这里有一大堆奇怪的C功能:http://www.steike.com/code/useless/evil-c/

Answer 85

在Perl中你可以做到:

my $test = "Hello World";
substr($test, 0, 5) = "Goodbye";

print $test;

这可能用其他语言吗？

Answer 86

在JavaScript中,!!a第一次看到(作为转换为布尔值的方式).

Answer 87

我喜欢偷偷摸摸C中的八进制值:

int values[8] = { 123, 154, 103, 310, 046, 806, 002, 970 };

Answer 88

C++模板机制是Turing-complete:只要您在运行时不需要输入,就可以在编译时进行任意计算.随心所欲.或者你可以轻松编写一个从不编译的C++程序 - 但在语法上是正确的.

Answer 89

这是我最喜欢的一个,你可以在没有main()的情况下用Java做println.

这将编译并运行,给出println,但也是一个异常(java.lang.NoSuchMethodError:main)

class Test {
    static {
        System.out.println("I'm printing in Java without main()");
    }
}

Answer 90

这可能已经提到了,但是 -

PHP对八进制值的处理:

$a = 07; // 7 (as it should be)
$b = 08; // 0 (would be an error in any sensible language)
$c = 018; // 1 (again, should have been an error)
$d = 0A; // error (as it should be)

见这里:http://bugs.php.net/bug.php？id = 29676

还要注意关于bug的评论 - Derick将其称为一个功能(如引用"修复"所示),而不是一个bug,他声称它会"在脚本中使用数字的所有情况下显着减慢PHP" - 但是,为什么PHP会为0A引发错误？

我想人们可以写一本关于PHP古怪的书......

Answer 91

在Java中你可能会期望

byte b = 0;
b++;

等于

byte b = 0;
b = b + 1;

但事实并非如此.实际上,您会收到编译器错误,因为添加的结果是int类型,因此无法分配给字节变量b.当使用化合物操作者 ++的编译器自动插入浇铸在这里.所以

b++;

变

b = (byte) b + 1;

Answer 92

VBScript的日期/时间文字(为什么这仍然是如此罕见？):

mydate = #1/2/2010 5:23 PM#

If mydate > #1/1/2010 17:00# Then ' ...

编辑:日期文字是相对的(他们是技术上的文字,然后呢？):

mydate = #Jan 3# ' Jan 3 of the current year

VB.NET,因为它是编译的,不支持相对日期文字.仅支持日期或仅支持时间文字,但假设缺少的时间或日期为零.

编辑[2]:当然,有一些奇怪的角落案例提出相对日期......

mydate = #Feb 29# ' executed on 2010-01-05, yields 2/1/2029

Answer 93

为什么C#的List <T> .AddRange()不允许我添加T的子类型的元素？List <T> .Add()呢!
所有这一切都将是微软的一个额外的代码行:

public void AddRange<S>(
    IEnumerable<S> collection
) where S : T

Answer 94

在C#中,这应该至少生成编译器警告,但它不会:

public int Something
{
    get { return Something; }
    set { Something = value; }
}

调用时,它会导致您的应用程序崩溃,并且您没有获得良好的堆栈跟踪,因为它是StackOverflowException.

Answer 95

Javascript中的变量/函数声明:

var x = 1;
function weird(){
  return x;
  var x = 2;
}

weird()返回undefined ...即使赋值从未发生过,x也被"捕获".

同样,但并非如此出乎意料

function weird2(){
   var x;
   return x();
   function x(){ return 2 };
}

返回2.

Answer 96

我为客户端编写了一种编程语言(用于实验性地驱动自定义硬件),其中包含一些自定义类型(Curl,Circuit,...),每种类型只有2个值.它们可以隐式转换为boolean,但是(根据客户端的请求)可以在运行时更改此类型的常量的确切布尔值.

例如:Curl类型有两个可能的值:CW和CCW(顺时针和逆时针).在运行时,您可以通过简单的赋值语句更改布尔值:

ccw := true

因此,您可以更改这些类型的所有值的布尔含义.

Answer 97

ActionScript 3:

当对象使用其接口时,编译器无法识别从中继承的方法Object,因此:

IInterface interface = getInterface();
interface.toString();

给出了编译错误.解决方法是转换为Object

Object(interface).toString();

PHP:

.和+运营商.它有其合理的解释,但仍然"a" + "5" = 5看起来很尴尬.

Java(以及IEEE754的任何实现):

System.out.println(0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1);

输出 0.9999999999999999

Answer 98

Perl充满奇怪而又整洁的功能.

if 可以在语句之前或之后使用,如下所示:

print "Hello World" if $a > 1;    
if ($a > 1) { print "Hello World"; }

对于以下情况也是如此foreach:

print "Hello $_!\n" foreach qw(world Dolly nurse);

Answer 99

当我在大学时,我用一种名为SNOBOL的语言做了一些工作.整个语言虽然很酷,却是一个很大的WTF.

它具有我见过的最奇怪的语法.而不是GoTo,您使用:(label).如果有的话,谁需要:S(标签)(成功/真实时转到标签)和:F(标签)(失败时转到标签/假)并在行检查某些条件或读取文件时使用这些功能.声明如下:

H = INPUT :F(end)

将读取文件或控制台中的下一行,如果读取失败,将转到标签"end"(因为达到EOF或任何其他原因).

然后是$ sign运算符.这将使用变量中的值作为变量名称.所以:

ANIMAL = 'DOG'
DOG = 'BARK'
output = $ANIMAL

将值'BARK'放在控制台上.因为那不够奇怪:

$DOG = 'SOUND'

将创建名为BARK的变量(请参阅上面分配给DOG的值),并为其赋予值'SOUND'.

你看的越多,它就越糟糕.我所发现的关于SNOBOL的最佳陈述(来自链接文本)是"语言的强大功能及其相当惯用的控制流程特性使得SNOBOL4代码在编写后几乎无法阅读和理解."

Answer 100

在PHP中,"true","false"和"null"是常量,通常不能被覆盖.但是,通过在PHP> = 5.3中引入名称空间,现在可以在任何名称空间中重新定义这些常量,而不是全局名称空间.这可能导致以下行为:

namespace {
    define('test\true', 42);
    define('test\false', 42);
    define('test\null', 42);
}

namespace test {
    var_dump(true === false && false === null); // is (bool) true
}

当然,如果你想要你的真实,你总是可以从全局命名空间导入true

namespace test {
    var_dump(\true === \false); // is (bool) false
}

Answer 101

在Haskell:

let 2 + 2 = 5 in 2 + 2

收益率5.

Answer 102

在PHP中:

echo 'foo' == 0;    // echos '1'
echo 'foo' == true; // echos '1'
echo 0 == true;     // echos '0'
$foo = 'foo';
echo $foo['bar']    // echos 'f'

PHP有一些最烦人的类型强制...

Answer 103

LOLCODE!

整个语言本身.虽然不完全是WTF的事情,但我从来没有遇到过一种语言,这种语言在我脑海中以一种狡猾的卡通声音播放出来.我以前也没有看过代码,想要惊叹"aaaawwww cuuute!"

该程序显示数字1-10并终止

HAI
CAN HAS STDIO?
IM IN YR LOOP UPPIN YR VAR TIL BOTHSAEM VAR AN 10
    VISIBLE SUM OF VAR AN 1
IM OUTTA YR LOOP
KTHXBYE

Answer 104

在C或C++中,您可以使用Macros获得很多乐趣.如

#define FOO(a,b) (a+b)/(1-a)

如果FOO(bar ++,4)被传入,它将增加两次.

Answer 105

Perl文件句柄式操作符调用.

一开始,有

print "foo", "bar", "baz"; # to stdout
print STDERR "foo", "bar", "baz";

注意夸张的缺少逗号,以便您知道这是一个打印到文件句柄,而不是以字符串方式打印的文件句柄.这是一个肮脏的黑客.

语言升级滚动,他们制作适当的OO文件句柄并x FOO y, z, abc转入FOO->x(y, z, abc).有点可爱.相同的打印语句有效运行

STDERR->print("foo", "bar", "baz");

当你错过一个逗号,或者尝试运行类似hashof $a, $b, $c(没有括号的子程序调用)并且忘记将hashof函数从其实用程序包导入到命名空间时,通常会注意到这一点,并且您会收到一条关于"无法调用方法"的奇怪错误消息'hashof'通过包''字符串$a' '的内容.

Answer 106

在Python中:

>>> a[0] = "hello"
NameError: name 'a' is not defined
>>> a[0:] = "hello"
NameError: name 'a' is not defined
>>> a = []
>>> a[0] = "hello"
IndexError: list assignment index out of range
>>> a[0:] = "hello"
>>> a
['h', 'e', 'l', 'l', 'o']

这些切片分配也会给出相同的结果:

a[:] = "hello"
a[42:] = "hello"
a[:33] = "hello"

Answer 107

简单的挑选,Erlang充满了他们.例如,3种形式的标点符号,

a_function(SomeVariable) ->
  statements_end_with_commas(),
  case PatternMatching of
    0 -> now_we_end_with_semicolon;
    true -> except_the_last_one
  end.

%%  Function definitions end with periods!

Answer 108

在JavaScript(和我认为的Java)中你可以逃避这样有趣的角色:

var mystring = "hello \"world\"";

如果你想把一个回车放入一个字符串,那是不可能的.你必须使用\n像这样:

var mystring = "hello, \nworld";

无论如何,对于编程语言而言,这都是正常的和预期的.奇怪的是你也可以逃避这样的实际回车:

var mystring = "hello, \
world";

Answer 109

更多的平台功能而不是语言功能:在iPhone上,创建一个带有少量计算的无限循环并运行程序.你的手机会升温,外面很冷的时候你可以用它作为暖手器.

Answer 110

在C或C++中,sizeof如果参数不是类型,则括号对于参数是可选的:

void foo() {
  int int_inst;

  // usual style - brackets ...
  size_t a = sizeof(int);
  size_t b = sizeof(int_inst);
  size_t c = sizeof(99);

  // but ...
  size_t d = sizeof int_inst; // this is ok
  // size_t e = sizeof int; // this is NOT ok
  size_t f = sizeof 99; // this is also ok
}

我永远不明白为什么会这样!

Answer 111

VBScript中的括号标识符

VBScript有所谓的括号标识符,它是用方括号中包含的标识符,如下所示:

[Foo]

实际上,它们非常方便,因为它们允许您在保留字之后命名变量和例程,调用名称为保留字的第三方对象的方法,并且还在标识符中使用几乎任何Unicode字符(包括空格和特殊字符).但这也意味着你可以和他们一起玩得开心:

[2*2] = 5

[??????????, ???!] = [Hello, world!]

[] = "Looks like my name is an empty string, isn't that cool?"

For[For[i=0]=[0]To[To[To[0]
  [Next[To]([For[i=0])=[For[i=0]
Next

另一方面,如果您忘记这样的语句中的引号,括号标识符可能是一个问题:

If MyString = "[Something]" Then

因为这If MyString = [Something] Then是完全合法的语法.(这就是为什么必须使用带语法高亮的IDE!)

有关Eric Lippert博客中括号标识符的更多信息:

• VBScript Trivia:支架标识符和保留字不兼容性
• VBScript测验答案,第六部分

Answer 112

C/C++:

该高速逆平方根算法采用的IEEE浮点表示(维基百科复制的代码)的优势:

float InvSqrt(float x)
{
    union {
        float f;
        int i;
    } tmp;
    tmp.f = x;
    tmp.i = 0x5f3759df - (tmp.i >> 1);
    float y = tmp.f;
    return y * (1.5f - 0.5f * x * y * y);
}

Answer 113

在早期版本的Visual Basic中,没有"返回"语句的函数只是"返回无",没有任何类型的编译器警告(或错误).

当我每天必须处理这种语言时,这导致了最疯狂的调试会话.

Answer 114

在PHP中,字符串字母不能像在C中一样使用,你需要使用ord()和chr()为了从数字转换为char而反之亦然:"a" != 97,但是ord("a") == 97.

虽然,有一个例外:

for ($i = 'a'; $i < 'z'; $i++) {
    print "$i ";
}

将打印字母a到y.就像你期望的那样,就好像它是C风格的数据类型一样.

但是如果测试条件改变为<=它将不会像你想象的那样打印到z,而是a到yz!(共打印676件)

如果你将'z'更改为676项目列表中'z'之后出现的'aa',并<再次更改测试条件,您将看到只打印出"a"!不像你期望的那样.

如果您将增量器更改为$i+=2它将再次仅打印"a"!唯一的方法是按顺序使用$i++,$i++现在它的工作方式与预期的一样.

尽管如此,这在PHP中输出字母az的组合是一种很好的方式,尽管实际上很难使用它.

Answer 115

Perl中的字符串数学非常奇怪.

$ perl -E '$string = "a"; $string++; say $string'
b

$ perl -E '$string = "abc"; $string++; say $string'
abd

$ perl -E '$string = "money"; $string++; say $string'
monez

$ perl -E '$string = "money"; $string--; say $string'
-1

Answer 116

在PowerShell中,您可以重命名变量:

> $a = "some value"
> $b = "a"
> $c = "d"
> Rename-Item variable:$b $c
> $d
some value

间接间接!拿那个,PHP!

文字也有效:

> Rename-Item variable:d e
> $e
some value

Answer 117

我知道的体面和怪异编程语言的最大集合(今天1313),你会在这里找到:http: //99-bottles-of-beer.net/ 准备看到真正奇怪的东西;-)每个人都应该做他的选择

Answer 118

红宝石

Time.parse经常假装解析没有失败,now而是返回

require 'time'

Time.parse '2000-01-01 12:00:00'
# -> 2000-01-01 12:00:00 +0100

Time.parse '2000-99-01 00:00:00'
# -> ArgumentError: argument out of range ...

Time.parse 'now'
# -> 2010-08-13 21:26:13 +0200

Time.parse 'yesterday'
# -> 2010-08-13 21:26:18 +0200

Time.parse 'billion years ago'
# -> 2010-08-13 21:26:37 +0200

Answer 119

早期的FORTRAN,其中空白并不重要.(反Python!)

DO 20 I = 1, 10

含义:从这里循环到第20行,将I从1变为10.

DO 20 I = 1. 10

含义:将1.10分配给名为DO20I的变量.

有传言说这个漏洞撞毁了太空探测器.

Answer 120

在我看来,这不应该在C++中允许:

class A {
public:
  virtual string foo(){return "A::foo";}
};

class B : public A {
public:
  virtual string foo(){return "B::foo";}
};

int main () {
  B* b = new B();
  // In my opinion the following should not be allowed
  cout << b->A::foo() << endl;  // Will print "A::foo"
}

这似乎是正确的,但这意味着您不能覆盖方法而不允许子类的用户调用原始方法而不是新方法.

只需考虑一个集合的子类,您希望在向集合本身添加元素时增加元素的数量.

一个逻辑解决方案是覆盖add()方法以在添加元素之前增加计数器,但是新集合的用户可以使用旧方法向其添加元素,从而绕过增量并导致元素计数器不同意与集合的实际元素数量.

这在Java中是不可能的.

Answer 121

Java的访问修饰符对我来说是最近的WTF(因为我必须学习一点).

显然,包比类层次结构更贴心.我无法定义子类可见的方法和属性,但不能定义包中的其他类.为什么我要将课程内容分享给其他课程？

但是我可以定义包内的每个类都可见的属性和方法,但不能定义包外的子类.

无论我怎么想这个,我仍然看不到逻辑.切换访问修饰符并使受保护的行为像在C++中一样工作,并保持包私有修饰符不变,这是有意义的.现在它没有.

Answer 122

在C:

warning C4013: 'myfunc' undefined; assuming extern returning int

我记得由于某种原因没有看到警告(在一些遗留代码中太多了吗？)并且令人费解为什么从int转换导致编译器错误,其中使用非int返回函数.

编译器假设这样的东西是非常意外的.

Answer 123

从Java中的文本文件中读取一行.

BufferedReader in = null;
try {
   in = new BufferedReader(new FileReader("filename"));
   String str;
   str = in.readLine();
   if (str != null) {
      ...
   } 
} catch (IOException e) {
   ...
} finally {
   try {
      if (in != null) {
         in.close();
      }
   } catch (IOException e) {}
}

啊.虽然我承认这并不奇怪......只是邪恶.:-)

更短,更惯用的版本:

try {
   BufferedReader in = new BufferedReader(new FileReader("filename"));
   try {
       String str = in.readLine();
       while (str != null) {
          str = in.readLine();
       } 
    } finally {
        in.close();
    }
} catch (IOException e) {
    e.printStackTrace();
}

Answer 124

对我来说,它绝对是PLEASEINTERCAL中的修饰符.如果PLEASE看起来不够频繁,则该程序被认为是不够礼貌的,并且错误消息说明了这一点; 如果过于频繁,该程序可能会被过度礼貌地拒绝.

Answer 125

PHP作为一种完整的语言大多是WTF.

langauge定义(参见www.php.org)不是通过语法或标准来定义的,而是通过一堆"你可以写这个例子 "的部分来定义的(你能写出其他的东西,当然,只是猜测一下这个概括) ),诚实的上帝用户贡献说"但它做了这个wacko事情......".

我经常使用我们构建的PHP解析器遇到故障.这是最新的:

 "abc$A[define]def"

现在,PHP是PERL的一个(真正糟糕的)副本,因此它允许使用隐含的变量替换来构造字符串.字符串中的$ X表示"将$ X的值插入字符串",相当于"abc".$ X. "def"在哪里"." 是PHP的字符串连接运算符.

字符串中的$ A [7]表示"将数组$ A的第七个插槽的值插入字符串",相当于"abc".$ A [7]."高清".

现在,语言(网站)清楚地说"定义"是一个关键字,并且无论何时找到表达式,都无法使用它.所以上面包含"定义"的宝石做了什么？抛出语法错误？不,这是有道理的.

不,它实际意味着:

 "abc" . $A["define"] . "def"

只有在字符串中的简单数组访问中编写看起来像标识符(关键字或不是!)的东西时,它才会执行此操作.语言中没有其他地方会发生此行为.什么,写"abc $ A ["define"] def"是不合理的,所以PHP发明者不得不抛弃它？给我一个休息时间.(为了复合重罪,有一个"字符串中的复杂数组访问",当然它的工作方式不同.请查看"abc {$ A [define]} def";根据PHP网站的说法,这是非法的.

(原来PHP数组是关联哈希,所以按名称查找数组(井,哈希表)成员并不是一个可怕的想法).

语言充满了这样的陷阱.如果你喜欢"哎呀,看看我今天在我的子程序中发现了什么东西",你应该切换到PHP.

Answer 126

学习PowerShell时发现:

尝试猜测结果数组的样子:

$a = 1, 2
$b = 1, 2+3
$c = 1, 2*3

回答:

1, 2
1, 2, 3
1, 2, 1, 2, 1, 2

哎哟! 它激起了我对PowerShell及其背后的人的信心.

Answer 127

在JavaScript中:

var something = 12;

function nicelyCraftedFunction()
{
  something = 13;
  // ... some other code
  // ... and in Galaxy far, far away this:
  if( false ) // so the block never executes:
  { 
    var something; 
  }
}
nicelyCraftedFunction(); // call of the function

通常你会期望something变量的值为13.但不是在JavaScript中 - 变量有函数作用域,所以后面的声明会影响上游的所有内容.

在使用C/C++/Java表示法(如JS)的语言中,您会期望变量具有块范围,而不是像这样......

因此编译器甚至可以从最终生成的字节码中删除的死代码块仍然会在正常执行的其余代码中产生副作用.

因此something仍然是12- 在调用函数后不会改变.

Answer 128

INTERCAL中的一元运算符(AND,OR和XOR).

Answer 129

在MUMPS中,你可以有一个带偏移的GOTO.如果你有(我的MUMPS生锈...)

some_label if x=1 do_something
           else  do_something_else

然后是代码

           goto some_label+1

将跳转到ELSE声明......

Answer 130

我很喜欢Smalltalk中缺少运算符优先级

2*3 + 4*5 = 6 + 4*5 = 10*5 = 50

代替

2*3 + 4*5 = 6 + 4*5 = 6 + 20 = 26

这是由于smalltalk的对象性质以及消息从左向右传递的事实.如果消息*以3号作为参数发送到2,则该消息的响应为6.非常棒,如果你感觉邪恶,你甚至可以修补它.

Answer 131

在SQL中

NULL 不等于 NULL

所以你做不到:

WHERE myValue == NULL

这将始终返回false.

NULL != NULL

Answer 132

Forth的控制结构有些奇怪.首先,因为它是反向抛光符号语言,所以条件先于IF,如:

x 0 = IF

现在,要关闭条件块,可以使用关键字THEN:

x 0 = IF ." Equals zero!" THEN

现在真正的WTF开始了.IF编译条件向前跳转是什么,并在堆栈上放置跳转偏移的地址.当THEN被发现,它从堆栈中弹出该地址,计算实际的偏移量,然后再编译.的ELSE,而另一方面,编译一个inconditional向前跳,从栈中弹出一个地址,在堆栈中压入一个新的地址,计算用于弹出地址的偏移量,然后编译该偏移.意思是语法是这样的:

x 0 = IF ." Equals zero!" ELSE ." Not equal to zero!" THEN

第一个和第二个语句编译如下:

x LITERAL 0 = (0BRANCH) LITERAL offset SLITERAL" Equals zero!" (DOTQ)
x LITERAL 0 = (0BRANCH) LITERAL offset SLITERAL" Equals zero!" (DOTQ) BRANCH LITERAL offset SLITERAL" Not equal to zero!" (DOTQ)

为了加剧这种怪异,这种行为并没有隐藏起来.它是该语言的ANSI规范的一部分,可以通过构建自定义流控制结构或以有趣的方式组合它们来自由地利用它.例如,采取Forth的WHILE循环:

BEGIN x 10 < WHILE x 1+ to x REPEAT

BEGIN和之间的部分WHILE是任意代码,因此您实际上可以在单个控制结构中的条件测试之前和之后执行代码.这是设计,但以下,虽然允许,不是:

BEGIN DUP 2 > WHILE DUP 5 < WHILE DUP 1+ REPEAT 123 ELSE 345 THEN 

这利用了每个控制流字如何工作以组合两个WHILE语句,并且,为了引导,为每个出口添加不同的后循环代码.为了表明我不是在开玩笑,我只是从互联网上的代码中复制了那个小片段,只需稍加修改就可以简化它.

Answer 133

在MAXScript中,所有运算符都被视为相等.因此,a = b + c设置a等于b,然后计算总和a+c,并丢弃结果.

Answer 134

通知7.有效程序的示例:

    Chomsky is a room. 
    A thought is a kind of thing. 
    Color is a kind of value. 
    The colors are red, green and blue. 
    A thought has a color. It is usually Green. 
    A thought can be colorful or colorless. It is usually colorless. 
    An idea is a thought in Chomsky with description "Colorless green ideas sleep furiously." 
    A manner is a kind of thing. 
    Furiously is a manner. 
    Sleeping relates one thought to one manner. 
    The verb to sleep (he sleeps, they sleep, he slept, it is slept, he is sleeping) implies the sleeping relation. 
    Colorless green ideas sleep furiously. 

可以找到像这个图灵机模拟器的其他愚蠢.

Answer 135

C++ 1x Lambda:

[] (int x) { std::cout << x << std::endl; } ();

这些可以被滥用于一些奇怪的语法:

[](){}();[]{[]{}();}();

这是完全有效的C++ 1x.

Answer 136

到目前为止,我遇到的最奇怪的特征是BASIC方言中的"RETURN n"语句(不记得哪一个,这是大约28年前的事)."n"是可选的,默认为1.它可以是正数或负数,表示相对于调用GOSUB的哪一行是下一个执行的行.

例如,以下将输出"30":

10 GOSUB 200
20 PRINT "20"
30 PRINT "30"
100 END
200 RETURN +2

当我不得不将这个奇怪的BASIC编写的程序翻译成FORTRAN时,我遇到了这个问题.基本程序使用此功能相当多,返回基于各种条件不同的报表,我花了一段时间来理解其中的逻辑流程.一旦我理解了它,我就能编写一个更简单的程序版本.不用说,更简单的FORTRAN版本比原始的BASIC程序具有更少的错误.

Answer 137

在PHP中:

for ($s="a";$s<="z";$s++) echo $s.' ';

这将写:

a b c d e .. .w x y z aa ab ac ad .. ay az ba bb bc ... by bz ca cb ... yz za zb ... zx zy zz

Answer 138

VB.NET的设计者为了保持与Visual Basic 6.0的向后兼容性做了几件非常愚蠢的事情.当然,还不够,它实际上是兼容的,只是足以让事情变得更加反直觉.但最糟糕的是你不必初始化变量,因为它们已经存在,除非在极少数情况下它们不是.

    For i As Integer = 1 To 3
        Try
            Dim k As Integer
            k += 1
            MsgBox(k)
        Catch ex As Exception
            MsgBox(ex.ToString)
        End Try
    Next

这将打印1 2 3.

拥有一个你无法信任的功能不是一个功能,这是一个错误.说它是设计的只是使它成为一个设计错误,而不是一个实现错误.

Answer 139

我曾经写过一个有"strfry"运算符的编程语言:

"hello world"?
# => "wdo rlholle"

有用,是吗？

Answer 140

另一个C-ism.

int i= 0;
while( i != 12 ) {
    /* Some comment 
    i += 1;
    /* Another comment */
}

为什么不起作用？林特会告诉你.然而,C编译器通常会轻易地通过它.和我一样

当我弄清楚出了什么问题时,这是一个真正的WTF时刻.

Answer 141

这是一个缺乏一种特性,它是怪异的:Python中没有switch声明(尽管存在解决方法).

Answer 142

在javaScript中,NaN是一个全局变量.

Answer 143

我所知道的最奇怪的功能来自C++世界:SFINAE.

最糟糕的是它碰巧实际上非常有用,在BOOST中广泛使用SFINAE对我来说已经证明了.

Answer 144

Java Generics是WTF:

List<String> ls = new ArrayList<String>(); //1
List<Object> lo = ls; //2

2:非法(???)这令人费解,但你必须考虑下一步会发生什么:

lo.add(new Object());
String s = ls.get(0);

我们会将一个Object分配给一个String引用,哦,不!像这样,周围有许多陷阱.

Answer 145

大约20年前,我使用编译器编写了一个名为Coral的语言,它允许我声明writeonly变量!

但这是有道理的,因为它们是全球性的并且用作信号机制.一个进程会写一个值而另一个进程会读取它.

Answer 146

以下C#代码抛出NullReferenceException而不是print 1:

    static void SomeMethod(string format, params object[] args)
    {
        Console.WriteLine(args.Length);
    }

    static void Main(string[] args)
    {
        SomeMethod("blabla", null, "Ok here"); // print 2
        SomeMethod("blabla", null); // exception
    }

Answer 147

PHP

从在线文档:
string implode ( string $glue , array $pieces )- 使用字符串连接数组元素
注意:由于历史原因,implode()可以按任意顺序接受其参数.

这样可行: implode($someArray, $glue)

希望他们在PHP 6中消除这些历史怪癖.

Answer 148

在Java中

int x = 010;

这将x指定为值8.

在Java中以零开头的任何整数都假定为八进制.

Answer 149

在PHP中,您可以使用sigil和包含变量名称的字符串文字或变量来引用变量,例如:

${'foo'} = 'test';
echo $foo;

这将打印"测试".这种行为的奇怪之处在于你也可以使用非字符串作为变量名,例如:

${array()} = 'test';
echo ${array()};
${NULL} = 'test';
echo ${NULL};

现在我们有变量名为array()甚至是NULL!全部包含字符串"test".

Answer 150

C++:

void f(int bitand i){ //WTF
    i++;
}
int main(){
    int i = 0;
    f(i);
    cout << i << endl; //1
    return 0;
}

Answer 151

在Java中,如果x的值是NaN,则x == x返回false并x != x返回true.

Answer 152

JavaScript的:

parseInt('06'); // 6
parseInt('08'); // 0

Answer 153

整个Malbolge编程语言:http://en.wikipedia.org/wiki/Malbolge

Answer 154

Commodore BASIC的命令快捷方式.基本上大多数命令都有缩写形式,通常是第一个字母+(shift + 2nd letter).但是因为C64上的字符集默认为全部大写,所以这些命令看起来像奇怪的符号.这是一个简短的hello world示例:

也许有人有一个更好的例子,实际上有更多的肉,但对于长期计划,这看起来完全荒谬.

以下是缩写列表:http://www.c64-wiki.com/index.php/BASIC_keyword_abbreviation

Answer 155

寻找功能？为什么不用语言？

我喜欢PHP,但它似乎总是像这样构建"哦s***!我忘了这个!我们只是为函数添加另一个参数",结果如下:

str_replace($ search,$ replace,$ subject,...)
strstr($ subject,$ search,...)

注意额外的下划线和参数的不同顺序.

这是别的东西

$a = array( 'a', 'b', 'c', 'd');

print_r($a); //Prints array( 0 => 'a', 1 => 'b',    2 => 'c', 3 => 'd');
unset($a[2]); //Destroys the element 2 of the list
print_r($a); //Prints array( 0 => 'a', 1 => 'b',    3 => 'd');

Answer 156

在Perl中(没有"使用严格"或"使用警告"):

if(true==undef)
{
    print "True\n";
}
else{
    print "False\n";
}
if(undef)
{
    print "True\n";
}
else{
    print "False\n";
}
if(true)
{
    print "True\n";
}
else{
    print "False\n";
}

打印:

True
False
True

Answer 157

在JavaScript中:

1 / 0; // Infinity
1 / -0; // -Infinity

Answer 158

C#的默认继承模型赢得了我的投票:

public class Animal
{
    public string Speak() { return "unknown sound" ; }
}

public class Dog : Animal
{
    public string Speak() { return "Woof!" ; }
}

class Program
{
    static void Main( string[] args )
    {
        Dog aDog = new Dog() ;
        Animal anAnimal = (Animal) aDog ;

        Console.WriteLine( "Dog sez '{0}'" , aDog.Speak() ) ;
        Console.WriteLine( "Animal sez '{0}'" , anAnimal.Speak() ) ;

        return ;
    }
}

运行程序会产生以下结果:

狗说'Woof!' 动物说"未知的声音"

获得这种行为应该要求程序员走出程序员的道路.子类实例并没有停止它是什么,因为它已被上传到它的超类型.相反,您必须明确请求预期的(并且几乎总是需要的)结果:

public class Animal
{
    public virtual string Speak() { return "unknown sound" ; }
}

public class Dog : Animal
{
    public override string Speak() { return "Woof!" ; }
}

Answer 159

C++最令人烦恼的解析:

struct S
{
    S() {} //default constructor
};

int main() {

    S s(); // this is not a default construction, it declares a function named s that takes no arguments and returns S.
}

Answer 160

PL/SQL允许声明作为关键字的变量和函数名称.以下是可编译的PL/SQL:

create or replace 
  function function 
  return number  as
  return number;
begin 
  function.return := 4;
  return   return;
end function;
/

这创建了一个名为的函数function.后来:

SQL> select function from dual;

  FUNCTION
----------
         4

Answer 161

一个意想不到的特性是枚举def列表中的尾随逗号和C,C#,Ruby等中的数组初始化列表.

string[] foods = { "tofu", "grits", "cabbage", }

public enum ArtPeriod {
  Modern,
  Romantic,
  Dada,
}

Answer 162

在Javascript中,我相信以下内容是等效的:

a['title'] = "Syntactic sugar is good for yr teeth.";
a.title = "Syntactic sugar is good for yr teeth.";

Answer 163

VBScript的With块:

With xml.appendChild(xml.createElement("category"))
  .setAttribute("id",id)
  .setAttribute("keywords",keywords)
  With .appendChild(xml.createElement("item"))
    .setAttribute("count",count)
    .setAttribute("tip",tip)
    .appendChild(xml.createTextNode(text))
  End With
End With

Answer 164

Javascript中的许多东西可以让你的眼睛流水.

局部变量的范围,只是一个简单的例子:

function foo(obj)
{
  for (var n = 0; n < 10; n++)
  {
    var t;        // Here is a 't'
    ...
  }
  t = "okay";     // And here's the same 't'
}

Answer 165

MySQL的枚举,特别是它们能够将毫无准备的同事与生活地狱混为一谈.

CREATE TABLE foo (
    ....
    dispatched ENUM('0','1') NOT NULL DEFAULT '0',
)

然后:

UPDATE TABLE foo SET ..., dispatched = 1;

哎呀,dispatched被设置为ZERO,因为没有引用1.这让我的代码工作变得非常恼火; 我现在使用普通的旧INT.

在相关的说明中,即使您向枚举添加空字符串选项,例如

blah ENUM('','A','B') NOT NULL,

如果您指定了无效值blah,MySQL将使用一个秘密隐藏的空字符串值来表示无效值,这将很难与您自己添加的值区分开来.好极了!

Answer 166

在X ++(Microsoft Dynamics AX)中:

1)需要在单独的行上使用分号(;)来将变量声明与语句分开(至少最高版本为4.0)

    int i;
    int myArray[5];
    ;
    i = 1;

2)数组索引是从1开始的,因此不允许使用索引0(零)从数组中读取

    int myArray[5];
    ;
    print myArray[0];    // runtime error

这并不奇怪,但你可以在一个分配的左侧使用零索引,就像在

    int myArray[5];
    ;
    myArray[2] = 102;
    myArray[0] = 100;    // this is strange
    print myArray[2];    // expcting 102?

怎么了？无论赋值中使用了什么值,数组都会初始化为默认值.上面的代码输出0(零)!

Answer 167

在c#中

Math.Round(2.5)==2

Answer 168

在MATLAB(面向交互式数组的语言,目前为TIOBE 20)中,有一个关键字end表示数组的最后一个元素(它对应于NumPy -1).所以这是一个众所周知的MATLAB语法:

myVar = myArray(end)

要从数组中间获取元素,通常会写:

myVar = myArray( ceil( length(myArray)/2 ) )

令人惊讶的是,关键字end根本不是关键字,而是一种变量:

myVar = myArray( ceil( end/2 ) )

Answer 169

JavaScript中的变量赋值可以创建全局变量.如果变量是在函数内分配的值,并且未var在同一范围内声明它,则隐式声明为全局变量.

function foo() {
  x = "juhu";  // creates a global variable x!
  var y = "kinners"
}

foo();
alert(x); // alerts "juhu"
alert(y); // alerts undefined

请注意,在var为变量赋值后,也可以使用该语句:

function foo() {
  x = 12;
  var x; // x is now local
  return x;
}

alert(foo()); // will alert 12;
alert(x); // will alert undefined

Answer 170

在Matlab中,以下内容可能会令人惊讶,特别是如果您习惯使用Python:

>> not true

ans =

     0     0     0     0
>> not false

ans =

     0     0     0     0     0

这里有两个奇怪的功能.第一个被a b解释为a('b'),因此not true被解释为not('true').第二个奇怪的特征是not任何字符返回0(可能是因为没有false或true在matlab中,只有0或者1).

Answer 171

Atari BASIC:

您可以使用字符填充字符串而无需编写循环:

10 DIM A$(100)
20 A$(1)=" ":A$(100)=" ":A$(2)=A$

Answer 172

NSIS(Nullsoft脚本安装系统)具有以下StrCmp指令:

StrCmp str1 str2 jump_if_equal [jump_if_not_equal]

比较(不区分大小写)str1到str2.如果str1和str2相等,则Gotos jump_if_equal,否则Gotos jump_if_not_equal.

StrCmp $0 "a string" 0 +3
 DetailPrint '$$0 == "a string"'
 Goto +2
 DetailPrint '$$0 != "a string"'

锦上添花:jump_if_equal也jump_if_not_equal可能是负面的.但我想你已经从+正数前面的符号中找出来了.我不记得它是强制性的,还是只是一个可怕的约定.

这基本上结合了最差的BASIC和最差的汇编程序.

Answer 173

在Java中

String s = null;
System.out.println(s + "hello");

这输出"nullhello".

Answer 174

Python 2.x演示了一个糟糕的列表理解实现:

z = 4
s = [z*z for z in range(255)]
print z

此代码返回254.列表推导的变量与上限定义冲突.

Python 3.x已经解决了这个问题,但是闭包仍然使用动态链接来处理外部变量,并在函数式python程序员中引入了许多WTF

def mapper(x):
    return x*x
continuations = [lambda: mapper(x) for x in range(5)]
print( [c() for c in continuations])

这段代码显然会返回[16,16,16,16,16].

Answer 175

以下类似于这个关于数组的答案.

在Powershell中,与其他动态语言一样,字符串和数字在某种程度上是可以互换的.然而,Powershell无法下定决心.

PS> $a = "4"    # string
PS> $a * 3      # Python can do this, too
444
PS> 3 * $a      # Python doesn't do it this way, string repetition is commutative
12
PS> $a + 3      # Python gives a mismatched types error
43
PS> 3 + $a      # Python would give an error here, too
7

如果变量是整数而不是字符串,则操作是可交换的.

PS> $a = 4      # integer
PS> $a * 3
12
PS> 3 * $a
12
PS> $a + 3
7
PS> 3 + $a
7

如有疑问,请进行演员表演:

PS> $a = "4"
PS> $b = 3
PS> [int] $a * [int] $b
12

你也可以用[float].

Answer 176

不确定是否有人提到它.

在Java中,在finally块中它可以返回一个值.它将停止异常的传播并覆盖正常的return语句.