Странная языковая особенность

] Еще один голос за JavaScript:[

parseInt('08') == 0

], потому что все, что имеет лидирующее 0, интерпретируется как восьмеричное (странное), а недействительные восьмеричные числа оцениваются до нуля (BAD). Я обнаружил это в августе, когда код, который я не трогал месяцами, сломался сам по себе. Как оказалось, он бы исправился в октябре.[

]Октябрьская поддержка, по-видимому, устарела, так что будущие поколения JavaScripter'ов не будут иметь этого обряда прохождения.[

Неожиданной особенностью были трейлинговые запятые в списках enum def и списках инициализации массивов на C, C#, Ruby и др.

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

public enum ArtPeriod {
  Modern,
  Romantic,
  Dada,
}

В Visual Basic 7 и выше я нашел реализацию логической оценки короткого замыкания для поддержания совместимости с наследственным Visual Basic <=6 кодом немного WTF:

AndAlso (MSDN)
OrElse (MSDN)

В Javascript я считаю, что следующие эквивалентны:

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

В C++ можно вызывать статические методы из нулевых указателей - смотрите!

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

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

Этот застал меня врасплох...

В MATLAB (язык, ориентированный на интерактивные массивы, в настоящее время TIOBE 20) есть ключевое слово end для обозначения последнего элемента массива (соответствует NumPy -1). Таким образом, это хорошо известный синтаксис MATLAB:

myVar = myArray(end)

Для получения элемента из середины массива обычно пишут:

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

Удивительно, но ключевое слово end вовсе не является ключевым словом, а является своего рода переменной:

myVar = myArray( ceil( end/2 ) )

Присвоение переменных в JavaScript может создавать глобальные переменные. Если переменной присваивается значение внутри функции и она не объявлена как var в той же области видимости, то она неявно объявляется глобальной.

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

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

Обратите внимание, что оператор var также может быть использован после присвоения переменной значения:

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

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

В Matlab следующее может вызывать удивление, особенно если вы привыкли к Python:

>> not true

ans =

     0     0     0     0
>> not false

ans =

     0     0     0     0     0

Здесь есть две странные особенности. Во-первых, ab интерпретируется как a ('b') , поэтому неверно интерпретируется как not ('true') . Вторая странная особенность заключается в том, что not любого символа возвращает 0 (предположительно потому, что в matlab нет false или true , только 0 или 1 ).

javascript:

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

Atari BASIC:

Вы можете заполнить строку символом без написания цикла:

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

В Java,

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

Это выводит "nullhello".

NSIS (система установки сценариев Nullsoft) имеет инструкцию StrCmp :

 StrCmp str1 str2 jump_if_equal [jump_if_not_equal]

Сравнивает (без учета регистра) str1 с str2. Если str1 и str2 равны, Gotos jump_if_equal, в противном случае Gotos jump_if_not_equal.

 StrCmp $ 0 "строка" 0 +3
DetailPrint '$$ 0 == "строка"'
Перейти к +2
DetailPrint '$$ 0! = "Строка"'

Вишенка на торте: jump_if_equal и jump_if_not_equal тоже могут быть отрицательными. Но я думаю, вы уже догадались об этом по символу + перед положительными числами. Не помню, обязательно это или просто ужасная условность.

Это в основном сочетание худшего из BASIC и худшего из Assembler.

Ищете функцию? Почему не язык?

Я люблю PHP, но кажется, что он всегда построен так: «О, дерьмо! Я забыл это! Давайте просто добавим еще один аргумент функции», что приведет к следующему:

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

Обратите внимание на лишнее подчеркивание и другой порядок аргументов.

Вот еще кое-что

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

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

Python 2.x демонстрирует плохую реализацию понимания списка:

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

Этот код возвращает 254. Переменная понимания списка сталкивается с определенным верхним.

Python 3.x избавился от этой функции, но в замыканиях по-прежнему используется динамическое связывание для внешних переменных и добавлено множество WTF в функциональном стиле программиста Python

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

В Perl (без «использовать строгие» или «использовать предупреждения»):

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

Печать:

True
False
True

Весь язык программирования Malbolge: http://en.wikipedia.org/wiki/Malbolge

В двух словах: множественное наследование. Это не имеет смысла и не создает ничего, кроме неприятностей.

Edit - я имею в виду MI на C++, а не микширование и тому подобное на Java и других языках.

Диграфы и альтернативные маркеры

C (ISO/IEC 9899:1999, 6.4.6/3) и C++ (ISO/IEC 14882:2003, 2.5) имеют редко используемую функцию, называемую "диграфами" на C и "альтернативными маркерами" на C++. Они отличаются от триграфов главным образом тем, что содержащие их строковые литералы никогда не будут интерпретироваться по-другому.

%:include <stdio.h>

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

С++ имеет гораздо больше, в том числе и , или , и не, которые должны вести себя как &&, ||, и !!. В C они тоже есть, но для их использования требуется включить , рассматривая их как макросы, а не как жетоны. Заголовок C++ буквально пустой файл.

Стоит отметить, что GCC реализует поддержку этой странной возможности языка, но многие другие компиляторы при попытке скомпилировать вышеприведенный сегмент кода задыхаются и погибают.

C#, например, порядок смены имен

.

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

Потому что

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

Чередование вещей на многих языках:

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

на первый взгляд: как b на самом деле не может быть равна самому себе!? На самом деле это напечатало бы только нечетные числа

]Perl's []sub[] не имеет реального списка параметров, только массив @_. Также в []sub[] происходит автоматическое размывание передаваемых в него параметров.[

] Я не понимаю, почему это постоянная особенность; это отражает то, что мне пришлось делать в качестве кляджа на моем TI-86 BASIC много лет назад, потому что этот язык не был достаточно популярен. [

Переменные в PHP

Странная возможность в PHP, позволяющая создавать и присваивать переменные из содержимого других переменных (предупреждение, непроверенный код):

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

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

Хорошо, допустим, у нас есть нечто подобное:

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

Как насчет того, чтобы позабавиться со всеми видами индирекции:

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

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

function getVarName() { return 'juliet'; }

В массивах ColdFusion начинаются с 1.

На C++ можно сделать:

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

Но нельзя:

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

Перегрузка оператора, как правило, подвержена WTF.

Perl's $[ (устаревший), об этом упоминалось в другой более ранней заметке об общих переменных perl, но это заслуживает особого упоминания с более подробным объяснением. Изменения в $[ ограничены текущей областью видимости. Дополнительную информацию и быструю запись о том, как это можно использовать и как это влияет ;) можно найти в $[ находится под уважением по адресу http://www.perlmonks.org/index.pl/?node_id=480333

На Питоне:

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

Возвращается ~18.03, что является расстоянием между точками (10,5) и (25,5) по теореме Пифагора. Это происходит потому, что Python имеет поддержку комплексных чисел на родном языке, например, в виде 2+2j. Так как абсолютное значение комплексного числа в виде a+bj = sqrt(a^2+b^2), то при вычитании одного комплексного числа из другого мы получаем расстояние, а затем применяем над ним функцию abs (абсолютную).

не то чтобы это сильно используется, но синтаксис "обратной ссылки на массив статического размера" С++ странный:

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

ofc, в данном случае метод может быть объявлен как статический const

Конструкция списка PHP:

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

Feature: Баш, оболочка Korn (ksh93) и оболочка Z позволяют подписывать массивы переменных со знаком доллара или без него:

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

Это, со знаком доллара, даст ожидаемое значение 10000:

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

Strangeness: Если убрать знак доллара из RANDOM, то итоговая сумма будет изменяться случайным образом, даже до 10000.

Аналогично, это производит 3 вместо 2:

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

И вы не можете использовать там знак доллара, потому что это присваивание (a находится на lhs), хотя вы могли бы сделать это, если бы использовали идирекцию, но двойное присваивание все равно происходит.

Причина: При знаке доллара расширение переменной выполняется до арифметической оценки, поэтому выполняется только один раз. Без знака доллара оно выполняется дважды, один раз для вычисления индекса для поиска и еще раз для вычисления индекса для присваивания (так что, по сути, присваивание на одном шаге цикла может выглядеть как array[4] = $array[6] + 1, что полностью скремблирует массив).

Далее может изменить основание чисел в любое время:

HEX 10 DECIMAL 16 - .
0 Ok

Это не должно быть ни одного заранее определенного:

36 BASE ! 1Z DECIMAL .
71 Ok