PHP

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和bar都会从缓存中检索相同的整数对象：例如： foo = new Integer(42)，因此在比较参考相等时，它们将是真实的而不是虚假的。比较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 (other than ALL of it),能够在一行中编写任何程序。

e.g。 Conway's Game of Life in one line in APL：

alt text http://catpad.net/michael/APLLife.gif

如果那条线不是WTF，那么什么都没有！

这是一个video

Answer 9

可以使用C ++模板的奇怪之处，"Multi-Dimensional Analog Literals"最好地展示了它使用模板来计算“绘制”形状的区域。以下代码是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-separators的奇怪变量
$! - 与errno类似，但strerror(errno)为字符串
$_ - 隐身变量，始终使用且从未见过
$#_ - 最后一个子例程参数的索引号...也许
@_ - 当前函数的（非）名称......也许
$@ - 最后提出的异常
%:: - 符号表
$:，$^，$~，$-和$= - 与输出格式有关的内容
$.和$% - 输入行号，输出页码
$/和$\ - 输入和输出记录分隔符
$| - 输出缓冲控制器
$[ - 将您的阵列基础从0更改为从1到基于42： WHEEE！
$} - 什么都没有，奇怪的是！
$<，$>，$(，$) - 真实有效的UID和GID
@ISA - 当前包的直接超类的名称
$^T - epoch seconds中的脚本启动时间
$^O - 当前操作系统名称
$^V - 这是什么版本的Perl

这些来自的地方还有很多。阅读完整列表here。

Answer 11

PHP处理字符串中的数值。有关详细信息，请参阅this previous answer to a different question，但简而言之：

"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

更多详情here。

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's device in 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

在Java中：

int[] numbers() {
  return null;
}

可以写成：

int numbers() [] {
  return null;
}

Answer 17

在Python中：

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

不是WTF，而是一个有用的功能。

Answer 18

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

COMEFROM大致相反 GOTO因为它可以执行从代码中的任意点开始的状态到COMEFROM语句。要点发生状态转移的代码通常作为参数给出来自。转移是否发生在指令之前或之后指定的转移点取决于使用的语言。取决于使用的语言，多个COMEFROM 引用相同的出发点可能无效，不确定，以某种定义的方式执行优先，甚至诱导平行或否则会看到并发执行在Threaded Intercal。一个简单的例子 “COMEFROM x”声明是一个标签 x（不需要位于其附近的任何地方作为一个相应的COMEFROM） “陷阱门”。代码执行时到达标签，控制权传递到后面的声明来自。这样做的效果是主要是为了进行调试（和了解控制流程程序）非常困难，因为标签附近没有任何迹象那种控制会神秘地跳到该计划的另一点。

Answer 19

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

f(1)

编译器会将常量池中常量1的地址传递给函数。如果为函数中的参数指定了值，则可以在程序中全局更改值（在本例中为值1）。引起一些头疼。

Answer 20

不知道它是否可以被认为是一种语言特性，但是，在C ++中，几乎所有与模板相关的编译器错误每天都会给全世界的许多C ++程序员带来相当多的WTF：）

Answer 21

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

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

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

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

Answer 22

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 23

我对此有点挣扎：

1;

在perl中，模块需要返回 true 。

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很长一段时间都是standard Unix command。

现在为“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的善良的人向我解释了整个事情： Why does 2 == [2] in JavaScript?

Answer 29

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

你最终只能用c ** 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问题。

Oracle将空字符串视为null。

处理“＆lt;＆gt;”中的空值比较。

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有一本关于它们的完整的书。

book 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值。大多数人并不真正理解JavaScript中void的真实本质，这可能导致许多令人讨厌的错误和奇怪的意外事情发生。

不幸的是，我认为void运算符是唯一真正保证在JavaScript中获取undefined值的方法，因为未定义，如另一个答案中所指出的，是一个可以重新赋值的变量名，并且{{ 1}}可以被{}.a

弄乱

更新：我想到了另一种生成Object.prototype.a = 'foo'的方法：

undefined

呃，虽然有点冗长，但回归“未定义”是其目的更为明显。

Answer 38

Perl拥有yada yada operator（...）。

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

if ($condition) { ... }

与
相同

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

Answer 39

在fortran中（肯定是77，也许在95中），未声明的变量和以I到N开头的参数（“in”组）将为{{1} }，以及所有其他未声明的变量和参数将为INTEGER （source）。结合“在某些情况下可选的空白”导致了最着名的错误之一。

正如Fred Webb在1990年REAL所说：

我在1963年夏天在美国国家航空航天局工作。我正在工作的小组   正在对任务控制中心计算机进行初步工作   系统和程序。我的办公室伙伴有测试的工作   在水星期间使用的轨道计算程序   航班。通过它运行一些已知答案的测试数据，他是   得到的答案很接近，但不够准确。所以，他   开始寻找算法中的数值问题，检查   确保他的测试数据真的正确等等。

几周后没有结果，他遇到了alt.folklore.computers   声明，格式为：
DO
编译器（正确地）将此语句解释为：
DO 10 I=1.10
程序员明确打算：
DO10I = 1.10
将DO 10 I = 1, 10更改为.后，程序结果正确无误期望的准确性。显然，该计划的答案是对于亚轨道水星飞行来说“足够好”，所以没有人怀疑一个错误，直到他们试图获得更高的准确性，在期待后来的轨道和月球飞行。据我所知，这个特殊的bug 从来没有因太空飞行的任何实际失败而受到指责，但是这里的其他细节似乎足够接近，我确信这件事是真的 ,故事的来源。

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

Answer 40

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

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

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

编译得很好。

语法突出显示有点破坏了这个笑话，但它仍然很有趣。

Answer 41

我不敢声称XML是一种编程语言，但它不是我们的心脏吗？： - ）

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

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

这是允许连续点的the lexical definition of NT-Name。

Answer 42

继承Ruby中的随机类：

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

（首次见于Hidden features of 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检查未定义的内容：

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标准所接受。可以在Table 22-8 in section 22.3.3 of Common Lisp the Language, 2nd Edition找到以下示例：

(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

MUMPS。有很多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语句，那么{{1 }}不取决于其上方行中的else，而取决于if内部评估的最后if！由于这个“功能”，MUMPS编码人员通常会教这样编写以上代码是安全的：

myTag

第一行末尾的if x>10 do myTag(x) if 1 else do otherTag(x)可确保在控件进入下一行之前正确设置if 1。（顺便说一句，这里的间距必须是这样的，在$TEST之后有两个空格，而在所有其他地方都有一个空格。间距是奇数，但至少一旦理解了模式就非常正交。）

Answer 50

ANSI SQL中nulls的三值逻辑。

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)。

更新： Here’s a jsPerf test case comparing the performance of these alternatives。

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 */
}

那条细微的线条完成以下任务：

声明BITMAPINFOHEADER结构
简洁地设置结构的“size”成员，而不用硬编码大小常量（因为许多Window结构，包括BITMAPINFOHEADER，遵循指定结构大小作为第一个成员的惯例}
声明结构的版本（因为许多Windows结构，包括BITMAPINFOHEADER，按照声明的大小标识它们的版本，遵循结构定义仅附加的约定）
清除结构的所有其他成员（结构未完全初始化时的C标准行为）。

Answer 55

爪哇;使所有对象实例都是互斥体。

Answer 56

在PHP中可以做到：

System.out.print("hello");

Answer 57

在JavaScript中：

alert(111111111111111111111) // alerts 111111111111111110000

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

Answer 58

在Python的else循环中

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 style，其中大括号放在方法签名之后和return语句之后：

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

foo() // returns an object here

现在，如果我将此代码格式化为Allman style，其中大括号总是放在新行上，结果会有所不同：

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 ++中如果基类具有 public 虚方法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;
};

我在 Effective C ++ 中从Scott Meyers那里偷了这个。看到一个纯虚拟（通常意味着“抽象”）和内联实现的方法看起来有点奇怪，但它是我发现的最好和最简洁的方法，以确保对象被多态破坏。

Answer 66

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

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

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

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

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

除此之外，所有命令都可以缩短为第一个字母（Z命令除外，缩写为两个字母，主要处理文件系统），以及IF（{{ 1}}）设置一个变量，然后由I（ELSE）进行咨询 - 当然，任何干预E或程序本身都可以覆盖它。第二个想法，我认为整个语言都是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”，但调试运行时spaghetti的结果令人难以置信。

Answer 70

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

Piet program that prints Piet

打印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爱好者，当我从Smalltalk听到become时，我感到非常激动......例如。

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属性），如下例所示（typeOf函数取自Crockford's remedial JavaScript page）：< / p>

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;

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

有关详细信息，请参阅here。

Answer 80

我很惊讶没有人提到大多数类似C语言的丑陋交换机案例实现

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

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

如果您没有看到这是多么奇怪：将等号作为断言的语句而不是赋值 action ，就像你以前在基本代数中所做的那样，这相当于说“零等于一”。

Answer 82

的Perl：

可以写a program consisting entirely of punctuation。

这是如何工作的？！

Answer 83

_{好的，因为问题将处于间歇模式，我将加入“有趣”}

Go（又名Issue9）使用大写字母表示可见性：

如果您使用大写字母命名，则可以公开访问。
如果你使用小写，它将受到包保护：

在包裹外可见：

func Print(v ...) { 
}

在包

之外不可见

func print( v ... ) {
}

您可以在此original answer.

中找到更多信息

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

另请注意有关该错误的评论 - Derick将其称为一项功能（如引用“修复”所示），而不是一个错误，他声称这将“在脚本中使用数字的所有情况下显着减慢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()会这样做！所有这一切都将是微软的 ONE 额外代码行：

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（）返回未定义 ...即使分配从未发生过，x也被“删除”。

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

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

返回2.

Answer 96

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

例如为： Curl类型有两个可能的值：CW和CCW（顺时针和逆时针）。在运行时，您可以通过简单的赋值语句更改布尔值：

ccw := true

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

Answer 97

ActionScript 3：

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

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

给出了编译错误。解决方法是转换为对象

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（来自link text）的最佳陈述是“语言的强大功能及其相当惯用的控制流程特性使得SNOBOL4代码在编写后几乎无法阅读和理解。”

Answer 100

在PHP中，“true”，“false”和“null”是通常无法覆盖的常量。但是，通过在PHP＆gt; = 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博客中括号标识符的更多信息：

Answer 112

C / C ++：

Fast Inverse Square Root算法利用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中，没有“Return”语句的函数只是“Return None”，没有任何编译器警告（或错误）。

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

Answer 114

在PHP中，字符串字母不能像在C中那样使用，您需要使用ord()和chr()才能将数字转换为字符串而反之亦然："a" != 97，但{ {1}}。

虽然有一个例外：

ord("a") == 97

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

但是，如果测试条件更改为for ($i = 'a'; $i < 'z'; $i++) { print "$i "; }，则不会像您想象的那样打印到z，而是打印到yz！（共打印676件）

如果您将6月项目列表中的'z'后面的'z'更改为'aa'，并再次将测试条件更改为<=，您将看到只打印了“a”出来了！不像你期望的那样。

如果您将增量器更改为<，它将再次仅打印“a”！唯一的方法是按顺序使用$i+=2，$i++，现在它的效果与预期的一样。

尽管如此，这在PHP中输出字母a-z的组合是一种很好的方式，尽管很难实际使用它。

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（）方法以增加计数器，但是新集合的用户可以使用旧方法向其添加元素，从而绕过增量并导致元素-counter不同意该集合的实际元素数量。

这在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

对我而言，这绝对是INTERCAL中的PLEASE修饰符。如果PLEASE经常出现不够频繁，则认为该程序不够礼貌，错误消息说明了这一点;如果过于频繁，程序可能会被过度礼貌地拒绝。

Answer 125

PHP作为一种完整的语言主要是WTF。

langauge定义（参见www.php.org）不是通过语法或标准来定义的，而是通过一堆“你可以写这个示例”部分来定义的（你能写吗？其他任何东西，当然，只是猜测一般化），诚实的上帝用户贡献说“但它确实做了这件事......”。

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

 "abc$A[define]def"

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

字符串中的$ [7]表示“将数组$ A的第七个插槽的值插入字符串”，相当于“abc”。 $ A [7]。 “DEF”。

现在，语言（网站）清楚地说“定义”是一个关键字，你不能无论你找到什么表达，都要用它。所以上面包含“定义”的宝石做了什么？抛出语法错误？不，这是有道理的。

不，它的实际含义是：

 "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编译一个无条件的向前跳转，从堆栈弹出一个地址，在堆栈上推送一个新地址，计算弹出地址的偏移量，然后编译该偏移量。意思是语法是这样的：

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

Inform 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.

可以找到像Turing machine simulator这样的其他愚蠢。

Answer 135

C ++ 1x Lambda's：

[] (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时，我遇到了这个问题。 BASIC程序使用此功能可以根据各种条件返回不同的语句，我花了一些时间来理解逻辑流程。一旦我理解了它，我就能编写一个更简单的程序版本。毋庸置疑，简单的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。

拥有一个你不能相信的功能100％的时间不是一个功能，这是一个错误。说它的设计只是使它成为一个设计错误，而不是一个实现错误。

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 has no switch statement（虽然存在变通方法）。

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上的字符集默认为全部大写，所以这些命令看起来像奇怪的符号。这是一个简短的问候世界的例子：

Commodore BASIC screenshot

也许有人有一个更好的例子，实际上有更多的肉，但对于长期计划，这看起来非常荒谬。

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

Answer 155

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

我喜欢PHP，但它似乎总是像这样构建“哦，我忘记了！我们只是在函数中添加另一个参数”，结果就是：

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中（没有“use strict”或“use warnings”）：

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 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（可能是因为matlab中没有false或true，只有0或{{1 }}）。

Answer 171

Atari BASIC：

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

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

Answer 172

NSIS（Nullsoft Scriptable Install System）有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. list comprehension的变量与上限定义碰撞。

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

以下内容类似于this answer，它与数组有关。

在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语句。

Answer 177

在Visual Basic 7及更高版本中，我发现了短路逻辑评估的实现，以保持与传统Visual Basic的兼容性＆lt; = 6代码有点像WTF：

AndAlso (MSDN)
OrElse (MSDN)

Answer 178

Perl的$[（已弃用），这在之前的另一篇关于泛型perl变量的文章中提到过，但值得特别提及并提供更好的解释。 $ [的变化仅限于当前范围。更多信息和快速撰写如何使用它及其含义;）可以在 $ [受到尊重 http://www.perlmonks.org/index.pl/?node_id=480333

中找到

Answer 179

对JavaScript的另一次投票：

parseInt('08') == 0

因为前导0的任何内容都被解释为八进制（奇怪），无效的八进制数被评估为零（BAD）。我发现这是八月份的一段时间，我几个月没有触及的代码就是自己破解了。事实证明，它将在10月份自行修复。

Octal支持显然已被弃用，因此未来几代JavaScripters将无法通过这种仪式。

Answer 180

在Perl中，对象只是bless ed refs，因此在运行时更改对象的类是一件小事：

package Foo;
sub new { bless {}, $_[0] }
package Bar;
package main;
my $foo = Foo->new;
ref($foo); # => "Foo"
bless $foo, 'Bar';
ref($foo); # => "Bar"

我很惊讶其他语言不能这样做。多么有用的功能！

Answer 181

有向图和替代标记

C（ISO / IEC 9899：1999,6.4.6 / 3）和C ++（ISO / IEC 14882：2003,2.5）具有很少使用的特征，被C称为“有向图”，“替代令牌”由C ++。这些与三字母不同，主要是因为包含它们的字符串文字永远不会被区别对待。

%:include <stdio.h>

int main() <%
    int a<:10:> = <%0%>;
    printf("Here's the 5th element of 'a': %d\n", a<:4:>);
    puts("Evil, eh? %:>");
    return 0;
%>

C ++还有更多，包括和，或，不，它们需要表现为&&，{{ 1}}和||。 C也有这些，但要求＆lt; iso646.h＆gt;包含使用它们，将它们视为宏而不是令牌。 C ++标题＆lt; ciso646＆gt;字面上是一个空文件。

值得注意的是，GCC实现了对这种奇怪语言功能的支持，但是在尝试编译上面的代码段时，许多其他编译器都会窒息而死。

Answer 182

在C ++中，你可以从空指针调用静态方法 - 看哪！

class Foo {
  public:
    static void bar() {
      std::cout << "WTF!?" << std::endl;
    }
};

int main(void) {
  Foo * foo = NULL;
  foo->bar(); //=> WTF!?
  return 0; // Ok!
}

那个让我惊讶的是......

Answer 183

PHP的列表构造：

$array = array(0,1,2);
list (,,$x) = $array;
$x == 2; // true

Answer 184

Forth可以随时更改数字的基数：

HEX 10 DECIMAL 16 - .
0 Ok

它不一定是一个预定义的：

36 BASE ! 1Z DECIMAL .
71 Ok

Answer 185

无论在哪里，变量都被视为Coldfusion中的全局变量。

<cffunction name="one" returntype="void">
    <cfset var wtf="coldfusion">
    <cfinvoke method="second">
</cffunction>

<cffunction name="two" returntype="void">
    <cfoutput>#wtf#</cfoutput>
</cffunction>

Answer 186

在Python中：

>>> x = 4
>>> y = 1000000
>>> x is 4
True
>>> y is 1000000
False
>>>

如果你不相信我就试试吧！

Answer 187

在php中：

easter_date - 获取给定年份复活节午夜的Unix时间戳

int easter_date（[int $ year]）

Answer 188

在Java中（实际上，我最近在不同的SO帖子上写过这个）：

    int x = 1 + + + + + + + + + + + + + 1;
    System.out.println(x);

Answer 189

SQLite允许您使用所需的任何数据类型声明列。它寻找一些特定的子串（“INT”，“REAL”，“TEXT”等）来确定亲和力。

这使得可以在你的类型声明中出现：

CREATE TABLE Quirks (
   X    FLOATING POINT,  -- = INTEGER affinity because of the "INT"
   Y    STRING,          -- = NUMERIC affinity
);

Answer 190

这个旧的PHP最喜欢的并不是它自己的 WTFish，但是范围分辨率错误是许多开发人员看到的事情之一，值得给予一些WTF爱：< / p>

$class = new StdClass();
$class::test();

PHP Parse error:  syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM on line 3

Answer 191

Fortran不同列的特殊含义。（如果你是用拳打卡长大的话，可能是完全自然的。）

这样的一个副作用是，例如在第72列之后，变量名称被截断。与IMPLICIT NONE结合使用时，当在第72列附近启动此类变量名称时，将静默引入新变量。

你需要

要注意这个
一个编辑器，它突出了另一个注释部分（在第72列之后）颜色比之前的部分...

Answer 192

用两个词来说：多重继承。没有任何意义，只会产生麻烦。

编辑 - 我指的是C ++中的MI，而不是Java和其他语言中的mixins等。

Answer 193

在多种语言的东西之间交替：

boolean b = true;
for(int i = 0; i < 10; i++)
  if(b = !b)
    print i;

乍一看：怎么能真的不等于自己！？这实际上只打印奇数

Answer 194

<强> Variable variables in PHP

PHP中的一个奇怪功能，它允许您从其他变量的内容创建和分配变量（警告，未经测试的代码）：

$a = 'Juliet';
$$a = 'awesome'; // assigns a variable named $Juliet with value 'awesome'

echo '$a';       // prints Juliet
echo '${$a}';    // prints awesome
echo '$Juliet';  // prints awesome

好吧，我们说我们有这样的事情：

$bob = 'I\'m bob';
$joe = 'I\'m joe';
$someVarName = 'bob';
$$someVarName = 'Variable \'bob\' changed';

各种间接的乐趣如何：

$juliet = 'Juliet is awesome!';
$func = 'getVarName'

echo '${$func()}'; // prints 'Juliet is awesome!'

function getVarName() { return 'juliet'; }

Answer 195

Perl的sub没有真正的参数列表，只有@_数组。此外，sub会自动展平传递给它的参数。

我不明白为什么这是一个持久的特征;这反映了我多年前在TI-86 BASIC上作为kludge所做的事情，因为语言功能不够。

Answer 196

C＃，命名空间重新编排顺序

例如。

namespace foo.bar.xyz{
  public class Foo{
    Exception e;   // you'll get compile time error here....
  }
}

由于

namespace foo.bar.Exception{
  class HowDoMyWayException : ApplicationException {
   // because someone did this
  } 
}

Answer 197

在C ++中，你可以这样做：

std::string my_str;
std::string my_str_concat = my_str + "foo";

但你不能这样做：

std::string my_str_concat = "foo" + my_str;

运营商超载通常受WTF的约束。

Answer 198

在ColdFusion数组中，从1开始。

Answer 199

不是这个用得很多，但是C ++的“返回对静态大小数组的引用”的语法很奇怪：

struct SuperFoo {
  int (&getFoo() const)[10] {
    static int foo[10];
    return foo;
  }
}

ofc，在上面的case中，方法可以声明为 static const

Answer 200

在Python中：

abs((10+5j)-(25+-5j))

返回~18.03，这是毕达哥拉斯定理点（10,5）和（25,5）之间的距离。发生这一事实是因为Python以2 + 2j的形式对复数进行本地语言支持。由于a + bj = sqrt（a ^ 2 + b ^ 2）形式的复数的绝对值，我们得到距离，同时从另一个中减去一个复数，然后在其上应用abs（绝对）函数。 / p>

Answer 201

功能：Bash，Korn shell（ksh93）和Z shell都允许带有或不带美元符号的变量的下标数组：

array[index]=$value
array[$index]=$value

这带有美元符号，将产生预期值10000：

unset array
for i in {1..10000}
do
    ((array[$RANDOM%6+1]++))
done
unset total
for count in ${array[@]}
do
    ((total += count))
done
echo $total

奇怪：如果您从RANDOM中删除美元符号，则总数会随机变化，甚至大于10000.

同样，这会产生3而不是2：

a=1; ((r[a++]++)); echo $a

你不能在那里使用美元符号，因为它是一个赋值（一个在lhs上），虽然如果你使用间接你可以这样做，但双重评估仍然会发生。

原因：使用美元符号，变量扩展在算术评估之前执行，因此只执行一次。没有美元符号，它执行两次，一次计算查找的索引，再次计算分配的索引（因此，实际上，循环中一步的赋值可能看起来像array[4] = $array[6] + 1扰乱数组）。

Answer 202

在PHP中

var_export('false' == 0);       // true

var_export('false' == true);    // true

var_export('false' == false);   // false

修改

正如@Kobi所提到的，它可能会发生，因为语言将任何值解释为“TRUE”，除了“FALSE”，但不是在PHP的情况下，事情比你想象的更奇怪！

这个案例在PHP手册的“字符串转换为数字”一章中有详细记载，其中说明了：

如果字符串以有效开头数值数据，这将是值用过的。否则，该值将为0 （零）。

以下是示例：

print (int) 'zero'; // 0 print (int) 'false'; // 0 // but print (int) '1 - one'; // 1

P.S。我发现这种隐式类型转换的危害性大于有用性。

Answer 203

Ruby Flip-Flops。条件语句中的“...”和“..”并不总是范围运算符：

(0..20).each do |x|
  if ((x%10) == 5)..((x%10) == 5)
    print "#{x} "
  end
end

(0..20).each do |x|
  if ((x%10) == 5)...((x%10) == 5)
    print "#{x} "
  end
end

这将输出：

5 15
5 6 7 8 9 10 11 12 13 14 15

..检查每次传递的两个语句，...仅检查每次传递中的“on”或“off”语句（取决于触发器状态）。他们是从awk和sed偷来的。

Matz在“The Ruby Programming Language”中写道：“Flip-flops是Ruby的一个相当模糊的特性，可能最好避免......”

Answer 204

在（MRI / C）Ruby和MacRuby（但不是JRuby）中导致年度翻转的整齐系统相关溢出如何导致更大数量的本地时间错误。这不是一个常见问题，但很奇怪：

$ ruby -version
ruby 1.8.7 (2009-06-12 patchlevel 174) [universal-darwin10.0]
$ irb
>> Time.at(67767976233550799)
=> Tue Dec 31 23:59:59 -0500 2147483647
>> Time.at(67767976233550800)
=> Wed Jan 01 00:00:00 -0500 -2147483648
>> Time.at(67768036191694799)
=> Wed Dec 31 23:59:59 -0500 -2147481749
>> Time.at(67768036191694800)
ArgumentError: localtime error
...
Maybe IRB bug!!

但这可能特定于64位环境。

Answer 205

因为我没有看到有人提到它... RPG 2或3（报告程序生成器...又名火箭推进垃圾）是迄今为止我用过的最棘手的语言。它几乎不对程序流程进行控制（在文件顶部输入，在底部退出），编程语句是根据使用固定字体在特定列中定义的字符定义的（想想PUNCH CARDS !!）。

要成为FUBAR，你必须尝试在DYL-280中编程。它将RPG流和逻辑与COBOL语法相结合。

在这里查看RPG：wikipedia.org / wiki / IBM_RPG

DYL-280的一个例子：http://99-bottles-of-beer.net/language-dyl-280-224.html

Answer 206

对于那些不知道的人，PostScript实际上是一种编程语言。我对它有点疯狂 - 我写了一个PostScript程序，它将Mandelbrot分形计算得非常高。它是真正可打印的PostScript，虽然它会使许多打印驱动程序崩溃......

无论如何，从哪里开始使用PostScript ......这里有一个：你实际上可以创建一个标识符为......的变量。

（）cvn 5 def％将数字5分配给......无

PostScript是一种基于堆栈的语言。（）在堆栈上放置一个空字符串。 cvn将其转换为名称（如果打印它，则为“/”，因为PS中的所有名称前面都有斜杠）。然后5 def为其分配值5。（％是评论字符）

你无法直接取回它，例如如果我说“/ print”，这将不会打印数字5.但你可以间接地取回它：

（）cvn load print％这将打印数字5

还有什么... PostScript将字典作为本机类型，您可以使用数组引用作为字典的键...但是REFERENCE是键，而不是数组。所以：

/ myDict 100 dict def

[0] dup myDict exch 42把myDict exch get ==％prints 42

myDict [1] 42把myDict [1] get％抛出一个未定义的错误

编辑：哦，是的，还有一件有趣的事情......在Ghostscript提示下尝试以下操作：

1 array dup dup 0 exch put ==

D'哦！

Answer 207

这是Perl调试器中的一些问题：

  DB<1> sub foo { +(1..20) } 
  DB<2> @bar = foo(); # list of 1, 2, 3, 4...20
  DB<3> x scalar @bar # size of list
0  20
  DB<4> x scalar foo();
0  ''

没错。当您调用这样的方法时，来自scalar的标量上下文会向下传播到子例程调用中，将看似无害的..转换为完全不同的运算符。（这是“触发器”操作符，而不是范围操作符。）

Answer 208

我的一个C ++收藏夹：

#include <iostream>
using namespace std;
int main()
{
    cout <<  3 << 5  << endl;
    cout << (3 << 5) << endl;
    return 0;
}

当然，这很容易解释，但它开始让编程学生摸不着头脑！

Answer 209

PHP 反对

来自http://www.php.net/manual/en/language.operators.execution.php

PHP支持一个执行操作符：反引号（``）。请注意，这些不是单引号！ PHP将尝试作为shell命令执行反引号的内容;将返回输出（即，它不会简单地转储到输出;它可以分配给变量）。

$output = `ls -al`;
echo "<pre>$output</pre>";

在代码中发现`而不是'是非常容易的。

这也很有趣：

经过多次麻烦，我得出结论，反引号运算符（和shell_exec）有一个有限缓冲区用于返回。我的问题是，我正在使用超过500,000行的文件，收到超过100,000行的响应。经过短暂的停顿，我被grep关于管道关闭的错误充斥着。

Answer 210

RSL编程语言用于一个奇怪的银行系统。数组有内置类TArray。但是如果你继承它，每个实例变量都会成为数组的一个元素。

class (TArray) DerivedArray
  var someField = 56;
end

var a = DerivedArray();
PrintLn(a.Size);     // => 1
PrintLn(a[0]);       // => 56

Answer 211

FORTRAN不是一个真正的WTF时刻，而是更多的是“为什么我需要输入所有这些垃圾时刻”

IF(12 .gt. 11) THEN
 // Do some magic
ENDIF

“.gt。”在我玩这种语言的时候把我扔掉了，直到我意识到它是“＆gt;”符号。哦，我不喜欢不是一个生物学专业，每天都不得不涉足这个废话

Answer 212

在Bash中，变量看起来既是标量又是数组：

$ a=3
$ echo $a
3
$ echo ${a[@]}    # treat it like an array
3
$ declare -p a    # but it's not
declare -- a="3"
$ a[1]=4          # treat it like an array
$ echo $a         # acts like it's scalar
3
$ echo ${a[@]}    # but it's not
3 4
$ declare -p a
declare -a a='([0]="3" [1]="4")'
$ a=5             # treat it like a scalar
$ echo $a         # acts like it's scalar
5
$ echo ${a[@]}    # but it's not
5 4
$ declare -p a
declare -a a='([0]="5" [1]="4")'

ksh做同样的事情，但使用typeset代替declare。

在zsh中执行此操作时，您将获得子串赋值而不是数组：

$ a=3
$ a[2]=4          # zsh is one-indexed by default
$ echo $a
34
$ a[3]=567
$ echo $a
34567
$ a[3]=9
$ echo $a
34967
$ a[3]=123         # here it overwrites the first character, but inserts the others
$ echo $a
3412367
$ a=(1 2 3)
$ echo $a
1 2 3              # it's an array without needing to use ${a[@]} (but it will work)
$ a[2]=99          # what about assignments?
$ echo $a
1 99 3

Answer 213

在Common Lisp中，零维度的数组很奇怪，当然，它们具有读取语法。

? (aref #0A5)
5

Answer 214

我多年前使用的Fortran编译器有一个有趣的特性：（a）数字首先存储为高字节; （b）数字按地址传递给子程序; （c）没有编制时间长度检查。

所以你可以编写一个这样的程序:(对不起，如果我弄乱了语法。自从我编写Fortran以来已经很长时间了。）

INTEGER*2 FUNCTION TIMESTWO (INTEGER*2 N)
RETURN N*2

... THEN CALL THIS SOMEWHERE WITH A LONG INTEGER ...

INTEGER*4 I, J

I=42
J=TIMESTWO(I)

J的最终值是......零！

为什么呢？因为传入的值是4个字节，但被调用的函数只查看前两个字节。由于前两个是零，它将零加倍并返回它。然后将此返回值转换回四个字节。

当我第一次遇到它时，这是非常神秘的。我传入某些函数的几乎所有数字都被解释为零！

Answer 215

Perl的CORE :: open和标准库，具有使用过程接口屏蔽的面向对象元素： open ( my $fh, '>', 'foobar' ); open是一个构造函数，它对my()返回的引用进行操作，并接受参数'＆gt;'和'foobar'。而且，这是一个有福的类型的对象（意味着它不能在对象内部保持状态）。

有关我的perlmonks的更多信息，请发送 IO :: File vs CORE :: open ：http://www.perlmonks.org/?node_id=763565

Answer 216

我认为这个实际上并不是一个“语言特征”（C）而且我很可能在发布它时一直无知，但我无法理解为什么会发生这种情况，所以我会问。如果它与一些奇怪的语言特征有关......好吧，它真的让我“WTF”，所以它值得这个地方。

int a = 0;
int *p = &a;

printf("%d, %d, %d.\n", *p, (*p)++, *p); // Outputs "1, 0, 0.\n" on MinGW's GCC 4.4.1

为什么？

- 编辑

刚刚得到它，并没有什么大不了的。我现在可以感觉到C ++大师在嘲笑我。我猜测函数参数的评估顺序是未指定的，因此编译器可以随意调用它们（我想我已经在boost文档中的某处读过它）。在这种情况下，参数语句被反向评估，可能反映了函数的调用约定。

Answer 217

在Lisp中你可以复制一个列表，你可以复制一个向量，你可以复制一个结构，你可以复制一个CLOS对象......

...但您无法复制数组或哈希表。

Answer 218

JCL条件执行。

//STEP02 EXEC PGM=PROG02,COND=(4,GT,STEP01) .

此功能允许您根据前面步骤的返回代码运行或不运行步骤。真的很不错。

除了一些小功能外，它们将逻辑内外翻转。

如果条件为真，则首先不运行步骤。

其次4，GT，STEP01实际上意味着“如果STEP01的返回代码大于4”

所以整个意思是“如果STEP01的返回代码大于4，则不要运行此步骤”。这与天真的解释几乎但不完全相同“如果4大于STEP01的返回代码则运行步骤”。

鉴于只有你认真看待这些事情的时间是凌晨2点30分左右，在线路的另一端有一个疯狂的夜班操作员，这种双重模糊导致严重的头痛。

Answer 219

反向波兰表示法（RPN）。这意味着参数在函数之前。或者，换句话说，您可以通过编写2 2 +来添加两个和两个。

WTF的语言包括Forth，Postscript（是的，激光打印机）和因子。

Answer 220

奇怪的东西 - 同时包含Null关键字和Nothing关键字（Null）的VBScript缺少数据而Nothing是缺少的对象）。为什么不只有一个关键字......？大多数其他语言似乎都很好！

Visual Basic 6.0和当然“经典ASP”代码（因为它使用VBScript）具有相同的奇特性。在Visual Basic旧版和新版中，我们还有DBNull。

然而，情况正在改善，因为Visual Basic.NET Null最终消失，因此Null未被使用，仅使用Nothing和DBNull。

Answer 221

在COBOL中惹恼我的一件非常小的事情是没有专门的模运算。相反，你可以做一个除法，指定你只想要整数结果并将其余的存储在另一个变量中。由于COBOL对变量非常敏感，这意味着你最终得到了一个你并不真正需要的变量，即除法的实际结果。这是我曾经如何命名变量“USELESS”的故事 - 这是我能想到的最合适的名字。

Answer 222

我无法相信这个还没有在这里： JSF属性访问。

在JSF UI标记中，您可以通过引用它将服务器端对象的属性值放入接口：

<h:inputText value="#{myObject.property}></h:inputText>

问题是Java不支持属性，因此您必须编写以get和set开头的方法，以便将UI对象链接到服务器上的“属性”。

public void setProperty(String property){...}
public String getProperty(){...}

当我第一次学习JSF时，这让我很困惑，我仍然认为它值得WTF ...尽管在Java实现对C＃风格属性的支持之前，实际上没有别的方法可以做到这一点。

Answer 223

在SQL server（至少MS）中：

这将始终评估为false：

IF @someint <> NULL

假设：

DECLARE @int INT

SET @int = 6

IF @int <> NULL
BEGIN
    Print '@int is not null'
END
ELSE
BEGIN
    Print '@int is evaluating to null'
END

输出将是：

@int is evaluating to null

必须写成：

IF @someint IS NOT NULL
BEGIN
END

谁将英语专业学生放在SQL团队中！：）

Answer 224

在Ruby中......

i=true
while(i)
   i=false
   a=2
end
puts defined?(a) // returns true

Answer 225

这不是一个奇怪的功能，事实上，如果你考虑它会让我感觉完全有意义，但不过给了我一个WTF时刻。

在C ++（和C＃中）中，基类的子类无法访问基础实例上的私有成员和受保护成员。

class Base {
protected:
 m_fooBar;
};

class Derived: public Base {
public:
 void Test(Base& baseInstance) {
  m_fooBar=1; //OK
  baseInstance.m_fooBar = 1; //Badness
  //This, however is OK:
  ((Derived&)baseInstance).m_fooBar = 1; //OK
 }
};

Answer 226

英语虚拟语气。

等等，你是说编程语言吗？然后使用C中的(macro)绕过#define的预处理器macro()。例如，如果某人有#define free(...)，(free)(...)将与free(...)不同。

Answer 227

在PHP中，以下内容：

<?php $foo = 'abc'; echo "{$foo";

是语法错误。

如果您确实想要{，然后是$foo的内容，则必须使用.：

<?php $foo = 'abc'; echo '{' . $foo;

Answer 228

Processing（processing.org）是一种基于Java的语言。简单来说，处理编译器是Java预处理器，它将特定于Processing的语法转换为Java。

由于语言的设计，它有一些惊喜：

Processing的类被编译成Java内部类，这会引起一些烦恼，就像非私有的私有变量一样

class Foo {
  private int var = 0; // compiles fine
}

void setup() {
  Foo f = new Foo();
  print(f.var); // but does not causes compile error
}

也缺少draw（）函数导致不调用事件处理程序：

// void draw() {} // if you forgot to include this
void mousePressed() {
  print("this is never called");
}

Answer 229

在C ++中，能够创建受保护的抽象虚拟基础纯虚拟私有析构函数。

这是一个纯虚拟私有析构函数，它继承自受保护的抽象虚拟基础。

IOW，一个析构函数，只能由类（私有）的成员或朋友调用，并且在声明它的基类（抽象基础）中被赋予0（纯虚拟），并且将被定义稍后/覆盖在以受保护的方式共享多重继承的基础（虚拟基础）的派生类中。

Answer 230

技术上不是语言WTF，而是架构。

http://www.6502.org/tutorials/6502opcodes.html#JMP

6502汇编，间接JMP：

请注意，没有与间接跳转关联的进位，所以：

间接跳跃绝不能使用

在最后一个字节上开始的矢量

OF A PAGE

例如，如果地址$ 3000包含40美元，$ 30FF包含80美元，3100美元包含50美元，则JMP（$ 30FF）的结果将是控制权转移到4080美元而不是5080美元，即6502采用低字节$ 30FF的地址和$ 3000的高字节。

因此，在代码中添加单个字节可能会使您的间接跳转远离目标。

Answer 231

Perl可以自动将基地26转换为基地10，如果你能在早上住在一起......

$ perl -E "say lc (@a='a'..'asdf')"
30530

Answer 232

其余的这些在令人震惊的Ruby Flip-Flop操作员上没有任何内容：

p = proc {|a,b| a..b ? "yes" : "no" }

p[false,false]    => "no"
p[true,false]     => "yes"
p[false,false]    => "yes"   # ???
p[false,true]     => "yes"
p[false,false]    => "no"

是的，程序状态存储在解释器的解析树中。这样的事情是为什么需要永远制作一个兼容的Ruby实现。但我原谅你，Ruby＆lt; 3

Answer 233

SA = “一个=” “一个=” “” “一个” “” “@一个= ”“ ”“ 2N ”“ ”“ 中，a = ”“ ”“ C = ”“ ”“ _（” “” “22” “” “？@ a）中，@一个””，@ A，A = “” 一个 “”，A（C）= “” S + “” _ C，E = $ T（@@一个@ （C））”，@一个

这是COS中的一个很好的单行（缓存objectscript）。这里有趣的是5种不同的代码间接模式* G

Answer 234

COMEFROM任何人？

Answer 235

在俄亥俄州立大学，他们使用名为Resolve / C ++的混蛋C ++语言教授编程。 Resolve / C ++使用逐个设计的方法来处理所有事情。它要求您在数学中对编译的注释中的组件和方法进行数学建模，以便它强制您维护方法和对象之间的需求/确保关系。

Answer 236

回想起来，FORTRAN的计算goto很奇怪。 Wikipedia tells me一些BASIC超越它。

另一个着名的喜爱是Algol 60的call by name参数传递。

Answer 237

我一直想知道Java Core库的Math类中此函数的用途：

static double expm1(double x);  // Returns e^x - 1.

Answer 238

在C＃中，为什么这不合法？

public class MyClass<T>
    where T: Enum
{

}

能够在Enum上添加扩展方法以及Func＆lt; T＆gt;是非常酷的。其中T将是您要扩展的枚举，以便您可以在该枚举上获得类型推断。

重新评论：是的，你可以扩展一个实际的枚举，但这是差异：

你可以这样做：

public static void DoSomethingWithEnum(this Enum e)
{
   //do whatever
}

但如果您想使用与您的枚举类型相同的方法获取Func，该怎么办？

public static void DoSomethingWithEnum<T>(this T e, Func<T,bool> func )
   where T: Enum
{
   //do whatever
}

这样，您可以这样调用您的方法：

DayOfWeek today = DayOfWeek.Monday;
today.DoSomethingWithEnum(e => e != DayOfWeek.Sunday);

或类似的东西。你明白了......那是不可能的，我不知道为什么......

Answer 239

C＃yield语句，不是很奇怪，但很有用。

http://msdn.microsoft.com/en-us/library/9k7k7cf0(VS.80).aspx

Answer 240

这并不奇怪或令人惊讶，但让我总是说 WTF ：

语法或标识符名称中的区分大小写。

大多数拥有它的语言似乎都拥有它，因为C拥有它。这没有充分的理由。

Answer 241

在SQL Server中，如果在生产代码中使用select *，可能会产生令人讨厌的惊喜。使用select *无论如何都不被认为是一种好习惯，但了解一些有趣的行为是很好的。

有关详细信息，请参阅问题“select * from table” vs “select colA,colB,etc from table” interesting behaviour in SqlServer2005

Answer 242

Haskell使用Maybe和Just。 Maybe a是一种类型构造函数，它返回Just a类型，但Maybe Int不接受Int，它要求它是Just Int或Nothing。所以在本质上，在哈斯克尔的说法中Just Int就像一个苹果就像橙子一样多。唯一的连接是Just 5返回Maybe Interger类型，可以使用函数Just和Integer参数构造。这是有道理的，但理论上很难解释，这是哈斯克尔的目的吗？那么Just真的是JustKindaLikeButNotAtAll是的，而Maybe真的是KindaLooksLikeOrIsNothing，再次有点了。

-- Create a function that returns a Maybe Int, and return a 5, which know is definitly Int'able
>  let x :: Maybe Int; x = 5;
<interactive>:1:24:
    No instance for (Num (Maybe Int))
      arising from the literal `5' at <interactive>:1:24
    Possible fix: add an instance declaration for (Num (Maybe Int))
    In the expression: 5
    In the definition of `x': x = 5

>  Just 5  
Just 5
it :: Maybe Integer

    -- Create a function x which takes an Int
>  let x :: Int -> Int; x _ = 0;
x :: Int -> Int
-- Try to give it a Just Int
>  x $ Just 5                   

<interactive>:1:4:
    Couldn't match expected type `Int' against inferred type `Maybe t'
    In the second argument of `($)', namely `Just 5'
    In the expression: x $ Just 5
    In the definition of `it': it = x $ Just 5

祝你好运阅读本文，我希望是对的。

Answer 243

什么数据类型是foo？

SELECT TOP 1
   NULL AS foo
INTO
   dbo.bar
FROM
   sys.columns --trivial

为什么一切都归零？

SELECT CAST('' AS int), CAST('' AS datetime), CAST('' AS float)

......除了这个

SELECT CAST('' AS decimal)

Answer 244

在MySQL中，字符串比较不区分大小写。

> SELECT * FROM blah WHERE foo = 'BAR';
> SELECT * FROM blah WHERE foo = 'Bar';
> SELECT * FROM blah WHERE foo = 'bAr';

都是平等的。它们不仅会匹配任何看起来像'bar'的foo值（例如，如果foo ='bar'它将匹配BAR，baR，bAR等）。

Answer 245

不久前，当我第一次在我的CS课程中找到C语言时，看到指针的行为方式是非常奇怪的。我们只是编写程序并猜测它会做什么，直到它们得到正确的行为

Answer 246

C预处理器及其用法。具体来说，预处理器元编程并使用预处理器生成可移植代码 - 完全精神错乱。

Answer 247

Labeled break and continue statements in Java.。

它们允许您通过一次中断来打破多个控制块。

Answer 248

C＃有一个名为“扩展方法”的功能，它大致类似于Ruby混合 - 实际上，你可以为任何预先存在的类定义添加一个方法（例如，你可以添加“reverse（）”到字符串，如果你是如此倾向）。仅此一点很好 - “奇怪”部分是您可以将这些扩展方法与方法体和所有内容一起添加到接口。一方面，这可以方便地将一个方法添加到不属于同一继承树的整个类中。另一方面，您正在为接口添加充实的方法，从根本上打破了接口的定义。

Answer 249

尝试，除了 else

try:     pass
except:  pass
else:    pass
finally: pass

如果没有捕获到异常，则执行else部分。

有道理，但起初我真的不知道它的作用。

Example：

def show_square(string):
  try:
    n = int(string, 10)
  except ValueError:
    print "I can't do that, Dave."
  else:
    print n * n

Answer 250

Python的三元运算符

在Python中，C三元运算符（C ++示例：bool isNegative = i < 0 ? true : false;）可用作语法糖：

>>> i = 1
>>> "It is positive" if i >= 0 else "It is negative!"
'It is positive'
>>> i = -1
>>> "It is positive" if i >= 0 else "It is negative!"
'It is negative!'

这不是一个奇怪的功能。奇怪的是，与C中的（IMO更符合逻辑）顺序（条件？A：B）相比，改变了顺序（A，如果条件为其他B）。

Answer 251

在C中，a[b][c]与c[b[a]]完全相同。

Answer 252

在PHP中，您必须显式引用全局变量并明确地将 this-＆gt; 用于类变量。使重构变得有趣。如果没有找到所有使用点，则无法将变量/参数提升为全局或类成员。

Answer 253

的Perl

my %h1 = map { $_ => 1 } qw/foo bar baz/;    // construct an 'is_member' type lookup table
my %h2 = map { "$_" => 1 } qw/foo bar baz/;

第二行是语法错误，即使对于经验丰富的perl程序员来说它看起来也是相同的。 perl的缺点总是试图做你的意思，而不是你说的。

Answer 254

这让我惊艳

#define _ -F<00||--F-OO--;
int F=00,OO=00;main(){F_OO();printf("%1.3f\n",4.*-F/OO/OO);}F_OO()
{
            _-_-_-_
       _-_-_-_-_-_-_-_-_
    _-_-_-_-_-_-_-_-_-_-_-_
  _-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
  _-_-_-_-_-_-_-_-_-_-_-_-_-_
    _-_-_-_-_-_-_-_-_-_-_-_
       _-_-_-_-_-_-_-_
           _-_-_-_
}

Answer 255

Smalltalk：

在类Test中有一个类方法，它返回一个常量字符串：

method1
    ^ 'niko'

你应该期望这个方法不断返回字符串'niko'无论发生什么。但事实并非如此。

s := Test method1

（设为'niko'。）

s at: 4 put: $i.

（将s设置为'niki'。）

s := Test method1

（再次设置为'niki'。）

所以，即使方法的源代码没有更新，第二行代码也会永久地将method1更改为'niki'而不是'niko'。

Answer 256

移;

有时你会在perl方法的第一行看到它来读取自指针

Answer 257

在ColdFusion中

Struct （又名Java HashMap）通过引用传递。

您认为其他数据类型的行为与Java相似......

数组 按值传递，wtf！

列表只是一个普通的旧逗号分隔字符串！

Answer 258

在Unity中，

GameObject.Find("MyObject")

将正常返回您的对象。但是，如果你这样做：

GameObject.Find("MyObject").active = false;
//do other stuff
if (GameObject.Find("MyObject").active)
{
    //do stuff
}

然后你会得到一个空引用。在Unity iPhone中，此代码在编辑器中通常可以正常工作，但在从iPhone运行时会产生SIGBUS。问题是GameObject.Find（）只会找到活动对象，所以即使你只是检查它是否处于活动状态，你实际上是在调用if（null.active）。

为了使其正常工作，您必须在使其无效之前存储它。

GameObject obj = GameObject.Find("MyObject");
obj.active = false;
//do other stuff
if (obj.active)
{
    //do stuff
}

无论如何，这可能是更好的做法，但Unity一般对待非活动对象的方式非常奇怪。它似乎卸载了大部分非活动对象（纹理等），但不是全部，因此非活动对象仍然会占用大量内存。

Answer 259

在J中，大多数基元（a.k.a.函数）是monadic（一个参数）或二元（两个参数，一个在左边，一个在右边）。但是修正原语需要3个（我认为它是除了foreigns之外的唯一一个）。这是可以理解的，它需要3，但它看起来只是......起初错了。

vector =: i. 10   NB. Vector will be 0 1 2 3 4 5 6 7 8 9
(10) (0) } vector NB. Will yield 10 1 2 3 4 5 6 7 8 9

Answer 260

在J中，foreigns（!:）是各种功能。左边的参数是一个类别，右边通常是（但不总是）不同的东西的增量值。例如：

    2!:55 NB. Close console
    9!:10 NB. Set print precision
    6!:0  NB. Actual time
    6!:2  NB. Execution time
    4!:3  NB. Loaded scripts

当然，聪明的事情是包装它们，但有些你只是承诺记忆。顺便说一下，所有这些都是三元一词，右边有2个参数，左边有一个参数。除非您给出最终有效参数，否则上述任何一项都无效。

Answer 261

在awk中，数组从索引1开始，这最令人困惑。

Answer 262

在Python中，至少对我来说，这非常糟糕！我第一次看到它：

>>> "ja " * 5
'ja ja ja ja ja '

你可以乘以字符串！ WTF ??

PS：我认为这是因为x * n表示：n times x所以，5 times "ja "是"ja ""ja ""ja ""ja ""ja "，因为您可以连接这样的字符串：

>>> "ja ""ja ""ja ""ja ""ja "
'ja ja ja ja ja '

这两个代码具有相同的结果（也许是相同的）

Answer 263

ruby中的隐式变量\常量和可变常量

Answer 264

在C＃中，以下代码生成编译器错误“无法从方法组转换为委托”。虽然背后的逻辑是合理的，但我仍感到很奇怪。

control.BeginInvoke(delegate { DoSomething(); });

Answer 265

Java源文件可以以字符\u001a（control-Z）结尾。

Answer 266

在Java中，Strings如何处理==运算符取决于它的构造方式存在一些不一致。

String a = "Hello";
String b = "Hello";
System.out.println(a == b ); // prints true.
String c = new String("Hello");
String d = new String("Hello"); 
System.out.println(c == d ); // prints false

Answer 267

这是关于python的一个：

>>> print 07
7
>>> print 08
  File "<stdin>", line 1
    print 08
           ^
SyntaxError: invalid token

这不是美女吗？

当你想到人类的写作日期时会特别无意义，这会产生以下影响：

datetime.date(2010,02,07) # ok
datetime.date(2010,02,08) # error!

（原因是0x被解释为八进制，因此print 010打印8！）

Answer 268

在Scheme中有 no 保留标识符。因此，以下表达式的计算结果为1：

((lambda (lambda) lambda) (let ((let 1)) let))

请注意，给定范围内的定义存在限制：没有定义可能会重新定义用于在该范围内定义标识符的标识符，因此以下是语法错误：

(begin (define define 1) define)

Answer 269

我想到的第一件事就是'noop'，当我第一次遇到它时，我的大脑做了同样的事情！

Answer 270

我不知道它是否仍然是真的，但我们偶然发现VS FORTRAN（66或77）不支持递归。递归是偶然的，我们的默认F77支持它很漂亮，但当我们把源代码发送到IBM - Whatta Mess。

Answer 271

C＃中的“动态”。

为每个必须与RAD或python受害者一起工作的人破坏了一天，因为Intellisense，类型安全和确定性会在第一次使用“dynamic”关键字时立即死亡。

Answer 272

在ColdFusion中，文本值会自动转换为各种数据类型以用于各种目的。我遇到了一个奇怪的问题，其中“00A”和“000”的回归是平等的。原来，ColdFusion将“00A”解释为时间，转换为某种数字时间格式，并将其转换为0.“000”被转换为0.因此它们都被认为是等价的。那时我学会了字符串的比较函数。

Answer 273

很久以前，我用BUT语句构建了一种语言。

Answer 274

Haskell再一次：

在Haskell中，您可以处理一个任意大小的文件，就好像它是一个简单的String。如果实际使用该字符串，则只读取该文件。由于Haskell令人难以置信的懒惰，这样的程序将在恒定的空间中运行，无论文件的大小如何：

main = interact (>>= \x -> if x == '\n' then "\r\n" else [x])

（此程序将文件从stdin转换为stdout并用CRLF替换LF，interact函数输入整个stdin到函数并将输出移动到stdout。）

这种懒惰也可能会导致问题，因为如果你关闭一个文件句柄，你就不能完全不知道，懒惰的Haskell是否已经解析了它的所有数据。

Answer 275

我试图找出一个绝对毫无意义但无论如何都工作的MACRO。这对于objective-c也是如此，但对于其他类型的C（或至少是gcc编译器）也可能如此

NSString *oneString = @"This " @"is " @"just " @"one " @"normal " @" string";

等于

NSString *oneString = @"This is just one normal string";

对于C样式字符串

也是如此

char* str = "this " "also " "works";

Answer 276

Go's伪常数Iota：

type ByteSize float64
const (
_ = iota;   // ignore first value by assigning to blank identifier
KB ByteSize = 1<<(10*iota); MB; GB; TB; PB; YB;
)

Answer 277

Tcl虚拟化解释器中的时间钩子很奇怪： http://www.tcl.tk/cgi-bin/tct/tip/233.html

基本上，它允许您使解释器使用其他一些时间数据源，例如：首先在模拟器中运行硬件测试，然后再更换计时器功能，并针对真实事件运行相同的测试。

Answer 278

呼叫/立方厘米。 Call / cc将表示程序其余部分的函数传递给它的主体。

Answer 279

在JavaScript中，2.0 - 1.1 = 0.8999999999999999。这是规范中实现浮点数的结果，所以它总是这样。

Answer 280

这是我认为很奇怪的一个：

在C / C ++中，至少在MS C ++中你可以拥有任意数量的分号：

int main(void)
{
 cout<<"Hello World";;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;;
 return 0;;;;;;;;;;;;;;;;;;;;;;;
}

Answer 281

在C ++中，我发现奇怪且令人反感的是“虚拟”MI（多重继承）允许“菱形”类层次结构“工作”

A : Base class, e.g. "Object" B, C: both derive (virtually or not) from Object and D: derives from both B and C

问题：“正常”继承导致D为2种不明确的A类。“虚拟”MI将B的A和C的A折叠为单个共享基础A对象。

所以，即使你的Wheel是一个物体而你的左前轮是一个轮子而你的车继承了四种轮子，你的车仍然只是一种具有虚拟MI的物体。否则，你的汽车不是一个物体，而是四个轮子物体。

这是一种语言功能，可以奖励糟糕的课程设计，惩罚编译器编写者，让你在运行时想知道对象到底是什么 - 以及是否有任何虚拟MI行李放错地方。

如果您真的需要类层次结构中的菱形图案，可以使用常规MI和委托给单个A基础的“AProxy”来完成。

A : Base class, e.g. "Object" AProxy: Base class, constructs with other A to bind to B : derives from A C : derives from AProxy D : derives from both B and C (passing B's A to C's AProxy at construction)

对于那些真正喜欢钻石MI 的人来说，这需要更多的工作，让我们其他人安静下来，拥有更易处理的语言特征。

Answer 282

Java中的

String("aaa")==String("aaa") //false
//you need to use
String("aaa").equals(String("aaa")) // true

Answer 283

在C中，

 int x = 1;
 int y = x++ + ++x;
 printf("%d", y);

不明确，打印的内容取决于编译器。编译器可以在评估++ x之前或在语句结束时存储x ++的新值。

Answer 284

Delphi不关心像“word”这样的类型转换，并且会在数组arr [0..65535]之外读取，其中pos = 65535： arr[word(pos + 10)]

Answer 285

在PHP中：

<?php
$o = new stdClass;
echo count($o);
?>

..打印1.永远不知道为什么。

Answer 286

PHP （再次？）

首先：(unset)类型转换。

$a = 1;
$b = (unset)$a;
var_dump($a); // 1
var_dump($b); // NULL

用法：http://www.php.net/manual/en/language.types.type-juggling.php#89637

第二：= NULL和unset()功能之间的差异。

$c = 10;
$d = &$c;
$c = NULL;
var_dump($c); // NULL
var_dump($d); // NULL


$e = 10;
$f = &$e;
unset($e);
var_dump($e); // NULL
var_dump($f); // 10 - WTF?

Answer 287

此C程序在x86与x86-64上打印不同的结果：

#include <stdio.h>
int main (void)
{
  long a = -1; 
  unsigned b = 1; 
  printf ("%d\n", a > b); 
  return 0;
}

Answer 288

对于那些从未使用过COBOL的人来说，这是一个常见的代码行，但它并没有你想到的那样做

PIC XXX

Answer 289

С＃：

var a = Double.Parse("10.0", CultureInfo.InvariantCulture); // returns 10
var b = Double.Parse("10,0", CultureInfo.InvariantCulture); // returns 100

在不变文化中，逗号不是小数点符号，而是组分隔符。

据我所知，对于某些语言环境的新手程序员来说，这是常见的错误。

Answer 290

PHP

PHP对实例变量和方法的重载处理不一致。考虑：

class Foo
{
    private $var = 'avalue';

    private function doStuff()
    {
        return "Stuff";
    }

    public function __get($var)
    {
        return $this->$var;
    }

    public function __call($func, array $args = array())
    {
        return call_user_func_array(array($this, $func), $args);
    }
}

$foo = new Foo;
var_dump($foo->var);
var_dump($foo->doStuff());

$var的转储有效。即使$var是私有的，也会为任何不存在或不可访问的成员调用__get()，并返回正确的值。对于doStuff()，的情况不是，它失败了：

Fatal error: Call to private method Foo::doStuff() from context ”.”

我认为很多这些都是用C风格的语言工作，但我不确定。

将here文档作为函数参数传递：

function foo($message)
{
    echo $message . "\n";
}

foo(<<<EOF
    Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc
    blandit sem eleifend libero rhoncus iaculis. Nullam eget nisi at
    purus vestibulum tristique eu sit amet lorem.
EOF
    );

您可以在参数列表中指定变量。
```
foo($message = "Hello");
echo $message;
```
这是有效的，因为赋值是一个返回指定值的表达式。这是最常见的C风格错误之一的原因，执行任务而不是比较。

的Python

在Python中，可变的默认函数参数会导致意外的结果：

def append(thing, collection=[]):
    collection.append(thing)
    return collection

print append("foo")
# -> ['foo']
print append("bar")
# -> ['foo', 'bar']
print append("baz", [])
# -> ['baz']
print append("quux")
# -> ['foo', 'bar', 'quux']

空列表在函数定义时初始化，而不是调用时，因此对它的任何更改都会在函数调用中持续存在。

MySQL案例敏感性

MySQL有非常不寻常的区分大小写规则：表格区分大小写，列名称和字符串值不是：

mysql> CREATE TEMPORARY TABLE Foo (name varchar(128) NOT NULL);
DESCRIBE foo;
ERROR 1146 (42S02): Table 'foo' doesn't exist
mysql> DESCRIBE Foo;
+-------+--------------+------+-----+---------+-------+
| Field | Type         | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+-------+
| name  | varchar(128) | NO   |     | NULL    |       |
+-------+--------------+------+-----+---------+-------+
1 row in set (0.06 sec)
mysql> INSERT INTO Foo (`name`) VALUES ('bar'), ('baz');
Query OK, 2 row affected (0.05 sec)

mysql> SELECT * FROM Foo WHERE name = 'BAR';
+------+
| name |
+------+
| bar  |
+------+
1 row in set (0.12 sec)

mysql> SELECT * FROM Foo WHERE name = 'bAr';
+------+
| name |
+------+
| bar  |
+------+
1 row in set (0.05 sec)

Answer 291

在C：

int main() {
  int i = 0;
  int array[] = {1,2};

  return (i[array] + 1 == array[i]);
}

该程序将返回1（真）。

Answer 292

任何内容都会自动复数或单个化任何类和成员名称。

Linq-to-Sql，例如

Answer 293

不知道它是否是一个功能。对某些人来说，是的，但对于其他人来说，这可能是一种恼人的行为。无论如何，我认为值得一提。

在Python中，内置函数round()在Python 2x和Python 3x之间的行为略有不同。

对于Py 2x，

>>> round(0.4)
0.0
>>> round(0.5)
1.0
>>> round(0.51)
1.0
>>> round(1.5)
2.0

对于Py 3x，

>>> round(0.4)
0
>>> round(0.5)
0
>>> round(0.51)
1
>>> round(1.5)
2

我只是不熟悉Py 3x中的round()使用0的方式。

Py 2x和Py 3x中round()的文档。

Answer 294

在Python中：

i = 1
++i
print i

打印'1'。行'++ i'求值为+（+ i）（Python不支持递增运算符）

Answer 295

在C＃中，您可以在界面上使用new运算符。

Answer 296

一般来说，打字很弱。

C：

printf("%c\n", 'a' + 3);

PHP：

echo 5 + "3";

还有太多其他语言。

Answer 297

COMEFROM是我见过的最奇怪，也可能是最无用的语言功能。

亚军将是三元运算符，因为它违反了优化的规则＃1。而且它解决问题的危害更大。它会带来更多伤害，因为它会降低代码的可读性。

不是真正的语言功能，但有趣/令人敬畏的功能使用是Duff's device。

Answer 298

Modula-2没有elseif或else if;它有elsif

Answer 299

Java的Integer类的基本转换静态方法。：P似乎很少有语言能够内置这种功能。

Answer 300

今天所有语言：

TypeA a = (TypeA)some_operation_returning_TypeB(1,2,3); // TypeB is not inheriting TypeA

在运行时因“转换为TypeA失败的异常”-message（或类似）而失败。这告诉我们的是程序员究竟是多么懒惰。他们无法生成消息“无法为TypeA分配变量'a'，其值为'some_operation_returning_TypeB（1,2,3）'的TypeB”。 Noooo ......他们的座右铭是“犯错误的人必须受苦”。

Answer 301

我发现Javascript Date Object对110年的喜爱令人愉快。试试吧。

<Script language ="JavaScript">
<!--
var now = new Date()
var dia = now.getDay()
var mes = now.getMonth()
var fecha

//Day of the week
if(dia==0){
 fecha="Domingo, ";
}else if(dia==1){
 fecha="Lunes, ";
}else if(dia==2){
 fecha="Martes, ";
}else if(dia==3){
 fecha="Miércoles, ";
}else if(dia==4){
 fecha="Jueves, ";
}else if(dia==5){
 fecha="Viernes, ";
}else{
 fecha="Sábado, ";
}

fecha = fecha + now.getDate() + " de "
//Which month is it?
if(mes==0){
 fecha=fecha + "Enero"
}else if(mes==1){
 fecha=fecha + "Febrero"
}else if(mes==2){
 fecha=fecha + "Marzo"
}else if(mes==3){
 fecha=fecha + "Abril"
}else if(mes==4){
 fecha=fecha + "Mayo"
}else if(mes==5){
 fecha=fecha + "Junio"
}else if(mes==6){
 fecha=fecha + "Julio"
}else if(mes==7){
 fecha=fecha + "Agosto"
}else if(mes==8){
 fecha=fecha + "Septiembre"
}else if(mes==9){
 fecha=fecha + "Octubre"
}else if(mes==10){
 fecha=fecha + "Noviembre"
}else{
 fecha=fecha + "Diciembre"
}

//Year
fecha = fecha + " del " + now.getYear()

document.write(fecha);
//-->
</Script>

脚本是西班牙语 - 如果您不理解代码，请抱歉。想法是让您看到110年的结果。

Answer 302

在Python中，每个字符串都包含空字符串。

answer = input("Enter 'Y[es] or N[o]:")
if answer in 'YyNn':        # verify input
    process(answer)

只需按上述查询返回，就会将answer设置为空字符串，通过if answer in ...测试，并作为正确答案处理。更简洁地说：

>>> "ABCDEFGHIJ".__contains__("")
True

像往常一样，Python在这里的行为在数学上和逻辑上都是无可挑剔的。我从很久以前的集合理论中回忆起：空集是每一组的成员。

在我被它咬过的少数情况下仍然令人惊讶，但我不会有任何其他方式。

Answer 303

在MOD_REWRITE中

RewriteRule ^([a-zA-Z0-9_-]+)\.php$ $1/ [R,NC]
RewriteRule ^([a-zA-Z0-9_-]+)/$ $1\.php [NC,L]

将导致：

"file.php > file > file.php > file > file.php > file >  ..."

最后：

Error 500 Too Many Redirects

（一般来说，我发现编辑.htaccess文件与构建正常运行的正则表达式一样乏味。）

Answer 304

PHP

$ php -r '::'
Parse error: syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM

WTF？ http://en.wikipedia.org/wiki/Scope_resolution_operator

为什么不说unexpected T_SCOPE_RESOLUTION_OPERATOR？

Answer 305

的Perl。

打印“Foo \ n”除非$ foo;

Answer 306

2000年Perl期刊的混淆Perl竞赛中最佳参展作品：

#:: ::-| ::-| .-. :||-:: 0-| .-| ::||-| .:|-. :||
open(Q,$0);while(<Q>){if(/^#(.*)$/){for(split('-',$1)){$q=0;for(split){s/\|
/:.:/xg;s/:/../g;$Q=$_?length:$_;$q+=$q?$Q:$Q*20;}print chr($q);}}}print"\n";
#.: ::||-| .||-| :|||-| ::||-| ||-:: :|||-| .:|

其作者在http://mysite.verizon.net/les.peters/id2.html

完整解释了该代码

Answer 307

C ++（或Java）中没有封装的事实。任何对象都可以违反任何其他对象的封装，乱用其私有数据，只要它是相同的类型。例如：

#include <iostream>
using namespace std;

class X
{
  public:
    // Construct by passing internal value
    X (int i) : i (i) {}

    // This breaks encapsulation
    void violate (X & other)
    {
        other.i += i;
    }

    int get () { return i; }

  private:
    int i;
};

int main (int ac, char * av[])
{
    X a(1), b(2), c(3);

    a.violate (c);
    b.violate (c);
    cout << c.get() << endl;    // "6"
}

Answer 308

在C＃中： a = cond？ b：c; 如果'b'＆amp; 'c'是“赋予不兼容”，你永远不会得到结果，即使'a'是对象。它经常被使用，并且是MS中最常见的操作员。为了比较，请参阅D语言中的实现（关于类型推断的注释）。

Answer 309

Objective-C使用@表示字符串。示例：@“这是一个字符串。”

Answer 310

在C。

int a;

（＆amp; a）[0] = 10; / *将值10分配给* /

（＆amp; a）[0]相当于*（＆amp; a +0），它给我们*（＆amp; a），它只不过是一个。

Answer 311

在java中（这是导致赋值的if语句）

result = (Boolean condition) ? (if Boolean is true) : (if Boolean is false);

或

data Nat = Z|S Nat deriving Show
nattoInt Z = 0
nattoInt (S a) = 1 + nattoInt a

buildNat 0 = Z
buildNat a  =  S (buildNat (a - 1))

在Haskell中...我仍然不太明白这是如何定义自然数的（我完全理解理论:-p）

Answer 312

我绝对会感谢Perl有多个可怕的例子：

if(!$#var)

或

if($mystring =~ m/(\d+)/) {

Answer 313

在c ++中

const char* wtf()
{
    char buf[100];
    return buf;
}
string s = ... + wtf() + ...;

在s中创建有趣的值。部分字符串，部分堆栈内容，与零混合，以便s.length（）！= strlen（s.c_str（））。最奇怪的是编译器在返回指向堆栈的指针时绝对没有问题 - 编译器程序员如果在那里添加警告就可能会失败。

Answer 314

在JavaScript中：

2 == [2]

//甚至更奇怪 2 == [[[2]]]

//右下角的坚果 var a = {“abc”：1}; a [[[[“abc”]]]] === a [“abc”]; //这也是真的

幸运的是，stackoverflow.com的善良的人向我解释了整个事情：http:/stackoverflow.com/questions/1724255/why-does-2-2-in-javascript

Answer 315

JavaScript的：

( {} == {} ) == false

Answer 316

这是我的2美分。在c ++中：

int* t = new int(15);
delete t;

Answer 317

Tcl中的串联是添加两个字符串，它变成一个字符串：

set s1 "prime"
set s2 "number"
set s3 $s1$s2
puts s3

输出

primenumber

Answer 318

你可以扔掉任何可以用Java编写的东西。

class YourBoss extends Throwable {
}
public class Main{
  public void main(String[] s) throws YourBoss {
   try{
    throw new YourBoss();
   }catch(Exception e){
   }catch(Error e){
   }
  }
}

Answer 319

BrainFuck language。真的是！

最奇怪的语言特征

320 个答案:

解释

x = x + 1

VBScript中的支架标识符

有向图和替代标记

在PHP中

尝试，除了 else

PHP

的Python

MySQL案例敏感性