最奇怪的语言特征


Strangest language feature

在您看来，您遇到的最令人惊讶、最奇怪、最奇怪或最真实的"wtf"语言功能是什么？

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

相关讨论

在C语言中，数组可以这样索引：

1
a[10]

这很常见。

然而，鲜为人知的形式(真的有效！)是：

1
10[a]

意思和上面一样。

相关讨论

(P)In Javascript：(p)字母名称(P)惠拉斯(p)字母名称

相关讨论

在javascript中，以下构造

1
2
3
4
5
return
{
    id : 1234,
    title : 'Tony the Pony'
};

返回undefinedis a syntax error due to the splyly implicit分号insertion on the newline after return。但是，下面的工作正如您所期望的那样：

1
2
3
4
return {
    id : 1234,
    title : 'Tony the Pony'
};

更糟糕的是，这一个也可以(至少在铬合金中)工作：

1
2
3
4
5
return /*
*/{
    id : 1234,
    title : 'Tony the Pony'
};

这里有一个相同问题的变体，它不会产生语法错误，只会无声地失败：

1
2
return
    2 + 2;
相关讨论

javascript真值表：

1
2
3
4
5
6
7
8
9
10
11
''        ==   '0'           // false
0         ==   ''            // true
0         ==   '0'           // true
false     ==   'false'       // false
false     ==   '0'           // true
false     ==   undefined     // false
false     ==   null          // false
null      ==   undefined     // true
" \t

" ==   0             // true

Source: Doug Crockford

相关讨论

Trigraphs在C和C++中。

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

这将打印LOL|，因为三角图??!转换为|。

相关讨论

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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源代码的快速窥视将得出以下结论：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * 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 <wyn>int</wyn> 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)，因此在比较引用相等性时，它们将是真而不是假。比较整数值的正确方法是使用.equals;。

相关讨论

引用尼尔·弗雷泽的话(看那页的结尾)

1
2
3
4
5
try {
    return true;
} finally {
    return false;
}

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

编辑：只要我们在主题上，也要考虑：

1
2
3
4
5
try {
    throw new AssertionError();
} finally {
    return false;
}
相关讨论

APL(除所有程序外)，只在一行中编写任何程序的能力。

例如，康威在APL的一行人生游戏：

alt文本http://catpad.net/michael/aplife.gif

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

这是一个视频

相关讨论

可以使用C++模板的奇特的东西，最好用"多维模拟文字"来演示，它使用模板来计算"绘制"形状的区域。下面的代码对于3x3矩形是有效的C++

1
2
3
4
5
6
7
8
#include"analogliterals.hpp"
using namespace analog_literals::symbols;

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

或者，另一个使用三维立方体的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
  assert( ( o-------------o
            |L             \
            | L             \
            |  L             \
            |   o-------------o
            |   !             !
            !   !             !
            o   |             !
             L  |             !
              L |             !
               L|             !
                o-------------o ).volume == ( o-------------o
                                              |             !
                                              !             !
                                              !             !
                                              o-------------o ).area * int(I-------------I) );
相关讨论

Perl的许多内置变量：

  • $#—不作评论！
  • $0、$$和$?—就像shell变量同名一样。
  • $ˋ、$&和$'—奇怪的匹配变量
  • $"和$,—列表和输出字段分隔符的奇怪变量
  • $!类似于errno作为数字，strerror(errno)作为字符串
  • $_—隐形变量，一直使用，从未见过。
  • $#_—最后一个子例程参数的索引号…也许吧
  • @_—当前函数的(非)名称…也许吧
  • $@—上次引发的异常
  • %::—符号表
  • $:、$^、$~、$-和$=——与输出格式有关。
  • $.和$%输入行号，输出页码
  • $/和$\输入和输出记录分隔符
  • $|—输出缓冲控制器
  • $[—把你的阵列基从0基改为1基，改为42基：whee！
  • $}—什么都没有，够奇怪的！
  • $<、$>、$(、$)—真实有效的uids和gids
  • @ISA—当前包的直接超类的名称
  • $^T—脚本启动时间(以epoch秒为单位)
  • $^O—当前操作系统名称
  • $^V—这是什么版本的perl

从哪里来的还有很多。在这里阅读完整的列表。

相关讨论

PHP处理字符串中的数值。有关完整的详细信息，请参阅前面对不同问题的回答，但简而言之：

1
"01a4" !="001a4"

如果有两个字符串包含不同数量的字符，则不能认为它们相等。前导零很重要，因为它们是字符串而不是数字。

1
"01e4" =="001e4"

PHP不喜欢字符串。它在寻找任何可以找到的借口，把你的价值观当作数字来对待。稍微改变这些字符串中的十六进制字符，突然，php决定这些字符不再是字符串，它们是科学记数法中的数字(php不关心您使用引号)，它们是等效的，因为数字忽略前导零。为了加强这一点，您将发现PHP还将"01e4" =="10000"评估为真，因为这些是具有等效值的数字。这是记录在案的行为，只是不太明智。

相关讨论

javascript八进制转换"特性"是一个很好的了解：

1
2
3
4
5
parseInt('06') // 6
parseInt('07') // 7
parseInt('08') // 0
parseInt('09') // 0
parseInt('10') // 10

更多详细信息。

相关讨论

让我们对所有试图去掉保留字的语言(如PL/I)进行投票。

除此之外，你还可以合法地写一些有趣的表达，比如：

1
IF IF THEN THEN = ELSE ELSE ELSE = THEN

(IF、THEN、ELSE为变量名)

或

1
IF IF THEN THEN ELSE ELSE

(IF是变量，THEN和ELSE是子程序)

达夫的装置在C！

在C语言中，可以将do/while与switch语句交替使用。下面是使用此方法的memcpy示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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);
    }
}
相关讨论

algol pass-by-name(使用C语法说明)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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]);
}
相关讨论

在Java中：

1
2
3
int[] numbers() {
  return null;
}

可以写为：

1
2
3
int numbers() [] {
  return null;
}
相关讨论

(P)In Python：(p)字母名称(P)不是一个WTF，但一个用户的形象。(p)

相关讨论

Intercal可能是最奇怪的语言特性的最佳概要。我个人最喜欢的是comefrom声明，它(几乎)与goto相反。

COMEFROM is roughly the opposite of
GOTO in that it can take the execution
state from any arbitrary point in code
to a COMEFROM statement. The point in
code where the state transfer happens
is usually given as a parameter to
COMEFROM. Whether the transfer happens
before or after the instruction at the
specified transfer point depends on
the language used. Depending on the
language used, multiple COMEFROMs
referencing the same departure point
may be invalid, be non-deterministic,
be executed in some sort of defined
priority, or even induce parallel or
otherwise concurrent execution as seen
in Threaded Intercal. A simple example
of a"COMEFROM x" statement is a label
x (which does not need to be
physically located anywhere near its
corresponding COMEFROM) that acts as a
"trap door". When code execution
reaches the label, control gets passed
to the statement following the
COMEFROM. The effect of this is
primarily to make debugging (and
understanding the control flow of the
program) extremely difficult, since
there is no indication near the label
that control will mysteriously jump to
another point of the program.

相关讨论

(P)不是一种真正的语言特征，但一种执行模式：一些早期的竞争对手通过使用一个Constant Pool执行了一些标准。所有的参数都通过参考。如果你呼叫一个功能，E.G.(p)字母名称(P)The compiler would pass the address of the constant 1 in the constant pool to the function.如果你在工作中向参数提供价值，你将改变方案中的全球价值(在此情况下是1)。我给你找了个头(p)

相关讨论

(P)Don't know if it can be considered a language feature，but，in C++almost any compiler error related to templates delivers a fair amount of WWF to many C++programmers around the world on daily basis:(p)

相关讨论

C的许多名称空间：

1
2
3
4
5
6
7
8
9
typedef int i;

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

或带有字符：

1
2
3
4
5
6
7
8
9
typedef char c;

void foo()
{
    struct c {c c;} c;
    c: c.c = 'c';
    printf("%c
", c.c);
}
相关讨论

(P)我想说的是，Python的whole white thing is my greatest WTF feature.是的，你比现代出版商更容易被用来处理这件事，但即使在过去几年里，我仍然认为这是一个坏主意。I've read all the reasoning behind it but honestly，it get in the way of my productivity.不是很多，但它仍然是一个布尔在萨德尔。(p)(P)Edit：Judging by the comments，some people seem to think I don't like to indent my code.这是不正确的评估。I've always indeed my code no matter what the language and whether I'm forced to or not.What I don't like that i t is the indentation that defines what block a line of code is in.我倾向于解释这一点。Among other reasons，I find explicit delimiters make it easier to cut and paste code.(p)(P)For example，if I have a block indented 4 spaces and paste it at the end of a block that is indented 8 spaces，my editor(all editors？)你们不知道过去的代码是否属于8-Space Block或是外层空间。Otoh，if I have explicit delimiters it's obvious which block the code belongs to and how it should be(re-)indented-it does so by intelligently looking for block delimiters.(p)(P)Edit 2:Some people who provide comments seem to think this is a feature I hate or that I think make pyton a poor language.Again，not true.While I don't like i t all that much，that's beside the point.The question is about the strangest language feature，and I think this is strange，by virture of it being some very，very few(but>0)languages use.(p)

相关讨论

我为此挣扎了一下：

1
1;

在Perl中，模块需要返回一些真实的内容。

相关讨论

我很惊讶没有人提到过VisualBasic的7个循环结构。

1
2
3
4
5
6
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

因为坚持！在你面前的条件太复杂了！

相关讨论

我一直想知道为什么最简单的程序是：

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

然而，它可能是：

1
print"Hello World!"

也许这是为了吓唬计算机科学专业的学生…

相关讨论

(P)对于那些不知道的人，EDOCX1的英文本0是"arbitrary precision calculator language"，而我使用这一点进行快速计算，特别是当数字涉及较大时(EDOCX1的英文本1是Prompt)：(p)字母名称(P)字母名称0已经是一个长期的标准单指令。(p)(P)Now for the WTF Feature.This is from EDOCX1 theographic 3(emphasis mine)：(p)布尔奇1

相关讨论

javascript是面向对象的，对吗？因此，对文本字符串和数字运行方法应该是有效的。像"hello".toUpperCase()和3.toString()一样。第二个是语法错误，为什么？因为解析器希望后面跟一个点的数字是浮点文本。这不是wtf，wtf是你只需要添加另一个点就可以了：

1
3..toString()

原因是文字3.被解释为3.0，3.0.toString()工作正常。

相关讨论

在JavaScript中：

1
2
3
4
5
6
7
8
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]？

相关讨论

我最讨厌的特性是任何包含条件逻辑的配置文件语法。在Java世界(蚂蚁，Maven等)你知道你是谁！.

您最终只需使用C**P语言进行编程，调试和编辑器支持有限。

如果您的配置中需要逻辑，那么用真正的语言对配置进行编码的"Python式"方法要好得多。

相关讨论

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

1
# BLOAT {bloatsize}

这将使编译的可执行文件的大小增加字节。这是放在编译器中的，以防创建可执行文件的人不喜欢生成的可执行文件的小尺寸。它使exe看起来更大，可以与膨胀的编程语言竞争：)

相关讨论

在PHP中，函数名不区分大小写。这可能会让您认为PHP中的所有标识符都不区分大小写。再猜一次。变量区分大小写。世界跆拳道联盟。

1
2
3
4
5
6
7
8
9
10
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
相关讨论

我一直非常喜欢在上下文之外的一行中使用两个冒号时抛出的PHP错误：

Parse error: syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM in /path/to/file/error.php on line 3

当我第一次遇到这个的时候，我完全困惑了。

相关讨论

在C中

1
a[i++] = i;

它编译，但很少做你认为应该做的事情。一个优化的改变会导致产生截然不同的结果。它在不同的平台上运行不同。

然而，编译器对它非常满意。

相关讨论

Python 2.xP＞＜／

1
2
3
>>>True = False
>>>True
False

你可以真的让这成为一个如此疯狂。P＞＜／

Oracle有几个SQL WTF问题。

  • Oracle对空字符串的处理为空。

  • 在"<>"比较中处理空值。

    1
    2
    3
    4
    5
    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')行。

    相关讨论

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

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

    Java解惑

    相关讨论

    在javascript中，void不是关键字，不是类型声明，也不是变量名，也不是函数，也不是对象。void是一个前缀运算符，类似于-、--、++和!。您可以将它作为任何表达式的前缀，并且该表达式的计算结果将为未定义。

    它经常在bookmarklets和内联事件处理程序中使用，在这个比较常见的示例中：

    1
    do nothing

    在这个例子中，它的使用方式使它看起来像一个函数调用，而实际上它只是一个非常巧妙的方法来获取原始的undefined值。大多数人并不真正理解javascript中void的真实本质，这会导致大量令人讨厌的错误和奇怪的意外事件发生。

    不幸的是，我认为void操作符是获取javascript中undefined值的唯一真正有保证的方法，因为正如另一个答案所指出的，undefined是一个可以重新分配的变量名，{}.a可能被Object.prototype.a = 'foo'弄乱。

    更新：我想到了另一种生成undefined的方法：

    1
    (function(){}())

    嗯，虽然有点冗长，但返回"undefined"是它的目的更不清楚。

    相关讨论

    Perl有yada yada操作符(...)。

    The so called"yada yada" operator of Perl 6 heritage is a shortcut to mark unimplemented code:

    1
    if ($condition) { ... }

    is the same as

    1
    if ($condition) { die"not yet implemented" }
    相关讨论

    在FORTRAN中(77当然，也可能在95中)，从I到N(in)组开始的未声明变量和参数将是INTEGER，所有其他未声明的变量和参数将是REAL(来源)。这一点，再加上"在某些情况下可选择空白"导致了最著名的错误之一。

    如1990年alt.folklore.computers中弗雷德·韦伯所说：

    I worked at Nasa during the summer of 1963. The group I was working
    in was doing preliminary work on the Mission Control Center computer
    systems and programs. My office mate had the job of testing out an
    orbit computation program which had been used during the Mercury
    flights. Running some test data with known answers through it, he was
    getting answers that were close, but not accurate enough. So, he
    started looking for numerical problems in the algorithm, checking to
    make sure his tests data was really correct, etc.

    After a couple of weeks with no results, he came across a DO
    statement, in the form:

    1
    DO 10 I=1.10

    This statement was interpreted by the compiler (correctly) as:

    1
    DO10I = 1.10

    The programmer had clearly intended:

    1
    DO 10 I = 1, 10

    After changing the . to a , the program results were correct to
    the desired accuracy. Apparently, the program's answers had been
    "good enough" for the sub-orbital Mercury flights, so no one suspected
    a bug until they tried to get greater accuracy, in anticipation of
    later orbital and moon flights. As far as I know, this particular bug
    was never blamed for any actual failure of a space flight, but the
    other details here seem close enough that I'm sure this incident is the
    source of the DO story.

    我认为把DO 10 I作为DO10I是一个很大的wtf，反过来，由于隐含的声明被认为是REAL类型。这是一个伟大的故事。

    相关讨论

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

    1
    2
    3
    4
    5
    6
    7
    int main( int argc, char *argv[] )
    {
        int i=10;

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

    这编译得很好。

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

    我不敢说XML是一种编程语言，但它离我们的心不近吗？-)

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

    1
    2
    <_....>
    </_....>

    下面是NT名称的词汇定义，它允许连续的点。

    相关讨论

    从Ruby中的随机类继承：

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

    (首先在Ruby的隐藏特性中看到)

    相关讨论

    我惊讶地发现，通过修改类的@ISA数组，可以在Perl中更改类的继承链。

    1
    2
    3
    4
    5
    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'
    相关讨论

    我喜欢这样一个事实，即在javascript中，这类事情是很好的：

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

    结果是从2010年10月0日起77个月154天，即2016年11月1日。

    相关讨论

    在ruby/python/c中，可以像这样连接字符串：

    1
    2
    a ="foo""bar"
    print a # =>"foobar"
    相关讨论

    在javascript中，undefined是一个全局变量，其默认值是原始值undefined。您可以更改undefined的值：

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

    由于undefined的可变性，一般最好通过typeof来检查不确定性：

    1
    2
    var a = {};
    typeof a.b =="undefined"; // always true
    相关讨论

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

    无论如何，这意味着人们可以重新定义一个数字来表示其他东西：

    1
    : 0 1 ;

    它创造了"EDOCX1"(2)这个词，由1组成，不管当时执行的是什么。反过来，它会导致以下结果：

    1
    2
    0 0 + .
    2 Ok

    另一方面，定义可以接管解析器本身——这是已经完成的工作用评论词。这意味着第四个程序实际上可以在中途变成一个完全不同语言的程序。事实上，这是forth中推荐的编程方法：首先编写要用以解决问题的语言，然后解决问题。

    相关讨论

    大约在1977年，在"printf"还没有出现之前，我将"format"函数添加到了lisp中(我是从与unix相同的源复制的：multics)。它一开始就很天真，但一个接一个的特性充斥着它。当盖伊·斯蒂尔(GuySteele)将迭代和相关的特性放入通用的lisp x3j13-ansi标准中时，事情就失控了。以下示例见通用LISP语言第2版第22.3.3节表22-8：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    (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)))
    相关讨论

    流行性腮腺炎。有很多wtf特性，我选择了一个，if声明。(请注意，为了适应那些不懂该语言的人，我下面使用了一种相当冗长的编码方式；真正的流行性腮腺炎代码通常对未入门的人来说更难以理解。)

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

    这与Java中的说法类似：

    1
    2
    3
    4
    5
    if (x > 10) {
      myMethod(x);
    } else {
      otherMethod(x);
    }

    除了腮腺炎中的else语句在语法上不是if块的一部分外，它是一个单独的语句，通过检查内置变量$TEST工作。每次执行if语句时，都会将$TEST设置为if语句的结果。else语句实际上是指"如果$TEST为假，执行行的其余部分，否则跳到下一行"。

    这意味着，如果x大于10，因此第一行称为myTag，而myTag包含if语句，那么else的行为不取决于其上一行的if而是取决于在myTag内部评估的最后一个if语句！由于这一"特性"，腮腺炎编码员通常被教导编写上述代码以确保安全：

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

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

    相关讨论

    python的everything-is-really-a-reference有趣的副作用：

    1
    2
    3
    4
    5
    6
    >>> a = [[1]] * 7
    >>> a
    [[1], [1], [1], [1], [1], [1], [1]]
    >>> a[0][0] = 2
    >>> a
    [[2], [2], [2], [2], [2], [2], [2]]
    相关讨论

    在javascript中，可以使用双位否定(~~n来代替Math.floor(n)(如果n是正数)或parseInt(n, 10)(即使n是负数)。n|n和n&n总是产生与~~n相同的结果。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    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测试案例，比较了这些备选方案的性能。

    相关讨论

    ansi-sql中nulls的三值逻辑。

    相关讨论

    从类型安全的角度来看，这并不是一个很奇怪的特性，而是一个真正令人恼火的特性：C中的数组协方差。

    1
    2
    3
    4
    5
    6
    class Foo { }
    class Bar : Foo { }
    class Baz : Foo { }

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

    我相信这是爪哇遗传的(双关语有意的)。

    相关讨论

    我在C中最喜欢的怪异是5["Hello World"]，但由于这已经发布，我下一个最喜欢的怪异是Windows版本的结构初始化黑客：

    1
    2
    3
    4
    5
    void someWindowsFunction() {
        BITMAPINFOHEADER header = {sizeof header};

        /* do stuff with header */
    }

    这条微妙的线条完成了以下任务：

  • 声明BitmapInfoHeader结构
  • 简洁地设置结构的"大小"成员，而不硬编码大小常量(因为许多窗口结构，包括BitmapInfoHeader，遵循将结构大小指定为第一个成员的惯例
  • 声明结构的版本(因为许多Windows结构，包括BitmapInfoHeader，按照仅追加结构定义的约定，按声明的大小标识其版本)
  • 清除结构的所有其他成员(结构未完全初始化时的C标准行为)。
    • 相关讨论

    使所有的对象实例都是互斥体。

    相关讨论

    在PHP中，可以做到：

    1
    System.out.print("hello");

    在JavaScript中：

    1
    alert(111111111111111111111) // alerts 111111111111111110000

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

    python的for循环中的else。

    从python文档中：

    1
    2
    3
    4
    5
    6
    7
    8
    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'

    输出：

    1
    2
    3
    4
    5
    6
    7
    8
    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
    相关讨论

    一些早期的动态语言(如果我记得正确的话，包括早期版本的Perl)没有发现什么是好的动态，什么是坏的动态。所以他们中的一些人允许：

    1
    1 = 2;

    在那句话之后，以下是真的：

    1
    if(1 + 1 == 4)

    在Python中，函数参数的"编译时"(或声明时)计算可能会令人困惑：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    def append(v, l = []):
        l.append(v)
        return l


    print append(1)
    print append(2)

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

    其目的可能是：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    def append(v, l = None):
        if l is None:
            l = []
        l.append(v)
        return l

    print append(1)
    print append(2)

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

    这种行为对于缓存之类的事情很有用，但它可能很危险。

    附加功能：具有可变内容的元组：

    1
    2
    3
    a = (1,2,[3])
    a[2][:] = [4] # OK
    a[2] = [2] # crashes
    相关讨论

    PHP中的字符串，函数is as good as a的指针：P＞＜／

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

    不幸的是他/她，这不工作：P＞＜／

    1
    "foo"();
    相关讨论

    在JavaScript中，方法的结果取决于样式大括号的位置。这是k&r样式，其中大括号位于方法签名之后和返回语句之后：

    1
    2
    3
    4
    5
    6
    7
    var foo = function() {
      return {
        key: 'value'
      };
    }

    foo() // returns an object here

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    var foo = function()
    {
      return
      {
        key: 'value'
      };
    }

    foo() // returns undefined here

    怎么会？在javascript中，如果您不自己做，语言会自动在每行的末尾放置分号。所以在最后一个代码片段中真正发生的是：

    1
    2
    3
    4
    5
    6
    7
    var foo = function()
    {
      return; // here's actually a semicolon, automatically set by JavaScript!
      {
        key: 'value'
      };
    }

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

    相关讨论

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

    相关讨论

    其他奇怪的事情：

    在C++中，重写虚拟方法隐藏了该方法的所有其他重载。在爪哇，这种情况不会发生。这很烦人。示例：http://codepad.org/uhvl1njp

    在C++中，如果基类具有公共虚拟方法FoE()，并且子类具有私有方法FoE()，则该私有方法重写另一个方法！这样，只需将子类对象指针强制转换为超类对象指针，就可以调用类外部的私有方法。这不可能：这违反了封装。新方法不应被视为旧方法的重写。示例：http://codepad.org/lugnpspdh

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

    相关讨论

    C++中我最喜欢的一个是"抽象抽象的具体内联析构函数"：

    1
    2
    3
    4
    5
    6
    7
    class AbstractBase {
    public:
        virtual ~AbstractBase() = 0 {}; // PACID!

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

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

    相关讨论

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

    相关讨论

    大约20年前，当我最后一次涉足流行性腮腺炎时，这些实现有一些奇怪的限制。当宿主流行性腮腺炎变得越来越流行时，传统上流行性腮腺炎是一种自宿主语言：计算机语言、操作系统和数据库在一个包中。

    腮腺炎基本上与数据库有关。本质上，是一个巨大的多维哈希表，由一个B*树支持，这使得访问非常快速。在语言和数据库之间也没有任何障碍：如果您希望在其中存储某个内容，您只需在变量前面加上一个符号，指示它将被持久化到后备存储。

    另一方面，文件系统几乎不存在，对它的支持甚至更少。唯一能做的就是将程序从一个文件加载到内存中，然后将内存中的任何内容发送回一个文件。在加载之前最好清除缓冲区，否则它会与之前存在的内容混合。

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

    好吧，技巧是能够将变量的内容作为源代码执行。然后，一个编辑器将自己加载到变量中，在变量中执行自己，清除内存，然后在内存中加载、保存和编辑文件，一直从变量执行。

    此外，所有命令都可以缩短为其第一个字母(除了z命令，缩短为两个字母，主要处理文件系统)，还有一个奇怪的事实，比如IF(I设置了一个变量，然后由ELSE查询(E)，当然，它可以被干预I或由程序本身。再想一想，我觉得整个语言都是一个wtf。然而，它有一种奇怪的吸引力。

    世界跆拳道最糟糕的就是科博改变了主意。

    语法非常直接："alter label1 to goto label2"，但是调试运行时意大利面条的结果令人难以置信。

    相关讨论

    和C型languages(包括C本身)，你可以使用"云下的操作： ＜／P >

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

    这将打印数字从0 19。 ＜／P >

    相关讨论

    "piet是由david morgan mar设计的一种深奥的编程语言，其程序是看起来像抽象艺术的位图。"

    Piet program that prints Piet

    打印piet的piet程序

    嗯，这个也是我一直以来最喜欢的难找的虫子…将以零开头的整数视为八进制数。这导致了一个只在早上8点到10点之间显示的错误：

    有一次，我帮助构建了一个自动回归测试，在晚上通过cron执行。它几乎适用于一个20人的团队中的每个人——期望开发人员偶尔抱怨一次自动测试失败，但是当手动运行时，一切都正常。即使是一次也不能手动复制。

    原因是，我们根据日期命令的输出进行了一些统计计算(在bash中)，但这只在早上8:00到9:59失败，因为我们将小时值读取为"08"(这是一个非法的八进制值，而"01"-"07"是有效的八进制值，从"10"开始，所有内容都将再次被视为十进制)。…

    相关讨论

    JavaScript是一个充满跆拳道。P＞＜／

    1
    2
    3
    4
    5
    6
    7
    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!
    相关讨论

    在FoxPro中，如果我没记错的话，每个命令都可以缩写为4个字符，其他的一切都会被忽略，所以read、ready、ready都是一样的——忽略前4个字符之后的内容。向我解释过的那个人喜欢这个功能，但我觉得它很恐怖。

    相关讨论

    作为一个脚踏实地的爱好者，当我从Smalltalk听到become时，我很激动…例如

    1
    a become: b

    它从字面上把A对象改为B，这使得编写懒惰的初始化代理变得很简单，因为对A的所有引用现在都将引用B。非常好！

    我认为它是一种奇怪的语言特征，因为在我的知识范围内，没有其他语言具有这种能力。

    相关讨论

    Java缓存整数对象实例的范围为-128到127。如果您不知道这一点，以下可能有些出乎意料。

    1
    2
    Integer.valueOf(127) == Integer.valueOf(127); // true, same instance
    Integer.valueOf(128) == Integer.valueOf(128); // false, two different instances
    相关讨论

    可能已经说过了(也许这对某些人来说并不奇怪)，但我觉得这很酷：

    在JavaScript中，声明函数接受的参数对程序员来说只是一种方便。通过函数调用传递的所有变量都可以通过关键字"arguments"访问。因此，以下内容将提醒"世界"：

    1
    2
    3
    4
    5
    6
    7
    <script type="text/javascript">

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

    blah("hello","world");

    注意，虽然看起来这些参数存储在一个数组中(因为您可以以与数组元素相同的方式访问对象属性)，但它们不是。arguments是一个对象，而不是一个数组(因此，它们是用数字索引存储的对象属性)，如以下示例所示(从crockford的补救javascript页面获取的函数类型)：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    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");
    相关讨论

    common lisp的format函数可以选择将数字打印为罗马数字。

    在Intercal中，这是您将获得的唯一输出形式。

    相关讨论

    在C语言中，sizeof运算符不评估其参数。这允许编写看起来错误但正确的代码。例如，给定类型T，调用malloc()的惯用方法是：

    1
    2
    3
    4
    #include <stdlib.h>

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

    在这里，当sizeof运算符(data是NULL时，不评估*data，所以如果评估它，就会发生不好的事情！).

    不管怎样，这允许我们为新来者编写令人惊讶的代码。注意，在他们的右脑中没有人会这样做：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    #include <stdio.h>

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

    这将打印1，而不是2，因为x永远不会递增。

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    #include <stdio.h>
    int main(void)
    {
        char a[] ="Hello";
        size_t s1 = sizeof a;
        size_t s2 = sizeof ("Hi", a);
        printf("%zu %zu
    ", s1, s2);
        return 0;
    }

    (只有当对数组、指针和运算符感到困惑时，才会产生混淆。)

    在我看来，在C中，能够将超出范围的整数转换为枚举是相当奇怪的。想象一下这个枚举：

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

    现在，如果你写：

    1
    2
    Colour eco;
    eco = (Colour)17;

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

    有关详细信息，请参阅此处。

    相关讨论

    Perl：

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

    这是怎么工作的？！

    相关讨论

    x= x＋1

    当我还是一个初学者的时候，这是很难理解的，现在函数式语言不使用它，这就更难了！

    如果你不明白这有多奇怪：把等号当作断言的陈述，而不是你在基础代数中所做的赋值动作，那么这就相当于说"0等于1"。

    相关讨论

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

    1
    2
    3
    4
    5
    6
    7
    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 -,-");        
    }

    好消息是，新的语言使其实现正确。

    相关讨论

    ok，因为问题将处于间歇模式，我将加入"fun"

    go(aka issue9)使用大写字母表示可见性：

    • 如果你用大写字母命名，它将具有公共访问权限。

    • 如果使用小写，它将受到包保护：

    包装外可见：

    1
    2
    func Print(v ...) {
    }

    在包外不可见

    1
    2
    func print( v ... ) {
    }

    你可以在这个原始答案中找到更多。

    相关讨论

    C++模板机制是图灵完成：只要在运行时不需要输入，就可以在编译时进行任意计算。任意的或者你可以很容易地编写一个永远编译的C++程序，但是语法上是正确的。

    在Perl中，您可以执行以下操作：

    1
    2
    3
    4
    my $test ="Hello World";
    substr($test, 0, 5) ="Goodbye";

    print $test;

    这在其他语言中是可能的吗？

    相关讨论

    我喜欢在C中偷偷输入八进制值：

    1
    int values[8] = { 123, 154, 103, 310, 046, 806, 002, 970 };
    相关讨论

    在javascript中，第一次看到!!a(作为一种转换为布尔值的方法)。

    相关讨论

    下面是一些奇怪的C特性：http://www.steike.com/code/unused/evil-c/

    这是我的最爱之一，你可以在没有主()的条件下用Java做一个打印。

    这将编译并运行，并给出println，但也有一个异常(java.lang.nosuchmethoderror:main)

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

    可能已经提到过，但是--

    PHP对八进制值的处理：

    1
    2
    3
    4
    $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称它为一个特性(如引用"fix"所示)，而不是一个bug，他声称它"在脚本中使用数字的所有情况下都会极大地降低PHP速度"——但是，为什么php会对0a产生错误呢？

    我想有人可以写一整本关于PHP古怪的书…

    相关讨论

    在爪哇，你可以期待

    1
    2
    byte b = 0;
    b++;

    等于

    1
    2
    byte b = 0;
    b = b + 1;

    但事实并非如此。实际上，您会得到一个编译器错误，因为加法的结果是int类型的，因此不能分配给字节变量b。当使用复合运算符++时，编译器会自动在此处插入一个转换。所以

    1
    b++;

    变成

    1
    b = (byte) b + 1;

    declarations和JavaScript变量/函数： ＜／P >

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

    奇怪的()returns undefined…词对"X"，即使在没有happened指派。 ＜／P >

    similarly，但不是unexpectedly ＜／P >

    1
    2
    3
    4
    5
    function weird2(){
       var x;
       return x();
       function x(){ return 2 };
    }

    returns 2。 ＜／P >

    相关讨论

    在C中，这至少会生成一个编译器警告，但不会：

    1
    2
    3
    4
    5
    public int Something
    {
        get { return Something; }
        set { Something = value; }
    }

    当被调用时，它会导致应用程序崩溃，并且不会得到一个好的堆栈跟踪，因为它是一个StackOverflowException。

    相关讨论

    vbscript的日期/时间文本(为什么仍然如此罕见？)：

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

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

    编辑：日期文本是相对的(那么它们在技术上是文本吗？)：

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

    因为它是编译的，所以不支持相对日期文本。只支持日期或时间文本，但缺少的时间或日期假定为零。

    编辑【2】：当然，有一些奇怪的角落案例提出了相关的日期……

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

    为什么c的list.addrange()不让我添加t子类型的元素？list.add()可以！微软需要的只是一行额外的代码：

    1
    2
    3
    public void AddRange<S>(
        IEnumerable<S> collection
    ) where S : T
    相关讨论

    当我上大学的时候，我用一种叫做snobol的语言做了一点工作。整个语言虽然很酷，但却是一个很大的wtf。

    它有我见过的最奇怪的语法。你用：(标签)代替goto。当您有：s(label)(goto label on success/true)和：f(label)(goto label on failure/false)并且您在检查某些条件或读取文件的行上使用这些函数时，谁需要if's。所以声明：

    1
    H = INPUT :F(end)

    将从文件或控制台读取下一行，如果读取失败(因为达到EOF或任何其他原因)，将转到标签"END"。

    然后是$sign运算符。它将使用变量中的值作为变量名。所以：

    1
    2
    3
    ANIMAL = 'DOG'
    DOG = 'BARK'
    output = $ANIMAL

    将在控制台上显示值"bark"。因为这还不够奇怪：

    1
    $DOG = 'SOUND'

    将创建名为bark的变量(请参见上面指定给dog的值)并为其提供"sound"值。

    你看得越多，情况就越糟。关于snobol(来自链接文本)，我发现的最好的说法是"语言的力量及其相当惯用的控制流特性使得snobol4代码在编写之后几乎不可能被阅读和理解。"

    相关讨论

    我为一个客户机编写了一种编程语言(用于实验驱动自定义硬件)，其中有一些自定义类型(curl、circuit，…)，每个类型只有2个值。它们可以隐式转换为布尔值，但是(在客户机的请求下)可以在运行时更改此类类型常量的确切布尔值。

    例如。：curl类型有两个可能的值：cw和ccw(顺时针和逆时针)。在运行时，可以通过简单的赋值语句更改布尔值：

    1
    ccw := true

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

    相关讨论

    Perl有许多奇怪但整洁的特性。

    if可在如下声明之前或之后使用：

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

    对于foreach也是如此：

    1
    2
    print"Hello $_!
    " foreach qw(world Dolly nurse);
    相关讨论

    PHP中的"真"、"假"和"零"normally cannot be overridden which是常数。不管一个人多介绍，with the of命名空间在PHP 5.3 =一>，现在可以在任何这些常数的名称，但全球命名空间的命名空间。which can to the following行为：铅P＞＜／

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    namespace {
        define('test\true', 42);
        define('test\false', 42);
        define('test
    ull', 42);
    }

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

    当然如果你想你真的真的好，你可以总是true from the全局命名空间导入P＞＜／

    1
    2
    3
    namespace test {
        var_dump(\true === \false); // is (bool) false
    }
    相关讨论

    在Haskell：

    1
    let 2 + 2 = 5 in 2 + 2

    收益率为5。

    ActionScript 3：

    当一个对象被它的接口使用时，编译器不识别从Object继承的方法，因此：

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

    给出编译错误。解决方法是投射到对象

    1
    Object(interface).toString();

    PHP:

    .和+运算符。它有其合理的解释，但仍然显得很尴尬。

    Java(以及IEEE74的任何实现)：

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

    相关讨论

    在PHP中：

    1
    2
    3
    4
    5
    echo 'foo' == 0;    // echos '1'
    echo 'foo' == true; // echos '1'
    echo 0 == true;     // echos '0'
    $foo = 'foo';
    echo $foo['bar']    // echos 'f'

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

    洛洛克！

    整个语言本身。虽然不完全是一个世界跆拳道的事情，但我从来没有遇到过一种语言，它在我的脑海中以卡通片般尖叫的声音播放。我以前也没有看过代码，想叫"aaawww cuuute！"

    此程序显示数字1–10并终止

    1
    2
    3
    4
    5
    6
    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
    相关讨论

    在C或C++中，你可以用宏来获得很多乐趣。如

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

    如果传入foo(bar++，4)，它将递增两次。

    相关讨论

    PerlFileHandle类型的运算符调用。

    一开始，有

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

    请注意，由于缺少逗号，所以您知道这是要打印的文件句柄，而不是要以字符串方式打印的文件句柄。这是一个肮脏的黑客。

    语言升级开始了，它们生成适当的OO文件句柄，并将x FOO y, z, abc转换为FOO->x(y, z, abc)。有点可爱。同样的print语句有效运行

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

    大多数情况下，当您错过逗号或尝试运行类似于hashof $a, $b, $c的子例程调用(不带括号)，并忘记从其实用程序包将hashof函数导入命名空间时，您会注意到这一点，并收到一条关于"can't call method‘hashof’via package’contents of string $a的奇怪错误消息"。

    相关讨论

    identifiers VBScript和支架

    VBScript是有所谓identifiers支架，这是identifiers定义式和backets广场，像这样： ＜／P >

    1
    [Foo]

    他们真的是相当的方便，actually，他们allow你我和routines保留字变量后，调用方法的对象的名称，是第三方的保留字也使用几乎任何Unicode和字符(包括空格和特殊字符和identifiers)。但这也意味着，你可以与他们有一些有趣的： ＜／P >

    1
    2
    3
    4
    5
    6
    7
    8
    9
    [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

    在其他的手，identifiers支架可以忘记你，但gotcha案例的quotes，但像这样的声明： ＜／P >

    1
    If MyString ="[Something]" Then

    因为法律是一If MyString = [Something] Thenperfectly语法。(这就是为什么和一个语法highlighting IDE是一个必须的！) ＜／P >

    ＞＜br / 他identifiers支架能信息和埃里克lippert的博客： ＜／P >

    • 花絮：支架identifiers VBScript和保留字incompatibilities
    • quiz VBScript的答案，第六
    相关讨论

    在Python中：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    >>> 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']

    这些切片分配也会产生相同的结果：

    1
    2
    3
    a[:] ="hello"
    a[42:] ="hello"
    a[:33] ="hello"

    在JavaScript(和Java中，我想)你可以逃脱这样有趣的字符：

    1
    var mystring ="hello "world"";

    如果你想把回车放到一个字符串中，那是不可能的。您必须这样使用：

    1
    2
    var mystring ="hello,
    world";

    对于编程语言来说，这都是正常的，也是意料之中的。奇怪的是，你也可以像这样逃离实际的回车：

    1
    2
    var mystring ="hello, \
    world";
    相关讨论

    C/C++：

    快速平方反比算法利用了IEEE浮点表示法(从维基百科复制的代码)：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    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);
    }
    相关讨论

    容易挑剔的人，二郎到处都是。例如，3种形式的标点符号，

    1
    2
    3
    4
    5
    6
    7
    8
    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!
    相关讨论

    在C或C + +，parentheses are optional for the argument sizeofto…提供T型：不是the argumentP＞＜／

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    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
    }

    为什么我从来没有understood this is！P＞＜／

    更多的是平台功能而不是语言功能：在iPhone上，创建一个包含少量计算的无限循环并运行程序。你的手机会发热，当外面很冷的时候，你可以把它当作暖手器。

    在PowerShell中，可以重命名变量：

    1
    2
    3
    4
    5
    6
    > $a ="some value"
    > $b ="a"
    > $c ="d"
    > Rename-Item variable:$b $c
    > $d
    some value

    间接间接间接！拿这个，PHP！

    文字也可以工作：

    1
    2
    3
    > Rename-Item variable:d e
    > $e
    some value
    相关讨论

    (P)In earlier version of visual basic，functions without a"return"statement just"return none"，without any kind of compiler warning(or mistake).(p)(P)This lead to the most crazy debugging sessions back when I had to deal with this language on a daily basis.(p)

    相关讨论

    字符串的数学和Perl是非常奇怪的。 ＜／P >

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    $ 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
    相关讨论

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

    不过，有一个例外：

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

    将打印字母A到Y。就像您所期望的那样，它是C样式的数据类型。

    但是，如果测试条件更改为<=，它将不会像您想象的那样打印a到z，而是打印a到yz！(共打印676项)

    另外，如果您将676项列表中"z"之后的"z"更改为"a a"，并再次将测试条件更改为<，则只会看到"a"被打印出来！不是你所期望的从A到Z。

    如果您将递增器更改为$i+=2，它将再次只打印"A"！唯一的方法是按顺序使用$i++，$i++，现在它像预期的那样工作。

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

    相关讨论

    我知道的最伟大的编程语言集(今天是1313)，您可以在这里找到：http://99-bothes-of-beer.net网站/准备好去看真正奇怪的东西；-)每个人都应该做出自己的选择

    相关讨论

    早期的Fortran，那里的空白不明显。(反Python！)

    1
    DO 20 I = 1, 10

    意思：从这里到第20行的循环，从1到10改变i。

    1
    DO 20 I = 1. 10

    含义：将1.10赋给名为do20i的变量。

    有传言说这个窃听器撞坏了一个太空探测器。

    红宝石

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    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
    相关讨论

    Java的访问修饰符是我最近的一个WTF(因为我必须学习一点)。

    显然，包比类层次结构更紧密。我无法定义对子类可见但对包中的其他类不可见的方法和属性。我为什么要和其他班级分享一个班级的内部信息呢？

    但我可以定义对包内的每个类都可见的属性和方法，但不能定义包外的子类。

    不管我怎么想，我还是看不出逻辑。切换访问修饰符，并进行保护行为，就像它在C++中工作，并保持包私有修饰符，它是有意义的。现在没有了。

    相关讨论

    在javascript中：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    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—在调用函数后不会改变。

    相关讨论

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    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) {}
    }

    呃。虽然我承认这并不奇怪…只是邪恶。-)

    较短、更惯用的版本：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    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();
    }
    相关讨论

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

    langauge的定义(参见www.php.org)不是由语法或标准定义的，而是由一组"你可以写这个例子"部分(当然，你能写任何其他东西吗，只是猜测一下概括)，诚实的用户贡献说"但是它做了这个古怪的事…"。

    我定期会遇到我们构建的PHP解析器的问题。以下是最新消息：

    1
    "abc$A[define]def"

    现在，php是Perl的一个(非常糟糕的)副本，因此它允许使用隐式变量子状态构造字符串。字符串中的$X表示"将$X的值插入字符串"，相当于"abc"。X元。"def"where"."是PHP的字符串连接运算符。

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

    现在，语言(网站)明确地说"define"是一个关键字，你不能在任何你能找到表达方式的地方使用它。所以上面包含"define"的gem是什么？是否引发语法错误？不，那是有道理的。

    不，它实际上是指：

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

    只有当你写了一个看起来像标识符的东西(关键字或不是！)在一个简单的数组中访问一个字符串。在语言中没有其他地方会发生这种行为。什么，写"abc$a["define"]def"是不合理的，所以PHP的发明家不得不把它写进去？让我休息一下。(为了复合重罪，有"字符串中的复杂数组访问"，当然它的工作方式不同。查看"abc$a[define]def"；根据PHP网站，这是非法的。

    (原来PHP数组是关联哈希，所以按名称查找数组(好吧，哈希表)成员不是一个糟糕的主意)。

    这种语言充满了这样的gotchas。如果你喜欢"哎呀，看看我今天在我的子程序下发现了什么蠕动的东西"，你应该切换到PHP。

    相关讨论

    (P)In my opinion this should not be allowed in C++：(p)字母名称(P)This may seem right，but this means that you cannot override a method without allowing users of the subclass to call the original method instead of the new one.(p)(P)Just think about a subclass of a collection where you want to increament the number of elements when adding an element to the collection itself.(p)(P)a logical solution would be to override the add(……)method to increase the counter before adding the element，but a user of the new collection could add an element to it using the old method so bypsing your increament and resulting in your elements-counter disagree with the actual number of elements of the collection.(p)(P)这是不可能在爪哇。(p)

    相关讨论

    在学习PowerShell时找到：

    尝试猜测结果数组的外观：

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

    答案：

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

    哎哟！它动摇了我对PowerShell及其背后的人的信心。

    相关讨论

    在C：

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

    我记得出于某种原因没有看到警告(在一些遗留代码中有太多警告？)还不明白为什么在使用非int返回函数的情况下，从int转换会导致编译器错误。

    编译器假定这样的事情是非常意外的。

    相关讨论

    对我来说，它绝对是intercal中的PLEASE修饰语。如果PLEASE出现的次数不够多，则认为该程序不够礼貌，错误消息表明这一点；如果出现的次数过多，则该程序可能会被视为过分礼貌而拒绝。

    相关讨论

    在mumps You can have a与跳转的偏移。如果你有一个(我的生锈的mumps is…)P＞＜／

    1
    2
    some_label if x=1 do_something
               else  do_something_else

    then the队列P＞＜／

    1
               goto some_label+1

    jump to the else statement will…P＞＜／

    相关讨论

    intercal(and，or和xor)中的一元运算符。

    相关讨论

    我喜欢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。太棒了，如果你感觉不好，你甚至可以用猴子来修补。

    第四，它的控制结构有些奇怪。首先，因为它是一种反向波兰符号语言，所以条件优先于IF，如：

    1
    x 0 = IF

    现在，要关闭条件块，可以使用关键字THEN：

    1
    x 0 = IF ." Equals zero!" THEN

    现在真正的WTF开始了。IF所做的是编译一个有条件的正向跳转，并将跳转偏移的地址放在堆栈上。当找到THEN时，它从堆栈中弹出该地址，计算实际偏移量，然后编译该地址。另一方面，ELSE编译一个不符合条件的向前跳转，从堆栈中弹出一个地址，在堆栈上推一个新地址，计算弹出地址的偏移量，然后编译该偏移量。意思是语法如下：

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

    第一和第二个语句的编译如下：

    1
    2
    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循环：

    1
    BEGIN x 10 < WHILE x 1+ to x REPEAT

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

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

    它利用每个控制流字的工作方式组合两个WHILE语句，并为每个出口添加不同的后循环代码。为了证明我不是在开玩笑，我只是从互联网上的一个代码中复制了这个小片段，并做了一些小修改来简化它。

    相关讨论

    在MAXScript中，所有运算符都被视为相等的。因此，a = b + c将a设为b的值，然后计算a+c的和，并丢弃结果。

    相关讨论

    在SQL中

    NULL不等于NULL。

    所以你不能这样做：

    1
    WHERE myValue == NULL

    这将始终返回false。

    1
    NULL != NULL
    相关讨论

    通知7。有效程序示例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
        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.

    其他像图灵机模拟器这样的愚蠢之处也可以找到。

    在PHP中：

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

    这将写下：

    1
    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
    相关讨论

    c++1x lambda：

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

    对于某些奇怪的语法，这些可能会被滥用：

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

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

    相关讨论

    为了保持与VisualBasic6.0的向后兼容性，vb.net的设计者做了一些非常愚蠢的事情。当然，这还不足以让它真正兼容，只足以让事情变得更反直觉。但最糟糕的是，你不必初始化变量，因为它们已经是了，除非在那些罕见的情况下它们不是。

    1
    2
    3
    4
    5
    6
    7
    8
    9
        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%信任的特性并不是一个特性，而是一个缺陷。说它是按设计的，只会使它成为设计缺陷，而不是实现缺陷。

    相关讨论

    到目前为止，我遇到过的最奇怪的功能是用BASIC语言的"返回n"语句(不记得是哪一个，大约是28年前)。n"是可选的，默认为1。它可以是一个正数，也可以是负数，表示下一个要执行的是哪个与调用gosub相关的行。

    例如，下面将输出"30"：

    1
    2
    3
    4
    5
    10 GOSUB 200
    20 PRINT"20"
    30 PRINT"30"
    100 END
    200 RETURN +2

    当我不得不将用这个奇怪的基本语言编写的程序翻译成Fortran时，我遇到了这个问题。基本程序使用这个特性相当多的时间来返回基于各种条件的不同语句，我花了一段时间来理解逻辑流。一旦我理解了它，我就能够写一个更简单的程序版本。不用说，更简单的fortran版本比原始的基本程序有更少的错误。

    相关讨论

    另一个C-ISM。

    1
    2
    3
    4
    5
    6
    int i= 0;
    while( i != 12 ) {
        /* Some comment
        i += 1;
        /* Another comment */
    }

    为什么不起作用？林特会告诉你的。然而，C编译器通常会轻而易举地忽略这一点。和I.一样

    那是一个真正的世界跆拳道时刻，当我发现什么是错误的。

    相关讨论

    Java泛型是一个WTF：

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

    2：是否非法(？？？)这令人费解，但你必须想想接下来会发生什么：

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

    我们将为一个字符串引用分配一个对象，噢，不！像这样，他们周围有很多人。

    相关讨论

    我曾经写过一种编程语言，它有一个"strfry"操作符：

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

    有用的，嗯？

    相关讨论

    大约20年前，我与一种叫做coral的语言的编译器合作，这种语言允许我声明writeonly变量！

    不过，这是有道理的，因为它们是全球性的，并被用作信号机制。一个进程将写入一个值，另一个进程将读取该值。

    相关讨论

    以下C代码引发nullreferenceexception，而不是print 1：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
        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
        }
    相关讨论

    我所知道的最怪异的特点是来自C++世界：

    最糟糕的是，它碰巧是非常有用的，广泛使用斯芬纳在助推足够证明我。

    相关讨论

    在JavaScript中，NaN是一个全局变量。

    相关讨论

    PHP

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

    所以这是可行的：implode($someArray, $glue)。

    希望他们能在php 6中消除这些历史怪癖。

    相关讨论

    这是缺少一个奇怪的特性：python没有switch语句(尽管存在解决方法)。

    相关讨论

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

    在Perl中(没有"use strict"或"use warnings")：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    if(true==undef)
    {
        print"True
    ";
    }
    else{
        print"False
    ";
    }
    if(undef)
    {
        print"True
    ";
    }
    else{
        print"False
    ";
    }
    if(true)
    {
        print"True
    ";
    }
    else{
        print"False
    ";
    }

    印刷品：

    1
    2
    3
    True
    False
    True
    相关讨论

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

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

    这将打印"测试"。这种行为的奇怪之处在于，您还可以使用非字符串作为变量名，例如：

    1
    2
    3
    4
    ${array()} = 'test';
    echo ${array()};
    ${NULL} = 'test';
    echo ${NULL};

    现在我们有了名为array()的变量，甚至为空！全部包含字符串"test"。

    相关讨论

    JavaScript： ＜／P >

    1
    2
    parseInt('06'); // 6
    parseInt('08'); // 0
    相关讨论

    C + +：P＞＜／

    1
    2
    3
    4
    5
    6
    7
    8
    9
    void f(int bitand i){ //WTF
        i++;
    }
    int main(){
        int i = 0;
        f(i);
        cout << i << endl; //1
        return 0;
    }
    相关讨论

    正在查找函数？为什么不是一种语言？

    我喜欢PHP，但它似乎总是这样构建的"噢，s***t！我忘了这个！让我们在函数"中添加另一个参数，结果是：

    str_replace($search，$replace，$subject，…)
    strstr($subject，$search，…)

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

    这还有别的东西

    1
    2
    3
    4
    5
    $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');

    在Java中，

    int x＝010；

    这将指定x的值为8。

    Java中任何一个前面加上0的整数都假定为八进制。

    相关讨论

    准将基本的命令快捷方式。基本上，大多数命令都有一个缩写形式，通常是第一个字母+(shift+第二个字母)。但是，由于c64上的字符集默认都是大写的，所以这些命令看起来像奇怪的符号。下面是一个简短的Hello World示例：

    Commodore BASIC screenshot

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

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

    相关讨论

    pl/sql允许声明关键字的变量和函数名。以下是可编译的pl/sql：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    create or replace
      function function
      return number  as
      return number;
    begin
      function.return := 4;
      return   return;
    end function;
    /

    这创建了一个名为function的函数。后来：

    1
    2
    3
    4
    5
    SQL> select function from dual;

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

    在Java中，如果x的值是NA，则EDCOX1〔14〕返回false，EDCX1〔15〕返回true。

    相关讨论

    在JavaScript中：

    1
    2
    1 / 0; // Infinity
    1 / -0; // -Infinity
    相关讨论

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    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 ;
        }
    }

    运行程序会导致以下结果：

    Dog says 'Woof!'
    Animal says 'unknown sound'

    获得这种行为应该需要程序员离开程序员的道路。子类实例并没有停止成为它的样子，因为它已经被上推到了它的父类型。相反，您必须显式地请求预期(几乎总是期望的)结果：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class Animal
    {
        public virtual string Speak() { return"unknown sound" ; }
    }

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

    C++最烦人的解析：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    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.
    }
    相关讨论

    下面是关于数组的这个答案。

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    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

    如果变量是整数而不是字符串，那么操作是交换的。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    PS> $a = 4      # integer
    PS> $a * 3
    12
    PS> 3 * $a
    12
    PS> $a + 3
    7
    PS> 3 + $a
    7

    当有疑问时，做一个演员：

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

    您也可以使用[float]。

    相关讨论

    在Java中，

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

    输出"nullhello"。

    相关讨论

    一个意外的特性是枚举定义列表中的尾随逗号和C、C、Ruby等中的数组初始化列表。

    1
    2
    3
    4
    5
    6
    7
    string[] foods = {"tofu","grits","cabbage", }

    public enum ArtPeriod {
      Modern,
      Romantic,
      Dada,
    }
    相关讨论

    在javascript中，我认为以下内容是等效的：

    1
    2
    a['title'] ="Syntactic sugar is good for yr teeth.";
    a.title ="Syntactic sugar is good for yr teeth.";
    相关讨论

    带块的vbscript：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    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
    相关讨论

    与MATLAB，下面可能会surprising especially，如果你用这一： ＜／P >

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    >> not true

    ans =

         0     0     0     0
    >> not false

    ans =

         0     0     0     0     0

    这里是两个有奇怪的特性。第一个是，a b是interpreted作为a('b')，not trueinterpreted not('true')是王牌。奇怪的是，第二特征not任何字符returns 0(presumably是因为有好的false或true和MATLAB，只0或1)。 ＜／P >

    相关讨论

    在javascript中有很多东西可以让你的眼睛湿润。

    局部变量的作用域，只是一个简单的例子：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    function foo(obj)
    {
      for (var n = 0; n < 10; n++)
      {
        var t;        // Here is a 't'
        ...
      }
      t ="okay";     // And here's the same 't'
    }
    相关讨论

    在C中

    1
    Math.Round(2.5)==2
    相关讨论

    基本雅达利：

    您可以在不编写循环的情况下用字符填充字符串：

    1
    2
    10 DIM A$(100)
    20 A$(1)="":A$(100)="":A$(2)=A$
    相关讨论

    MySQL的Enums，特别是他们把毫无准备的同事搞混的能力。

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

    然后：

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

    哎呀，dispatched改为零，因为1没有被引用。这真的让我的代码开发人员很恼火；我现在使用的是简单的旧ints。

    在相关注释中，即使向枚举中添加空字符串选项，例如

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

    如果给blah分配一个无效值，mysql将使用一个秘密的隐藏空字符串值来表示无效值，这将很难与您自己添加的值区分开来。哎呀！

    相关讨论

    在X++中(Microsoft Dynamics AX)：

    1)需要在单独的行上使用分号(；)将变量声明与语句分开(至少在4.0版之前)

    1
    2
    3
    4
        int i;
        int myArray[5];
        ;
        i = 1;

    < BR>

    2)数组索引是基于1的，因此不允许像in一样使用索引0(零)从数组中读取

    1
    2
    3
        int myArray[5];
        ;
        print myArray[0];    // runtime error

    这并不奇怪，但是允许您使用分配左侧的零索引，如

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

    发生什么事了？数组将被初始化为它的默认值，无论在赋值中使用了什么值。以上代码输出0(零)！

    相关讨论

    不确定是否有人提到过。

    在爪哇中，在最后一个块中，它可以返回一个值。它将停止异常的传播并重写正常的返回语句。

    相关讨论

    在matlab(交互式面向数组语言，目前是tiobe 20)中，有一个关键字end表示数组的最后一个元素(它对应于numpy -1)。这是一个众所周知的matlab语法：

    1
    myVar = myArray(end)

    要从数组中间获取元素，通常需要编写：

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

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

    1
    myVar = myArray( ceil( end/2 ) )
    相关讨论

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

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

    此代码返回254。列表理解的变量与上定义的冲突。

    python 3.x已经处理了这个特性，但是闭包仍然在使用外部变量的动态链接，并且在函数式的python程序员中引入了许多wtf。

    1
    2
    3
    4
    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]。

    相关讨论

    NSI(NullSoft可脚本化安装系统)具有StrCmp指令：

    1
    StrCmp str1 str2 jump_if_equal [jump_if_not_equal]

    Compares (case insensitively) str1 to str2. If str1 and str2 are equal, Gotos jump_if_equal, otherwise Gotos jump_if_not_equal.

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

    蛋糕上的糖霜：jump_if_equal和jump_if_not_equal也可以是负的。但我想你已经从正数前面的+符号中找到了答案。我不记得这是强制性的，还是一个可怕的惯例。

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

    javascript中的变量分配可以创建全局变量。如果变量是一个函数内的赋值，并且在同一范围内没有声明为var，则该变量隐式声明为全局变量。

    1
    2
    3
    4
    5
    6
    7
    8
    function foo() {
      x ="juhu";  // creates a global variable x!
      var y ="kinners"
    }

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

    注意，在为变量赋值后，也可以使用var语句：

    1
    2
    3
    4
    5
    6
    7
    8
    function foo() {
      x = 12;
      var x; // x is now local
      return x;
    }

    alert(foo()); // will alert 12;
    alert(x); // will alert undefined
    相关讨论

    第四可以变化的基部数在任何时间： ＜／P >

    1
    2
    HEX 10 DECIMAL 16 - .
    0 Ok

    它需要一个便条，请预先定义的一指： ＜／P >

    1
    2
    36 BASE ! 1Z DECIMAL .
    71 Ok
    相关讨论

    Fortran对不同列的特殊意义。(如果你是和打孔机一起长大的，那可能是完全自然的。)

    这样做的一个副作用是，变量名在第72列后被截断。与IMPLICIT NONE结合在一起，当这样一个变量名在第72列附近开始时，它会悄悄地引入一个新变量。

    你需要

  • 意识到这一点

  • 在另一个编辑器中突出显示注释部分(第72列之后)颜色比以前的部分…

    • 相关讨论

    对javascript的另一个投票：

    1
    parseInt('08') == 0

    因为任何以0开头的数字都被解释为八进制(奇怪)，无效的八进制数的值为零(错误)。我发现这是一个八月，几个月来我没有接触过的代码自行中断。事实证明，它将在10月份自行修复。

    八进制支持显然已被弃用，所以JavaScripter的后代将不会有这种通过仪式。

    相关讨论

    PHP的列表结构：

    1
    2
    3
    $array = array(0,1,2);
    list (,,$x) = $array;
    $x == 2; // true
    相关讨论

    这个老的PHP最喜欢的并不是所有的wtfish，但是范围解析错误是许多开发人员看到的值得给wtf一些爱的事情之一：

    1
    2
    3
    4
    $class = new StdClass();
    $class::test();

    PHP Parse error:  syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM on line 3
    相关讨论

    和Python。 ＜／P >

    1
    2
    3
    4
    5
    6
    7
    >>> x = 4
    >>> y = 1000000
    >>> x is 4
    True
    >>> y is 1000000
    False
    >>>

    如果你只是尝试它don′t相信我！ ＜／P >

    在Perl中，对象只是blessed refs，因此在运行时更改对象的类很容易：

    1
    2
    3
    4
    5
    6
    7
    8
    package Foo;
    sub new { bless {}, $_[0] }
    package Bar;
    package main;
    my $foo = Foo->new;
    ref($foo); # =>"Foo"
    bless $foo, 'Bar';
    ref($foo); # =>"Bar"

    我很惊讶其他语言不能做到这一点。多有用的功能啊！

    使用sqlite可以声明具有所需数据类型的列。它查找一些特定的子字符串("int"、"real"、"text"等)，以确定相关性。

    这使得您可以躺在类型声明中：

    1
    2
    3
    4
    CREATE TABLE Quirks (
       X    FLOATING POINT,  -- = INTEGER affinity because of the"INT"
       Y    STRING,          -- = NUMERIC affinity
    );
    相关讨论

    有向图和可选标记

    C(ISO/IEC 9899:1999，4.4.6／3)和C++(ISO/IEC 1488∶2003，2.5)有一个很少被使用的特性，被C称为"有向图"和C++的"替代令牌"。这些与三元图的区别主要是因为包含它们的字符串文字永远不会被不同的解释。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    %:include <stdio.h>

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

    C++有很多，包括和/或不需要作为EDCOX1，0，EDCOX1，1，EDCX1，2的行为。C也有这些代码，但需要包含才能使用它们，将它们视为宏而不是令牌。C++Health[CISO64 6]字面上是一个空文件。

    值得注意的是，gcc实现了对这种奇怪语言特性的支持，但是在试图编译上述代码段时，许多其他编译器都会死气沉沉。

    相关讨论

    和PHP。 ＜／P >

    复活节的日期_ UNIX timestamp为他准备一个给定年复活节午夜 ＜／P >

    国际_复活节的日期(年] [国际美元) ＜／P >

    相关讨论

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    class Foo {
      public:
        static void bar() {
          std::cout <<"WTF!?" << std::endl;
        }
    };

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

    那个让我吃惊的…

    相关讨论

    在Java中(实际上，我最近在不同的POST上写了这个)：

    1
    2
        int x = 1 + + + + + + + + + + + + + 1;
        System.out.println(x);
    相关讨论

    在ColdFusion中，所有的变量都被当作全局变量，不管它们放在哪里。

    1
    2
    3
    4
    5
    6
    7
    8
    <cffunction name="one" returntype="void">
        <cfset var wtf="coldfusion">
        <cfinvoke method="second">
    </cffunction>

    <cffunction name="two" returntype="void">
        <cfoutput>#wtf#</cfoutput>
    </cffunction>
    相关讨论

    在Visual Basic 7及更高版本中，我发现了短路逻辑评估的实现，以保持与旧版Visual Basic的兼容性<=6代码一点WTF：

    AndAlso (MSDN)
    OrElse (MSDN)

    相关讨论

    Perl的$[(已弃用)，这在前面关于通用Perl变量的另一篇文章中提到过，但它值得特别提及，并提供更好的解释。对$[的更改仅限于当前范围。有关如何使用它及其含义的更多信息和快速说明，请访问$[http://www.perlmounds.org/index.pl/？NoDyIID＝480333

    相关讨论

    因为我没看到有人提起…RPG 2或3(报告程序生成器…也就是火箭推动的垃圾)是迄今为止我使用过的最古怪的语言。它结合了对程序流几乎没有控制的功能(在文件的顶部输入，在底部退出)，并且编程语句是基于使用固定字体在特定列中定义的字符来定义的(想想穿孔卡片！！！)

    要成为真正的Fubar，你必须尝试在DY-280中编程。它将RPG流和逻辑与COBOL语法结合在一起。

    请看这里的rpg:wikipedia.org/wiki/ibm_rpg

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

    相关讨论

    整洁的依赖系统的溢出会导致(mri/c)ruby和macruby(但不是jruby)中的年滚动，然后出现较大数量的本地时间错误，这又如何呢？这不是一个常见的问题，但很奇怪：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    $ 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位环境的。

    相关讨论

    PHP背板

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

    PHP supports one execution operator: backticks (``). Note that these are not single-quotes! PHP will attempt to execute the contents of the backticks as a shell command; the output will be returned (i.e., it won't simply be dumped to output; it can be assigned to a variable).

    1
    2
    $output = `ls -al`;
    echo"[cc]$output

    ；< /代码>

    在代码中发现"而不是"是"相当容易的"。

    这也很有趣：

    After much trouble, I have concluded that the backtick operator (and shell_exec) have a limited buffer for the return. My problem was that I was grepping a file with over 500,000 lines, receiving a response with well over 100,000 lines. After a short pause, I was flooded with errors from grep about the pipe being closed.

    特征：bash的大麦，壳牌(ksh93)和Z shell允许阵列的每个下标变量与或不与美元符号：(一) ＜／P >

    1
    2
    array[index]=$value
    array[$index]=$value

    这与美元符号，将产生的预期值(10000美元。 ＜／P >

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    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

    如果你strangeness：remove the美元最虔诚的总会随机的，如果randomly，甚至是更大的比10000。 ＜／P >

    这similarly产生，而不是2 3： ＜／P >

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

    你不能用一美元的标志，因为它有一个分配的(A冰在LHS)，尽管你可以做的，如果你是用间接的评价，但双动发生。 ＜／P >

    的原因：与美元符号，"变频冰performed扩张前的arithmetic评价只山羊做这么一次。"美元"的标志，它的performed两次，一次对《指南calculate指数再次到Lookup and calculate的索引的分配(SO、效应、分配在一步在回路可能看起来像array[4] = $array[6] + 1totally scrambles"阵列")。 ＜／P >

    相关讨论

    在一个陌生的银行系统中使用了RSL编程语言。数组有内置类TArray。但是，如果从中继承，则每个实例变量都将成为数组的元素。

    1
    2
    3
    4
    5
    6
    7
    class (TArray) DerivedArray
      var someField = 56;
    end

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

    以下是Perl调试器中的一些混乱：

    1
    2
    3
    4
    5
    6
      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的标量上下文向下传播到子例程调用中，将看起来无害的..转换为完全不同的运算符。(这是"触发器"运算符，而不是范围运算符)。

    相关讨论

    C，命名空间重新排序

    例如。

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

    因为

    1
    2
    3
    4
    5
    namespace foo.bar.Exception{
      class HowDoMyWayException : ApplicationException {
       // because someone did this
      }
    }
    相关讨论

    对于那些不知道的人来说，PostScript实际上是一种编程语言。我对它有点疯狂——我写了一个PostScript程序，它将曼德布洛特分形计算到非常高的细节级别。它确实是可打印的PostScript，尽管它会使许多打印驱动程序崩溃…

    不管怎样，从何处开始使用PostScript…这里有一个：您实际上可以创建一个标识符为….没有什么。

    ()cvn 5 def%将数字5分配给…没有什么

    PostScript是一种基于堆栈的语言。()将空字符串放入堆栈。cvn将其转换为一个名称(如果打印它，则为"/"，因为ps中的所有名称前面都有斜杠)。然后5 def将值5分配给它。(%是注释字符)

    你不能直接把它拿回来，例如，如果我说"打印"，这不会打印5号。但是你可以间接地得到它：

    ()cvn load print%这将打印数字5

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

    /mydict 100听写定义

    [0]dup mydict exch 42放置mydict exch get=%打印42

    mydict[1]42 put mydict[1]get%引发未定义的错误

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

    1
    1 array dup dup 0 exch put ==

    哦！

    相关讨论

    PHP中的变量

    PHP中的一个奇怪特性，允许您从其他变量的内容(警告、未测试的代码)创建和分配变量：

    1
    2
    3
    4
    5
    6
    $a = 'Juliet';
    $$a = 'awesome'; // assigns a variable named $Juliet with value 'awesome'

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

    好吧，假设我们有这样的东西：

    1
    2
    3
    4
    $bob = 'I\'m bob';
    $joe = 'I\'m joe';
    $someVarName = 'bob';
    $$someVarName = 'Variable \'bob\' changed';

    各种间接的娱乐如何？

    1
    2
    3
    4
    5
    6
    $juliet = 'Juliet is awesome!';
    $func = 'getVarName'

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

    function getVarName() { return 'juliet'; }
    相关讨论

    heavily used this is not that，but of syntax c + S"Return to静态参考尺寸阵列："Weird isP＞＜／

    1
    2
    3
    4
    5
    6
    struct SuperFoo {
      int (&getFoo() const)[10] {
        static int foo[10];
        return foo;
      }
    }

    ofc method can be above，在房屋declared as静态常量P＞＜／

    相关讨论

    在Ruby中，你可以用Heredocs做一些奇怪的事情。考虑：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    a = <<ONE
    This is one. #{<<TWO}
    This is two. #{<<THREE}
    This is three.
    THREE
    TWO
    ONE

    p a # =>"This is one. This is two. This is three.


    "

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

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

    但你不能这样做：

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

    操作员过载通常受到wtf的影响。

    在ColdFusion阵列中，从1开始。

    相关讨论

    换句话说：多重继承。它毫无意义，只会制造麻烦。

    我指的是C++中的米河，而不是Java和其他语言中的混音等。

    相关讨论

    Python的：P＞＜／

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

    18.03归来~，which is the between the点距离(10.5)和(25.5%)by the了毕达哥拉斯定理。事实上，因为这能支持本地语言Python has to the form of numbers在复合for example)2 +。since the number of a的绝对值在复合形态BJ＝sqrt(of a + a + b平方公尺)，我们得到一个距离subtracting while the number from another复合然后apply the function ABS(绝对)过来。P＞＜／

    相关讨论

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

    我不明白为什么这是一个持久的特性；这反映了几年前我作为一个笨蛋在我的TI-86基础版上所做的事情，因为语言的特性还不够。

    相关讨论

    在PHP中

    1
    2
    3
    4
    5
    var_export('false' == 0);       // true

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

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

    编辑

    正如@kobi所提到的，这可能是因为语言将任何值解释为"true"，除了"false"，但对于php来说则不是这样，因为这里的情况比您想象的更奇怪！

    这个例子在PHP手册的"字符串转换为数字"一章中有详细的记录，其中说：

    If the string starts with valid
    numeric data, this will be the value
    used. Otherwise, the value will be 0
    (zero).

    以下是示例：

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

    P.S.我认为这种隐式类型转换比有用性更有害。

    相关讨论

    我最喜欢的C++之一：

    1
    2
    3
    4
    5
    6
    7
    8
    #include <iostream>
    using namespace std;
    int main()
    {
        cout <<  3 << 5  << endl;
        cout << (3 << 5) << endl;
        return 0;
    }

    当然，这很容易解释，但它已经开始让学生们抓耳挠腮！

    相关讨论

    红宝石人字拖。"条件语句中的"…"和"…"并不总是范围运算符：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    (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

    这将输出：

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

    …在每次传递时检查这两个语句，…在每次传递中只检查"on"或"off"语句(取决于触发器状态)。他们是从awk和sed那里偷来的。

    Matz用"Ruby编程语言"编写："触发器是Ruby的一个相当模糊的特性，最好避免使用…"

    在多种语言中交替使用：

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

    乍一看：B怎么可能真的不等于自己呢！？这个意外地只会打印奇数

    相关讨论

    来自任何人？

    处理(Orthor.org)是一种基于Java的语言。简单来说，处理编译器是Java预处理器，它将处理特定的语法转换成Java。

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

    处理类被编译成Java内部类，这会引起一些麻烦，比如私有变量并不是真正的私有。

    1
    2
    3
    4
    5
    6
    7
    8
    class Foo {
      private int var = 0; // compiles fine
    }

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

    此外，缺少draw()函数会导致不调用事件处理程序：

    1
    2
    3
    4
    // void draw() {} // if you forgot to include this
    void mousePressed() {
      print("this is never called");
    }
    相关讨论

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

    这是从受保护的抽象虚拟基继承的纯虚拟私有析构函数。

    iow，一个析构函数，只能由类(private)的成员或朋友调用，并在声明它的基类(abstract base)中分配了0(纯虚拟)，该析构函数稍后将在派生类中定义/重写，该派生类以受保护的方式共享多个继承的基(virtual base)。

    相关讨论

    在俄亥俄州立大学，他们用一种叫做Simult/C++的私生子C++语言来编程。Reals/C++使用契约设计的方法来实现一切。它要求您对编译后的注释中的组件和方法进行数学建模，从而强制您维护方法和对象之间的需求/确保关系。

    相关讨论

    s a="a="a"，@a="2n"，a="c="("22"？@a)，@a"，@a，a="a"，a(c)"s+"，e=$t(@@a@(c))"，@a

    这是cos(cache-objectscript)中一个很好的一行程序。有趣的是这里要注意的是5种不同的代码间接模式*G

    Perl可以自动将Base 26转换为Base 10，如果您可以在早晨与自己一起生活…

    1
    2
    $ perl -E"say lc (@a='a'..'asdf')"
    30530
    相关讨论

    Fortran不是一个真正的WTF时刻，而是一个"为什么我需要输入所有这些垃圾时刻"的时刻。

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

    "gt."让我在玩这门语言的时候有点不知所措，直到我意识到它是">"符号。哦，我多么喜欢不学生物专业，每天都要涉猎这个垃圾。

    相关讨论

    在常见的Lisp中，零维数组是奇怪的，而且很自然，它们具有读取语法。

    1
    2
    ? (aref #0A5)
    5
    相关讨论

    在bash中，变量既可以是标量，也可以是数组：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    $ 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中执行此操作时，将得到子字符串分配，而不是数组：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    $ 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
    相关讨论

    其余的这些都没有关于惊人的Ruby触发器的操作：

    1
    2
    3
    4
    5
    6
    7
    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实现。但我原谅你，鲁比<3

    相关讨论

    技术上不是一种语言，而是一种体系结构。

    http://www.6502.org/tutorials/6502opcodes.html jmp

    6502组件，间接JMP：

    Note that there is no carry associated with the indirect jump so:

    AN INDIRECT JUMP MUST NEVER USE A

    VECTOR BEGINNING ON THE LAST BYTE

    OF A PAGE

    For example if address $3000 contains $40, $30FF contains $80, and $3100 contains $50, the result of JMP ($30FF) will be a transfer of control to $4080 rather than $5080 as you intended i.e. the 6502 took the low byte of the address from $30FF and the high byte from $3000.

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

    相关讨论

    我不相信这个人是不是在这里，JSF的性质：访问。 ＜／P >

    在一个JSF UI的时间，你会把财产的价值，一个是从客户端到服务器对象的接口referencing thusly村的信息： ＜／P >

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

    的事这是Java不支持的特性，所以你有写方法启动与山羊和集为了链接的用户界面对象的"财产"的服务器。 ＜／P >

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

    这是我的第一个混淆的时候学习JSF和静止的跆拳道-值得考虑的信息。即使真的有没有其他的方式做它，直到implements支持Java，C #型置业。 ＜／P >

    相关讨论

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

    …但不能复制数组或哈希表。

    JCL的条件执行。P＞＜／

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

    你allows features this or not to run on the run a步depending回车代码从以前的步骤。那么在好的特征。P＞＜／

    除了偶of which features for a小转弯出去backwards inside the逻辑。P＞＜／

    第一步does not run the true if the condition is。P＞＜／

    4 secondly茶，其实"step01 GT，if the回车尾均值比4大step01 is from"P＞＜／

    我知道所有的事情，"Do not the means this if the run from step01步回车代码是比4的大。"which is the几乎but not the same as a那么幼稚的解释"Run the step is if 4大的比从step01回车代码"。P＞＜／

    我只给你看这些东西时认真is about 2.30疯狂夜班下降AM与经营者at the end of the other在线headaches这双ambiguity导致严重。P＞＜／

    相关讨论

    在SQL Server中(至少ms)：

    这将始终评估为错误：

    1
    IF @someint <> NULL

    鉴于：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    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

    输出将是：

    1
    @int is evaluating to null

    必须写下：

    1
    2
    3
    IF @someint IS NOT NULL
    BEGIN
    END

    谁把英语专业的学生加入了SQL小组？：)

    相关讨论

    我认为这篇文章实际上不是一个"语言特性"(C)，我可能在发布它时非常无知，但我不知道为什么会发生这种情况，所以我会问。如果它与一些奇怪的语言特征有关。好吧，它真的让我成为"wtf"，所以它值得这个地方。

    1
    2
    3
    4
    5
    6
    int a = 0;
    int *p = &a;

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

    为什么？

    --编辑

    刚拿到，没什么大不了的。我可以感觉到C++大师在嘲笑我。我猜函数参数的计算顺序是未知的，所以编译器可以随意调用它们(我想我已经在Boost文档的某个地方读过了)。在这种情况下，参数语句被向后计算，可能反映了函数的调用约定。

    相关讨论

    在PHP中，以下内容：

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

    是语法错误。

    如果你真的想要{，然后是$foo的内容，你就必须使用.：

    1
    <?php $foo = 'abc'; echo '{' . $foo;
    相关讨论

    这是在一个奇怪的事实和特征，它使得总感如果你想想它，但是给了我一个时刻，然而哇，EL T。 ＜／P >

    和C + +(和C #)，但不能访问该基地的subclasses和保护成员在审的基地。 ＜／P >

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    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
     }
    };
    相关讨论

    subjunctive案例和英语。 ＜／P >

    哦，等等，你的意思languages做设计？然后利用(macro)和C预处理器#definemacro()旁路的学院。例如，如果有人有#define free(...)，(free)(...)会在自己的free(...)是王牌。 ＜／P >

    相关讨论

    红宝石…

    1
    2
    3
    4
    5
    6
    i=true
    while(i)
       i=false
       a=2
    end
    puts defined?(a) // returns true
    相关讨论

    逆波兰符号(RPN)。这意味着参数在函数之前。或者，换言之，您可以通过编写2 2 +来添加2和2。

    具有wtf的语言包括forth、postscript(是的，激光打印机)和factor。

    相关讨论

    Perl的core:：open和标准库，其对象定向元素被过程接口屏蔽：open ( my $fh, '>', 'foobar' );open是对my()返回的引用进行操作的构造函数，它接受参数">"和"foobar"。而且，作为一个幸运的typeglob对象(也就是说它不能在对象内保持状态)。

    关于我的Perlmonks post io:：file vs core:：open here:http://www.perlmonks.org/？NoDyIID＝763565

    相关讨论

    几年前我使用的Fortran编译器有一个有趣的特性：(a)数字首先存储在高位字节；(b)数字通过地址传递给子例程；(c)没有编译时长度检查。

    所以你可以写一个这样的程序：(对不起，如果我把语法搞乱了。我很久没写过Fortran了。)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    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个字节，但被调用函数只查看前两个字节。因为前两个是零，所以它将零加倍并返回它。然后将返回值转换回四个字节。

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

    相关讨论

    很小的事情，这是我在annoyed COBOL，那里是没有于取模运算。你可以做的，而不是一个师，你只想specifying全数字结果和伟大的《A进入不同的变量。 由于COBOL冰非常敏感，当它是对变量的均值，你那端和一个可变的DPS，你不真的需要的实际结果，即部分。这是一次秘密的故事》中的"useless名叫A变"，那是"最适当的名称是可以的。 ＜／P >

    相关讨论

    有点奇怪——vbscript有一个Null关键字和一个Nothing关键字(Null缺少数据，Nothing缺少对象)。为什么不只用一个关键词…？大多数其他语言似乎对一种语言很好！

    当然，VisualBasic6.0和"Classic ASP"代码(因为它使用vbscript)具有相同的商业性。在VisualBasic的新旧版本中，我们也有DBNull。

    然而，情况正在改善，就像在Visual Basic.NET中一样，Null最终消失了，因此Null未使用，只使用Nothing和DBNull。

    相关讨论

    回想起来，Fortran的计算goto非常奇怪。维基百科告诉了我一些超越它的基本知识。

    另一个最受欢迎的是algol 60的按名称调用参数传递。

    相关讨论

    移位；

    有时，您会在Perl方法的第一行看到它来读取自指针。

    相关讨论

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

    相关讨论

    在Python中，至少对我来说，这是非常棒的！我第一次看到它的时候：

    1
    2
    >>>"ja" * 5
    'ja ja ja ja ja '

    你可以增加字符串！世界跆拳道联盟？？

    附：我认为这是因为x * n的意思是：n times x所以，5 times"ja"是"ja""ja""ja""ja""ja"并且因为可以像这样连接字符串：

    1
    2
    >>>"ja""ja""ja""ja""ja"
    'ja ja ja ja ja '

    两个代码有相同的结果(可能是相同的)

    相关讨论

    我一直想知道这个函数在Java核心库的数学类中的用途：

    1
    static double expm1(double x);  // Returns e^x - 1.
    相关讨论

    呼叫/抄送。call/cc将表示程序其余部分的函数传递给它的主体。

    Smalltalk：

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

    1
    2
    method1
        ^ 'niko'

    您应该期望这个方法不断地返回字符串"niko"，不管发生什么。但事实并非如此。

    1
    s := Test method1

    (将S设置为"Niko"。)

    1
    s at: 4 put: $i.

    (将S设置为"NIKI"。)

    1
    s := Test method1

    (再次将S设置为"Niki"。)

    因此，发生的情况是，第二行代码永久性地更改了method1，返回"niki"而不是"niko"，即使该方法的源代码没有更新。

    相关讨论

    在Java的声明和标记连续打破。P＞＜／

    they allow to break out of You多重调控与单-块打破。P＞＜／

    相关讨论

    我不知道它是否仍然是真的，但是我们偶然发现vs fortran(66或77)不支持递归。递归是意外的，我们的默认f77非常支持它，但是当我们把源代码放到ibm-whatta混乱的地方时。

    相关讨论

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

    相关讨论

    在# has called"特征的C扩展的方法"，which are roughly analogous to Ruby插件组合的本质，You can add a method to any existing class定义(预审文件oould for You"，逆向(字符串)"如果你是知道的倾向)。that is the"Weird光环结束部分is that"You can add方法，这些方法的扩展，与身体的一切，to an interface。在一个方面，this can be as a Way to add a方便单身method to a Whole of which是T类swath part of the same继承树。on the other，增了你所有的方法fleshed to，of an非常本质通过定义的接口。P＞＜／

    我在试图找出一个完全没有意义但仍然有效的宏时遇到了这个问题。这对于objective-c是正确的，但对于其他类型的c(或者至少是gcc编译器)也可能是正确的。

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

    等于

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

    对于C样式的字符串也是如此

    1
    char* str ="this""also""works";
    相关讨论

    还有哈斯克尔：

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

    1
    2
    3
    4
    main = interact (>>= \x -> if x == '
    ' then"

    " else [x])

    (此程序将文件从stdin转换为stdout，并用crlf替换lf，interact函数输入将整个stdin转换为函数，并将输出移动到stdout。)

    这种懒惰也可能导致问题，因为如果关闭文件句柄，就不能完全舒尔，不管lazy haskell是否已经解析了其中的所有数据。

    相关讨论

    除了其他的尝试，

    1
    2
    3
    4
    try:     pass
    except:  pass
    else:    pass
    finally: pass

    如果没有其他的例外是计数executed is the part。P＞＜／

    让意识在第一，但我真的没有任何线索它does。P＞＜／

    实例：P＞＜／

    1
    2
    3
    4
    5
    6
    7
    def show_square(string):
      try:
        n = int(string, 10)
      except ValueError:
        print"I can't do that, Dave."
      else:
        print n * n

    在awk中，数组从索引1开始，这至少让人困惑。

    相关讨论

    进入统一， ＜／P >

    1
    GameObject.Find("MyObject")

    你normally将返回的对象。然而，如果你像这样： ＜／P >

    1
    2
    3
    4
    5
    6
    GameObject.Find("MyObject").active = false;
    //do other stuff
    if (GameObject.Find("MyObject").active)
    {
        //do stuff
    }

    然后你会得到一个空的参考。进入统一的iPhone，这个代码会经常没有精细的工作，但会造成SIGBUS当从iPhone上运行。的问题，这是gameobject.find(只读)会主动对象的地理定位，所以即使是如果你再看如果它检测到的主动，你是effectively呼if(null.active)。 ＜／P >

    要使它工作，好了，好了，你有伟大的计算机到计算机的不活动的前期制作。 ＜／P >

    1
    2
    3
    4
    5
    6
    7
    GameObject obj = GameObject.Find("MyObject");
    obj.active = false;
    //do other stuff
    if (obj.active)
    {
        //do stuff
    }

    是的，arguably最好的实践方式，但不管怎样，统一treats不活动的对象一般的冰quite怪异。它appears卸载到一大份的不活动的对象(textures等)，但不是所有的信息，所以不活动的对象可以静静地吃上很多内存。 ＜／P >

    相关讨论

    珀尔

    1
    2
    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的缺点总是试图做到你想做的，而不是你说的。

    相关讨论

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

    在国外，J(!:)是各种函数的捆绑在一起。我的论点是一个类，在为右是经常(但不总是)为不同的增量值。的东西。例如： ＜／P >

    1
    2
    3
    4
    5
        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

    大学课程，"聪明的事情对他们的冰包，但一些你刚刚提交到存储器。BTW，所有的这些问题，来考虑它，三元，与2的论点和一个右到左。没有人会在杂志的工作除非你给他们最终有效的论点。 ＜／P >

    相关讨论

    在PHP中，您必须显式地引用全局变量，并对类变量显式地使用这个->。使重构变得有趣。在未找到所有使用点的情况下，无法将变量/参数提升为全局成员或类成员。

    相关讨论

    TCL在解释器中虚拟化时间感非常奇怪：网址：http://www.tcl.tk/cgi-bin/tct/tip/233.html

    基本上，它允许您让解释器使用一些其他的时间数据源，例如，首先在模拟器中运行硬件测试，而不是稍后只替换计时器函数，并针对实际情况运行相同的测试。

    Go的伪常量iota：

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

    在J，最primitives(又名函数)是一元(一个参数)或式(双的论点，一左一右，to the)。但amend基元以3(我认为这唯一的一站，此外外国人)。它的understandable，它会把3，但它只是看起来…………………实习的第一个错误。 ＜／P >

    1
    2
    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
    相关讨论

    这让我很震惊

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    #define _ -F<00||--F-OO--;
    int F=00,OO=00;main(){F_OO();printf("%1.3f
    ",4.*-F/OO/OO);}F_OO()
    {
                _-_-_-_
           _-_-_-_-_-_-_-_-_
        _-_-_-_-_-_-_-_-_-_-_-_
      _-_-_-_-_-_-_-_-_-_-_-_-_-_
     _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
     _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
    -_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
    _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
    _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
    _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
     _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
     _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
      _-_-_-_-_-_-_-_-_-_-_-_-_-_
        _-_-_-_-_-_-_-_-_-_-_-_
           _-_-_-_-_-_-_-_
               _-_-_-_
    }
    相关讨论

    C预处理器及其用法。特别是预处理器元编程和使用预处理器生成可移植代码——total mindfcuk。

    相关讨论

    哈斯克尔使用了Maybe和Just。Maybe a是返回Just a类型的类型构造函数，但Maybe Int不只接受Int类型，它要求它是Just Int或Nothing类型。所以在本质上，用haskell的话说，Just Int和苹果是橙色差不多。唯一的连接是Just 5返回一个Maybe Interger类型，它可以用函数Just和整数参数构造。这很有道理，但理论上解释起来也很难，哈斯克尔的目的是什么？江户十一〔7〕真的是江户十一〔19〕年，江户十一〔6〕真的是江户二十一〔21〕年，又是江户一〔21〕年。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    -- 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

    祝你读完这本书好运，我希望它是对的。

    相关讨论

    C中的"动态"。

    对于必须与rad或python受害者一起工作的所有人来说，这一天都会被破坏，因为intellisense、类型安全和确定性会在第一次使用"dynamic"关键字时立即消失。

    这里是一个关于Python。 ＜／P >

    1
    2
    3
    4
    5
    6
    7
    >>> print 07
    7
    >>> print 08
      File"<stdin>", line 1
        print 08
               ^
    SyntaxError: invalid token

    不是，但美吗？ ＜／P >

    当你把especially unthoughtful人如何写日期，它有以下效果： ＜／P >

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

    一个原因是，0x是interpreted作为octal，print 010prints 8！) ＜／P >

    相关讨论

    Ruby中的隐含变量常量和可变常量

    相关讨论

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

    1
    2
    3
    > 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等)。

    相关讨论

    冷融合

    结构(AKA Java HASMAP)通过引用传递。

    您可能认为其他数据类型的行为类似Java…

    数组是按值传递的，wtf！

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

    相关讨论

    有很好的保留identifiers和计划。这是继evaluates 1的表达 ＜／P >

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

    他是一个音符，有无意思联络数限制在一给定范围：好的定义可能redefine一标识符，用来define identifiers范围内，下面是一个语法错误。 ＜／P >

    1
    (begin (define define 1) define)
    相关讨论

    和Java的，有一些是如何处理这inconsistency作为字符串的= =运算符depending他如何它是constructed。 ＜／P >

    1
    2
    3
    4
    5
    6
    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
    相关讨论

    foo是什么数据类型？

    1
    2
    3
    4
    5
    6
    SELECT TOP 1
       NULL AS foo
    INTO
       dbo.bar
    FROM
       sys.columns --trivial

    为什么一切都归零了？

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

    ……除了这个

    1
    SELECT CAST('' AS decimal)
    相关讨论

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

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

    1
    2
    3
    4
    5
    public class MyClass<T>
        where T: Enum
    {

    }

    如果能够在枚举上添加扩展方法，以及func，其中t将是您要扩展的枚举，这样您就可以在该枚举上得到类型推断，这将是非常酷的。

    回复注释：是的，您可以扩展实际的枚举，但区别如下：

    您可以这样做：

    1
    2
    3
    4
    public static void DoSomethingWithEnum(this Enum e)
    {
       //do whatever
    }

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

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

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

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

    或者类似的。你明白了…那是不可能的，我也不知道为什么…

    相关讨论

    好吧，这第一件事来到我的想法是"noop"，我的大脑没有一样东西的时候，我第一次来到在它！ ＜／P >

    C让步声明，不奇怪，但很有用。

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

    这并不奇怪，也不令人惊讶，但正是这件事让我总是说：

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

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

    相关讨论

    python的三元运算符

    在Python中，C三元运算符(C++示例：EDCOX1〔5〕)可用作句法糖：

    1
    2
    3
    4
    5
    6
    >>> 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 if条件，否则b)是什么？答：

    在SQL Server中，如果在生产代码中使用select *，最终可能会遇到令人讨厌的意外。不管怎样，使用select *并不被认为是一种好的实践，但是了解一些有趣的行为是很好的。

    有关更多详细信息，请参阅sqlserver2005中的问题"从表中选择*与"从表中选择cola、colb等"有趣的行为。

    相关讨论

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

    1
    control.BeginInvoke(delegate { DoSomething(); });
    相关讨论

    在ColdFusion中，文本值会自动转换为各种数据类型以用于各种目的。我遇到了一个奇怪的问题，"00a"和"000"是相等的。事实证明，ColdFusion将"00a"解释为时间，将其转换为某种数字时间格式，并将其转换为0。000"被转换为0。所以他们都被认为是等价的。那是我学习字符串比较函数的时候。

    相关讨论

    一个Java源文件可以结束与角色\u001a(控制)。 ＜／P >

    相关讨论

    对于那些从未使用过COBOL的人来说，这是一行常见的代码，但它并不能实现您可能想到的功能。

    PIC XXX

    相关讨论

    在PHP中：

    1
    2
    3
    4
    <?php
    $o = new stdClass;
    echo count($o);
    ?>

    打印1。没弄明白为什么。

    相关讨论

    PHP(又一次)？

    第一种：(unset)型铸造。

    1
    2
    3
    4
    $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()功能的区别。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    $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?
    相关讨论

    Delphi不关心像"word"这样的类型转换，它将在arr[0..65535]数组外部读取，其中pos=65535:arr[word(pos + 10)]

    相关讨论

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    #include <stdio.h>
    int main (void)
    {
      long a = -1;
      unsigned b = 1;
      printf ("%d
    ", a > b);
      return 0;
    }
    相关讨论

    α：

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

    在不变区域性中，逗号不是小数点符号，而是组分隔符。

    正如我所知，对于来自某些地区的初学者来说，这是一个常见的错误。

    相关讨论

    在C中，

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

    不明确，打印的内容取决于编译器。编译器可以在计算+X之前或在语句末尾存储X++的新值。

    在C++中，我发现"虚拟"MI(多重继承)允许"菱形"类层次结构"工作"是奇怪和令人厌恶的。

    1
    2
    3
    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对象。

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

    这是一个奖励糟糕的类设计、惩罚编译器编写者的语言特性，并让您在运行时怀疑对象到底在哪里——以及是否有任何虚拟MI包放错了位置。

    如果您真的需要类层次结构中的菱形模式，可以使用常规的mi和委托给单个a基的"approxy"来完成。

    1
    2
    3
    4
    5
     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)

    对于那些真正喜欢Diamond Mi的人来说，这需要做更多的工作，让我们的其他人拥有更易于处理的语言特性。

    相关讨论

    用Java语言

    1
    2
    3
    String("aaa")==String("aaa") //false
    //you need to use
    String("aaa").equals(String("aaa")) // true
    相关讨论

    我觉得这很奇怪：

    在C/C++中，至少可以在MS C++中拥有尽可能多的分号：

    1
    2
    3
    4
    5
    6
    int main(void)
    {
     cout<<"Hello World";;;;;;;;;;;;;;;;;;;;;;;;;;;;
     ;;;;;
     return 0;;;;;;;;;;;;;;;;;;;;;;;
    }
    相关讨论

    PHP

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    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()的情况并非如此，它失败的原因是：

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

    我认为这些语言中有很多是用C语言编写的，但我不确定。

  • 将此处文档作为函数参数传递：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    function foo($message)
    {
        echo $message ."
    ";
    }

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

  • 可以在参数列表中指定变量。

    1
    2
    foo($message ="Hello");
    echo $message;

    这是因为赋值是返回赋值的表达式。这是最常见的C样式错误之一的原因，执行一个分配而不是比较。

    • Python

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    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有非常不寻常的区分大小写规则：表区分大小写，列名-字符串值不：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    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)
    相关讨论

    在C：

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

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

    此程序将返回1(真)。

    相关讨论

    不知道它是不是一个特性。对一些人来说，是的，但对其他人来说，这可能是一种令人讨厌的行为。不管怎样，我觉得值得一提。

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

    对于Py 2x，

    1
    2
    3
    4
    5
    6
    7
    8
    >>> round(0.4)
    0.0
    >>> round(0.5)
    1.0
    >>> round(0.51)
    1.0
    >>> round(1.5)
    2.0

    对于Py 3x，

    1
    2
    3
    4
    5
    6
    7
    8
    >>> round(0.4)
    0
    >>> round(0.5)
    0
    >>> round(0.51)
    1
    >>> round(1.5)
    2

    我只是不熟悉Py3x中的round()与0的工作方式。

    PY 2X和PY 3X中的round()文件。

    相关讨论

    任何东西都会自动地将任何类和成员名称复数或奇点化。

    例如，Linq to SQL

    相关讨论

    在Python中：

    1
    2
    3
    i = 1
    ++i
    print i

    打印"1"。行"++i"的计算结果为+(+i)(python不支持递增运算符)

    相关讨论

    在C中，您可以在接口上使用新的操作符。

    相关讨论

    今天的所有语言：

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

    运行时失败，出现"强制转换为类型A失败异常"-消息(或类似消息)。这告诉我们程序员是多么的懒惰。他们无法生成消息"无法为类型A的变量"a"赋值，值为"some"operation"返回类型B的"u typeb(1,2,3)"。Noooo…他们的座右铭是"犯错误的人必须受苦"。

    相关讨论

    find JavaScript的约会对象的爱的delightful 110年。 尝试它。 ＜／P >

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    <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);
    //-->

    剧本是在西班牙-对不起，如果你不明白的代码。为你的思想"冰"110到看到结果。 ＜／P >

    相关讨论

    一般来说，打字不好。

    丙：

    1
    2
    printf("%c
    ", 'a' + 3);

    PHP:

    1
    echo 5 +"3";

    还有太多的其他语言。

    相关讨论

    模-2没有elseif或else if；它有elsif。

    相关讨论

    Java的整数类的基数转换静态方法。：p似乎很少有语言内置了这种功能。

    PHP

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

    世界跆拳道联盟？http://en.wikipedia.org/wiki/scope_resolution_operator

    为什么不说unexpected T_SCOPE_RESOLUTION_OPERATOR？

    相关讨论

    comefrom是我见过的最奇怪，也可能是最无用的语言特性。

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

    不是真正的语言功能，但有趣/很棒的功能使用是达夫的设备。

    相关讨论

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

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

    只要在上面的查询中点击返回，就会将answer设置为空字符串，通过if answer in ...测试，并作为正确答案进行处理。简而言之：

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

    和往常一样，这里的python行为在数学和逻辑上都是无可挑剔的。正如我在很久以前的集合论课上所记得的：空集合是每个集合的一个成员。

    当我被它咬了几次的时候，这仍然是令人惊讶的，但我不会有任何其他的方式。

    在MODY重写中

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

    将导致：

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

    最后：

    1
    Error 500 Too Many Redirects

    (一般来说，我发现编辑.htaccess文件就像构造一个正常工作的正则表达式一样乏味。)

    相关讨论

    在C.

    国际会计准则；

    (&；A)[0]=10；/*将值10赋给*/

    (&A)[0]相当于*(&A+0)，它给了我们*(&A)，它只不过是a。

    相关讨论

    Objective-C对字符串使用@。示例：@"这是一个字符串。"

    相关讨论

    C中：A =康德？B:C；如果"b"和"c"是"分配不兼容"，则即使"a"是对象，也永远不会得到结果。它是MS中经常使用和最愚蠢实现的运算符。要进行比较，请参阅D语言中的实现(关于类型推断的注释)。

    相关讨论

    2000年Perl Journal的模糊Perl竞赛的最佳展示条目：

    1
    2
    3
    4
    5
    #:: ::-| ::-| .-. :||-:: 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"
    ";
    #.: ::||-| .||-| :|||-| ::||-| ||-:: :|||-| .:|

    代码完全由其作者在http://mysite.verizon.net/les.peters/id2.html上解释。

    相关讨论

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    #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"
    }

    Perl。P＞＜／

    打印"foo"N"foo除非美元；P＞＜／

    在Java中(这是一个导致赋值的if语句)

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

    或

    1
    2
    3
    4
    5
    6
    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

    相关讨论

    在C++中

    1
    2
    3
    4
    5
    6
    const char* wtf()
    {
        char buf[100];
        return buf;
    }
    string s = ... + wtf() + ...;

    在s.party string、party stack contents中创建有趣的值，并与零混合，以便s.length()！=strlen(s.c_str())。最奇怪的是，编译器在返回指向堆栈的指针方面绝对没有问题——如果他在堆栈中添加警告，编译器程序员的手可能会掉下来。

    相关讨论

    JavaScript：

    1
    ( {} == {} ) == false
    相关讨论

    我肯定会给Perl带来许多可怕的例子：

    1
    if(!$#var)

    或

    1
    if($mystring =~ m/(\d+)/) {
    相关讨论

    和JavaScript。 ＜／P >

    2 = = [ 2 ] ＜／P >

    甚至stranger / / 2 = = [ [ [ 2 ] ] ] ＜／P >

    / /和井下的坚果 var a = { 1 }："ABC"； [ [ [ [ ] ] ] ]"ABC"= = ="abc"[一] / /这是真也； ＜／P >

    luckily的类folks在stackoverflow.com explained全我的东西：stackoverflow.com /问题/ 1724255 /为什么不- 2 - 2 -和- JavaScript ＜／P >

    相关讨论

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

    1
    2
    int* t = new int(15);
    delete t;
    相关讨论

    tcl中的串联将添加两个字符串，它将变为一个字符串：

    1
    2
    3
    4
    set s1"prime"
    set s2"number"
    set s3 $s1$s2
    puts s3

    输出是

    primenumber

    相关讨论

    你可以在Java中投掷任何可投掷的东西。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    class YourBoss extends Throwable {
    }
    public class Main{
      public void main(String[] s) throws YourBoss {
       try{
        throw new YourBoss();
       }catch(Exception e){
       }catch(Error e){
       }
      }
    }
    相关讨论

    愚蠢的语言。真的！

    相关讨论