Добавьте его в модель

has_one :sender, :class_name => "User"
has_one :recipient, :class_name => "User"

И вы можете вызвать @ message.sender и @ message.recipient и обе ссылки на пользовательскую модель.

Вместо user: references в команде создания вам понадобится sender: references и recipient: references

На самом деле больше нет такого понятия, как «ядро». Раньше был стандартный дистрибутив Perl, но у многих людей нет стандартного дистрибутива Perl. Дистрибутивы операционной системы изменяют его, добавляя или удаляя модули, меняя модули и т. д. Нельзя полагаться на то, что стандартное распределение действительно является стандартным. Некоторые дистрибутивы Linux даже не включают документацию Perl как часть базовой установки Perl.

Вы говорите, что вы не можете использовать Module:: CoreList , потому что он не является ядром, но если вы можете создать файлы, вы можете установить модуль. Можно даже притвориться, что написал сам.

В J большинство примитивов (а.к. функции) являются монадическими (один аргумент) или диадическими (два аргумента, один слева, один справа). Но поправка примитив занимает 3 (я думаю, что это единственный, кроме иностранцев). Понятно, что это займет 3, но это просто выглядит... сначала неправильно.

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

в j , иностранные (!: ) различные функции, свернутые вместе. Левый аргумент - это категория, где, как правило, часто (но не всегда) инкрементные значения для разных ... вещей. Например:

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

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

В awk массивы начинаются с индекса 1, что сбивает с толку наименее.

В Питоне, по крайней мере для меня, это было очень сильно! Первый раз, когда я увидел это:

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

Ты можешь умножать строки! WTF???

PS: Я думаю, это потому, что x * n означает: n раз x так что 5 раз "ja " это "ja ""ja ""ja ""ja " и потому что вы можете соединять строки вот так:

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

Что два кода имеют один и тот же результат (и, возможно, просто один и тот же)

In C#, следующий код генерирует ошибку компилятора "Cannot convert from method group to Delegate" (Невозможно преобразовать из группы методов в Delegate). И хотя логика, лежащая в основе ошибки, разумна, она все же кажется мне странной.

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

имплантат variables\constants и мутирующие константы в рубине

В Java существует некоторая несогласованность в том, как Strings обрабатывают оператор == в зависимости от того, как он был построен.

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

Исходный файл Java может заканчиваться символом \ u001a (control-Z).

Вот один о питоне:

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

Разве это не красота?

Особенно невнимательно, когда вы думаете о том, как люди пишут даты, у которых есть следующий эффект:

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

(причина в том, что 0x интерпретируется как восьмеричное, поэтому print 010 выводит 8 !)

Ну, первое, что пришло мне в голову, было «нет», мой мозг сделал то же самое, когда я впервые наткнулся на это!

В схеме нет зарезервированных идентификаторов . Итак, следующее выражение оценивается как 1:

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

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

(begin (define define 1) define)

Слабый набор текста, в общем.

C:

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

PHP:

echo 5 + "3";

И слишком много других языков.

Статические методы преобразования базы класса Integer Java. :P Похоже, что очень немногие языки имеют встроенную функциональность.

]Modula-2 не имеет []elseif[] или []else if[]; он имеет []elsif[][

Вот одна, которая мне показалась странной:

В языке Си/Си++ вы можете иметь столько точек с запятой, сколько захотите, по крайней мере, в MS C++:

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

COMEFROM - самая странная и, наверное, самая бесполезная языковая особенность, которую я когда-либо видел.

Runner-up был бы тернарным оператором, так как он нарушает правило #1 оптимизации. И он наносит больше вреда, чем решает проблемы. Он приносит больше вреда, потому что делает код менее читабельным.

На самом деле это не совсем языковая возможность, но интересное/очаровательное использование возможностей - это устройство Даффа .

Все автоматически умножает или сингулирует любые имена классов и членов.

Linq-to-Sql, например

PHP

PHP имеет непоследовательную обработку перегрузок, например, переменных и методов. Рассмотрим:

class Foo
{
    private $var = 'avalue';

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

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

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

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

Работает дамп $var. Несмотря на то, что $var является приватным, __get() вызывается для любого члена, который не существует или недоступен, и возвращает правильное значение. Это не случай для doStuff(), который не работает с:

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

Я думаю, что многое из этого работает в языках в стиле Си, но я не уверен.

1. Передайте здесь документ в качестве аргумента функции:

   функция foo($message)
   {
    эхо-сообщение . "\n";
   }
   
   foo(<

2. Вы можете присвоить переменную в списке аргументов.

   foo($message = "Hello");
   echo $message;
   

   Это работает, потому что присваивание - это выражение, которое возвращает присваиваемое значение. Это является причиной одной из наиболее распространенных ошибок в C-стиле, выполняющей присваивание вместо сравнения.

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

в Python , встроенная функция () () [) ведет себя немного по-разному между Python 2X и Python 3X.

для PY 2X,

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

для PY 3X,

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

Я просто не знаком с тем, как Round () в PY 3X работает с 0.

Docs для Круглый () в PY 2x и PY 3x .

в Python:

i = 1
++i
print i

Принты «1». Линия «++ I» оценивает + (+ I) (Python не поддерживает операторы приращения)

Я не знаю, правда ли это по-прежнему, но мы случайно обнаружили, что VS FORTRAN (66 или 77) не поддерживает рекурсию. Рекурсия была случайной, и наш F77 по умолчанию прекрасно ее поддерживал, но когда мы взяли источник в IBM - Whatta Mess.

«динамический» в C #.

Разрушает день для всех, кому приходится работать вместе с жертвой RAD или python, потому что Intellisense, безопасность типов и детерминизм мгновенно умирают при первом использовании ключевого слова dynamic.

Я однажды построил язык с предложением BUT, давным-давно.

На C:

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

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

Эта программа вернет 1 (true).

в Java

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

В ColdFusion текстовые значения автоматически преобразуются в различные типы данных для различных целей. Я столкнулся с странной проблемой, когда «00A» и «000» возвращались как равные. Оказалось, что ColdFusion интерпретировал «00A» как время, преобразовывая в какой-то числовой формат времени и преобразовывая его в 0. «000» преобразовывалось в 0. Таким образом, они оба считались эквивалентными. Именно тогда я узнал о функции сравнения строк.

И снова Haskell:

В Haskell вы можете обрабатывать файл произвольного размера, как если бы он был простой String . Файл будет прочитан только в том случае, если строка действительно используется. Из-за невероятной лени Haskell такая программа будет работать в постоянном пространстве, независимо от размера файла:

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

(Эта программа преобразует файл из стандартного ввода в стандартный вывод и заменяет LF на CRLF, взаимодействуют ] функция вводит весь стандартный ввод в функцию и перемещает вывод в стандартный вывод.)

Эта лень может также вызвать проблемы, потому что, если вы закроете дескриптор файла, вы не сможете быть полностью уверены, что ленивый Haskell уже проанализировал все данные от него.

В C,

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

Неясно, что будет напечатано, зависит от компилятора. Компилятор может сохранить новое значение x ++ до вычисления ++ x или в конце оператора.

Язык BrainFuck . Это действительно так!