Что Ruby является аналогом к Метаклассам Python?

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

В некоторых объектно-ориентированных языках объекты создаются конструкторами. Однако в Ruby нет конструкторов. Конструкторы - это всего лишь фабричные методы (с дурацкими ограничениями); нет причин использовать их на хорошо разработанном языке, если вместо этого вы можете просто использовать (более мощный) фабричный метод.

Создание объекта в Ruby работает следующим образом: построение объекта делится на две фазы: размещение и инициализация . Распределение выполняется общедоступным методом класса allocate , который определяется как метод экземпляра класса Class и обычно никогда не переопределяется. (На самом деле, я не думаю, что вы на самом деле можете переопределить его.) Он просто выделяет пространство памяти для объекта и устанавливает несколько указателей, однако объект на данный момент не может использоваться.

Здесь на помощь приходит инициализатор: это метод экземпляра с именем initialize , который устанавливает внутреннее состояние объекта и переводит его в согласованное, полностью определенное состояние, которое может использоваться другими объектами.

Итак, чтобы полностью создать новый объект, вам нужно сделать следующее:

x = X.allocate
x.initialize

[Примечание: программисты Objective-C могут это понять.]

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

class Class
  def new(*args, &block)
    obj = allocate
    obj.initialize(*args, &block)

    return obj
  end
end

[Примечание: на самом деле initialize является закрытым, поэтому необходимо использовать отражение для обхода таких ограничений доступа: obj.send (: initialize, * args, & block ) ]

Это, кстати, причина, по которой для создания объекта вы вызываете метод открытого класса Foo.new , но вы реализуете метод частного экземпляра Foo # initialize , что, кажется, сбивает с толку многих новичков.

Однако ничего из этого никоим образом не встроено в язык.Тот факт, что основной фабричный метод для любого класса обычно называется new , является просто соглашением (и иногда мне хотелось бы, чтобы он был другим, потому что он похож на конструкторы в Java, но полностью ] другой). В других языках у конструктора должно быть определенное имя. В Java он должен иметь то же имя, что и класс, что означает, что а) может быть только один конструктор и б) анонимные классы не могут иметь конструкторов, потому что у них нет имен. В Python фабричный метод должен называться __ new __ , что опять же означает, что может быть только один. (И в Java, и в Python вы, конечно, можете иметь разные фабричные методы, но их вызов выглядит иначе, чем вызов по умолчанию, тогда как в Ruby (и в Smalltalk, откуда возник этот шаблон) он выглядит точно так же.)

В Ruby , может быть сколько угодно фабричных методов с любым именем, а фабричный метод может иметь много разных имен. (Для классов коллекций, например, фабричный метод часто имеет псевдоним [], что позволяет писать List [1, 2, 3] вместо List.new (1, 2) , 3) , который больше похож на массив, что подчеркивает коллекционную природу списков.)

Вкратце:

• стандартизированный заводской метод - Foo.new , но это может быть что угодно
• Foo.new вызывает allocate для выделения памяти для пустого объекта foo
• Foo.new затем вызывает foo.initialize , т.е.метод экземпляра Foo # initialize
• все три из них являются такими же методами, как и любые другие, которые вы можете отменить, переопределить, переопределить, обернуть, использовать псевдоним и еще много чего
• , кроме allocate , которому необходимо выделить память внутри среды выполнения Ruby, чего нельзя сделать в Ruby

В Python, __ new __ примерно соответствует как new , так и allocate в Ruby, а __ init __ точно соответствует initialize в Ruby. Основное отличие состоит в том, что в Ruby new вызывает initialize , тогда как в Python среда выполнения автоматически вызывает __ init __ после __ new __ .

Например, вот класс, который позволяет создавать максимум 2 экземпляра:

class Foo
  def self.new(*args, &block)
    @instances ||= 0
    raise 'Too many instances!' if @instances >= 2

    obj = allocate
    obj.send(:initialize, *args, &block)

    @instances += 1

    return obj
  end

  attr_reader :name

  def initialize(name)
    @name = name
  end
end

one = Foo.new('#1')
two = Foo.new('#2')
puts two.name         # => #2
three = Foo.new('#3') # => RuntimeError: Too many instances!