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

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

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

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

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

class Bank

def open_safe

# ...

end

def close_safe

# ...

end

private :open_safe, :close_safe

def make_withdrawal(amount)

if access_allowed

open_safe

get_cash(amount)

close_safe

end

end

# Остальные методы закрытые.

private

def get_cash

# ...

end

def access_allowed

# ...

end

end

Поскольку методы из семейства attrпросто определяют методы, метод privateопределяет и видимость атрибутов.

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

Модификатор доступа protectedналагает меньше ограничений. Защищенные методы доступны только экземплярам того класса, в котором определены, и его подклассов. Для защищенного метода разрешается указывать вызывающий объект, так что к ним можно обращаться из других объектов (при условии, что вызывающий и вызываемый объекты принадлежат одному классу). Обычно защищенные методы применяются для определения методов доступа, чтобы два объекта одного типа могли взаимодействовать. В следующем примере объекты класс Personможно сравнивать по возрасту, но сам возраст недоступен вне класса Person:

class Person

def initialize(name, age)

@name, @age = name, age

end

def <=>(other)

age <=> other.age

end

attr_reader :name, :age

protected :age

end

p1 = Person.new("fred", 31)

p2 = Person.new("agnes", 43)

compare = (p1 <=> p2) # -1

x = p1.age # Ошибка!

Чтобы завершить картину, модификатор publicделает метод открытым. Неудивительно!..

И последнее: методы, определенные вне любого класса и модуля (то есть на верхнем уровне программы), по умолчанию закрыты. Поскольку они определены в классе Object, то видимы глобально, но обращаться к ним с указанием вызывающего объекта нельзя.

Встроенные методы Object#cloneи #dupпорождают копию вызывающего объекта. Различаются они объемом копируемого контекста. Метод #dupкопирует только само содержимое объекта, тогда как cloneсохраняет и такие вещи, как синглетные классы, ассоциированные с объектом.

s1 = "cat"

def s1.upcase

"CaT"

end

s1_dup = s1.dup

s1_clone = s1.clone

s1 #=> "cat"

s1_dup.upcase #=> "CAT" (синглетный метод не копируется)

s1_clone.upcase #=> "СаТ" (используется синглетный метод)

И dup, и cloneвыполняют поверхностное копирование, то есть копируют лишь содержимое самого вызывающего объекта. Если вызывающий объект содержит ссылки на другие объекты, то последние не копируются — копия будет ссылаться на те же самые объекты. Проиллюстрируем это на примере. Объект arr2— копия arr1, поэтому изменение элемента целиком, например arr2[2], не оказывает влияния на arr1. Но исходный массив и его копия содержат ссылку на один и тот же объект String, поэтому изменение строки через arr2приведет к такому же изменению значения, на которое ссылается arr1.

arr1 = [ 1, "flipper", 3 ]

arr2 = arr1.dup

arr2[2] = 99

arr2[1][2] = 'a'

arr1 # [1, "flapper", 3]

arr2 # [1, "flapper", 99]

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

Самый «чистый» способ — потребовать, чтобы классы реализовывали метод deep_copy. Он мог бы рекурсивно обходить все объекты, на которые ссылается исходный объект, и вызывать для них метод deep_copy. Необходимо было бы еще добавить метод deep_copyво все встроенные классы Ruby, которыми вы пользуетесь.

Но есть и более быстрый способ с использованием модуля Marshal. Если вы сериализуете исходный объект, представив его в виде строки, а затем загрузите в новый объект, то этот новый объект будет копией исходного.

arr1 = [ 1, "flipper", 3 ]

arr2 = Marshal.load(Marshal.dump(arr1))

arr2[2] = 99

arr2[1][2] = 'a'

arr1 # [1, "flipper", 3]

arr2 # [1, "flapper", 99]

Обратите внимание, что изменение строки через arr2не отразилось на строке, на которую ссылается arr1.

При копировании объекта методом dupили cloneконструктор не вызывается. Копируется вся информация о состоянии.

Но что делать, если вам такое поведение не нужно? Рассмотрим пример:

class Document

attr_accessor :title, :text

attr_reader :timestamp

def initialize(title, text)

@title, @text = title, text

@timestamp = Time.now

end

end

doc1 = Document.new("Random Stuff",File.read("somefile"))

sleep 300 # Немного подождем...

doc2 = doc1.clone

doc1.timestamp == doc2.timestamp # true

# Оп... временные штампы одинаковы!

При создании объекта Documentс ним ассоциируется временной штамп. При копировании объекта копируется и его временной штамп. А как быть, если мы хотим запомнить время, когда было выполнено копирование?