Программирование на языке Ruby - Хэл Фултон

11.1.6. Опрос класса объекта

Часто возникает вопрос: «Что это за объект? Как он соотносится с данным классом?» Есть много способов получить тот или иной ответ.

Во-первых, метод экземпляра class всегда возвращает класс объекта. Применявшийся ранее синоним type объявлен устаревшим.

s = "Hello"

n = 237

sc = s.class # String

nc = n.class # Fixnum

He думайте, будто методы class или type возвращают строку, представляющую имя класса. На самом деле возвращается экземпляр класса Class! При желании мы могли бы вызвать метод класса, определенный в этом типе, как если бы это был метод экземпляра класса Class (каковым он в действительности и является).

s2 = "some string"

var = s2.class            # String

my_str = var.new("Hi...") # Новая строка.

Можно сравнить такую переменную с константным именем класса и выяснить, равны ли они; можно даже использовать переменную в роли суперкласса и определить на ее основе подкласс! Запутались? Просто помните, что в Ruby Class — это объект, a Object — это класс.

Иногда нужно сравнить объект с классом, чтобы понять, принадлежит ли данный объект указанному классу. Для этого служит метод instance_of?, например:

puts (5.instance_of? Fixnum)       # true

puts ("XYZZY".instance_of? Fixnum) # false

puts ("PLUGH".instance_of? String) # true

А если нужно принять во внимание еще и отношение наследования? К вашим услугам метод kind_of? (похожий на instance_of?). У него есть синоним is_a?, что вполне естественно, ибо мы описываем классическое отношение «является».

n = 9876543210

flag1 = n.instance_of? Bignum # true

flag2 = n.kind_of? Bignum     # true

flag3 = n.is_a? Bignum        # true

flag3 = n.is_a? Integer       # true

flag4 = n.is_a? Numeric       # true

flag5 = n.is_a? Object        # true

flag6 = n.is_a? String        # false

flag7 = n.is_a? Array         # false

Ясно, что метод kind_of или is_a? более общий, чем instance_of?. Например, всякая собака — млекопитающее, но не всякое млекопитающее — собака.

Для новичков в Ruby приготовлен один сюрприз. Любой модуль, подмешиваемый в класс, становится субъектом отношения «является» для экземпляров этого класса. Например, в класс Array подмешан модуль Enumerable; это означает, что всякий массив является перечисляемым объектом.

x = [1, 2, 3]

flag8 = x.kind_of? Enumerable # true

flag9 = x.is_a? Enumerable    # true

Для сравнения двух классов можно пользоваться также операторами сравнения. Интуитивно очевидно, что оператор «меньше» обозначает наследование суперклассу.

flag1 = Integer < Numeric # true

flag2 = Integer < Object  # true

flag3 = Object == Array   # false

flag4 = IO >= File        # true

flag5 = Float < Integer   # nil

В любом классе обычно определен оператор «тройного равенства» ===. Выражение class === instance истинно, если экземпляр instance принадлежит классу class. Этот оператор еще называют оператором ветвящегося равенства, потому что он неявно используется в предложении case. Дополнительную информацию о нем вы найдете в разделе 11.1.7.

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

# Искать открытые методы.

if wumpus.respond_to?(:bite)

 puts "У него есть зубы!"

else

 puts "Давай-ка подразним его."

end

# Необязательный второй параметр позволяет

# просматривать и закрытые методы.

if woozle.respond_to?(:bite,true)

 puts "Вузлы кусаются!"

else

 puts "Ага, это не кусающийся вузл."

end

Иногда нужно знать, является ли данный класс непосредственным родителем объекта или класса. Ответ на этот вопрос дает метод superclass класса Class.

array_parent = Array.superclass  # Object

fn_parent = 237.class.superclass # Integer

obj_parent = Object.superclass   # nil

У любого класса, кроме Object, есть суперкласс.

11.1.7. Проверка объектов на равенство

Все животные равны, но некоторые равнее других.

При написании своих классов желательно, чтобы семантика типичных операций была такой же, как у встроенных в Ruby классов. Например, если объекты класса можно упорядочивать, то имеет смысл реализовать метод <=> и подмешать модуль Comparable. Тогда к объектам вашего класса будут применимы все обычные операции сравнения.

Однако картина перестает быть такой однозначной, когда дело доходит до проверки объектов на равенство. В Ruby объекты реализуют пять разных методов для этой операции. И в ваших классах придется реализовать хотя бы некоторые из них, поэтому рассмотрим этот вопрос подробнее.

Самым главным является метод equal? (унаследованный от класса Object); он возвращает true, если вызывающий объект и параметр имеют один и тот же идентификатор объекта. Это фундаментальный аспект семантики объектов, поэтому переопределять его не следует.

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

Следующим в шкале абстракции стоит метод eql? — тоже часть класса Object. (На самом деле метод eql? реализован в модуле Kernel, который подмешивается в Object.) Как и оператор ==, этот метод сравнивает значения вызывающего объекта и аргумента, но несколько более строго. Например, разные числовые объекты при сравнении с помощью == приводятся к общему типу, но метод eql? никогда не считает объекты разных типов равными.

flag1 = (1 == 1.0)    # true

flag2 = (1.eql?(1.0)) # false

Метод eql? существует по одной-единственной причине: для сравнения значений ключей хэширования. Если вы хотите переопределить стандартное поведение Ruby при использовании объектов в качестве ключей хэша, то переопределите методы eql? и hash.

Любой объект реализует еще два метода сравнения. Метод === применяется для сравнения проверяемого значения в предложении case с каждым селектором: selector===target. Хотя правило на первый взгляд кажется сложным, на практике оно делает предложения case в Ruby интуитивно очевидными. Например, можно выполнить ветвление по классу объекта:

case an_object

 when String

  puts "Это строка."

 when Numeric

  puts "Это число."

 else

  puts "Это что-то совсем другое."

end

Эта конструкция работает, потому что в классе Module реализован метод ===, проверяющий, принадлежит ли параметр тому же классу, что вызывающий объект (или одному из его предков). Поэтому, если an_object — это строка «cat», выражение string === an_object окажется истинным и будет выбрана первая ветвь в предложении case.

Наконец, в Ruby реализован оператор сопоставления с образцом =~. Традиционно он применяется для сопоставления строки с регулярным выражением. Но если вы найдете ему применение в других классах, то можете переопределить.

У операторов == и =~ есть противоположные формы: != и !~ соответственно. Внутри они реализованы путем обращения значения основной формы. Это означает, что если, например, вы реализовали метод ==, то метод != получаете задаром.

11.1.8. Управление доступом к методам

В Ruby объект определяется, прежде всего, своим интерфейсом: теми методами, которые он раскрывает внешнему миру. Но при написании класса часто возникает необходимость во вспомогательных методах, вызывать которые извне класса опасно. Тут-то и приходит на помощь метод private класса Module.

Использовать его можно двумя способами. Если в теле класса или модуля вы вызовете private без параметров, то все последующие методы будут закрытыми в данном классе или модуле. Если же вы передадите ему список имен методов (в виде символов), то эти и только эти методы станут закрытыми. В листинге 11.5 показаны оба варианта.

class Bank

 def open_safe

  # ...

 end

 def close_safe

  # ...

 end