Хэл Фултон - Программирование на языке Ruby
На первый взгляд, методы to_s и to_str могут вызвать недоумение. Ведь оба преобразуют объект в строковое представление, так?
Но есть и различия. Во-первых, любой объект в принципе можно как-то преобразовать в строку, поэтому почти все системные классы обладают методом to_s. Однако метод to_str в системных классах не реализуется никогда.
Как правило, метод to_str применяется для объектов, очень похожих на строки, способных «замаскироваться» под строку. В общем, можете считать, что метод to_s — это явное преобразование, а метод to_str — неявное.
Я уже сказал, что ни в одном системном классе не определен метод to_str (по крайней мере, мне о таких классах неизвестно). Но иногда они вызывают to_str (если такой метод существует в соответствующем классе).
Первое, что приходит на ум, — подкласс класса String; но на самом деле объект любого класса, производного от String, уже является строкой, так что определять метод to_str излишне.
А вот пример из реальной жизни. Класс Pathname определен для удобства работы с путями в файловой системе (например, конкатенации). Но путь естественно отображается на строку (хотя и не наследует классу String).
require 'pathname'
path = Pathname.new("/tmp/myfile")
name = path.to_s # "/tmp/myfile"
name = path.to_str # "/tmp/myfile" (Ну и что?)
# Вот где это оказывается полезно...
heading = "Имя файла равно " + path
puts heading# " Имя файла равно /tmp/myfile"
В этом фрагменте мы просто дописали путь в конец обычной строки "Имя файла равно". Обычно такая операция приводит к ошибке во время выполнения, поскольку оператор + ожидает, что второй операнд — тоже строка. Но так как в классе Pathname есть метод to_str, то он вызывается. Класс Pathname «маскируется» под строку, то есть может быть неявно преобразован в String.
На практике методы to_s и to_str обычно возвращают одно и то же значение, но это необязательно. Неявное преобразование должно давать «истинное строковое значение» объекта, а явное можно расценивать как «принудительное» преобразование.
Метод puts обращается к методу to_s объекта, чтобы получить его строковое представление. Можно считать, что это неявный вызов явного преобразования. То же самое справедливо в отношении интерполяции строк. Вот пример:
class Helium
def to_s
"He"
end
def to_str
"гелий"
end
end
e = Helium.new
print "Элемент "
puts e # Элемент He.
puts "Элемент " + e # Элемент гелий.
puts "Элемент #{e}" # Элемент He.
Как видите, разумное определение этих методов в собственном классе может несколько повысить гибкость применения. Но что сказать об идентификации объектов, переданных методам вашего класса?
Предположим, например, что вы написали метод, который ожидает в качестве параметра объект String. Вопреки философии «утипизации», так делают часто, и это вполне оправдано. Например, предполагается, что первый параметр метода File.new — строка.
Решить эту проблему просто. Если вы ожидаете на входе строку, проверьте, имеет ли объект метод to_str, и при необходимости вызывайте его.
def set_title(title)
if title.respond_to? :to_str
title = title.to_str
end
# ...
end
Ну а если объект не отвечает на вызов метода to_str? Есть несколько вариантов действий. Можно принудительно вызвать метод to_s; можно проверить, принадлежит ли объект классу String или его подклассу; можно, наконец, продолжать работать, понимая, что при попытке выполнить операцию, которую объект не поддерживает, мы получим исключение ArgumentError.
Короткий путь к цели выглядит так:
title = title.to_str rescue title
Он опирается на тот факт, что при отсутствии реализации метода to_str возникнет исключение. Разумеется, модификаторы rescue могут быть вложенными:
title = title.to_str rescue title.to_s rescue title
# Обрабатывается маловероятный случай, когда отсутствует даже метод to_s.
С помощью неявного преобразования можно было бы сделать строки и числа практически эквивалентными:
class Fixnum
def to_str
self.to_s end
end
str = "Число равно " + 345 # Число равно 345.
Но я не рекомендую так поступать: «много хорошо тоже нехорошо». В Ruby, как и в большинстве языков, строки и числа — разные сущности. Мне кажется, что ясности ради преобразования, как правило, должны быть явными.
И еще: в методе to_str нет ничего волшебного. Предполагается, что он возвращает строку, но если вы пишете такой метод сами, ответственность за то, что он действительно так и поступает, ложится на вас.
2.17. Дописывание в конец строки
Для конкатенации строк применяется оператор <<. Он «каскадный», то есть позволяет выполнять подряд несколько операций над одним и тем же операндом-приемником.
str = "А"
str << [1,2,3].to_s << " " << (3.14).to_s
# str теперь равно "А123 3.14".
Если число типа Fixnum принадлежит диапазону 0..255, то оно будет преобразовано в символ:
str = "Marlow"
str << 101 << ", Christopher"
# str теперь равно "Marlowe, Christopher".
2.18. Удаление хвостовых символов новой строки и прочих
Часто бывает необходимо удалить лишние символы в конце строки. Типичный пример — удаление символа новой строки после чтения строки из внешнего источника.
Метод chop удаляет последний символ строки (обычно это символ новой строки). Если перед символом новой строки находится символ перевода каретки (r), он тоже удаляется. Причина такого поведения заключается в том, что разные операционные системы неодинаково трактуют понятие «новой строки». В UNIX-подобных системах новая строка представляется символом n. А в DOS и Windows для этой цели используется пара символов rn.
str = gets.chop # Прочитать, удалить символ новой строки.
s2 = "Some stringn" # "Some string" (нет символа новой строки).
s3 = s2.chop! # s2 теперь тоже равно "Some string".
s4 = "Other stringrn"
s4.chop! # "Other string" (нет символа новой строки).
Обратите внимание, что при вызове варианта chop! операнд-источник модифицируется.
Важно еще отметить, что последний символ удаляется, даже если это не символ новой строки:
str = "abcxyz"
s1 = str.chop # "abcxy"
Поскольку символ новой строки присутствует не всегда, иногда удобнее применять метод chomp:
str = "abcxyz"
str2 = "123n"
str3 = "123r"
str4 = "123rn"
s1 = str.chomp # "abcxyz"
s2 = str2.chomp # "123"
# Если установлен стандартный разделитель записей, то удаляется не только
# n, но также r и rn.
s3 = str3.chomp # "123"
s4 = str4.chomp # "123"
Как и следовало ожидать, имеется также метод chomp! для замены «на месте». Если методу chomp передана строка-параметр, то удаляются перечисленные в ней символы, а не подразумеваемый по умолчанию разделитель записей. Кстати, если разделитель записей встречается в середине строки, то он не удаляется:
str1 = "abcxyz"
str2 = "abcxyz"
s1 = str1.chomp("yz") # "abcx"
s2 = str2.chomp("x") # "abcxyz"
2.19. Удаление лишних пропусков
Метод strip удаляет пропуски в начале и в конце строки, а вариант strip! делает то же самое «на месте».
str1 = "t nabc tn"
str2 = str1.strip # "abc"
str3 = str1.strip! # "abc"
#str1 теперь тоже равно "abc".
Под пропусками, как обычно, понимаются пробелы, символы табуляции и перевода на новую строку.
Чтобы удалить пропуски только в начале или только в конце строки, применяйте методы lstrip и rstrip:
str = " abc "
s2 = str.lstrip # "abc "
s3 = str.rstrip # " abc"
Имеются также варианты lstrip! и rstrip! для удаления «на месте».
2.20. Повтор строк
В Ruby оператор (или метод) умножения перегружен так, что в применении к строкам выполняет операцию повторения. Если строку умножить на n, то получится строка, состоящая из n конкатенированных копий исходной:
etc = "Etc. "*3 # "Etc. Etc. Etc. "
ruler = " + " + (". "*4+"5" + "."*4+" + ")*3
# "+....5....+....5....+....5....+"
2.21. Включение выражений в строку
Это легко позволяет сделать синтаксическая конструкция #{}. Нет нужды думать о преобразовании, добавлении и конкатенации; нужно лишь интерполировать переменную или другое выражение в любое место строки:
puts "#{temp_f} по Фаренгейту равно #{temp_c} по Цельсию"
