Термин duck typing ("утиная типизация" или просто "утипизация"), насколько я знаю, принадлежит Дейву Томасу (Dave Thomas) и восходит к поговорке: "если кто-то выглядит как утка, ковыляет как утка и крякает как утка, то, наверное, это и есть утка". Точный смысл термина "утипизация" - тема для дискуссий, но мне кажется, что это намек на тенденцию Ruby заботиться не столько о точном классе объекта, сколько о том, какие методы для него можно вызывать и какие операции над ним можно выполнять. В Ruby мы редко пользуемся методом is_a? или kind_of, зато гораздо чаще прибегаем к методу respond_to?. Обычное дело - просто передать объект методу, зная, что при неправильном использовании будет возбуждено исключение. Так оно рано или поздно и случается.
Унарную звездочку, которая служит для расширения массива, можно было бы назвать оператором расширения массива, но не думаю, что кто-нибудь слышал такое выражение. В хакерских кругах ходят словечки "звездочка" (star) и "расплющивание" (splat), а также производные определения - "расплющенный" (splatted) и "сплющенный" (unsplatted). Дэвид Алан Блэк придумал остроумное название "унарный оператор линеаризации" (unary unarray operator).
Термин синглет (singleton) многие считают перегруженным. Это вполне обычное английское слово, означающее вещь, существующую в единственном экземпляре. Пока мы используем его в качестве модификатора, никакой путаницы не возникает.
Но Singleton (Одиночка) - это еще и хорошо известный паттерн проектирования, относящийся к классу, для которого может существовать лишь один объект. В Ruby для реализации этого паттерна имеется библиотека singleton.
Синглетный класс (singleton class) в Ruby - подобная классу сущность, методы которой хранятся на уровне объекта, а не класса. Пожалуй, это не "настоящий класс", потому что его нельзя инстанцировать. Ниже приведен пример открытия синглетного класса для строкового объекта с последующим добавлением метода:
str = "hello"
class << str # Альтернатива:
def hyphenated # def str.hyphenated
self.split("").join("-")
end
end
str.hyphenated # "h-e-l-l-o"
Кто-то предложил использовать термин eigenclass (класс в себе) - производное от немецкого слова eigen (свой собственный), коррелирующее с термином "собственное значение" (eigenvalue), применяемым в математике и физике. Остроумно, но в сообществе не прижилось и некоторым активно не нравится.
Вернемся к предыдущему примеру. Поскольку метод hyphenate не существует ни в каком-либо другом объекте, ни в классе, это синглетный метод данного объекта. Это не вызывает неоднозначности. Иногда сам объект называется синглетным, поскольку он единственный в своем роде - больше ни у кого такого метода нет.
Однако вспомним, что в Ruby сам класс является объектом. Поэтому мы можем добавить метод в синглетный класс класса, и этот метод будет уникален для объекта, который - по чистой случайности - оказался классом. Пример:
class MyClass
class << self # Альтернатива: def self.hello
def hello # или: def MyClass.hello
puts "Привет от #{self}!"
end
end
end
Поэтому необязательно создавать объект класса MyClass для вызова этого метода.
MyClass.hello # Привет от MyClass!
Впрочем, вы, наверное, заметили, что это не что иное, как метод класса в Ruby. Иными словами, метод класса - синглетный метод объекта-класса. Можно также сказать, что это синглетный метод, определенный для объекта, который случайно оказался классом.
Осталась еще парочка терминов. Переменная класса - это, разумеется, то, имя чего начинается с двух символов @. Возможно, название неудачно из-за нетривиального поведения относительно наследования. Переменная экземпляра класса - нечто совсем иное. Это обычная переменная экземпляра; только объект, которому она принадлежит, является классом. Дополнительную информацию по этой теме вы найдете в главе 11.
1.7. Заключение
На этом завершается наш обзор объектно-ориентированного программирования и краткая экскурсия по языку Ruby. В последующих главах изложенный материал будет раскрыт более полно.
Хотя в мои намерения не входило "учить Ruby" новичков, не исключено, что даже начинающие программисты на Ruby почерпнут что-то полезное из этой главы. Как бы то ни было, последующие главы будут полезны "рубистам" начального и среднего уровня. Надеюсь, что даже опытные программисты на Ruby найдут для себя что-то новенькое.
Глава 2. Строки
Когда-то элементарными кирпичиками мироздания считались атомы, потом протоны, потом кварки. Теперь таковыми считаются струны.
Дэвид Гросс, профессор теоретической физики,
Принстонский университет
В начале 1980-х годов один профессор информатики, начиная первую лекцию по структурам данных, не представился студентам, не сказал, как называется курс, не рассказал о его программе и не порекомендовал никаких учебников - а вместо этого сходу спросил: "Какой тип данных самый важный?"
Было высказано несколько предположений. Когда профессор услышал слово "указатели", он выразил удовлетворение, но все-таки не согласился со студентом, а высказал свое мнение: "Самым важным является тип символ".
У него были на то основания. Компьютерам предназначено быть нашими слугами, а не хозяевами, а человеку понятны только символьные данные. (Есть, конечно, люди, которые без труда читают и двоичные данные, но о них мы сейчас говорить не будем.) Символы, а стало быть, и строки, позволяют человеку общаться с компьютером. Любую информацию, в том числе и текст на естественном языке, можно закодировать в виде строк.
Как и в других языках, строка в Ruby - просто последовательность символов. Подобно другим сущностям, строки являются полноценными объектами. В программах приходится выполнять разнообразные операции над строками: конкатенировать, выделять лексемы, анализировать, производить поиск и замену и т.д. Язык Ruby позволяет все это делать без труда.
Почти всюду в этой главе предполагается, что байт - это символ. Но при работе в многоязычной среде это не совсем так. Вопросы интернационализации обсуждаются в главе 4.
2.1. Представление обычных строк
Строка в Ruby - это последовательность 8-битовых байтов. Она не завершается нулевым символом, как в С, и, следовательно, может содержать такие символы. В строке могут быть символы с кодами больше 0xFF, но такие строки имеют смысл, лишь если выбран некоторый набор символов (кодировка). Дополнительную информацию о кодировках вы найдете в главе 4.
Простейшая строка в Ruby заключается в одиночные кавычки. Такие строки воспринимаются буквально; в качестве управляющих символов в них распознаются только экранированная одиночная кавычка (\') и экранированный символ обратной косой черты (\\):
s1 = 'Это строка' # Это строка.
s2 = 'Г-жа О\'Лири' # Г-жа О'Лири.
s3 = 'Смотри в С:\\TEMP' # Смотри в C:\TEMP.
Строки, заключенные в двойные кавычки, обладают большей гибкостью. В них допустимо много других управляющих последовательностей, в частности для представления символов забоя, табуляции, возврата каретки и перевода строки. Можно также включать произвольные символы, представленные восьмеричными цифрами:
s1 = "Это знак табуляции: (\t)"
s2 = "Несколько символов забоя: xyz\b\b\b"
s3 = "Это тоже знак табуляции: \011"
s4 = "А это символы подачи звукового сигнала: \а \007"
Внутри строки, заключенной в двойные кавычки, могут встречаться даже выражения (см. раздел 2.21).
2.2. Альтернативная нотация для представления строк
Иногда встречаются строки, в которых много метасимволов, например одиночных и двойных кавычек и т.д. В этом случае можно воспользоваться конструкциями %q и %Q. Вслед за ними должна идти строка, обрамленная с обеих сторон символами-ограничителями; лично я предпочитаю квадратные скобки ([]).
При этом %q ведет себя как одиночные кавычки, a %Q - как двойные.
S1 = %q[Как сказал Магритт, "Ceci n'est pas une pipe."]
s2 = %q[Это не табуляция: (\t)] # Равнозначно 'Это не табуляция: \t'
s3 = %Q[А это табуляция: (\t)] # Равнозначно "А это табуляция: \t"
В обоих вариантах можно применять и другие ограничители, помимо квадратных скобок: круглые, фигурные, угловые скобки.
s1 = %q(Билл сказал: "Боб сказал: 'This is a string.'")
s2 = %q{Дpyгaя строка.}
s3 = %q<B этой строке есть специальные символы '" [ ] (){}.>
Допустимы также непарные ограничители. В этом качестве может выступать любой символ, кроме букв, цифр и пропусков (пробелов и им подобных), который имеет визуальное представление и не относится к числу перечисленных выше парных ограничителей.
s1 = %q:"Я думаю, что это сделала корова г-жи О'Лири," сказал он.:
s2 = %q*\r - это control-M, a \n - это control-J.*
2.3. Встроенные документы
Для представления длинной строки, занимающей несколько строк в тексте, можно, конечно, воспользоваться обычными строками в кавычках:
str = "Три девицы под окном
Пряли поздно вечерком..."
Но тогда отступ окажется частью строки.
Можно вместо этого воспользоваться встроенным документом, изначально предназначенным для многострочных фрагментов. (Идея и сам термин заимствованы из более старых языков.) Синтаксически он начинается с двух знаков <<, за которыми следует концевой маркер, нуль или более строк текста и в завершение тот же самый концевой маркер в отдельной строке:
str = <<EOF
Три девицы под окном
Пряли поздно вечерком...
EOF
Но следите внимательно, чтобы после завершающего концевого маркера не было пробелов. В текущей версии Ruby маркер в такой ситуации не распознается.
Встроенные документы могут быть вложенными. В примере ниже показано, как передать методу три представленных таким образом строки:
some_method(<<str1, <<str2, <<str3)
первый кусок
текста...
str1
второй кусок...
str2
третий кусок
текста.
str3
По умолчанию встроенный документ ведет себя как строка в двойных кавычках, то есть внутри него интерпретируются управляющие последовательности и интерполируются выражения. Но если концевой маркер заключен в одиночные кавычки, то и весь документ ведет себя как строка в одиночных кавычках:
str = <<'EOF'
Это не знак табуляции: \t
а это не символ новой строки: \n
EOF
Если концевому маркеру встроенного документа предшествует дефис, то маркер может начинаться с красной строки. При этом удаляются только пробелы из той строки, на которой расположен сам маркер, но не из предшествующих ей строк документа.
str = <<-EOF
Каждая из этих строк
начинается с пары
пробелов.
EOF
Опишу стиль, который нравится лично мне. Предположим, что определен такой метод margin:
class String
def margin
arr = self.split("\n") # Разбить на строки.
arr.map! {|x| x.sub!(/\s*\|/,"")) # Удалить начальные символы.
str = arr.join("\n") # Объединить в одну строку.
self.replace(str) # Подменить исходную строку.
end
end
Для ясности я включил подробные комментарии. В этом коде применяются конструкции, которые будут рассмотрены ниже - как в этой, так и в последующих главах. Используется этот метод так:
str = <<end.margin
|Этот встроенный документ имеет "левое поле"
|на уровне вертикальной черты в каждой строке.
|
| Можно включать цитаты,
| делать выступы и т.д.
end
В качестве концевого маркера естественно употребить слово end. (Впрочем, это дело вкуса. Выглядит такой маркер как зарезервированное слово end, но на самом деле этот выбор ничуть не хуже любого другого.) Каждая строка начинается с символа вертикальной черты, но эти символы потом отбрасываются вместе с начальными пробелами.
2.4. Получение длины строки
Для получения длины строки служит метод length. У него есть синоним size.
str1 = "Карл"
x = str1.length # 4
str2 = "Дойль"
x = str2.size # 5
2.5. Построчная обработка
Строка в Ruby может содержать символы новой строки. Например, можно прочитать в память файл и сохранить его в виде одной строки. Применяемый по умолчанию итератор each в этом случае перебирает отдельные строки:
str = "Когда-то\nдавным-давно...\nКонец\n"
num = 0
str.each do |line|
num += 1
print "Строка #{num}: #{line}"
end
Выполнение этого кода дает следующий результат:
Строка 1: Когда-то
Строка 2: давным-давно...
Строка 3: Конец
Альтернативно можно было бы воспользоваться методом each_with_index.
2.6. Побайтовая обработка
Поскольку на момент написания этой книги язык Ruby еще не поддерживал интернационализацию в полной мере, то символ и байт - по существу одно и то же. Для последовательной обработки символов пользуйтесь итератором each_byte:
str = "ABC"
str.each_byte {|char| print char, " " }
#Результат: 65 66 67.
В текущей версии Ruby строку можно преобразовать в массив односимвольных строк с помощью метода scan, которому передается простое регулярное выражение, соответствующее одному символу:
str = "ABC"
chars = str.scan(/./)
chars.each {|char| print char, " " }
#Результат: ABC.
2.7. Специализированное сравнение строк
В язык Ruby уже встроен механизм сравнения строк: строки сравниваются в привычном лексикографическом порядке (то есть на основе упорядочения, присущего данному набору символов). Но при желании можно задать собственные правила сравнения любой сложности.
Предположим, например, что мы хотим игнорировать английские артикли a, an и the, если они встречаются в начале строки, а также не обращать внимания на большинство знаков препинания. Для этого следует переопределить встроенный метод <=> (он вызывается из методов <, <=, > и >=). В листинге 2.1 показано, как это сделать.