Программирование на языке Ruby. Идеология языка, теория и практика применения

Предисловие

Предисловие ко второму изданию

В древнем Китае люди, в особенности философы, полагали, что под внешней оболочкой мира и любого существа скрыто нечто, чего нельзя ни объяснить, ни описать словами. Это нечто китайцы называли Дао, а японцы — До. На русский язык это слово можно перевести как Путь. Слово «до» входит в такие названия, как дзюдо, кендо, карате-до и айкидо. Это не просто боевые искусства, а целая философия и взгляд на жизнь.

Так и в языке программирования Ruby есть свои философия и способ мышления. Этот язык заставляет думать по-новому. Он помогает программистам получать удовольствие от своей работы. И не потому, что Ruby был создан в Японии, а потому, что программирование стало важной частью существования — по крайней мере, для некоторых людей, жизнь которых Ruby призван улучшить.

Как всегда, описать, что такое Дао, трудно. Я чувствую это, но не могу подыскать нужных слов даже на японском, моем родном языке. А вот один смельчак по имени Хэл Фултон попытался, и его первая попытка (первое издание этой книги) оказалась довольно удачной. Попытка номер два увенчалась еще лучшим результатом, чему немало способствовала помощь многих людей из сообщества пользователей Ruby. По мере того как Ruby набирает популярность (отчасти благодаря продукту Ruby on Rails), все важнее становится овладение секретами мастерства производительного программирования на этом языке. Надеюсь, что книга, которую вы держите в руках, поможет вам в решении этой задачи.

Удачной работы!

Юкихиро «Мац» Мацумото

Август 2006 года, Япония

Предисловие к первому изданию

Вскоре после того как я впервые познакомился с компьютерами в начале 1980-х годов, меня заинтересовали языки программирования. С тех пор я буквально помешался на этой теме. Думаю, причина такого интереса в том, что языки программирования — это способ выражения мыслей. Они по сути своей предназначены для человека.

Но вопреки этому факту языки программирования почему-то всегда оказывались в большей степени машинно-ориентированными. Многие из них спроектированы с учетом удобства для компьютеров.

По мере того как компьютеры становятся мощнее и дешевле, ситуация постепенно меняется. Возьмем, к примеру, структурное программирование. Машине все равно, насколько хорошо структурирована программа: она просто исполняет ее команда за командой. Идеи структурного программирования обращены к людям, а не к машинам. То же относится и к объектно-ориентированному программированию.

Пришло время проектировать языки, удобные для людей!

В 1993 году я разговаривал со своим коллегой о сценарных языках, их выразительности и перспективах. Я считал, что программирование пойдет именно по этому пути и будет ориентироваться на человека. Но меня не вполне устраивали существующие языки, такие как Perl и Python. Я хотел видеть язык более мощный, чем Perl, и более объектно-ориентированный, чем Python. Найти идеальный вариант мне не удалось, поэтому остался один выход: изобрести свой собственный.

Ruby — не самый простой язык, но ведь и человеческая душа не проста. Ей равно нравятся простота и сложность. Она не приемлет ни слишком примитивных, ни чересчур заумных вещей. Она ищет равновесия.

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

Как всегда, хочу выразить величайшую благодарность всем членам сообщества, сложившегося вокруг Ruby. Они — причина его успеха.

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

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

Юкихиро «Мац» Мацумото

Сентябрь 2001, Япония

Благодарности

Благодарности за второе издание

Здравый смысл подсказывает, что второе издание требует в два раза меньше работы, чем первое. Но здравый смысл ошибается.

Хотя значительная часть текста книги перекочевала прямиком из первого издания, даже эту часть пришлось сильно править. К каждому предложению приходилось ставить вопрос: «Сохранилось ли в 2006 году то, что было верно в 2001-м?» И это только начало!

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

Книга появляется на свет в результате усилий многих людей. Если говорить об издательстве, то я благодарен Дебре Вильямс Коули (Debra Williams Cauley), Соньлин Киу (Songlin Qiu) и Менди Фрэнк (Mandie Frank) за тяжелый труд и бесконечное терпение. Спасибо Джениль Бриз (Geneil Breeze) за неутомимое вычитывание и выпалывание сорняков из моего английского. Есть много других сотрудников, которых я не могу назвать, поскольку их работа проходила за кулисами и я никогда с ними не встречался.

За техническое редактирование отвечали главным образом Шашанк Дейт (Shashank Date) и Фрэнсис Хван (Francis Hwang). Они прекрасно справились со своей задачей — если остались какие-то ошибки, это всецело моя вина.

Большое спасибо людям, которые предлагали объяснения, писали код примеров и отвечали мне на многочисленные вопросы. Это сам Мац (Юкихиро Мацумото), Дейв Томас (Dave Thomas), Кристиан Нойкирхен (Christian Neukirchen), Чед Фаулер (Chad Fowler), Дэниэл Бергер (Daniel Berger), Армин Рерль (Armin Roehrl), Стефан Шмидль (Stefan Schmiedl), Джим Вайрих (Jim Weirich), Райан Дэвис (Ryan Davis), Дженни У. (Jenny W.), Джим Фриз (Jim Freeze), Лайл Джонсон (Lyle Johnson), Мартин Де Мелло (Martin DeMello), Март Лоуренс (Mart Lawrence), Рон Джеффрис (Ron Jeffries), Тим Хантер (Tim Hunter), Чет Хендриксон (Chet Hendrickson), Натаниэль Талбот (Nathaniel Talbott) и Бил Клеб (Bil Kleb).

Особая благодарность активным помощникам. Эндрю Джонсон (Andrew Johnson) здорово обогатил мои знания о регулярных выражениях. Пол Бэтли (Paul Battley) предоставил обширный материал для главы об интернационализации. Macao Муто (Masao Mutoh) помог в написании той же главы, а также снабдил меня материалами по GTK. Остин Зиглер (Austin Ziegler) научил меня секретам подготовки PDF-файлов. Калеб Теннис (Kaleb Tennis) дал материал по Qt. Эрик Ходел (Eric Hodel) помог в описании продуктов Rinda и Ring, а Джеймс Бритт (James Britt) внес большой вклад в главу о разработке приложений для Web.

И еще раз выражаю искреннюю благодарность и восхищение Мацу — не только за помощь, но и прежде всего — за создание Ruby. Domo arigato gozaimasu^[1]!

Еще раз хочу поблагодарить своих родителей. Они постоянно подбадривали меня и с нетерпением ждали выхода книги… Я еще сделаю из них программистов!

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

Благодарности за первое издание

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

Прежде всего, выражаю благодарность и восхищение Мацу (Юкихиро Мацумото), который создал язык Ruby. Domo arigato gozaimasu!

Спасибо Конраду Шнейкеру (Conrad Schneiker), который подал мне идею написать эту книгу и помог выработать ее общий план. Он же оказал мне неоценимую услугу, познакомив с языком Ruby в 1999 году.

Материалом для книги меня снабжали несколько человек. Первым хочу назвать Гая Хэрста (Guy Hurst), который написал значительную часть начальных глав, а также два приложения. Его помощь поистине бесценна.

Спасибо также другим помощникам, называя которых, я не придерживаюсь какого-то определенного порядка. Кэвин Смит (Kevin Smith) многое сделал для раздела главы 6, посвященного GTK, избавив меня от изучения сложной темы в условиях жесткого графика. Патрик Логан (Patrick Logan) пролил свет на графическую систему FOX GUI, описанную в той же главе. Чед Фаулер (Chad Fowler) в главе 9 углубился в тайны XML, а также помог при написании раздела о CGI.

Благодарю всех, кто правил корректуру, писал рецензии и помогал иными способами: Дона Мучоу (Don Muchow), Майка Стока (Mike Stok), Михо Огисима (Miho Ogishima) и уже упомянутых выше. Спасибо Дэвиду Эпштейну (David Eppstein), профессору математики, который ответил на вопросы по теории графов.

Одна из замечательных особенностей Ruby — поддержка со стороны сообщества пользователей. В списке рассылки и в конференции многие отвечали на мои вопросы, подавали идеи и всячески помогали. Опять же не придерживаясь определенного порядка, хочу упомянуть Дейва Томаса (Dave Thomas), Энди Ханта (Andy Hunt), Хи-Соб Парка (Hee-Sob Park), Майка Уилсона (Mike Wilson), Ави Брайанта (Avi Bryant), Ясуси Шоджи (Yasushi Shoji «Yashi»), Шуго Маэда (Shugo Maeda), Джима Вайриха (Jim Weirich) и Масаки Сукета (Masaki Suketa). Как это ни печально, но, скорее всего, кого-то я пропустил.

Очевидно, что книга никогда не вышла бы без помощи издателя. Многие работали над ней незримо для меня, но особенно я хотел бы поблагодарить Вильяма Брауна (William Brown), который тесно сотрудничал со мной и постоянно поощрял, и Скотта Мейера (Scott Meyer), который скрупулезно занимался объединением всех материалов. Других назвать не могу, потому что никогда о них не слышал. Но они знают себя сами.

Хочу поблагодарить своих родителей, которые следили за проектом издалека, подбадривали меня и даже дали себе труд ради меня освоить азы программирования.

Один мой друг как-то сказал: «Если ты написал книгу, которую никто не читает, значит, ты не написал ее вовсе». Поэтому напоследок я хочу поблагодарить читателей. Эта книга для вас. Надеюсь, что она окажется полезной.

Об авторе

Хэл Фултон — обладатель двух ученых степеней по информатике, полученных в Университете штата Миссисипи. Он четыре года преподавал информатику в колледже, пока не переехал в Остин, штат Техас, для работы по контрактам (в основном с отделением компании IBM в Остине). Более 15 лет он работал с различными версиями ОС UNIX, в том числе AIX, Solaris и Linux. С языком Ruby впервые познакомился в 1999 году, а в 2001 приступил к работе над первым изданием этой книги - второй книги на английском языке, посвященной Ruby. Фултон присутствовал на шести конференциях по Ruby и проводил презентации на четырех из них, в частности на первой европейской конференции по языку Ruby, состоявшейся в Карлсруэ (Германия). Сейчас Хэл работает в компании Broadwing Communications, располагающейся в Остине, и занимается вопросами, связанными с большим хранилищем данных и относящимися к нему телекоммуникационными приложениями. В работе он использует язык C++, СУБД Oracle и, конечно, Ruby.

Фултон по-прежнему постоянно присутствует в списке рассылки и в IRC-канале, посвященном Ruby, а также участвует в нескольких разрабатываемых проектах на Ruby. Он член Ассоциации по вычислительной технике (ACM — Association for Computing Machinery) и компьютерного общества IEEE (Институт инженеров по электротехнике и электронике). В свободное от работы время увлекается музыкой, чтением, искусством и фотографией. Кроме всего прочего, Хэл член общества по изучению Марса и энтузиаст космических полетов. Мечтал бы когда-нибудь совершить такой полет. Проживает в Остине, штат Техас.

Введение

Путь, о котором можно поведать, — не постоянный Путь.

Лao Цзы, «Дао де цзин»^[2]

Эта книга называется «Путь Ruby». Название нуждается в некотором пояснении.

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

Конечно, я не могу абсолютно точно сказать, в чем же состоит истинный дух Ruby. Эту задачу я оставляю Мацу, но подозреваю, что даже ему трудно будет облечь свои ощущения в слова.

Короче говоря, «Путь Ruby» — всего лишь книга, а Путь Ruby — удел создателя языка и сообщества в целом. Втиснуть его в рамки книги довольно трудно. И все- таки в этом введении я попытаюсь хотя бы отчасти передать неуловимый дух Ruby. Мудрый ученик не воспримет эту попытку как окончательный вердикт!

Не забывайте, что это второе издание. Большая часть введения сохранена, но впереди раздел «О втором издании», в котором описываются изменения и вновь включенный материал.

О втором издании

Все меняется, и Ruby — не исключение. Я пишу это введение в 2006 году, когда с момента выхода первого издания прошло уже почти пять лет. Настало время для обновления.

В это издание внесено немало исправлений и добавлено много нового материала. Прежняя глава 4 («Простые задачи, связанные с обработкой данных») превратилась в шесть глав, две из которых («Диапазоны и символы» и «Интернационализация в Ruby») совсем новые; в четыре остальных добавлены новые примеры и комментарии к ним. Сильно расширен материал о регулярных выражениях: теперь рассматриваются не только «классические» выражения, но и новая библиотека для их поддержки, Oniguruma.

Главы 8 и 9 раньше составляли одну главу. Она была разбита на две, поскольку из-за вновь добавленного материала оказалась слишком большой.

Аналогичным образом главы 18, 19 и 20 образовались в результате разделения главы 9. Приложения удалены, чтобы освободить место для основного материала.

Появились также следующие новые главы:

• глава 15, «Форматы данных в Ruby». Здесь рассматриваются форматы XML, RSS, графические файлы, создание PDF-файлов и другие вопросы;

• глава 16, «Тестирование и отладка». Речь идет о тестировании, профилировании, отладке, анализе кода и тому подобных вещах;

• в главе 17, «Создание пакетов и распространение программ», обсуждаются, в частности, инструмент setup.rb и создание пакетов в формате RubyGem;

• глава 21, «Инструменты разработки для Ruby», знакомит с поддержкой Ruby в редакторах и интегрированных средах разработки (IDE), утилитой ri и форматом RubyGem с точки зрения пользователя;

• в главе 22, «Сообщество Ruby», приводятся основные Web-сайты, списки рассылки, форумы, конференции, IRC-каналы по Ruby и прочие дополнительные сведения.

В широком смысле все главы в этой книге «новые». Каждую из них я подверг тщательной ревизии, внес сотни мелких и десятки крупных изменений. Был исключен материал, утративший актуальность и показавшийся мне не слишком важным. Я учел изменения в самом языке Ruby, а также добавил в каждую главу новые примеры и комментарии.

Возможно, вас интересует, что было добавлено в старые главы. Отвечаю: уже упомянутая библиотека регулярных выражений Oniguruma; математические библиотеки и классы, включая BigDecimal, mathn и matrix; такие новые классы, как Set и DateTime.

В главу 10, «Ввод/вывод и хранение данных», я добавил материал о методе readpartial, неблокирующем вводе/выводе и классе StringIO. Также рассмотрены форматы CSV, YAML и KirbyBase. В ту часть главы 10, которая посвящена базам данных, включены сведения о СУБД Oracle и SQLite, интерфейсе DBI, а также об объектно-реляционном отображении (Object-Relational Mappers — ORM).

Глава 11, «ООП и динамические механизмы в Ruby», пополнилась информацией о таких недавно добавленных в язык конструкциях, как initialize_copy, const_get, const_missing и define_method. Также я рассматриваю делегирование и перенаправление.

Глава 12, «Графические интерфейсы для Ruby», была переработана целиком (в особенности разделы, посвященные GTK и Fox). Раздел по QtRuby — новый от начала до конца.

В главе 14, «Сценарии и системное администрирование», теперь обсуждаются моментальный инсталлятор для Windows и ряд аналогичных пакетов. Кроме того, улучшен код примеров.

В главе 18, «Сетевое программирование», появились разделы о вложениях в электронные письма и о взаимодействии с IMАР-сервером. Также рассматривается библиотека OpenURI.

В главе 19, «Ruby и Web-приложения», теперь рассматриваются продукты Ruby on Rails, Nitro, Wee, IOWA и другие инструменты для Web. Также уделено внимание инструментам WEBrick и в какой-то мере Mongrel

В главу 20, «Распределенный Ruby», добавлен материал о системе Rinda — реализации пространства кортежей, написанной на Ruby. Тут же приводятся сведения о родственной системе Ring.

Так ли необходимы все эти добавления? Да, уверяю вас.

Напомню, кстати, что «Путь Ruby» — это вторая вышедшая на английском языке книга по языку Ruby; первой была знаменитая «Мотыга», или «Programming Ruby», Дэйва Томаса (Dave Thomas) и Энди Ханта (Andy Hunt). Моя книга была составлена так, чтобы не перекрывать, а дополнять свою предшественницу; это и стало одной из основных причин ее популярности.

Когда я приступал к работе над первым изданием, еще не было международных конференций по Ruby. Не было сайтов Ruby Forge, ruby-doc.org, не было Wiki-страницы rubygarden.org. Вообще в Сети не было почти ничего, кроме официального сайта Ruby. В архиве приложений Ruby насчитывалось всего несколько сотен программ.

В то время лишь немногие периодические издания (как обычные, так и онлайновые) знали о существовании этого языка. Когда где-то публиковалась статья о Ruby, мы все брали ее на заметку; о ней сообщалось в списке рассылки и там же проводилось обсуждение.

Многих привычных сегодня инструментов и библиотек еще не существовало. Все пока было впереди: и система RDoc, и пакет REXML для анализа XML-документов. Математическая библиотека была куда беднее нынешней. Поддержка баз данных была фрагментарной, а драйверы ODBC и вовсе отсутствовали. Tk был чуть ли не единственным графическим интерфейсом. Приложения для Web разрабатывались в виде низкоуровневых CGI-сценариев.

Еще не появился «моментальный» инсталлятор для Windows. Пользователям Windows приходилось выполнять компиляцию исходных текстов в среде Cygwin или с помощью minigw.

Системы RubyGem не было даже в примитивной форме. Процедура поиска и установки приложений проводилась вручную; для решения этой задачи использовались инструменты типа tar и make.

Никто слыхом не слыхал о Ruby on Rails. Никто (насколько мне известно) не употреблял термина «утипизация»^[3]. Не было ни YAML для Ruby, ни системы Rake.

В то время мы пользовались версией Ruby 1.6.4 и считали ее безмерно крутой. Но Ruby 1.8.5 (с которой я обычно работаю сейчас) еще круче!

Был незначительно изменен синтаксис, но не настолько серьезно, чтобы об этом писать. По большей части речь идет о «граничных случаях», и теперь синтаксис в этих ситуациях выглядит более разумно. Ruby всегда отличали странности в отношении к необязательности скобок; в 98% случаев вы никакой разницы не заметите, а если заметите, то, наверное, согласитесь, что язык стал более последовательным.

Изменилась семантика некоторых системных методов. Но несущественно. Например, раньше метод Dir#chdir не принимал в качестве параметра блок, но несколько лет назад это стало допустимо.

Некоторые системные методы объявлены устаревшими или переименованы. Метод class утратил свой псевдоним type (поскольку в Ruby мы обычно не говорим о типах объектов). Метод intern получил более понятное название to_sym, а метод Array#indices называется Array#values_at. Можно было бы продолжить, но думаю, что суть вы уловили.

Кроме того, было добавлено несколько новых системных методов, например Enumerable#inject, Enumerable#zip и IO#readpartial. Старая библиотека futils теперь называется fileutils, и у нее появилось собственное пространство имен FileUtil, тогда как раньше она добавляла методы в класс File.

Есть и еще много изменений. Но важно понимать, что все они вносились очень осторожно и аккуратно. Язык как был Ruby, так им и остался. Красота Ruby в немалой степени обязана тому факту, что он изменяется медленно и обдуманно, ведомый мудростью Маца и других разработчиков.

Сегодня нет недостатка в книгах по Ruby. Публикуется больше статей, чем мы в состоянии переварить. Множатся руководства и документация в сети Web.

Появились новые инструменты и библиотеки. По разным причинам большая их часть — это каркасы и инструменты для разработки Web-приложений, средства для создания сетевых дневников (блогов), разметки, а также для объектно-реляционного отображения (ORM). Но есть и инструментарий для работы с базами данных, организации графических интерфейсов, математических расчетов, Web-сервисов, обработки изображений, управления версиями и т.д.

Поддержка Ruby в редакторах широко распространена и достигла немалой изощренности. Существуют интегрированные среды разработки (IDE), весьма полезные и зрелые; частично они перекрываются с конструкторами графических интерфейсов.

Нет сомнений и в том, что сообщество пользователей разрослось и изменилось. Сегодня Ruby никак не назовешь нишевым языком: им пользуются в НАСА, Национальной администрации по океану и атмосфере (NOAA), компании Motorola и во многих других крупных организациях. Он применяется для работы с графикой, доступа к базам данных, численного анализа, Web-приложений и в других областях. Короче говоря, Ruby стал весьма популярным языком.

Я работал над новой редакцией этой книги с любовью. Надеюсь, что она окажется вам полезной.

Как организована эта книга

Вряд ли вы станете изучать Ruby по этой книге. В ней не так уж много вводного и учебного материала. Если вы еще ничего не знаете о Ruby, то лучше начать с какой-нибудь другой книги.

Но программисты - народ упорный, и я допускаю, что научиться Ruby только по этой книге возможно. В главе 1, «Обзор Ruby», приводится краткое введение в язык и очень скромное руководство.

Также в главе 1 есть довольно полный перечень «скользких мест» (который трудно поддерживать в актуальном состоянии). Для разных читателей этот перечень полезен в разной мере, поскольку что для одного интуитивно очевидно, для другого выглядит странно.

В основном эта книга призвана отвечать на вопросы типа «Как сделать?». И потому вы, вероятно, многое будете пропускать. Я почту за честь, если кто-то прочтет книгу от корки до корки, но не надеюсь на это. Скорее я ожидаю, что вы будете искать в оглавлении темы, которые вас интересуют в конкретный момент. Впрочем, с момента выхода первого издания мне приходилось беседовать с разными людьми, и оказалось, что многие прочли книгу целиком. Более того, несколько человек писали мне, что выучили по ней Ruby. Что ж, все возможно!..

Некоторые рассматриваемые в книге вопросы могут показаться элементарными. Но ведь у разных людей и опыт разный; то, что очевидно одному, будет откровением для другого. Я старался сделать изложение как можно более полным. С другой стороны, было стремление уложиться в разумный объем (ясно, что эти цели противоречивы).

Можно назвать эту книгу «справочником наоборот». Вы ищете то, что нужно, не по имени класса или метода, а по функции или назначению. Например, в классе String есть несколько методов для манипулирования регистром букв: capitalize, upcase, casecmp, downcase и swapcase. В настоящем справочнике они встречались бы в алфавитном порядке, а в этой книге собраны в одном месте.

Конечно, в борьбе за полноту охвата материала я иногда сворачивал на путь, которому следуют справочные руководства. Во многих случаях я старался компенсировать это, предлагая не совсем обычные примеры или разнообразя их по сравнению со справочниками.

Я старался не перегружать код комментариями. Если не считать первой главы, то думаю, что достиг этой цели. Писатель может стать не в меру болтливым, но программист-то хочет видеть код (а если не хочет, то должен хотеть).

Иногда примеры выглядят искусственными, за что я приношу свои извинения. Проиллюстрировать какой-то прием или принцип в отрыве от реальной задачи бывает сложно. Но чем сложнее задача, чем выше ее уровень, тем большие усилия я прилагал к подысканию реального примера. Так, если речь идет о конкатенации строк, то, наверное, вы увидите безыскусный фрагмент кода с упоминанием пресловутых "foo" и "bar", но когда рассматривается тема разбора XML-документа, будет приведен куда более содержательный и реалистичный пример.

Есть в этой книге два-три каприза, в которых хочу заранее сознаться. Во-первых, я всеми силами старался избегать «уродливых» глобальных переменных типа $_ и ей подобных, пришедших из языка Perl. Они есть в Ruby и прекрасно работают, даже применяются в повседневной работе всеми или большинством программистов. Но почти всегда от их использования можно уйти, что я и позволил себе чуть ли не во всех примерах.

Другой каприз состоит в том, что я избегаю пользоваться обособленными выражениями, если у них нет побочных эффектов. В Ruby выражения - одна из основ языка, и это прекрасно; я старался извлечь из этой особенности максимум пользы. Но во фрагментах кода предпочитаю не употреблять выражения, которые просто возвращают никак не используемое значение. Например, для иллюстрации конкатенации строк достаточно было бы написать "abc" + "def", но я в этом случае пишу что-то вроде str = "abc" + "def". Кому-то это покажется излишеством, но выглядит естественным для программиста на языке С, привыкшего к тому, что бывают функции типа void и не-void (а также программисту на Pascal, мыслящему в терминах процедур и функций).

Третий каприз заключается в моем нежелании употреблять символ решетки для обозначения методов экземпляра. Многие поклонники Ruby считают, что я проявляю излишнюю болтливость, когда пишу «метод экземпляра crypt класса String», а не просто string#crypt, но я полагаю, что так никто не запутается. (На самом деле мне придется постепенно смириться с использованием такой нотации, так как ясно, что она уже никуда не исчезнет.)

Я старался давать ссылки на внешние ресурсы там, где это уместно. Ограничения по времени и объему не позволили мне включить в книгу все, что я хотел бы, но надеюсь, что это хотя бы отчасти компенсируется указаниями на то, где найти недостающую информацию. Из всех источников самым главным, наверное, следует считать архив приложений Ruby (Ruby Application Archive) в сети; вы не раз встретите ссылки на него.

В начале книги принято приводить соглашения об использовании шрифтов, применяемых для выделения кода, и о том, как отличить пример от обычного текста. Но я не стану оскорблять вас недоверием к вашим умственным способностям, - вы ведь и раньше читали техническую литературу.

Хочу подчеркнуть, что примерно 10% текста книги было написано другими людьми. И это не считая технического редактирования и корректуры!.. Вы просто обязаны прочитать благодарности, приведенные в этой (и любой другой) книге. Большинство читателей пропускают их. Прошу, прочтите прямо сейчас. Это будет так же полезно, как питание овощами.

Об исходных текстах, приведенных в книге

Все сколько-нибудь значительные фрагменты кода собраны в архив, который можно загрузить из сети. Этот архив есть на сайте www.awprofessional.com и на моем собственном сайте (www.rubyhacker.com).

Он предлагается в виде tgz-файла и в виде zip-файла. При именовании файлов в нем принято следующее соглашение: код, которому в тексте соответствует пронумерованный листинг, находится в файле с таким же именем (например, listing14-1.rb). Более короткие фрагменты именуются по номеру страницы, возможно, с добавленной буквой (например, p260a.rb и p260b.rb). Совсем короткие фрагменты, которые нельзя исполнить «вне контекста», в архиве обычно отсутствуют.

«Путь Ruby»

Что мы имеем и виду, творя о Пути Ruby? Я полагаю, что тут есть два взаимосвязанных аспекта: философия проектирования Ruby и философия использования этого языка. Естественно, что дизайн и применение связаны друг с другом, будь то программное или аппаратное обеспечение. Иначе зачем бы существовала наука эргономика?.. Если я снабжаю устройство ручкой, то, наверное, предполагаю, что кто-то за эту ручку возьмется.

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

Очевидно, Ruby — не просто инструмент для написания программ, но и сам по себе является программой. Почему работа программ, написанных на Ruby, должна следовать законам, отличным от тех, которым подчинена работа интерпретатора? В конце концов, Ruby — исключительно динамичный и расширяемый язык. Могут найтись причины, по которым эти два уровня где-то расходятся, вероятно, стараясь приспособиться к несовершенству реального мира. Но в общем случае мыслительные процессы могут и должны быть сходными. Интерпретатор Ruby можно было бы написать на самом Ruby, в полном соответствии с принципом Хофштадтера, хотя в настоящее время это еще не сделано.

Мы нечасто задумываемся над этимологией слова «путь», но оно употребляется в двух разных смыслах. Во-первых, это метод или техника, а во-вторых - дорога. Ясно, что оба значения взаимосвязаны, и, говоря «путь Ruby», я имею в виду и то и другое.

Следовательно, мы говорим о мыслительном процессе, но вместе с тем и о дороге, по которой движемся. Даже величайшие гуру программирования не могут сказать о себе, что достигли совершенства: они лишь на пути к нему. Таких путей может быть несколько, но я здесь говорю только об одном.

Привычная мудрость гласит, что форма определяется функцией. Это верно, спору нет. Однако Фрэнк Ллойд Райт^[4] (имея в виду свою собственную область интересов) как-то сказал: «Форма определяется функцией, которая была понята неправильно. Форма и функция должны быть едины, сливаться в духовном единении».

Что Райт имел в виду? Я бы сказал, что на этот вопрос вы найдете ответ не в книгах, а в собственном опыте.

Однако я думаю, что Райт выразил эту мысль где-то еще, разбив ее на части, которые проще переварить. Он был великим поборником простоты, который однажды заметил: «Самые полезные инструменты архитектора — это ластик рядом с чертежной доской и гвоздодер на строительной площадке».

Итак, одним из достоинств Ruby является простота. Надо ли цитировать других мыслителей, высказывавшихся на эту тему? Согласно Антуану де Сент-Экзюпери, «совершенство достигнуто не тогда, когда нечего добавить, а тогда, когда нечего убрать».

Но Ruby — сложный язык. Почему же я называю его простым?

Если бы мы лучше понимали мироздание, то, наверное, открыли бы «закон сохранения сложности» - факт, который вмешивается в нашу жизнь подобно энтропии, которую мы не можем преодолеть, а способны лишь рассеивать.

И в этом ключ. Нельзя избежать сложности, но можно укрыться от нее. Мы можем убрать ее из виду! Это тот же старый добрый принцип черного ящика, внутри которого решается сложная задача, хотя на поверхности лишь голая простота.

Если вам еще не наскучили цитаты, то будет уместно привести слова Альберта Эйнштейна: «Все должно быть просто настолько, насколько возможно, но не проще».

Таким образом, на взгляд программиста, Ruby - это воплощенная простота (хотя у человека, отвечающего за сопровождение интерпретатора, взгляд может быть иной). Но вместе с тем имеется пространство для компромиссов. В реальном мире всем нам приходится немного «прогибаться». К примеру, все сущности в программе на Ruby должны были бы быть истинными объектами, однако некоторые, в том числе целые числа, хранятся как непосредственные значения. Это компромисс, знакомый всем студентам отделений информатики уже много десятилетий: элегантность дизайна приносится в жертву практичности реализации. По существу, мы променяли одну простоту на другую.

То, что Ларри Уолл говорил о языке Perl, остается справедливым: «Когда вы хотите что-то выразить на маленьком языке, оно становится большим. А когда вы пытаетесь выразить то же самое на большом языке, оно становится маленьким». Это верно и в отношении английского языка. Если биолог Эрнст Хэккель смог всего тремя словами выразить глубокую мысль «онтогенез повторяет филогенез», то лишь потому, что эти слова с весьма специфическим смыслом были в его распоряжении. Мы соглашаемся на внутреннюю сложность языка, потому что она позволяет избежать сложности в отдельных высказываниях.

Переформулирую этот принцип по-другому: «не пишите 200 строк кода, когда достаточно 10».

Я считаю само собой разумеющимся, что краткость в общем случае хороша. Короткий фрагмент кода занимает меньше места в мозгу программиста, его проще воспринять как единое целое. Благоприятным побочным эффектом следует считать и то, что в короткой программе будет меньше ошибок.

Конечно, не нужно забывать предупреждение Эйнштейна о простоте. Если расположить краткость слишком высоко в списке приоритетов, то получится совершенно загадочный код. Согласно теории информации, сжатые данные статистически похожи на белый шум. Если вы видели код на С или APL либо регулярное выражение — особенно плохо написанные, то понимаете что я имею в виду. «Просто, но не слишком просто» — это ключевая фраза. Стремитесь к краткости, но не жертвуйте понятностью.

Трюизмом следует считать мысль о том, что краткость в сочетании с понятностью — это хорошо. Но тому есть причина, причем настолько фундаментальная, что мы часто о ней забываем. А состоит она в том, что компьютер создан для человека, а не человек для компьютера.

В старые добрые дни все было почти наоборот. Компьютеры стоили миллионы долларов и пожирали многие киловатты электричества. Люди же вели себя так, будто компьютер - божество, а программисты - его скромные жрецы. Час машинного времени стоил дороже часа личного времени.

Когда компьютеры стали меньше и дешевле, приобрели популярность языки высокого уровня. Они неэффективны с точки зрения машины, зато эффективны с позиции человека. Ruby — всего лишь одно из последних достижений на этом пути. Некоторые даже называют его языком сверхвысокого уровня (VHLL — Very High-Level Language). Хотя этот термин еще не получил четкого определения, я думаю, что он оправдан.

Компьютер призван быть слугой, а не хозяином, а, как сказал Мац, толковый слуга должен выполнять сложное задание при минимуме указаний. Так было на протяжении всей истории информатики. Мы начали с машинного языка, перешли к языку ассемблера, а потом добрались и до языков высокого уровня.

Мы сейчас говорим о смещении парадигмы: от машиноцентрической к человекоцентрической. На мой взгляд, Ruby дает великолепный пример человекоцентрического программирования.

Теперь я хочу взглянуть на вопрос под несколько иным углом. В 1980 году вышла чудесная книжка Джеффри Джеймса «Дао программирования» (Geoffrey James, The Tao of Programming). Каждая строчка из нее достойна цитирования, но я ограничусь лишь одной выдержкой: «Программа должна следовать "закону наименьшего удивления". Что это за закон? Все просто: программа должна отвечать пользователю так, чтобы вызывать у него как можно меньше удивления». (Конечно, если речь идет об интерпретаторе языка, то пользователем является программист.)

Не знаю, Джеймс ли придумал термин «закон наименьшего удивления», но я впервые узнал его из упомянутой книги. Этот закон хорошо известен и часто цитируется в сообществе пользователей Ruby. Правда, обычно его называют «принципом наименьшего удивления» (Principle of Least Surprise, POLS). Лично я упрямо придерживаюсь акронима LOLA — Law of Least Astonishment.

Но, как ни называй, правило остается справедливым и служит основополагающим принципом продолжающейся работы над языком Ruby. О нем полезно помнить и тем, кто разрабатывает библиотеки и пользовательские интерфейсы.

Конечно, одна проблема остается: разные люди удивляются разным вещам; не существует всеобщего согласия о том, как «должен» вести себя объект или метод. Но мы можем стремиться быть последовательными и находить веские обоснования принимаемым проектным решениям, а каждый человек должен тренировать собственную интуицию.

Кстати, Мац как-то заметил, что «принцип наименьшего удивления» должен относиться и к нему как к дизайнеру. Чем больше ваше мышление походит на его, тем меньше удивления будет вызывать Ruby. И смею уверить, подражание Мацу большинству из нас пойдет только на пользу.

Какой бы ни была логическая конструкция системы, тренировать свою интуицию необходимо. Каждый язык программирования - это отдельный мир со своими допущениями, точно так же как и любой естественный язык. Когда я начал изучать немецкий, то обнаружил, что все существительные пишутся с прописной буквы… за исключением слова deutsch (немецкий язык). Я пожаловался профессору, подчеркивая, что ведь это же название самого языка. Он улыбнулся и ответил: «Не надо с этим бороться».

Профессор говорил, что надо позволить немцу оставаться немцем. Продолжая эту мысль, хочу дать совет всем, кто переходит на использование Ruby после освоения других языков. Пусть Ruby остается Ruby! Не ожидайте, что это будет Perl. Не требуйте от него поведения, характерного для языков LISP или Smalltalk. С другой стороны, у Ruby есть элементы, присущие любому из этих трех языков. Для начала действуйте в соответствии с априорными представлениями, но когда они оказываются неверны, не боритесь с установленными правилами (если только Мац не согласится с тем, что в них необходимо внести изменения).

Каждый программист сегодня знает о принципе ортогональности (хотя лучше было бы назвать его принципом ортогональной полноты). Вообразим пару осей, по одной из которых откладываются языковые сущности, а по другой — множество атрибутов и возможностей. Когда мы говорим об ортогональности, то обычно имеем в виду, что пространство, определяемое этими осями, настолько «полно», насколько это логически возможно.

Одна из составных частей Пути Ruby — стремление к ортогональности. Массив в некоторых отношениях подобен хэшу, а потому и операции над ними должны быть похожи. До тех пор пока мы не вступаем в область, где эти сущности начинают отличаться друг от друга.

Мац говорит, что «естественность» важнее ортогональности. Но чтобы понять, что естественно, а что нет, надо долго думать и писать программы.

Ruby стремится быть дружелюбным к программисту. Например, у многих методов есть синонимы; оба метода size и length возвращают число элементов в массиве. Два разных написания слова — indexes и indices — относятся к имени одного и того же метода. Некоторые называют это досадным недоразумением, но я склонен считать такую избыточность хорошим дизайном.

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

Например, в Ruby принято добавлять вопросительный знак (?) в конец имени метода, ведущего себя как предикат. Это хорошо и удобно, программа становится яснее, а в пространстве имен легче ориентироваться. Но менее последовательным является аналогичное употребление восклицательного знака для обозначения потенциально «деструктивных» или «опасных» методов (в том смысле, что они модифицируют внутреннее состояние вызывающего объекта). Непоследовательность состоит в том, что не все деструктивные методы помечаются таким образом. Нужно ли восстановить справедливость?

Нет, на самом деле не нужно. Некоторые методы по сути своей изменяют состояние (например, методы replace и concat класса Array). Одни являются «методами установки», которые допускают присваивание атрибуту класса; ясно, что не следует добавлять восклицательный знак к имени атрибута или к знаку равенства. Другие в каком-то смысле изменяют состояние объекта, например read, но это происходит так часто, что нет смысла особо отмечать данный факт. Если бы имя каждого деструктивного метода заканчивалось символом !, то программа превратилась бы в рекламную брошюру фирмы, занимающейся многоуровневым маркетингом.

Вы замечаете действие разнонаправленных сил, тенденцию нарушать все правила? Тогда позвольте мне сформулировать второй закон Фултона: «У каждого правила есть исключения, кроме второго закона Фултона». (Доля шутки тут есть, но небольшая.)

В Ruby мы видим не «педантичную непротиворечивость», а строгое следование набору простых правил. Может быть, отчасти Путь Ruby состоит в том, что его подход не является закостенелым и неподвижным. Мац как-то сказал, что при проектировании языка нужно «следовать велениям своего сердца». И еще один аспект философии Ruby: «Не бойтесь изменений во время выполнения, не бойтесь быть динамичными». Мир динамичен, так почему язык программирования должен быть статичным? Ruby — один из самых динамичных среди существующих языков.

С некоторыми оговорками я бы выделил и такой аспект: «Не будьте рабом производительности». Если производительность оказывается недопустимо низкой, проблему придется решать, но не следует с самого начала выводить ее на первый план. Предпочитайте элегантность эффективности в тех случаях, когда эффективность не слишком критична. Впрочем, когда вы пишете библиотеку, которая будет использоваться непредвиденными способами, о производительности следует задуматься с самого начала.

Когда я смотрю на язык Ruby, то вижу равновесие между разными проектными целями, вижу сложное взаимодействие, напоминающее о задаче n тел в физике. Я могу представить себе, что он моделировался как мобил Александра Кальдера. Быть может, больше всего завораживает само взаимодействие, гармония, лежащая в основе философии Ruby, а не отдельные составные части. Программисты знают, что их ремесло — не просто сплав науки и технологии, но еще и искусство. Мне неловко говорить, что в компьютерных дисциплинах есть какой-то духовный аспект, но — строго между нами! — он безусловно присутствует. (Если вы не читали книгу Роберта Пирсига «Дзен и искусство ухода за мотоциклом» (Robert Pirsig, Zen and the Art of Motorcycle Maintenance), горячо рекомендую.)

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

Глава 1. Обзор Ruby

Язык формирует способ нашего мышления и определяет то, о чем мы можем размышлять.

Бенджамин Ди Уорф

Стоит напомнить, что в новом языке программирования иногда видят панацею, особенно его адепты. Но ни один язык не сможет заменить все остальные. Не существует инструмента, безусловно пригодного для решения любой мыслимой задачи. Есть много предметных областей и много ограничений, налагаемых решаемыми в них задачами.

А самое главное — есть разные пути обдумывания задач, и это следствие разного опыта и личных качеств самих программистов. Поэтому в обозримой перспективе будут появляться все новые и новые языки. А пока есть много языков, будет много людей, которые их критикуют и защищают. Короче говоря, «языковым войнам» конца не предвидится, но мы в этой книге не станем принимать в них участия.

И тем не менее в постоянном поиске новой, более удачной системы записи программ нас иногда озаряют идеи, переживающие контекст, в котором зародились. Как Pascal многое позаимствовал у Algol, как Java выросла из С, так и каждый язык что-то берет у своих предшественников.

Язык - это одновременно набор инструментов и площадка для игр. У него есть практическая сторона, но он же служит и полигоном для испытания новых идей, которые могут быть приняты или отвергнуты сообществом программистов.

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

Вездесущность ООП породила много «рекламной чепухи» в индустрии. В классической работе, написанной в конце 1980-х годов, Роджер Кинг отметил: «Если вы хотите продать кошку специалисту по компьютерам, скажите, что она объектно-ориентированная». Мнения по поводу того, что на самом деле представляет собой ООП, весьма неоднородны, и даже среди тех, кто разделяет общую точку зрения, имеются разногласия относительно терминологии.

Мы не ставим себе целью поучаствовать в спорах. Мы согласны, что ООП — полезный инструмент и ценная методология решения задач; мы не утверждаем, что она способна излечить рак.

Что касается истинной природы ООП, то у нас есть любимые определения и термины, но мы пользуемся ими лишь для эффективного общения, так что пререкаться по поводу смысла слов не станем.

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

1.1. Введение в объектно-ориентированное программирование

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

1.1.1. Что такое объект

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

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

Объект считается экземпляром класса объекта (обычно он называется просто классом). Класс можно представлять себе как чертеж или образец, а объект — как вещь, изготовленную по этому чертежу. Также класс часто называют абстрактным типом, то есть типом более сложным, нежели целое или строка символов.

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

Иногда возникает ситуация, когда некоторые данные имеют широкую область видимости, не ограниченную одним объектом, и помещать копию такого атрибута в каждый экземпляр класса неправильно. Рассмотрим, к примеру, класс MyDogs и три объекта этого класса: fido, rover и spot. У каждой собаки могут быть такие атрибуты, как возраст и дата вакцинации. Предположим, однако, что нужно сохранить еще и имя владельца всех собак. Можно, конечно, поместить его в каждый объект, но это пустая трата памяти, к тому же искажающая смысл дизайна. Ясно, что атрибут «имя владельца» принадлежит не отдельному объекту, а классу в целом. Такие атрибуты (синтаксис их определения в разных языках различен) называются атрибутами класса (или переменными класса).

Есть немало ситуаций, в которых может понадобиться переменная класса. Допустим, например, что нужно знать, сколько всего было создано объектов некоторого класса. Можно было бы завести переменную класса, инициализировать ее нулем и увеличивать на единицу при создании каждого объекта. Эта переменная ассоциирована именно с классом, а не с каким-то конкретным объектом. С точки зрения области видимости она не отличается от любого другого атрибута, но существует лишь одна ее копия для всего множества объектов данного класса.

Чтобы отличить атрибуты класса от обыкновенных атрибутов, последние часто называют атрибутами объекта (или атрибутами экземпляра). Условимся, что в этой книге под словом «атрибут» понимается атрибут экземпляра, если явно не оговорено, что это атрибут класса.

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

Стоит отметить, что в некотором смысле все методы являются методами класса. Не нужно думать, что, создав сто объектов, мы породили сотню копий кода методов! Однако правила ограничения области видимости гласят, что метод каждого объекта оперирует данными только того объекта, от имени которого вызван. Тем самым у нас создается иллюзия, будто методы объекта ассоциированы с самими объектами.

1.1.2. Наследование

Мы подходим к одной из самых сильных сторон ООП — наследованию. Наследование —- это механизм, позволяющий расширять ранее определенную сущность путем добавления новых возможностей. Короче говоря, наследование - это способ повторного использования кода. (Простой и эффективный механизм повторного использования долго был Святым Граалем в информатике. Много десятилетий назад его поиски привели к изобретению параметризованных процедур и библиотек. ООП - лишь одна из последних попыток реализации искомого.)

Обычно наследование рассматривается на уровне класса. Если нам необходим какой-то класс, а в наличии имеется более общий, то можно определить свой класс так, чтобы он наследовал поведение уже существующего. Предположим, например, что есть класс Polygon, описывающий выпуклые многоугольники. Тогда класс прямоугольника Rectangle можно унаследовать от Polygon. При этом Rectangle будет иметь все атрибуты и методы класса Polygon. Так, может уже быть написан метод, вычисляющий периметр путем суммирования длин всех сторон. Если все было реализовано правильно, этот метод автоматически будет работать и для нового класса; переписывать код не придется.

Если класс B наследует классу A, мы говорим, что B является подклассом A, а A — суперкласс B. По-другому говорят, что А — базовый или родительский класс, а B — производный или дочерний класс.

Как мы видели, производный класс может трактовать методы своего базового класса как свои собственные. С другой стороны, он может переопределить метод базового класса, предоставив иную его реализацию. Кроме того, в большинстве языков есть возможность вызвать из переопределенного метода метод базового класса с тем же именем. Иными словами, метод fоо класса B знает, как вызвать метод foo класса A. (Любой язык, не предоставляющий такого механизма, можно заподозрить в отсутствии истинной объектной ориентированности.) То же верно и в отношении атрибутов.

Отношение между классом и его суперклассом интересно и важно, обычно его называют отношением «является». Действительно, квадрат Square «является» прямоугольником Rectangle, а прямоугольник Rectangle «является» многоугольником Polygon и т.д. Поэтому, рассматривая иерархию наследования (а такие иерархии в том или ином виде присутствуют в любом объектно-ориентированном языке), мы видим, что в любой ее точке специализированные сущности «являются» подклассами более общих. Отметим, что это отношение транзитивно, — если обратиться к предыдущему примеру, то квадрат «является» многоугольником. Однако отношение «является» не коммутативно — каждый прямоугольник есть многоугольник, но не каждый многоугольник — прямоугольник.

Это подводит нас к теме множественного наследования. Можно представить себе класс, который наследует нескольким классам. Например, классы Dog (Собака) и Cat (Кошка) могут наследовать классу Mammal (Млекопитающее), а Sparrow (Воробей) и Raven (Ворон) — классу WingedCreature (Крылатое). Но как быть с классом Bat (ЛетучаяМышь)? Он с равным успехом может наследовать и Mammal, и WingedCreature! Это хорошо согласуется с нашим жизненным опытом, ведь многие вещи можно отнести не к одной категории, а сразу к нескольким, не вложенным друг в друга.

Множественное наследование, вероятно, наиболее противоречивая часть ООП. Некоторые указывают на потенциальные неоднозначности, требующие разрешения. Например, если в обоих классах Mammal и WingedCreature имеется атрибут size (размер) или метод eat (есть), то какой из них имеется в виду, когда мы обращаемся к нему из объекта класса Bat? С этой трудностью тесно связана проблема ромбовидного наследования; она называется так из-за формы диаграммы наследования, возникающей, когда оба суперкласса наследуют одному классу. Представьте себе, что классы Mammal и WingedCreature наследуют общему предку Organism (Организм); тогда иерархия наследования от Organism к Bat будет иметь форму ромба. Но как быть с атрибутами, которые оба промежуточных класса наследуют от своего родителя? Получает ли Bat две копии? Или они должны быть объединены в один атрибут, поскольку все равно заимствованы у общего предка?

Это скорее проблемы проектировщика языка, а не программиста. В разных объектно-ориентированных языках они решаются по-разному. Иногда вводятся правила, согласно которым какое-то одно определение атрибута «выигрывает». Либо же предоставляется возможность различать одноименные атрибуты. Иногда даже язык позволяет вводить псевдонимы или переименовывать идентификаторы. Многими это рассматривается как аргумент против множественного наследования — о механизмах разрешения подобных конфликтов имен нет единого мнения, поэтому все они «языкозависимы». В языке C++ предлагается минимальный набор средств для разрешения неоднозначностей; механизмы языка Eiffel, наверное, получше, а в Perl проблема решается совсем по-другому.

Есть и альтернатива — полностью запретить множественное наследование. Такой подход принят в языках Java и Ruby. На первый взгляд, это даже не назовешь компромиссным решением, но, вскоре мы убедимся, что все не так плохо, как кажется. Мы познакомимся с приемлемой альтернативой традиционному множественному наследованию, но сначала обсудим полиморфизм — еще одно понятие из арсенала ООП.

1.1.3. Полиморфизм

Термин «полиморфизм», наверное, вызывает самые жаркие семантические споры. Каждый знает, что это такое, но все понимают его по-разному. (Не так давно вопрос «Что такое полиморфизм?» стал популярным во время собеседования при поступлении на работу. Если его зададут вам, рекомендую процитировать какого-нибудь эксперта, например Бертрана Мейера или Бьерна Страуструпа; если собеседник не согласится, то пусть он спорит с классиком, а не с вами.)

Буквально слово «полиморфизм» означает «способность принимать разные формы или обличья». В самом широком смысле так называют ситуацию, когда различные объекты по-разному отвечают на одно и то же сообщение или вызов метода.

Дамиан Конвей (Damian Conway) в книге «Object-Oriented Perl» проводит смысловое различие между двумя видами полиморфизма. Первый, наследственный полиморфизм, - то, что имеет в виду большинство программистов, говорящих о полиморфизме.

Если некоторый класс наследует своему суперклассу, то по определению все методы суперкласса присутствуют также и в подклассе. Таким образом, цепочка наследования представляет собой линейную иерархию классов, отвечающих на одни и те же методы. Нужно, конечно, помнить, что в любом подклассе метод может быть переопределен; именно это и составляет сильную сторону наследования. При вызове метода объекта обычно отвечает либо метод, унаследованный от суперкласса, либо более специализированный вариант этого метода, созданный в интересах именно данного подкласса.

В языках со статической типизацией, например в C++, наследственный полиморфизм гарантирует совместимость типов вниз по цепочке наследования (но не в обратном направлении). Скажем, если B наследует A, то указатель на объект класса А может указывать и на объект класса в; обратное же неверно. Совместимость типов — существенная черта ООП в подобных языках, можно даже сказать, что полиморфизм ей и исчерпывается. Но, конечно же, полиморфизм можно реализовать и в отсутствие статической типизации (как в Ruby).

Второй вид полиморфизма, упомянутый Конвеем, — это интерфейсный полиморфизм. Для него не требуется наличия отношения наследования между классами; нужно лишь, чтобы в интерфейсах объектов были методы с одним и тем же именем. Такие объекты можно трактовать как принадлежащие одному виду, и потому мы имеем некую разновидность полиморфизма (хотя в большинстве работ он так не называется).

Читатели, знакомые с языком Java, понимают, что в нем реализованы оба вида полиморфизма. Класс в Java может расширять другой класс, наследуя ему с помощью ключевого слова extends, а может с помощью ключевого слова implements реализовывать интерфейс, за счет чего приобретает заранее известный набор методов (которые необходимо переопределить). Такой синтаксис позволяет интерпретатору Java во время компиляции определить, можно ли вызывать данный метод для конкретного объекта.

Ruby поддерживает интерфейсный полиморфизм, но по-другому. Он позволяет определять модули, методы которых допускается «подмешивать» к существующим классам. Но обычно модули так не используются. Модуль состоит из методов и констант, которые можно использовать так, будто они являются частью класса или объекта. Когда модуль подмешивается с помощью предложения include, мы получаем ограниченную форму множественного наследования. (По словам проектировщика языка Юкихиро Мацумото, это можно рассматривать как одиночное наследование с разделением реализации.) Таким образом удается сохранить преимущества множественного наследования, не страдая от его недостатков.

1.1.4. Еще немного терминов

В языках, подобных C++, существует понятие абстрактного класса. Такому классу разрешается наследовать, но создать его экземпляр невозможно. В более динамичном языке Ruby такого понятия нет, но если программист пожелает, то может смоделировать его, потребовав, чтобы все методы были переопределены в производных классах. Полезно это или нет, оставляем на усмотрение читателя.

Создатель языка C++ Бьерн Страуструп определяет также понятие конкретного типа. Это класс, существующий только для удобства. Он спроектирован не для наследования; более того, ожидается, что ему никто никогда наследовать не будет. Другими словами, преимущества ООП в этом случае сводятся только к инкапсуляции. Ruby не поддерживает такой конструкции синтаксически (как и C++), но по природе своей прекрасно приспособлен для создания подобных классов.

Считается, что некоторые языки поддерживают более «чистую» модель ООП, чем другие. (К ним мы применяем термин «радикально объектно-ориентированный».) Это означает, что любая сущность в языке является объектом, даже примитивные типы представлены полноценными классами, а переменные и константы рассматриваются как экземпляры. В таких языках, как Java, C++ и Eiffel, дело обстоит иначе. В них примитивные типы (особенно константы) не являются настоящими объектами, хотя иногда могут рассматриваться как таковые с помощью «классов-оберток». Вероятно, есть языки, которые более радикально объектно ориентированы, чем Ruby, но их немного.

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

На этом мы завершаем беглую экскурсию в мир ООП. Мы старались последовательно применять введенные здесь термины на протяжении всей книги. Перейдем теперь к краткому обзору самого языка Ruby.

1.2. Базовый синтаксис и семантика Ruby

Выше мы отметили, что Ruby — настоящий динамический объектно-ориентированный язык.

Прежде чем переходить к обзору синтаксиса и семантики, упомянем некоторые другие его особенности.

Ruby — прагматичный (agile) язык. Он пластичен и поощряет частую переработку (рефакторинг), которая выполняется без особого труда.

Ruby — интерпретируемый язык. Разумеется, в будущем ради повышения производительности могут появиться и компиляторы Ruby, но мы считаем, что у интерпретатора много достоинств. Он не только позволяет быстро создавать прототипы, но и сокращает весь цикл разработки.

Ruby ориентирован на выражения. Зачем писать предложение, когда выражения достаточно? Это означает, в частности, что программа становится более компактной, поскольку общие части выносятся в отдельное выражение и повторения удается избежать.

Ruby — язык сверхвысокого уровня (VHLL). Один из принципов, положенных в основу его проектирования, заключается в том, что компьютер должен работать для человека, а не наоборот. Под «плотностью» Ruby понимают тот факт, что сложные, запутанные операции можно записать гораздо проще, чем в языках более низкого уровня.

Начнем мы с рассмотрения общего духа языка и некоторых применяемых в нем терминов. Затем вкратце обсудим природу программ на Ruby, а потом уже перейдем к примерам.

Прежде всего отметим, что программа на Ruby состоит из отдельных строк, — как в С, но не как в «древних» языках наподобие Фортрана. В одной строке может быть сколько угодно лексем, лишь бы они правильно отделялись пропусками.

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

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

1.2.1. Ключевые слова и идентификаторы

Ключевые (или зарезервированные) слова в Ruby обычно не применяются ни для каких иных целей. Вот их полный перечень:

BEGIN  END   alias  and    begin

break  case  class  def    defined?

do     else  elsif  end    ensure

false  for   if     in     module

next   nil   not    or     redo

rescue retry return self   super

then   true  undef  unless until

when   while yield

Имена переменных и других идентификаторов обычно начинаются с буквы или специального модификатора. Основные правила таковы:

• имена локальных переменных (и таких псевдопеременных, как self и nil) начинаются со строчной буквы или знака подчеркивания _;

• имена глобальных переменных начинаются со знака доллара $;

• имена переменных экземпляра (принадлежащих объекту) начинаются со знака «собачки» @;

• имена переменных класса (принадлежащих классу) предваряются двумя знаками @ (@@);

• имена констант начинаются с прописной буквы;

• в именах идентификаторов знак подчеркивания _ можно использовать наравне со строчными буквами;

• имена специальных переменных, начинающиеся со знака доллара (например, $1 и $/), здесь не рассматриваются.

Примеры:

• локальные переменные alpha, _ident, some_var;

• псевдопеременные self, nil, __FILE__;

• константы K6chip, Length, LENGTH;

• переменные экземпляра @foobar, @thx1138, @not_const;

• переменные класса @@phydeaux, @@my_var, @@not_const;

• глобальные переменные $beta, $B2vitamin, $not_const.

1.2.2. Комментарии и встроенная документация

Комментарии в Ruby начинаются со знака решетки (#), находящегося вне строки или символьной константы, и продолжаются до конца строки:

x = y + 5 # Это комментарий.

# Это тоже комментарий.

print "# А это не комментарий."

Предполагается, что встроенная документация будет извлечена из программы каким-нибудь внешним инструментом. С точки зрения интерпретатора это обычный комментарий. Весь текст, расположенный между строками, которые начинаются с лексем =begin и =end (включительно), игнорируется интерпретатором (этим лексемам не должны предшествовать пробелы).

=begin

Назначение этой программы - излечить рак

и установить мир во всем мире.

=end

1.2.3. Константы, переменные и типы

В Ruby переменные не имеют типа, однако объекты, на которые переменные ссылаются, тип имеют. Простейшие типы — это символ, число и строка.

Числовые константы интуитивно наиболее понятны, равно как и строки. В общем случае строка, заключенная в двойные кавычки, допускает интерполяцию выражений, а заключенная в одиночные кавычки интерпретируется почти буквально — в ней распознается только экранированная обратная косая черта.

Ниже показана «интерполяция» переменных и выражений в строку, заключенную в двойные кавычки:

а = 3

b = 79

puts "#{а} умноженное на #{b} = #{а*b}" # 3 умноженное на 79 = 237

Более подробная информация о литералах (числах, строках, регулярных выражениях и т.п.) приведена в следующих главах.

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

`whoami`

`ls -l`

%x[grep -i meta *.html | wc -l]

Регулярные выражения в Ruby похожи на символьные строки, но используются по-другому. Обычно в качестве ограничителя выступает символ косой черты.

Синтаксис регулярных выражений в Ruby и Perl имеет много общего. Подробнее о регулярных выражениях см. главу 3.

Массивы в Ruby — очень мощная конструкция; они могут содержать данные любого типа. Более того, в одном массиве можно хранить данные разных типов. В главе 8 мы увидим, что все массивы — это экземпляры класса Array, а потому к ним применимы разнообразные методы. Массив-константа заключается в квадратные скобки. Примеры:

[1, 2, 3]

[1, 2, "застегни мне молнию на сапоге"]

[1, 2, [3,4], 5]

["alpha", "beta", "gamma", "delta"]

Во втором примере показан массив, содержащий целые числа и строки. В третьем примере мы видим вложенный массив, а в четвертом - массив строк. Как и в большинстве других языков, нумерация элементов массива начинается с нуля. Так, в последнем из показанных выше примеров элемент "gamma" имеет индекс 2. Все массивы динамические, задавать размер при создании не нужно.

Поскольку массивы строк встречаются очень часто (а набирать их неудобно), для них предусмотрен специальный синтаксис:

%w[alpha beta gamma delta]

%w(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec)

%w/am is are was were be being been/

Здесь не нужны ни кавычки, ни запятые; элементы разделяются пробелами. Если встречаются элементы, содержащие внутренние пробелы, такой синтаксис, конечно, неприменим.

Для доступа к конкретному элементу массива по индексу применяются квадратные скобки. Результирующее выражение можно получить или выполнить для него присваивание:

val = myarray[0]

print stats[j]

x[i] = x[i+1]

Еще одна «могучая» конструкция в Ruby — это хэш. Его также называют ассоциативным массивом или словарем. Хэш — это множество пар данных; обыкновенно он применяется в качестве справочной таблицы или как обобщенный массив, в котором индекс не обязан быть целым числом. Все хэши являются экземплярами класса Hash.

Хэш-константа, как правило, заключается в фигурные скобки, а ключи отделяются от значений символом =>. Ключ можно считать индексом для доступа к ассоциированному с ним значению. На типы ключей и значений не налагается никаких ограничений. Примеры:

{1=>1, 2=>4, 3=>9, 4=>16, 5 = >25, 6=>36}

{"cat"=>"cats", "ox"=>"oxen", "bacterium"=>"bacteria"}

{"водород"=>1, "гелий"=>2, "углерод"=>12}

{"нечетные"=>[1,3,5,7], "четные"=>[2,4,6,8]}

{"foo"=>123, [4,5,6]=>"my array", "867-5309"=>"Jenny"}

К содержимому хэша-переменной доступ осуществляется так же, как для массивов, — с помощью квадратных скобок:

print phone_numbers["Jenny"]

plurals["octopus"] = "octopi"

Однако следует подчеркнуть, что у массивов и хэшей много методов, именно они и делают эти контейнеры полезными. Ниже, в разделе «ООП в Ruby», мы раскроем эту тему более подробно.

1.2.4. Операторы и приоритеты

Познакомившись с основными типами данных, перейдем к операторам в языке Ruby. В приведенном ниже списке они представлены в порядке убывания приоритета:

::                  Разрешение области видимости

[]                  Взятие индекса

**                  Возведение в степень

+ - ! ~             Унарный плюс/минус, НЕ…

* / %               Умножение, деление…

+ -                 Сложение/вычитание

<< >>               Логические сдвиги…

&                   Поразрядное И

|| ^                Поразрядное ИЛИ, исключающее ИЛИ

> >= < <=           Сравнение

== === <=> != =~ !~ Равенство, неравенство…

&&                  Логическое И

||                  Логическое ИЛИ

.. ...              Операторы диапазона

= (also +=, -=, …)  Присваивание

?:                  Тернарный выбор

not                 Логическое отрицание

and or              Логическое И, ИЛИ

Некоторые из перечисленных символов служат сразу нескольким целям. Например, оператор << обозначает поразрядный сдвиг влево, но также применяется для добавления в конец (массива, строки и т.д.) и как маркер встроенного документа. Аналогично знак + означает сложение чисел и конкатенацию строк. Ниже мы увидим, что многие операторы — это просто сокращенная запись вызова методов.

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

1.2.5. Пример программы

В любом руководстве первой всегда приводят программу, печатающую строку Hello, world!, но мы рассмотрим что-нибудь более содержательное. Вот небольшая интерактивная консольная программа, позволяющая переводить температуру из шкалы Фаренгейта в шкалу Цельсия и наоборот.

print "Введите температуру и шкалу (С or F): "

str = gets

exit if str.nil? or str.empty?

str.chomp!

temp, scale = str.split(" ")

abort "#{temp} недопустимое число." if temp !~ /-?\d+/

temp = temp.to_f case scale

 when "С", "с"

  f = 1.8*temp + 32

 when "F", "f"

  с = (5.0/9.0)*(temp-32)

 else

  abort "Необходимо задать С или F."

end

if f.nil?

 print "#{c} градусов C\n"

else

 print "#{f} градусов F\n"

end

Ниже приведены примеры прогона этой программы. Показано, как она переводит градусы Фаренгейта в градусы Цельсия и наоборот, а также как обрабатывает неправильно заданную шкалу или число:

Введите температуру и шкалу (С or F): 98.6 F

37.0 градусов С

Введите температуру и шкалу (С or F): 100 С

212.0 градусов F

Введите температуру и шкалу (С or F):

92 G Необходимо задать С или F.

Введите температуру и шкалу (С or F): junk F

junk недопустимое число.

Теперь рассмотрим, как эта программа работает. Все начинается с предложения print, которое есть не что иное, как вызов метода print из модуля Kernel. Данный метод выполняет печать на стандартный вывод. Это самый простой способ оставить курсор в конце строки.

Далее мы вызываем метод gets (прочитать строку из стандартного ввода) и присваиваем полученное значение переменной str. Для удаления хвостового символа новой строки вызывается метод chomp!.

Обратите внимание, что print и gets, которые выглядят как «свободные» функции, на самом деле являются методами класса Object (который, вероятно, наследует Kernel). Точно так же chomp! — метод, вызываемый от имени объекта str. При вызовах методов в Ruby обычно можно опускать скобки: print "foo" и print("foo") — одно и то же.

В переменной str хранится символьная строка, но могли бы храниться данные любого другого типа. В Ruby данные имеют тип, а переменные - нет. Переменная начинает существовать, как только интерпретатор распознает присваивание ей; никаких предварительных объявлений не существует.

Метод exit завершает программу. В той же строке мы видим управляющую конструкцию, которая называется «модификатор if». Он аналогичен предложению if, существующему в большинстве языков, только располагается после действия. Для модификатора if нельзя задать ветвь else, и он не требует закрытия. Что касается условия, мы проверяем две вещи: имеет ли переменная str значение (то есть не равна nil) и не является ли она пустой строкой. Если встретится конец файла, то будет истинно первое условие; если же пользователь нажмет клавишу Enter, не введя никаких данных, — второе.

Это предложение можно было бы записать и по-другому:

exit if not str or not str[0]

Эти проверки работают потому, что переменная может иметь значение nil, а nil в Ruby в логическом контексте вычисляется как «ложно». На самом деле как «ложно» вычисляются nil и false, а все остальное — как «истинно». Это означает, кстати, что пустая строка "" и число 0 — не «ложно».

В следующем предложении над строкой выполняется операция chomp! (для удаления хвостового символа новой строки). Восклицательный знак в конце предупреждает, что операция изменяет значение самой строки, а не возвращает новую. Восклицательный знак применяется во многих подобных ситуациях как напоминание программисту о том, что у метода есть побочное действие или что он более «опасен», чем аналогичный метод без восклицательного знака. Так, метод chomp возвращает такой же результат, но не модифицирует значение строки, для которой вызван.

В следующем предложении мы видим пример множественного присваивания. Метод split разбивает строку на куски по пробелам и возвращает массив. Двум переменным в левой части оператора присваиваются значения первых двух элементов массива в правой части.

В следующем предложении if с помощью простого регулярного выражения выясняется, введено ли допустимое число. Если строка не соответствует образцу, который состоит из необязательного знака «минус» и одной или более цифр, то число считается недопустимым и программа завершается. Отметим, что предложение if оканчивается ключевым словом end. Хотя в данном случае это не нужно. Мы могли бы включить перед end ветвь else. Ключевое слово then необязательно; в этой книге мы стараемся не употреблять его.

Метод to_f преобразует строку в число с плавающей точкой. Это число записывается в ту же переменную temp, в которой раньше хранилась строка.

Предложение case выбирает одну из трех ветвей: пользователь указал С, F или какое-то другое значение в качестве шкалы. В первых двух случаях выполняется вычисление, в третьем мы печатаем сообщение об ошибке и выходим.

Кстати, предложение case в Ruby позволяет гораздо больше, чем показано в примере. Нет никаких ограничений на типы данных, а все выражения могут быть произвольно сложными, в том числе диапазонами или регулярными выражениями.

В самом вычислении нет ничего интересного. Но обратите внимание, что переменные с и f впервые встречаются внутри ветвей case. В Ruby нет никаких объявлений — переменная начинает существовать только в результате присваивания. А это означает, что после выхода из case лишь одна из переменных elif будет иметь действительное значение.

Мы воспользовались этим фактом, чтобы понять, какая ветвь исполнялась, и в зависимости от этого вывести то или другое сообщение. Сравнение f с nil позволяет узнать, есть ли у переменной осмысленное значение. Этот прием применен только для демонстрации возможности: ясно, что при желании можно было бы поместить печать прямо внутрь предложения case.

Внимательный читатель заметит, что мы пользовались только «локальными» переменными. Это может показаться странным, так как, на первый взгляд, их областью видимости является вся программа. На самом деле они локальны относительно верхнего уровня программы. Глобальными они кажутся лишь потому, что в этой простой программе нет контекстов более низкого уровня. Но если бы мы объявили какие-нибудь классы или методы, то в них переменные верхнего уровня были бы не видны.

1.2.6. Циклы и ветвление

Потратим немного времени на изучение управляющих конструкций. Мы уже видели простое предложение if и модификатор if. Существуют также парные структуры, в которых используется ключевое слово unless (в них также может присутствовать необязательная ветвь else), а равно применяемые в выражениях формы if и unless. Все они сведены в таблицу 1.1.

Таблица 1.1. Условные предложения

Формы с if	Формы с unless
if x < 5 then statement1 end	unless x >= 5 then statement1 end
if x < 5 then statement1 else statement2 end	unless x < 5 then statement2 else statement1 end
statement1 if y == 3	statement1 unless y != 3
x = if a>0 then b else c end	x = unless a<=0 then с else b end

Здесь формы с ключевыми словами if и unless, расположенные в одной строке, выполняют в точности одинаковые функции. Обратите внимание, что слово then можно опускать во всех случаях, кроме последнего (предназначенного для использования в выражениях). Также заметьте, что в модификаторах (третья строка) ветви else быть не может.

Предложение case в Ruby позволяет больше, чем в других языках. В его ветвях можно проверять различные условия, а не только сравнивать на равенство. Так, например, разрешено сопоставление с регулярным выражением. Проверки в предложении case эквивалентны оператору ветвящегося равенства (===), поведение которого зависит от объекта. Рассмотрим пример:

case "Это строка символов."

 when "одно значение"

  puts "Ветвь 1"

 when "другое значение"

  puts "Ветвь 2"

 when /симв/

  puts "Ветвь 3"

 else

  puts "Ветвь 4"

end

Этот код напечатает Ветвь 3. Почему? Сначала проверяемое выражение сравнивается на равенство с двумя строками: "одно значение" и "другое значение". Эта проверка завершается неудачно, поэтому мы переходим к третьей ветви. Там находится образец, с которым сопоставляется выражение. Поскольку оно соответствует образцу, то выполняется предложение print. В ветви else обрабатывается случай, когда ни одна из предшествующих проверок не прошла.

Если проверяемое выражение — целое число, то его можно сравнивать с целочисленным диапазоном (например, 3..8); тогда проверяется, что число попадает в диапазон. В любом случае выполняется код в первой подошедшей ветви.

В Ruby имеется богатый набор циклических конструкций. К примеру, while и until — циклы с предварительной проверкой условия, и оба работают привычным образом: в первом случае задается условие продолжения цикла, а во втором — условие завершения. Есть также их формы с модификатором, как для предложений if и unless. Кроме того, в модуле Kernel есть метод loop (по умолчанию бесконечный цикл), а в некоторых классах реализованы итераторы.

В примерах из таблицы 1.2 предполагается, что где-то определен такой массив list:

list = %w[alpha bravo charlie delta echo];

В цикле этот массив обходится и печатается каждый его элемент.

Таблица 1.2. Циклы

# Цикл 1 (while)	# Цикл 2 (until)
i=0 while i < list.size do print "#{list[i]} " i += 1 end	i=0 until i == list.size do print "#{list[i]} " i += 1 end
# Цикл 3 (for)	# Цикл 4 (итератор 'each')
for x in list do print "#{x} " end	list.each do |x| print "#{x} " end
# Цикл 5 (метод 'loop')	# Цикл 6 (метод 'loop')
i = 0 n=list.size-1 loop do print "#{list[i]} " i += 1 break if i > n end	i=0 n=list.size-1 loop do print "#{list[i]} " i += 1 break unless i <= n end
# Цикл 7 (итератор 'times')	# Цикл 8 (итератор 'upto')
n=list.size n.times do |i| print "#{list[i]} " end	n=list.size-1 0.upto(n) do |i| print "#{list[i]} " end
# Цикл 9 (for)	# Цикл 10 ('each_index')
n=list.size-1 for i in 0..n do print "#{list[i]} " end	list.each_index do |x| print "#{list[x]} " end

Рассмотрим эти примеры более подробно. Циклы 1 и 2 — «стандартные» формы циклов while и until; ведут они себя практически одинаково, только условия противоположны. Циклы 3 и 4 — варианты предыдущих с проверкой условия в конце, а не в начале итерации. Отметим, что использование слов begin и end в этом контексте — просто грязный трюк; на самом деле это был бы блок begin/end (применяемый для обработки исключений), за которым следует модификатор while или until. Однако для тех, кто желает написать цикл с проверкой в конце, разницы нет.

На мой взгляд, конструкции 3 и 4 — самый «правильный» способ кодирования циклов. Они заметно проще всех остальных: нет ни явной инициализации, ни явной проверки или инкремента. Это возможно потому, что массив «знает» свой размер, а стандартный итератор each (цикл 6) обрабатывает такие детали автоматически. На самом деле в цикле 5 производится неявное обращение к этому итератору, поскольку цикл for работает с любым объектом, для которого определен итератор each. Цикл for — лишь сокращенная запись для вызова each; часто такие сокращения называют «синтаксической глазурью», имея в виду, что это не более чем удобная альтернативная форма другой синтаксической конструкции.

В циклах 5 и 6 используется конструкция loop. Выше мы уже отмечали, что хотя loop выглядит как ключевое слово, на самом деле это метод модуля Kernel, а вовсе не управляющая конструкция.

В циклах 7 и 8 используется тот факт, что у массива есть числовой индекс. Итератор times исполняется заданное число раз, а итератор upto увеличивает свой параметр до заданного значения. И тот, и другой для данной ситуации приспособлены плохо.

Цикл 9 — это вариант цикла for, предназначенный специально для работы со значениями индекса при помощи указания диапазона. В цикле 10 мы пробегаем весь диапазон индексов массива с помощью итератора each_index.

В предыдущих примерах мы уделили недостаточно внимания вариантам циклов while и loop с модификаторами. Они довольно часто используются из-за краткости. Вот еще два примера, в которых делается одно и то же:

perform_task() until finished

perform_task() while not finished

Также из таблицы 1.2 осталось неясным, что циклы не всегда выполняются от начала до конца. Число итераций не всегда предсказуемо. Нужны дополнительные средства управления циклами.

Первое из них — ключевое слово break, встречающееся в циклах 5 и 6. Оно позволяет досрочно выйти из цикла; в случае вложенных циклов происходит выход из самого внутреннего. Для программистов на С это интуитивно очевидно.

Ключевое слово retry применяется в двух случаях: в контексте итератора и в контексте блока begin-end (обработка исключений). В теле итератора (или цикла for) оно заставляет итератор заново выполнить инициализацию, то есть повторно вычислить переданные ему аргументы. Отметим, что к циклам общего вида это не относится.

Ключевое слово redo — обобщение retry на циклы общего вида. Оно работает в циклах while и until, как retry в итераторах.

Ключевое слово next осуществляет переход на конец самого внутреннего цикла и возобновляет исполнение с этой точки. Работает для любого цикла и итератора.

Как мы только что видели, итератор — важное понятие в Ruby. Но следует отметить, что язык позволяет определять и пользовательские итераторы, не ограничиваясь встроенными.

Стандартный итератор для любого объекта называется each. Это существенно отчасти из-за того, что позволяет использовать цикл for. Но итераторам можно давать и другие имена и применять для разных целей.

В качестве примера рассмотрим многоцелевой итератор, который имитирует цикл с проверкой условия в конце (как в конструкции do-while в С или repeat-until в Pascal):

def repeat(condition)

 yield

 retry if not condition

end

В этом примере ключевое слово yield служит для вызова блока, который задается при таком вызове итератора:

j=0

repeat (j >= 10) do

 j += 1

 puts j

end

С помощью yield можно также передать параметры, которые будут подставлены в список параметров блока (между вертикальными черточками). В следующем искусственном примере итератор всего лишь генерирует целые числа от 1 до 10, а вызов итератора порождает кубические степени этих чисел:

def my_sequence

 for i in 1..10 do

  yield i

 end

end

my_sequence {|x| puts x**3 }

Отметим, что вместо фигурных скобок, в которые заключен блок, можно написать ключевые слова do и end. Различия между этими формами есть, но довольно тонкие.

1.2.7. Исключения

Как и многие другие современные языки, Ruby поддерживает исключения.

Исключения — это механизм обработки ошибок, имеющий существенные преимущества по сравнения с прежними подходами. Нам удается избежать возврата кодов ошибок и запутанной логики их анализа, а код, который обнаруживает ошибку, можно отделить от кода, который ее обрабатывает (чаще всего они так или иначе разделены).

Предложение raise возбуждает исключение. Отметим, что raise — не зарезервированное слово, а метод модуля Kernel. (У него есть синоним fail.)

raise                                               # Пример 1

raise "Произошла ошибка"                            # Пример 2

raise ArgumentError                                 # Пример 3

raise ArgumentError, "Неверные данные"              # Пример 4

raise ArgumentError.new("Неверные данные ")         # Пример 5

raise ArgumentError, " Неверные данные ", caller[0] # Пример 6

В первом примере повторно возбуждается последнее встретившееся исключение. В примере 2 создается исключение RuntimeError (подразумеваемый тип), которому передается сообщение "Произошла ошибка".

В примере 3 возбуждается исключение типа ArgumentError, а в примере 4 такое же исключение, но с сообщением "Неверные данные". Пример 5 — просто другая запись примера 4. Наконец, в примере 6 еще добавляется трассировочная информация вида "filename:line" или "filename:line:in 'method'" (хранящаяся в массиве caller).

А как обрабатываются исключения в Ruby? Для этой цели служит блок begin-end. В простейшей форме внутри него нет ничего, кроме кода:

begin

 #Ничего полезного.

 #...

end

Просто перехватывать ошибки не очень осмысленно. Но у блока может быть один или несколько обработчиков rescue. Если произойдет ошибка в любой точке программы между begin и rescue, то управление сразу будет передано в подходящий обработчик rescue.

begin

 x = Math.sqrt(y/z)

 # ...

rescue ArgumentError

 puts "Ошибка при извлечении квадратного корня."

rescue ZeroDivisionError

 puts "Попытка деления на нуль."

end

Того же эффекта можно достичь следующим образом:

begin

 x = Math.sqrt(y/z)

 # ...

rescue => err

 puts err

end

Здесь в переменной err хранится объект-исключение; при выводе ее на печать объект будет преобразован в осмысленную символьную строку. Отметим, что коль скоро тип ошибки не указан, то этот обработчик rescue будет перехватывать все исключения, производные от класса StandardError. В конструкции rescue => variable можно перед символом => дополнительно указать тип ошибки.

Если типы ошибок указаны, то может случиться так, что тип реально возникшего исключения не совпадает ни с одним из них. На этот случай после всех обработчиков rescue разрешается поместить ветвь else.

begin

 # Код, в котором может возникнуть ошибка...

rescue Type1

 # ...

rescue Type2

 # ...

else

 #Прочие исключения...

end

Часто мы хотим каким-то образом восстановиться после ошибки. В этом поможет ключевое слово retry (внутри тела обработчика rescue). Оно позволяет повторно войти в блок begin и попытаться еще раз выполнить операцию:

begin

 # Код, в котором может возникнуть ошибка...

rescue

 # Пытаемся восстановиться...

 retry # Попробуем еще раз.

end

Наконец, иногда необходим код, который «подчищает» что-то после выполнения блока begin-end. В этом случае можно добавить часть ensure:

begin

 # Код, в котором может возникнуть ошибка...

rescue

 # Обработка исключений.

ensure

 # Этот код выполняется в любом случае.

end

Код, помещенный внутрь части ensure, выполняется при любом способе выхода из блока begin-end — вне зависимости от того, произошло исключение или нет.

Исключения можно перехватывать еще двумя способами. Во-первых, существует форма rescue в виде модификатора:

x = a/b rescue puts("Деление на нуль!")

Кроме того, тело определения метода представляет собой неявный блок begin-end; слово begin опущено, а все тело метода подготовлено к обработке исключения и завершается словом end:

def some_method

 # Код...

rescue

 # Восстановление после ошибки...

end

На этом мы завершаем как обсуждение обработки исключений, так и рассмотрение основ синтаксиса и семантики в целом.

У Ruby есть многочисленные аспекты, которых мы не коснулись. Оставшаяся часть главы посвящена более развитым возможностям языка, в том числе рассмотрению ряда практических приемов, которые помогут программисту среднего уровня научиться «думать на Ruby».

1.3. ООП в Ruby

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

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

1.3.1. Объекты

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

3.succ                # 4

"abc".upcase          # "ABC"

[2,1,5,3,4].sort      # [1,2,3,4,5]

someObject.someMethod # какой-то результат

В Ruby каждый объект представляет собой экземпляр какого-то класса. Класс содержит реализацию методов:

"abc".class       # String

"abc".class.class # Class

Помимо инкапсуляции собственных атрибутов и операций объект в Ruby имеет уникальный идентификатор:

"abc".object_id # 53744407

Этот идентификатор объекта обычно не представляет интереса для программиста.

1.3.2. Встроенные классы

Свыше 30 классов уже встроено в Ruby. Как и во многих других объектно-ориентированных языках, в нем не допускается множественное наследование, но это еще не означает, что язык стал менее выразительным. Современные языки часто построены согласно модели одиночного наследования. Ruby поддерживает модули и классы-примеси, которые мы обсудим в следующей главе. Также реализованы идентификаторы объектов, что позволяет строить устойчивые, распределенные и перемещаемые объекты.

Для создания объекта существующего класса обычно используется метод new:

myFile = File.new("textfile.txt","w")

myString = String.new("Это строковый объект")

Однако не всегда его обязательно вызывать явно. В частности, при создании объекта String можно и не упоминать этот метод:

yourString = "Это тоже строковый объект"

aNumber =5 # и здесь метод new не нужен

Ссылки на объекты хранятся в переменных. Выше уже отмечалось, что сами переменные не имеют типа и не являются объектами — они лишь ссылаются на объекты.

x = "abc"

Из этого правила есть исключение: небольшие неизменяемые объекты некоторых встроенных классов, например Fixnum, непосредственно копируются в переменные, которые на них ссылаются. (Размер этих объектов не превышает размера указателя, поэтому хранить их таким образом более эффективно.) В таком случае во время присваивания делается копия объекта, а куча не используется.

При присваивании переменных ссылки на объекты обобществляются.

y = "abc"

x = y

x # "abc"

После выполнения присваивания x = y и x, и y ссылаются на один и тот же объект:

x.object_id # 53732208

y.object_id # 53732208

Если объект изменяемый, то модификация, примененная к одной переменной, отражается и на другой:

x.gsub!(/а/, "x")

y # "хbс"

Однако новое присваивание любой из этих переменных не влияет на другую:

# Продолжение предыдущего примера

x = "abc"

y # по-прежнему равно "хbс"

Изменяемый объект можно сделать неизменяемым, вызвав метод freeze:

x.freeze

x.gsub!(/b/,"y") # Ошибка!

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

Hearts = :Hearts # Это один из способов присвоить

Clubs = :Clubs # уникальное значение константе,

Diamonds = :Diamonds # некий аналог перечисления

Spades = :Spades # в языках Pascal или С.

puts Hearts.to_s # Печатается "Hearts"

Продемонстрированный выше фокус с «перечислением» был более осмыслен на ранних этапах развития Ruby, когда еще не было класса Symbol, а наличие двоеточия перед идентификатором превращало его в целое число. Если вы пользуетесь таким трюком, не предполагайте, что фактическое значение символа будет неизменным или предсказуемым - просто используйте его как константу, значение которой неважно.

1.3.3. Модули и классы-примеси

Многие встроенные методы наследуются от классов-предков. Особо стоит отметить методы модуля Kernel, подмешиваемые к суперклассу Object. Поскольку класс Object повсеместно доступен, то и добавленные в него из Kernel методы также доступны в любой точке программы. Эти методы играют важную роль в Ruby.

Термины «модуль» и «примесь» — почти синонимы. Модуль представляет собой набор методов и констант, внешних по отношению к программе на Ruby. Его можно использовать просто для управления пространством имен, но основное применение модулей связано с «подмешиванием» его возможностей в класс (с помощью директивы include). В таком случае он используется как класс-примесь.

Этот термин очевидно заимствован из языка Python. Стоит отметить, что в некоторых вариантах LISP такой механизм существует уже больше двадцати лет.

Не путайте описанное выше употребление термина «модуль» с другим значением, которое часто придается ему в информатике. Модуль в Ruby — это не внешний исходный текст и не двоичный файл (хотя может храниться и в том, и в другом виде). Это объектно-ориентированная абстракция, в чем-то похожая на класс.

Примером использования модуля для управления пространством имен служит модуль Math. Так, чтобы получить определение числа π, необязательно включать модуль Math с помощью предложения include; достаточно просто написать Math::PI.

Примесь дает способ получить преимущества множественного наследования, не отягощенные характерными для него проблемами. Можно считать, что это ограниченная форма множественного наследования, но создатель языка Мац называет его одиночным наследованием с разделением реализации.

Отметим, что предложение include включает имена из указанного пространства имен (модуля) в текущее. Метод extend добавляет объекту функции из модуля. В случае применения include методы модуля становятся доступны как методы экземпляра, а в случае extend — как методы класса.

Необходимо оговориться, что операции load и require не имеют ничего общего с модулями: они относятся к исходным и двоичным файлам (загружаемым динамически или статически). Операция load читает файл и вставляет его в текущую точку исходного текста, так что начиная с этой точки становятся видимы все определения, находящиеся во внешнем файле. Операция require аналогична load, но не загружает файл, если он уже был загружен ранее.

Программисты, только начинающие осваивать Ruby, особенно имеющие опыт работы с языком С, могут поначалу путать операции require и include, которые никак не связаны между собой. Вы еще поймаете себя на том, что сначала вызываете require, а потом include для того, чтобы воспользоваться каким-то внешним модулем.

1.3.4. Создание классов

В Ruby есть множество встроенных классов, и вы сами можете определять новые. Для определения нового класса применяется такая конструкция:

class ClassName

# ...

end

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

Попутное замечание: строго говоря, классы в Ruby не имеют имен. «Имя» класса — это всего лишь константа, ссылающаяся на объект типа Class (поскольку в Ruby Class — это класс). Ясно, что на один и тот же класс могут ссылаться несколько констант, и их можно присваивать переменным точно так же, как мы поступаем с любыми другими объектами (поскольку в Ruby Class — это объект). Если вы немного запутались, не расстраивайтесь. Удобства ради новичок может считать, что в Ruby имя класса — то же самое, что в C++.

Вот как определяется простой класс:

class Friend

 @@myname = "Эндрю"           # переменная класса

 def initialize(name, sex, phone)

  @name, @sex, @phone = name, sex, phone

  # Это переменные экземпляра

 end

 def hello # метод экземпляра

  puts "Привет, я #{@name}."

 end

 def Friend.our_common_friend # метод класса

  puts "Все мы друзья #{@@myname}."

 end

end

f1 = Friend.new("Сюзанна","F","555-0123")

f2 = Friend.new("Том","M","555-4567")

f1.hello                      # Привет, я Сюзанна.

f2.hello                      # Привет, я Том.

Friend.our_common_friend      # Все мы друзья Эндрю.

Поскольку данные уровня класса доступны во всем классе, их можно инициализировать в момент определения класса. Если определен метод с именем initialize, то гарантируется, что он будет вызван сразу после выделения памяти для объекта. Этот метод похож на традиционный конструктор, но не выполняет выделения памяти. Память выделяется методом new, а освобождается неявно сборщиком мусора.

Теперь взгляните на следующий фрагмент, обращая особое внимание на методы getmyvar, setmyvar и myvar=:

class MyClass

 NAME = "Class Name"  # константа класса

 @@count = 0          # инициализировать переменную класса

 def initialize       # вызывается после выделения памяти для объекта

  @@count += 1

  @myvar = 10

 end

 def MyClass.getcount # метод класса

  @@count             # переменная класса

 end

 def getcount         # экземпляр возвращает переменную класса!

  @@count             # переменная класса

 end

 def getmyvar         # метод экземпляра

  @myvar              # переменная экземпляра

 end

 def setmyvar(val)    # метод экземпляра устанавливает @myvar

  @myvar = val

 end

 def myvar=(val)      # другой способ установить @myvar

  @myvar = val

 end

end

foo = MyClass.new # @myvar равно 10

foo.setmyvar 20 # @myvar равно 20

foo.myvar =30 # @myvar равно 30

Здесь мы видим, что getmyvar возвращает значение переменной @myvar, а setmyvar устанавливает его. (Многие программисты говорят о методах чтения и установки). Все это работает, но не является характерным способом действий в Ruby. Метод myvar= похож на перегруженный оператор присваивания (хотя, строго говоря, таковым не является); это более удачная альтернатива setmyvar, но есть способ еще лучше.

Класс Module содержит методы attr, attr_accessor, attr_reader и attr_writer. Ими можно пользоваться (передавая символы в качестве параметров) для автоматизации управления доступом к данным экземпляра. Например, все три метода getmyvar, setmyvar и myvar= можно заменить одной строкой в определении класса:

attr_accessor :myvar

При этом создается метод myvar, который возвращает значение @myvar, и метод myvar=, который позволяет изменить значение той же переменной. Методы attr_reader и attr_writer создают соответственно версии методов доступа к атрибуту для чтения и для изменения.

Внутри методов экземпляра, определенных в классе, можно при необходимости пользоваться переменной self. Это просто ссылка на объект, от имени которого вызван метод экземпляра.

Для управления видимостью методов класса можно пользоваться модификаторами private, protected и public. (Переменные экземпляра всегда закрыты, обращаться к ним извне класса можно только с помощью методов доступа.) Каждый модификатор принимает в качестве параметра символ, например :foo, а если он опущен, то действие модификатора распространяется на все последующие определения в классе. Пример:

class MyClass

 def method1

  # ...

 end

 def method2

  # ...

 end

 def method3

  # ...

 end

 private :method1

 public

 :method2

 protected :method3

 private

 def my_method

  # ...

 end

 def another_method

  # ...

 end

end

В этом классе метод method1 закрытый, method2 открытый, a method3 защищенный. Поскольку далее вызывается метод private без параметров, то методы my_method и another_method будут закрытыми.

Уровень доступа public не нуждается в объяснениях, он не налагает никаких ограничений ни на доступ к методу, ни на его видимость. Уровень private означает, что метод доступен исключительно внутри класса или его подклассов и может вызываться только в «функциональной форме» от имени self, причем вызывающий объект может указываться явно или подразумеваться неявно. Уровень protected означает, что метод вызывается только внутри класса, но, в отличие от закрытого метода, не обязательно от имени self.

По умолчанию все определенные в классе методы открыты. Исключение составляет лишь initialize. Методы, определенные на верхнем уровне программы, тоже по умолчанию открыты. Если они объявлены закрытыми, то могут вызываться только в функциональной форме (как, например, методы, определенные в классе Object).

Классы в Ruby сами являются объектами — экземплярами метакласса Class. Классы в этом языке всегда конкретны, абстрактных классов не существует. Однако теоретически можно реализовать и абстрактные классы, если вам это для чего-то понадобится.

Класс Object является корнем иерархии. Он предоставляет все методы, определенные во встроенном модуле Kernel.

Чтобы создать класс, наследующий другому классу, нужно поступить следующим образом:

class MyClass < OtherClass

 # ...

end

Помимо использования встроенных методов, вполне естественно определить и собственные либо переопределить унаследованные. Если определяемый метод имеет то же имя, что и существующий, то старый метод замещается. Если новый метод должен обратиться к замещенному им «родительскому» методу (так бывает часто), можно воспользоваться ключевым словом super.

Перегрузка операторов, строго говоря, не является неотъемлемой особенностью ООП, но этот механизм знаком программистам на C++ и некоторых других языках. Поскольку большинство операторов в Ruby так или иначе являются методами, то не должен вызывать удивления тот факт, что их можно переопределять или определять в пользовательских классах. Переопределять семантику оператора в существующем классе редко имеет смысл, зато в новых классах определение операторов — обычное дело.

Можно создавать синонимы методов. Для этого внутри определения класса предоставляется такой синтаксис:

alias newname oldname

Число параметров будет таким же, как для старого имени, и вызываться метод-синоним будет точно так же. Обратите внимание на отсутствие запятой; alias — это не имя метода, а ключевое слово. Существует метод с именем alias_method, который ведет себя аналогично, но в случае его применения параметры должны разделяться запятыми, как и для любого другого метода.

1.3.5. Методы и атрибуты

Как мы уже видели, методы обычно используются в сочетании с простыми экземплярами классов и переменными, причем вызывающий объект отделяется от имени метода точкой (receiver.method). Если имя метода является знаком препинания, то точка опускается. У методов могут быть аргументы:

Time.mktime(2000, "Aug", 24, 16, 0)

Поскольку каждое выражение возвращает значение, то вызовы методов могут сцепляться:

3.succ.to_s

/(x.z).*?(x.z).*?/.match("x1z_1a3_x2z_1b3_").to_a[1..3]

3+2.succ

Отметим, что могут возникать проблемы, если выражение, являющееся результатом сцепления, имеет тип, который не поддерживает конкретный метод. Точнее, при определенных условиях некоторые методы возвращают nil, а вызов любого метода от имени такого объекта приведет к ошибке. (Конечно, nil — полноценный объект, но он не обладает теми же методами, что и, например, массив.)

Некоторым методам можно передавать блоки. Это верно для всех итераторов — как встроенных, так и определенных пользователем. Блок обычно заключается в операторные скобки do-end или в фигурные скобки. Но он не рассматривается так же, как предшествующие ему параметры, если таковые существуют. Вот пример вызова метода File.open:

my_array.each do |x|

 some_action

end

File.open(filename) { |f| some_action }

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

Методы могут принимать переменное число аргументов:

receiver.method(arg1, *more_args)

В данном случае вызванный метод трактует more_args как массив и обращается с ним, как с любым другим массивом. На самом деле звездочка в списке формальных параметров (перед последним или единственным параметром) может «свернуть» последовательность фактических параметров в массив:

def mymethod(a, b, *с)

 print a, b

 с.each do |x| print x end

end

mymethod(1,2,3,4,5,6,7)

# a=1, b=2, c=[3,4,5,6,7]

В Ruby есть возможность определять методы на уровне объекта (а не класса). Такие методы называются синглетными; они принадлежат одному-единственному объекту и не оказывают влияния ни на класс, ни на его суперклассы. Такая возможность может быть полезна, например, при разработке графических интерфейсов пользователя: чтобы определить действие кнопки, вы задаете синглетный метод для данной и только данной кнопки.

Вот пример определения синглетного метода для строкового объекта:

str = "Hello, world!"

str2 = "Goodbye!"

def str.spell

 self.split(/./).join("-")

end

str.spell # "H-e-l-l-o-,- -w-o-r-l-d-!"

str2.spell # Ошибка!

Имейте в виду, что метод определяется для объекта, а не для переменной. Теоретически с помощью синглетных методов можно было бы создать систему объектов на базе прототипов. Это менее распространенная форма ООП без классов^[5]. Основной структурный механизм в ней состоит в конструировании нового объекта путем использования существующего в качестве образца; новый объект ведет себя как старый за исключением тех особенностей, которые были переопределены. Тем самым можно строить системы на основе прототипов, а не наследования. Хотя у нас нет опыта в этой области, мы полагаем, что создание такой системы позволило бы полнее раскрыть возможности Ruby.

1.4. Динамические аспекты Ruby

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

Наверное, это самая трудная тема для программиста, приступающего к изучению Ruby. В данном разделе мы вкратце рассмотрим некоторые следствия, вытекающие из динамической природы языка.

1.4.1. Кодирование во время выполнения

Мы уже упоминали директивы load и require. Важно понимать, что это не встроенные предложения и не управляющие конструкции; на самом деле это методы. Поэтому их можно вызывать, передавая переменные или выражения как параметры, в том числе условно. Сравните с директивой #include в языках С и C++, которая обрабатывается во время компиляции.

Код можно строить и интерпретировать по частям. В качестве несколько искусственного примера рассмотрим приведенный ниже метод calculate и вызывающий его код:

def calculate(op1, operator, op2)

 string = op1.to_s + operator + op2.to_s

 # Предполагается, что operator - строка; построим длинную

 # строку, состоящую из оператора и операндов.

 eval(string)                    # Вычисляем и возвращаем значение.

end

@alpha = 25

@beta = 12

puts calculate(2, "+",2)         # Печатается 4

puts calculate(5, "*", "@alpha") # Печатается 125

puts calculate("@beta", "**", 3) # Печатается 1728

Вот та же идея, доведенная чуть ли не до абсурда: программа запрашивает у пользователя имя метода и одну строку кода. Затем этот метод определяется и вызывается:

puts "Имя метода: "

meth_name = gets

puts "Строка кода: "

code = gets

string = %[def #{meth_name}\n #{code}\n end] # Строим строку.

eval(string) # Определяем метод.

eval(meth_name) # Вызываем метод.

Зачастую необходимо написать программу, которая могла бы работать на разных платформах или при разных условиях, но при этом сохранить общий набор исходных текстов. Для этого в языке С применяются директивы #ifdef, но в Ruby все определения исполняются. Не существует такого понятия, как «этап компиляции»; все конструкции динамические, а не статические. Поэтому для принятия решения такого рода мы можем просто вычислить условие во время выполнения:

if platform == Windows

 action1

elsif platform == Linux

 action2

else

 default_action

end

Конечно, за такое кодирование приходится расплачиваться некоторым снижением производительности, поскольку иногда условие вычисляется много раз. Но рассмотрим следующий пример, который делает практически то же самое, однако весь платформенно-зависимый код помещен в один метод, имя которого от платформы не зависит:

if platform == Windows

 def my_action

  action1

 end

 elsif platform == Linux

 def my_action

  action2

 end

 else

 def my_action

  default_action

 end

end

Таким способом мы достигаем желаемого результата, но условие вычисляется только один раз. Когда программа вызовет метод my_action, он уже будет правильно определен.

1.4.2. Отражение

В языках Smalltalk, LISP и Java реализована (с разной степенью полноты) идея рефлексивного программирования — активная среда может опрашивать структуру объектов и расширять либо модифицировать их во время выполнения.

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

Для определения того, используется ли идентификатор с данным именем, служит ключевое слово defined? (обратите внимание на вопросительный знак в конце слова):

if defined? some_var

 puts "some_var = #{some_var}"

else

 puts "Переменная some_var неизвестна."

end

Аналогично метод respond_to? выясняет, может ли объект отвечать на вызов указанного метода (то есть определен ли данный метод для данного объекта). Метод respond_to? определен в классе Object.

В Ruby запрос информации о типе во время выполнения поддерживается очень полно. Тип или класс объекта можно определить, воспользовавшись методом type (из класса Object). Метод is_a? сообщает, принадлежит ли объект некоторому классу (включая и его суперклассы); синонимом служит имя kind_of?. Например:

puts "abc".class "" # Печатается String

puts 345.class # Печатается Fixnum

rover = Dog.new

print rover.class # Печатается Dog

if rover.is_a? Dog

 puts "Конечно, является."

end

if rover.kind_of? Dog

 puts "Да, все еще собака."

end

if rover.is_a? Animal

 puts "Да, он к тому же и животное."

end

Можно получить полный список всех методов, которые можно вызвать для данного объекта. Для этого предназначен метод methods из класса Object. Имеются также его варианты private_instance_methods, public_instance_methods и т.д.

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

В классе Module есть метод ancestors, возвращающий список модулей, включенных в данный модуль. В этот список входит и сам данный модуль, то есть список, возвращаемый вызовом Mod.ancestors, содержит по крайней мере элемент Mod. В этот список входят не только родительские классы (отобранные в силу наследования), но и «родительские» модули (отобранные в силу включения).

В классе Object есть метод superclass, который возвращает суперкласс объекта или nil. Не имеет суперкласса лишь класс Object, и, значит, только для него может быть возвращен nil.

Модуль ObjectSpace применяется для получения доступа к любому «живому» объекту. Метод _idtoref преобразует идентификатор объекта в ссылку на него; можно считать, что это операция, обратная той, что выполняет двоеточие в начале имени. В модуле ObjectSpace есть также итератор each_object, который перебирает все существующие в данный момент объекты, включая и те, о которых иным образом узнать невозможно. (Напомним, что некоторые неизменяемые объекты небольшого размера, например принадлежащие классам Fixnum, NilClass, TrueClass и FalseClass, не хранятся в куче из соображений оптимизации.)

1.4.3. Отсутствующие методы

При вызове метода (myobject.mymethod) Ruby ищет поименованный метод в следующем порядке:

1. Синглетные методы, определенные для объекта myobject.

2. Методы, определенные в классе объекта myobject.

3. Методы, определенные в предках класса объекта myobject.

Если найти метод mymethod не удается, Ruby ищет метод с именем method_missing. Если он определен, то ему передается имя отсутствующего метода (в виде символа) и все переданные ему параметры. Этот механизм можно применять для динамической обработки неизвестных сообщений, посланных во время выполнения.

1.4.4 Сборка мусора

Управлять памятью на низком уровне трудно и чревато ошибками, особенно в таком динамичном окружении, какое создает Ruby. Наличие механизма сборки мусора — весомое преимущество. В таких языках, как C++, за выделение и освобождение памяти отвечает программист. В более поздних языках, например Java, память освобождается сборщиком мусора (когда объект покидает область видимости).

Явное управление памятью может приводить к двум видам ошибок. Если освобождается память, занятая объектом, на который еще есть ссылки, то при последующем доступе к нему объект может оказаться в противоречивом состоянии. Так называемые висячие указатели трудно отлаживать, поскольку вызванные ими ошибки часто проявляются далеко от места возникновения. Утечка памяти имеет место, когда не освобождается объект, на который больше никто не ссылается. В этом случае программа потребляет все больше и больше памяти и в конечном счете аварийно завершается; такие ошибки искать тоже трудно. В языке Ruby для отслеживания неиспользуемых объектов и освобождения занятой ими памяти применяется механизм сборки мусора. Для тех, кто в этом разбирается, отметим, что в Ruby используется алгоритм пометки и удаления, а не подсчета ссылок (у последнего возникают трудности при обработке рекурсивных структур).

Сборка мусора влечет за собой некоторое снижение производительности. Модуль GC предоставляет ограниченные средства управления, позволяющие программисту настроить его работу в соответствии с нуждами конкретной программы. Можно также определить чистильщика (finalizer) объекта, но это уже тема для «продвинутых» (см. раздел 11.3.14).

1.5. Потренируйте свою интуицию: что следует запомнить

Надо честно признаться: «все становится интуитивно ясным после того, как поймешь». Эта истина и составляет суть данного раздела, поскольку в Ruby немало особенностей, отличающих его от всего, к чему привык программист на одном из традиционных языков.

Кто-то из читателей решит, что не нужно зря тратить время на повторение известного. Если вы из их числа, можете пропустить разделы, содержание которых кажется вам очевидным. Программисты имеют неодинаковый опыт; искушенные пользователи С и Smalltalk воспримут Ruby совсем по-разному. Впрочем, мы надеемся, что внимательное прочтение последующих разделов поможет многим читателям разобраться в том, что же такое Путь Ruby.

1.5.1. Синтаксис

Синтаксический анализатор Ruby сложен и склонен прощать многие огрехи. Он пытается понять, что хотел сказать программист, а не навязывать ему жесткие правила. Но к такому поведению надо еще привыкнуть. Вот перечень того, что следует знать о синтаксисе Ruby.

• Скобки при вызове методов, как правило, можно опускать. Все следующие вызовы допустимы:

foobar

foobar()

foobar(a,b,c)

foobar a, b, с

• Коль скоро скобки необязательны, что означает такая запись: x у z? Оказывается, вот что: «Вызвать метод y, передав ему параметр z, а результат передать в виде параметра методу x.» Иными словами, x(y(z)). Это поведение в будущем изменится. См. обсуждение поэтического режима в разделе 1.6 ниже.

• Попробуем передать методу хэш:

my_method {а=>1, b=>2}

Это приведет к синтаксической ошибке, поскольку левая фигурная скобка воспринимается как начало блока. В данном случае скобки необходимы:

my_method({а=>1, b=>2})

• Предположим теперь, что хэш — единственный (или последний) параметр метода. Ruby снисходительно разрешает опускать фигурные скобки:

my_method(а=>1, b=>2)

Кто-то увидит здесь вызов метода с именованными параметрами. Это обманчивое впечатление, хотя никто не запрещает применять подобную конструкцию и в таком смысле.

• Есть и другие случаи, когда пропуски имеют некоторое значение. Например, на первый взгляд все четыре выражения ниже означают одно и то же:

x = y + z

x = y+z

x = y+ z

x = y +z

Но фактически эквивалентны лишь первые три. В четвертом же случае анализатор считает, что вызван метод у с параметром +z! И выдаст сообщение об ошибке, так как метода с именем у не существует. Мораль: пользуйтесь пробелами разумно.

• Аналогично x = y*z — это умножение у на z, тогда как x = y *z — вызов метода у, которому в качестве параметра передается расширение массива z.

• В именах идентификаторов знак подчеркивания _ считается строчной буквой. Следовательно, имя идентификатора может начинаться с этого знака, но такой идентификатор не будет считаться константой, даже если следующая буква прописная.

• В линейной последовательности вложенных предложений if применяется ключевое слово elsif, а не else if или elif, как в некоторых других языках.

• Ключевые слова в Ruby нельзя назвать по-настоящему зарезервированными. Если метод вызывается от имени некоторого объекта (и в других случаях, когда не возникает неоднозначности), имя метода может совпадать с ключевым словом. Но поступайте так с осторожностью, не забывая, что программу будут читать люди.

• Ключевое слово then (в предложениях if и case) необязательно. Если вам кажется, что с ним программа понятнее, включайте его в код. То же относится к слову do в циклах while и until.

• Вопросительный и восклицательный знаки не являются частью идентификатора, который модифицируют, — их следует рассматривать как суффиксы. Таким образом, хотя идентификаторы chop и chop! считаются различными, использовать восклицательный знак в любом другом месте имени не разрешается. Аналогично в Ruby есть конструкция defined?, но defined — ключевое слово.

• Внутри строки символ решетки # — признак начала выражения. Значит, в некоторых случаях его следует экранировать обратной косой чертой, но лишь тогда, когда сразу за ним идет символ {, $ или @.

• Поскольку вопросительный знак можно добавлять в конец идентификатора, то следует аккуратно расставлять пробелы в тернарном операторе. Пусть, например, имеется переменная my_flag, которая может принимать значения true или false. Тогда первое из следующих предложений правильно, а второе содержит синтаксическую ошибку:

x = my_flag ? 23 : 45 # Правильно.

x = my_flag? 23 : 45  # Синтаксическая ошибка.

• Концевой маркер для встроенной документации не следует считать лексемой. Он помечает строку целиком, поэтому все находящиеся в той же строке символы не являются частью текста программы, а принадлежат встроенному документу.

• В Ruby нет произвольных блоков, то есть нельзя начать блок в любом месте, как в С. Блоки разрешены только там, где они нужны, — например, могут присоединяться к итератору. Исключение составляет блок begin-end, который можно употреблять практически везде.

• Не забывайте, что ключевые слова BEGIN и END не имеют ничего общего с begin и end.

• При статической конкатенации строк приоритет конкатенации ниже, чем у вызова метода. Например:

str = "Первая " 'second'.center(20)     # Примеры 1 and 2

str = "Вторая " + 'second'.center(20)   # дают одно и то же.

str = "Первая вторая".center(20)        # Примеры 3 and 4

str = ("Первая " + 'вторая').center(20) # дают одно и то же.

• В Ruby есть несколько псевдопеременных, которые выглядят как локальные переменные, но применяются для особых целей. Это self, nil, true, false, __FILE__ и __LINE__.

1.5.2. Перспективы программирования

Наверное, каждый, кто знает Ruby (сегодня), в прошлом изучал или пользовался другими языками. Это, с одной стороны, облегчает изучение Ruby, так как многие средства похожи на аналогичные средства в других языках. С другой стороны, у программиста может возникнуть ложное чувство уверенности при взгляде на знакомые конструкции Ruby. Он может прийти к неверным выводам, основанным на прошлом опыте; можно назвать это явление «багажом эксперта».

Немало специалистов переходит на Ruby со Smalltalk, Perl, C/C++ и других языков. Ожидания этих людей сильно различаются, но так или иначе присутствуют. Поэтому рассмотрим некоторые вещи, на которых многие спотыкаются.

• Символ в Ruby представляется целым числом. Это не самостоятельный тип, как в Pascal, и не эквивалент строки длиной 1. В ближайшем будущем положение изменится и символьная константа станет строкой, но на момент написания данной книги этого еще не произошло. Рассмотрим следующий фрагмент:

x = "Hello"

y = ?А

puts "x[0] = #{x[0]}" # Печатается x[0] = 72

puts "y = #{y}"       # Печатается y = 65

if y == "А"           # Печатается no

 puts "yes"

else

 puts "no"

end

• He существует булевского типа. TrueClass и FalseClass — это два разных класса, а единственными их экземплярами являются объекты true и false.

• Многие операторы в Ruby напоминают операторы в языке С. Два заметных исключения — операторы инкремента и декремента (++ и --). Их в Ruby нет ни в «пост», ни в «пред» форме.

• Известно, что в разных языках оператор деления по модулю работает по-разному для отрицательных чисел. Не вдаваясь в споры о том, что правильно, проиллюстрируем поведение в Ruby:

puts (5 % 3)   # Печатается 2

puts (-5 % 3)  # Печатается 1

puts (5 % -3)  # Печатается -1

puts (-5 % -3) # Печатается -2

• Некоторые привыкли думать, что «ложь» можно представлять нулем, пустой строкой, нулевым символом и т.п. Но в Ruby все это равно «истине». На самом деле истиной будет все кроме объектов false и nil.

• В Ruby переменные не принадлежат никакому классу: класс есть только у значений.

• Переменные в Ruby не объявляются, однако считается хорошим тоном присваивать переменной начальное значение nil. Разумеется, при этом с переменной не ассоциируется никакой тип и даже не происходит истинной инициализации, но анализатор знает, что данное имя принадлежит переменной, а не методу.

• ARGV[0] — первый аргумент в командной строке; они нумеруются начиная с нуля. Это не имя файла или сценария, предшествующего параметрам, как argv[0] в языке С.

• Большинство операторов в Ruby на самом деле является методами; их запись в виде «знаков препинания» — не более чем удобство. Первое исключение из этого правила — набор операторов составного присваивания (+=, -= и т.д.). Второе исключение - операторы =, .., ..., !, not, &&, and, ||, or, !=, !~.

• Как и в большинстве современных языков программирования (хотя и не во всех), булевские операции закорачиваются, то есть вычисление булевского выражения заканчивается, как только его значение истинности становится известным. В последовательности операций or вычисление заканчивается, когда получено первое значение true, а в последовательности операций and — когда получено первое значение false.

• Префикс @@ применяется для переменных класса (то есть ассоциированных с классом в целом, а не с отдельным экземпляром).

• loop — не ключевое слово. Это метод модуля Kernel, а не управляющая конструкция.

• Кому-то синтаксис unless-else может показаться интуитивно неочевидным. Поскольку unless — противоположность if, то ветвь else выполняется, когда условие истинно.

• Простой тип Fixnum передается как непосредственное значение и, стало быть, не может быть изменен внутри метода. То же относится к значениям true, false и nil.

• Не путайте операторы && и || с операторами & и |. Те и другие используются в языке С; первые два предназначены для логических операций, последние два — для поразрядных.

• Операторы and и or имеют более низкий приоритет, чем && и ||. Взгляните на следующий фрагмент:

а = true

b = false

с = true

d = true

a1 = a && b or с && d   # Операции && выполняются первыми.

a2 = a && (b or с) && d # Операция or выполняется первой.

puts a1                 # Печатается false

puts a2                 # Печатается true

• He забывайте, что «оператор» присваивания имеет более высокий приоритет, чем операторы and и or! (это относится и к составным операторам присваивания: +=, -= и пр.). Например, код x = y or z выглядит как обычное предложение присваивания, но на самом деле это обособленное выражение (эквивалент (x=у) or z). Вероятно, программист имел в виду следующее: x = (y or z).

y = false

z = true

x = y or z   # Оператор = выполняется РАНЬШЕ or!

puts x       # Печатается false

(x = y) or z # Строка 5: то же, что и выше.

puts x       # Печатается false

x = (y or z) # Оператор or вычисляется сначала.

puts x       # Печатается true

• Не путайте атрибуты объектов с локальными переменными. Если вы привыкли к C++ или Java, можете забыть об этом! Переменная @my_var в контексте класса — это переменная экземпляра (или атрибут), но my_var в том же контексте — локальная переменная.

• Во многих языках, и в Ruby в том числе, есть цикл for. Рано или поздно возникает вопрос, можно ли модифицировать индексную переменную. В некоторых языках эту управляющую переменную запрещено изменять вовсе (выводится предупреждение либо сообщение об ошибке на этапе компиляции или выполнения); в других это допустимо, хотя и приводит к изменению поведения цикла. В Ruby принят третий подход. Переменная, управляющая циклом for, считается обычной переменной, которую можно изменять в любой момент, но это изменение не оказывает влияния на поведение цикла! Цикл for присваивает этой переменной последовательные значения, что бы с ней ни происходило внутри тела цикла. Например, следующий цикл будет выполнен ровно 10 раз и напечатает значения от 1 до 10:

for var in 1..10

 puts "var = #{var}"

 if var > 5

  var = var + 2

 end

end

• Имена переменных не всегда легко «на глаз» отличить от имен методов. Как решает этот вопрос анализатор? Правило такое: если анализатор видит, что идентификатору присваивается значение до его использования, то он считается переменной; в противном случае это имя метода. (Отметим, что операция присваивания может и не выполняться: достаточно того, что интерпретатор ее видел.)

1.5.3. Предложение case в Ruby

Во всех современных языках есть та или иная форма многопутевого ветвления. В C/C++ и Java это предложение switch, а в Pascal — предложение case. Служат они одной и той же цели и функционируют примерно одинаково.

Предложение case в Ruby похоже, но при ближайшем рассмотрении оказывается настолько уникальным, что варианты ветвления, принятые в С и в Pascal, кажутся близкими родственниками. Точного аналога предложению case в Ruby нет ни в каком другом знакомом мне языке, поэтому оно заслуживает особого внимания.

Выше мы уже рассматривали синтаксис этого предложения, а теперь сосредоточимся на его семантике.

• Для начала рассмотрим тривиальный пример. Выражение expression сравнивается со значением value, и, если они совпадают, выполняется некоторое действие. Ничего удивительного.

case expression

 when value

  некоторое действие

end ...