Мы нередко пользуемся исключениями, чтобы уйти от кодов возврата. Но никто не мешает возвращать коды ошибки, если вам так хочется. К тому же в Ruby метод может возвращать более одного значения.
В таком механизме часто возникает необходимость. Когда-то символ NUL кода ASCII вообще не считался символом. В языке С есть понятие нулевого указателя (
NULL
), в Pascal есть указатель
nil
, в SQL NULL означает отсутствие какого бы то ни было значения. В Ruby, конечно, тоже есть свой
nil
.
Проблема в том, что такие метазначения часто путают
с действительными значениями. В наши дни все считают NUL настоящим символом кода ASCII. И в Ruby нельзя сказать, что
nil
не является объектом; его можно хранить, над ним можно выполнять какие-то операции. Поэтому не вполне понятно, как интерпретировать ситуацию, когда
hash [key]
возвращает
nil
: то ли указанный ключ вообще не найден, то ли с ним ассоциировано значение
nil
.
Идея в том, что иногда символы могут выступать в роли подходящих метазначений. Представьте метод, который получает строку из сети (возможно, по протоколу HTTP или иным способом). При желании можно было бы вернуть нестроковое значение как индикатор исключительной ситуации.
str = get_string
case str
when String
# Нормальная обработка.
when :eof
# Конец файла, закрытие сокета и т.п.
when :error
# Ошибка сети или ввода/вывода.
when :timeout
# Ответ не получен вовремя.
end
Можно ли сказать, что это «лучше», чем механизм исключений? Необязательно. Но такую методику стоит иметь в виду, особенно когда приходится обрабатывать «граничные случаи», которые не считаются ошибками.
6.1.3. Символы, переменные и методы
Наверное, чаще всего символы применяются для определения атрибутов класса:
class MyClass
attr_reader :alpha, :beta
attr_writer :gamma, :delta
attr_accessor :epsilon
# ...
end
Имейте в виду, что в этом фрагменте на самом деле исполняется некий код. Например,
attr_accessor
использует имя символа для определения имени переменной экземпляра, а также методов для ее чтения и изменения. Это не означает, что всегда имеется точное соответствие между символом и именем переменной экземпляра. Например, обращаясь к методу
instance_variable_set
, мы должны задать точное имя переменной, включая и знак @:
sym1 = :@foo
sym2 = :foo
instance_variable_set(sym1,"str") # Правильно.
instance_variable_set(sym2,"str") # Ошибка.
Короче говоря, символ, передаваемый методам из семейства
attr
, — всего лишь аргумент, а сами эти методы создают требуемые переменные и методы экземпляра, основываясь на значении символа. (В конец имени метода изменения добавляется знак равенства, а в начало имени переменной экземпляра — знак @.) Бывают также случаи, когда символ должен точно соответствовать идентификатору, на который ссылается.
В большинстве случаев (если не во всех!) методы, ожидающие
на входе символ, принимают также строку. Обратное не всегда верно.
6.1.4. Преобразование строки в символ и обратно
Строки и символы можно преобразовывать друг в друга с помощью методов
to_str
и
to_sym
:
a = "foobar"
b = :foobar
a == b.to_str # true
b == a.to_sym # true
Для метапрограммирования иногда бывает полезен такой метод:
class Symbol
def +(other)
(self.to_s + other.to_s).to_sym
end
end
Он позволяет конкатенировать символы (или дописывать строку в конец символа). Ниже приведен пример использования; мы принимаем на входе символ и пытаемся определить, представляет ли он какой-нибудь метод доступа (то есть существует ли метод чтения или установки атрибута с таким именем):
class Object
def accessor?(sym)
return (self .respond_to?(sym) and self .respond_to?(sym+"="))
end
end
Упомяну также о более изощренном способе применения символов. Иногда при выполнении операции map нужно указать сложный блок. Однако во многих случаях мы просто вызываем некоторый метод для каждого элемента массива или набора:
list = words.map {|x| x.capitalize }
He кажется ли вам, что для такой простой задачи слишком много знаков препинания? Давайте вместо этого определим метод
to_proc
в классе
Symbol
. Он будет приводить любой символ к типу объекта
proc
. Но какой именно объект
proc
следует вернуть? Очевидно, соответствующий самому символу в контексте объекта; иными словами, такой, который пошлет сам символ в виде сообщения объекту.
def to_proc
proc {|obj, *args| obj.send(self, *args) }
end
Кстати, этот код заимствован из проекта Гэвина Синклера (Gavin Sinclair) «Расширения Ruby». Имея такой метод, мы можем следующим образом переписать первоначальный код:
list = words.map(&:capitalize)
Стоит потратить немного времени и разобраться, как это работает. Метод
map
обычно принимает только блок (никаких других параметров). Наличие знака
&
(амперсанд) позволяет передать объект
proc
вместо явно указанного блока. Поскольку мы применяем амперсанд к объекту, не являющемуся proc, то интерпретатор пытается вызвать метод
to_proc
этого объекта. Получающийся в результате объект proc подставляется вместо явного блока, чтобы метод
map
вызывал его для каждого элемента массива. А зачем передавать
self
в виде сообщения элементу массива? Затем, что объект
proc
является замыканием и, следовательно, помнит контекст, в котором был создан. А в момент создания
self
был ссылкой на символ, для которого вызывался метод