Модули

Модули в Ruby служат двум целям: именованным пространствам и функциональности миксинов.

Именованное пространство может использоваться для организации кода по пакетам или функциональности, которая отделяет общие имена от конфликтов с другими пакетами. Например, именованное пространство IRB предоставляет функциональность для irb, предотвращая коллизию для общего имени «Context».

Функциональность миксинов позволяет совместно использовать общие методы между несколькими классами или модулями. Ruby поставляется с модулем миксинов Enumerable, который предоставляет множество методов перечисления, основанных на методе each и Comparable, позволяющем сравнивать объекты на основе метода сравнения <=>.

Обратите внимание, что между модулями и классами существует много сходства. Помимо возможности включения модуля, описание модулей ниже также относится к классам.

Определение модуля

Модуль создается с использованием ключевого слова module.

module MyModule
  # ...
end

Модуль может быть повторно открыт любое количество раз, чтобы добавить, изменить или удалить функциональность:

module MyModule
  def my_method
  end
end

module MyModule
  alias my_alias my_method
end

module MyModule
  remove_method :my_method
end

Повторное открытие классов — очень мощная функция Ruby, но лучше всего повторно открывать только свои классы. Повторное открытие классов, которые вам не принадлежат, может привести к конфликтам имен или трудно диагностируемым ошибкам.

Вложенность

Модули могут быть вложенными:

module Outer
  module Inner
  end
end

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

Вы также можете определить внутренние модули с помощью ::, при условии, что внешние модули (или классы) уже определены:

module Outer::Inner::GrandChild
end

Обратите внимание, что это вызовет NameError, если Outer и Outer::Inner еще не определены.

Этот стиль имеет преимущество, позволяющее автору сократить количество отступов. Вместо 3 уровней отступов необходим только один. Однако область поиска констант отличается при создании именованного пространства с помощью этого синтаксиса по сравнению с более громоздким синтаксисом.

Область видимости

self

self относится к объекту, определяющему текущую область видимости. self будет изменяться при переходе к другому методу или при определении нового модуля.

Константы

Доступные константы различаются в зависимости от вложенности модуля (какой синтаксис был использован для определения модуля). В следующем примере константа A::Z доступна из B, так как A является частью вложенности:

module A
  Z = 1

  module B
    p Module.nesting #=> [A::B, A]
    p Z #=> 1
  end
end

Однако, если вы используете :: для определения A::B без вложенности внутри A, будет поднято исключение NameError, потому что вложенность не включает A.

module A
  Z = 1
end

module A::B
  p Module.nesting #=> [A::B]
  p Z #=> raises NameError
end

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

Z = 0

module A
  Z = 1

  module B
    p ::Z #=> 0
  end
end

Методы

Для документации определения методов см. документацию синтаксиса методов.

Методы класса могут вызываться непосредственно. (Это немного запутанно, но метод в модуле часто называют «методом класса», а не «методом модуля». См. также Module#module_function, который может преобразовать метод экземпляра в метод класса.)

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

Методы экземпляров, определенные в модуле, могут вызываться только при включении. Эти методы имеют доступ к константам, определенным при их включении, через список предков:

module A
  Z = 1

  def z
    Z
  end
end

include A

p self.class.ancestors #=> [Object, A, Kernel, BasicObject]
p z #=> 1

Видимость

Ruby имеет три типа видимости. По умолчанию — public. Публичный метод может вызываться из любого другого объекта.

Вторая видимость — protected. При вызове защищенного метода отправитель должен быть подклассом получателя или получатель должен быть подклассом отправителя. В противном случае будет выброшено исключение NoMethodError.

Защищенная видимость чаще всего используется для определения == и других методов сравнения, когда автор не хочет раскрывать состояние объекта любому вызывающему объекту и хотел бы ограничить его только унаследованными классами.

Вот пример:

class A
  def n(other)
    other.m
  end
end

class B < A
  def m
    1
  end

  protected :m

end

class C < B
end

a = A.new
b = B.new
c = C.new

c.n b #=> 1 -- C is a subclass of B
b.n b #=> 1 -- m called on defining class
a.n b # raises NoMethodError A is not a subclass of B

Третья видимость — private. Приватный метод не может быть вызван с получателем, даже если получателем является self. Если приватный метод вызывается с получателем, будет выброшено исключение NoMethodError.

alias и undef

Вы также можете переименовывать или удалять методы, но эти операции не ограничены модулями или классами. См. раздел документации по различным синтаксисам.

Классы

Каждый класс также является модулем, но в отличие от модулей, класс нельзя включать в другой модуль (или класс). Как и модуль, класс можно использовать в качестве именованного пространства. Класс также наследует методы и константы от своего суперкласса.

Определение класса

Используйте ключевое слово class для создания класса:

class MyClass
  # ...
end

Если вы не укажете суперкласс, ваш новый класс унаследует от Object. Вы можете унаследовать от другого класса с помощью < за которым следует имя класса:

class MySubclass < MyClass
  # ...
end

Существует специальный класс BasicObject, предназначенный как пустой класс и включающий минимум встроенных методов. Вы можете использовать BasicObject для создания независимой структуры наследования. См. документацию BasicObject для получения дополнительной информации.

Наследование

Любой метод, определенный в классе, может быть вызван из его подкласса:

class A
  Z = 1

  def z
    Z
  end
end

class B < A
end

p B.new.z #=> 1

То же самое верно и для констант:

class A
  Z = 1
end

class B < A
  def z
    Z
  end
end

p B.new.z #=> 1

Вы можете переопределить функциональность метода суперкласса, переопределив метод:

class A
  def m
    1
  end
end

class B < A
  def m
    2
  end
end

p B.new.m #=> 2

Если вы хотите вызвать функциональность суперкласса из метода, используйте super:

class A
  def m
    1
  end
end

class B < A
  def m
    2 + super
  end
end

p B.new.m #=> 3

Когда используется без каких-либо аргументов, super использует аргументы, переданные методу подкласса. Чтобы не передавать аргументы методу суперкласса, используйте super(). Чтобы передать конкретные аргументы методу суперкласса, укажите их вручную, как в super(2).

super может вызываться любое количество раз в методе подкласса.

Синглтон классы

Синглтон-класс (также известный как метакласс или собственный класс) объекта — это класс, который хранит методы только для этого экземпляра. Вы можете получить доступ к синглтон-классу объекта с помощью class << object так:

class C
end

class << C
  # self is the singleton class here
end

Чаще всего вы увидите доступ к синглтон-классу так:

class C
  class << self
    # ...
  end
end

Это позволяет определить методы и атрибуты в классе (или модуле) без необходимости писать def self.my_method.

Поскольку вы можете открыть синглтон-класс любого объекта, это означает, что данный фрагмент кода:

o = Object.new

def o.my_method
  1 + 1
end

эквивалентен этому фрагменту кода:

o = Object.new

class << o
  def my_method
    1 + 1
  end
end

Оба объекта будут иметь метод my_method, который вернет 2.