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

Импорт - это синтаксический сахар, который позволяет избежать ввода, например, java.io.File file = new java.io.File («foo.txt») каждый раз, но позволяет вводить File File = new File («foo.txt») .

Больше ничего.

Таким образом, если не требуется создать новый объект или назначить объект переменной, а также не требуется запись имени класса в полном объеме, импорт не требуется.

(в приведенном выше описании интерфейсы рассматриваются как подкласс)

Переменные\константы и изменяемые константы в рубине

в Руби...

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

Это не странная особенность, на самом деле она имеет полный смысл, если подумать, но все же дала мне момент WTF.

В C++(и в C#) подклассы базы не могут получить доступ к приватным и защищенным членам на экземпляре базы.

class Base {
protected:
 m_fooBar;
};

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

Можно записать функцию в файл .profile для переключения псевдонимов

function toggle-ruby() {
  if [ "$1" == "1.9" ]; then
    alias ruby=/opt/local/bin/ruby1.9
  else
    alias ruby=/opt/local/bin/ruby1.8
  fi
}

, а затем запустить

toggle-ruby 1.9

или

toggle-ruby 1.8

для переключения назад и вперед.

Выбор DISTINCT можно выполнить с помощью GROUP BY без AGGREGATES .

Сослагательный падеж в английском языке.

Подождите, вы имели в виду языки программирования? Затем с помощью (macro) в C для обхода препроцессора # определите из macro () . Например, если кто-то имеет # define free (...) , (free) (...) не будет таким же, как free (...) .

В PHP следующее:

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

- синтаксическая ошибка.

Если вы действительно хотите {, за которым следует содержимое $ foo , вам придется использовать . :

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

Processing (processing.org) - это язык, основанный на Java. Проще говоря, компилятор обработки - это препроцессор Java, который переводит специфичный для обработки синтаксис в Java.

Из-за дизайна языка в нем есть несколько сюрпризов:

Класс обработки компилируется во внутренний класс Java, это вызывает некоторое раздражение, например, частные переменные, которые на самом деле не являются частными

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

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

, также отсутствует функция draw () заставляет обработчики событий не вызываться:

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

В C ++ - возможность создавать защищенную абстрактную виртуальную базу чистого виртуального частного деструктора.

Это чистый виртуальный частный деструктор, унаследованный от защищенной абстрактной виртуальной базы.

IOW, деструктор, который может быть вызван только членами или друзьями класса (частный), и которому присваивается 0 (чисто виртуальный) в базовом классе (абстрактной базе), который его объявляет, и который будет определен. later / overriden в производном классе, который разделяет множественную унаследованную базу (виртуальную базу) защищенным способом.

Технически не язык WTF, а архитектурный.

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

Сборка 6502, непрямой JMP:

Обратите внимание, что с непрямым переходом не связан перенос, поэтому:

КОСВЕННЫЙ JUMP НИКОГДА НЕ ДОЛЖЕН ИСПОЛЬЗОВАТЬ ВЕКТОР

, НАЧИНАЮЩИЙСЯ НА ПОСЛЕДНЕМ БАЙТЕ

СТРАНИЦЫ

. Например, если адрес $ 3000 содержит $ 40, $ 30FF содержит $ 80, а $ 3100 содержит $ 50, результат JMP ($ 30FF) будет быть передачей управления на 4080 долларов, а не на 5080 долларов, как вы предполагали, т.е. 6502 взял младший байт адреса из 30FF и старший байт из 3000 долларов.

Таким образом, добавление одного байта к вашему коду может привести к тому, что ваш непрямой прыжок будет сильно отклоняться от цели.

Остальные не имеют ничего общего с поразительным оператором Ruby Flip-Flop:

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

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

Да, состояние программы хранится в дереве синтаксического анализа интерпретатора. Вот почему на создание совместимой реализации Ruby уходит целая вечность. Но я прощаю тебя, Руби <3

Perl может автоматически преобразовывать основание 26 в основание 10, если вы можете жить с собой по утрам...

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

sa = "a =" "a =" "" "a" "" ", @ a =" "" "2N" "" ", a =" "" "c =" "" "" _ ("" "" 22 "" ""? @ a), @ a "", @ a, a = "" a "", a (c) = "" S + "" _ c , e = $ T (@@ a @ (c)) ", @ a

это хороший однострочник в COS (сценарий кеширования объектов). Интересно отметить 5 различных режимов косвенного обращения к коду * G

Как насчет аккуратных системно-зависимых переполнений, вызывающих переносы года в (MRI / C) Ruby и MacRuby (но не в JRuby) с последующими ошибками местного времени для большего числа. Не частая проблема, но странная:

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

Однако это может быть специфическим для 64-битных сред.

Попробуйте, кроме как

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

Если не было поймано ни одного исключения, то выполняется другая часть.

Логично, но поначалу я действительно понятия не имел, что она делает.

Example:

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

В C, a[b][c] точно такая же, как c[b[a]].

Пометка брейка и продолжение выражений на Java..

Они позволяют вырваться из нескольких блоков управления с одним перерывом.

В MySQL сравнения строк не чувствительны к регистру.

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

Все они эквалентны. Мало того, что они будут соответствовать любому значению foo, которое выглядит как 'bar' (например, если foo = 'bar', то оно будет соответствовать для BAR, baR, bAR и т.д.)

Ничего странного или удивительного, но это то, что заставило меня всегда говорить WTF:

Чувствительность к регистру в синтаксисе, или в именах идентификаторов.

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

Хаскелл использует Может быть и Просто . Может быть является конструктором типа, который возвращает тип Просто , но Может быть, Int не принимает просто Int, а требует, чтобы это был Просто Int или Ничего . Так что по существу в хаскелевом языке Just Int - это примерно столько же Int, сколько яблоко - это апельсин. Единственная связь заключается в том, что Только 5 возвращает тип Может быть Interger, который может быть построен с помощью функции Только и Интегрального аргумента. Это имеет смысл, но это примерно так же сложно объяснить, как это может быть теоретически, для чего и нужен хаскелл, верно? Так же как и Просто на самом деле JustKindaLikeButNotAtAtAll yea sorta, и это Maybe really a KindaLooksLikeOrIsNothing, yea sorta again.

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

Удачи с чтением, надеюсь, что это правильно.

] Какой тип данных foo? [

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

] Почему все идет на ноль? [

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

]...кроме этого[

SELECT CAST('' AS decimal)

В SQL-сервере вы можете получить неприятный сюрприз, если вы используете , выбрав * в своем производственном коде. Использование select * в любом случае не считается хорошей практикой, но полезно знать о некоторых интересных действиях.

Смотрите вопрос "select * from table" vs "select colA,colB,etc from table" интересное поведение в SqlServer2005 для более подробной информации

Тернарный оператор Python

В Python тернарный оператор C (пример C++: bool isNegative = i < 0 ? true : false;) доступен в виде синтаксического сахара:

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

На самом деле это не странно, а особенность. Странным является измененный порядок (A if CONDITION else B) по сравнению с (IMO более логичным) порядком в C (CONDITION ? A : B).

Не так давно, когда я впервые познакомился с языком Си в своем классе CS, было очень странно наблюдать за поведением указателей. мы просто писали программы и угадывали, что они будут делать, пока они не получат правильное поведение

C# имеет функцию, называемую "методы расширения", которая примерно аналогична Ruby mix-ins - По сути, вы можете добавить метод к любому существующему определению класса (например, вы могли бы добавить "reverse()" в String, если бы были так наклонны). Сама по себе "странность" заключается в том, что вы можете добавить эти методы расширения, с телом метода и всем остальным, в интерфейс . С одной стороны, это может быть удобно как способ добавить один метод к целому ряду классов, которые не являются частью одного и того же дерева наследования. С другой стороны, вы добавляете методы во плоскости к интерфейсам, существенно нарушая само определение интерфейса.

Препроцессор C и его использование. В частности, препроцессорное метапрограммирование и использование препроцессора для генерации переносимого кода -- total mindfcuk.

это поразило меня

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

Perl

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

Вторая строка является синтаксической ошибкой, хотя даже опытному perl программисту кажется, что она будет идентична. Недостатком Perl является то, что всегда пытаешься делать то, что имеешь в виду, а не то, что говоришь.

В PHP вы должны явно ссылаться на глобулы и явно использовать this-> для переменных класса. Делает рефакторинг забавным. Вы не можете продвигать переменную/параметр к глобалу или члену класса, не найдя всех точек использования.

Smalltalk:

Имейте метод класса в классе Test, который возвращает постоянную строку:

method1
    ^ 'niko'

Вы должны ожидать, что этот метод постоянно возвращает строку 'niko', что бы ни случилось. Но это не тот случай.

s := Test method1 

(Установить s на 'niko'.)

s at: 4 put: $i.

(Установить s на 'niki'.)

s := Test method1

(Установить s на 'niki' снова.)

Итак, что происходит, так это то, что вторая строка код навсегда изменил method1, чтобы вернуть niki, а не niko, даже несмотря на то, что исходный код метода не был обновлен.

сдвиг;

иногда можно увидеть в самой первой строке метода perl, чтобы прочитать самонаводящийся указатель

Я думаю, что попытаюсь ответить на свой собственный вопрос, предоставив некоторую обновленную информацию о дальнейших исследованиях, которые я провел. По умолчанию старые версии заглушек Axis2 могут быть только «совместимыми с потоком» (не могут одновременно выполнять вызовы одного и того же экземпляра заглушки из нескольких потоков, но вызовы различных экземпляров являются нормальными).

См., например:

http://markmail.org/message/3lu7x7pfo47vgnck http://markmail.org/message/sljyf6lpecxqllgx

При отсутствии вызова метода cleanup/cleanupTransport могут возникнуть некоторые утечки сокетов, а также отсутствие сокетов.

http://issues.apache.org/jira/browse/AXIS2-3670

В некоторых случаях, по крайней мере, лежащий в его основе StartClient теперь кажется защищенным от потоков, но в зависимости от того, как вы создали ваш клиент, вся заглушка может быть не такой:

http://amilachinthaka.blogspot.com/2009/05/improving-axis2-client-http-transport.html

Использование области памяти xData зависит от архитектуры системы. Некоторые системы могут иметь ОЗУ по этому адресу, в то время как другие могут иметь ПЗУ или флэш-память. В любом случае доступ будет медленнее, чем доступ к внутреннему ОЗУ, ПЗУ или флэш-памяти.

Вообще говоря, большие предметы, постоянные предметы и менее используемые предметы должны переходить в xData. Нет стандартных правил относительно того, что происходит в xData, поскольку это зависит от архитектуры.

В ColdFusion

Struct (иначе Java HashMap) передается по ссылке.

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

Массив - это , переданный значением , wtf!

Список - это только старый ряд, разделенный запятыми!

В javascript «функция» является примитивным типом переменной, который может иметь переменная. Javascript также неплотно набран, поэтому значение переменной зависит от последнего, что ей было присвоено. «event» является только член переменной объекта окна. Таким образом, вы можете назначить его тому, что вам нравится. Если он никогда не был назначен чему-либо, он примет примитивное значение «undefined» в javascipt. Таким образом, проверка для:

if (typeof window.onload != 'function') {

действительно проверяет, был ли обработчик событий window.onload еще определен или нет.

Если он еще не определен, то эта функция назначает func обработчику событий window.onload (т.е. func будет вызван при загрузке окна).

Если она была определена ранее, то эта функция создаст новую функцию, которая вызовет существующий обработчик onload, а затем func при загрузке окна. В этом примере также используется свойство/language-feature javascript под названием «closure», так что вновь определенная функция «compose» имеет доступ к переменным выше своей области действия, которые сохраняются после того, как внешняя функция теряет область действия.

Возможно, более значимой проверкой будет:

if (typeof window.onload === 'undefined') {

Есть ли причина, по которой вы не переворачиваете порядок A и B? Когда вы плаваете что-то прямо с текстом, порядок инвертируется.

В Unity

GameObject.Find("MyObject")

возвращает объект в обычном режиме. Однако если сделать что-то подобное:

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

Тогда вы получите нулевую ссылку. В Unity iPhone этот код часто будет хорошо работать в редакторе, но вызовет SIGBUS при запуске с iPhone. Проблема в том, что GameObject.Find () будет находить только активные объекты, поэтому даже если вы просто проверяете, является ли он активным, вы эффективно вызываете if (null.active).

Чтобы он работал правильно, необходимо сохранить его до того, как он станет неактивным.

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

Возможно, это в любом случае лучше, но то, как Unity относится к неактивным объектам в целом, довольно странно. Похоже, он выгружает большую часть неактивного объекта (текстуры и т.д.), но не всю его часть, поэтому неактивные объекты могут по-прежнему съедать много памяти.