Programming Ruby 1.9 (3rd edition): The Pragmatic Programmers' Guide / Программирование на Ruby 1.9 (3-е издание): Руководство прагматичного программиста: Ruby.New

<b>Ruby.new</b>

white_rabbit 19.09.10 в 11:00

Большинство книг по программированию одинаковы. Они начинаются главами посвященными базовым типам: числам, строкам и др. Затем рассматриваются выражения, далее управляющие структуры <code>if</code> и <code>while</code>. Затем, возможно в 7 или 8 главе, переходят к классам. Все это представляется весьма скучным.

white_rabbit 19.09.10 в 10:55

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

Droidos 19.09.10 в 15:52

К сожалению, оказалось сложно описывать язык таким методом. Если не описать строки, операторы, присвоения и другие детали, то становится сложно придумывать примеры классов. С использованием нашего описания сверху-вниз, мы одновременно рассматриваем и низкоуровневые детали которые нуждаются в описании и по этому примеры кода имеют смысл.

Droidos 19.09.10 в 16:11

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

Droidos 19.09.10 в 19:20

<b>Ruby это объектно-ориентированный язык программирования</b>

white_rabbit 19.09.10 в 11:01

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

Droidos 21.09.10 в 19:45

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

Droidos 23.09.10 в 17:48

Как только у вас есть эти классы вы типично собираетесь создать некоторое количество экземпляров. Для системы музыкального автомата содержащей класс Song(Песня), у вас будут разные экземпляры для популярных хитов типа “Ruby Tuesday,” “Enveloped in Python,” “String of Pearls,” “Small Talk,” и так далее. Слово объект используется как синоним экземпляра класса ( но потому что нам лень печатать, мы скорее всего будем использовать слово объект чаще).

Droidos 23.09.10 в 18:15

В Ruby эти объекты создаются вызовом конструктора-специального метода ассоциированного с классом. Стандартный конструктор new вызван сейчас.

Droidos 23.09.10 в 18:46

&nbsp;&nbsp;&nbsp;&nbsp;<code>song1 = Song.new("Ruby Tuesday")</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code>song2 = Song.new("Enveloped in Python")</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code># and so on</code>

white_rabbit 19.09.10 в 11:02

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

Droidos 24.09.10 в 16:07

Внутри каждого класса вы можете определить методы экземпляра. Каждый метод это часть функциональности которая может быть вызвана в контексте класса и (в зависимости от ограничений доступа) снаружи класса. Эти методы экземпляров в свою очередь имеют доступ к переменным экземпляра объекта и следовательно к состоянию объекта. Класс Song, к примеру, может определять метод экземпляра под названием "play". Если переменная my_way (мой_путь) ссылается на особый экземпляр Song то у вас будет возможность вызвать этот метод экземпляра play и воспроизвести особую песню.

Droidos 24.09.10 в 17:51

Методы вызываются отправкой сообщения (команды) объекту. Сообщение содержит в себе имя метода вместе с любыми нужными параметрами для метода (Эта идея выражения вызовов метода в форме сообщения пришла из Smalltalk.). Когда объект получает сообщение то ищет в его собственном классе соответствующий метод. Если находит то этот метод выполняется. Ну а если метод не найден...мы вернемся к этому позже.

Droidos 25.09.10 в 17:59

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

Droidos 25.09.10 в 18:28

&nbsp;&nbsp;&nbsp;&nbsp;<code>puts "gin joint".length</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code>puts "Rick".index("c")</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code>puts 42.even?</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code>puts sam.play(song)</code>

white_rabbit 19.09.10 в 11:04

<i>выводит</i>

white_rabbit 19.09.10 в 11:06

&nbsp;&nbsp;&nbsp;&nbsp;<code>9</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code>2</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code>true</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code>duh dum, da dum de dum ...</code>

white_rabbit 19.09.10 в 11:06

Каждая строчка показывает, что метод вызывается как аргумент для puts. Вещь перед точкой названа получателем и имя после точки это тот метод который вызывается. Первый пример запрашивает длину строки, а второй запрашивает другую строку найти индекс буквы "с". И третья строчка запрашивает число 42 если оно четное (знак вопроса это часть названия метода even?). Да, и наконец мы просим Сэма проиграть нам песню (при том что это имеющаяся переменная sam которая ссылается на соответствующий объект).

Droidos 25.09.10 в 18:53

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

Droidos 26.09.10 в 08:30

&nbsp;&nbsp;&nbsp;&nbsp;<code>num = Math.abs(num) // Java code</code>

white_rabbit 19.09.10 в 11:07

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

Droidos 26.09.10 в 09:03

&nbsp;&nbsp;&nbsp;&nbsp;<code>num = 1234</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code># =&gt; 1234</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code>positive = num.abs # =&gt; 1234</code>

white_rabbit 19.09.10 в 11:07

Тоже самое примениме ко всем объектам Ruby. В C используется strlen(name), но в Ruby это name.length, и так далее. Это какраз та часть которую мы имели ввиду когда говорили что Ruby объектно-ориентированный язык.

Droidos 26.09.10 в 09:23

<b>Некоторые начала Ruby</b>

white_rabbit 19.09.10 в 11:09

Не много людей любит читать кучи надоедливых синтаксических правил когда они начинают изучать новый язык, так-что мы собираемся схитрить. В этой секции мы покажем самое важное - то что только вам необходимо если вы собираетесь писать программы на Ruby. И только в 22 главе, которая начинается на 325 странице мы перейдем к мелким деталям. Давайте начнем с простенькой программы на Ruby. Мы напишем метод который возвращает персональное радостное приветствие. И потом мы вызовем метод несколько раз:

Droidos 26.09.10 в 10:01

&nbsp;&nbsp;&nbsp;&nbsp;<code>def say_goodnight(name)</code>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<code>result = "Good night, " + name</code>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<code>return result</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code>end</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code># Time for bed...</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code>puts say_goodnight("JohnBoy")</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code>puts say_goodnight("MaryEllen")</code>

white_rabbit 19.09.10 в 11:10

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

Droidos 26.09.10 в 16:54

Методы определяются ключевым словом def, за ним следует имя метода (здесь как say_goodnight) и параметры между круглыми скобками. (Факт тот что скобки не обязательны, но мы любим использовать их.) Ruby не использует фигурные скобки для ограничения тел составных выражений и определений. И так, вы просто заканчиваете тело с ключевым словом end. Метод нашего тела очень простой. Первая линия объединяет строку символов "Good night, " и имя параметра и присваивает результат результату переменной. Следующая линия возвращает результат вызывавшему. Кстати нам не нужно декларировать результат переменной, она начинает существовать когда мы назначаем ее.

Droidos 26.09.10 в 18:31

Определив метод, мы вызываем его дважды. В обоих примерах, мы передавали результат в метод <i>puts</i>, который просто выводит аргумент следующий за новой строкой (переходя на следующую строку вывода):

Droidos 14.10.10 в 19:02

&nbsp;&nbsp;&nbsp;&nbsp;<code>Good night, JohnBoy</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code>Good night, MaryEllen</code>

white_rabbit 19.09.10 в 11:14

Cтрока

aist 19.09.10 в 12:15

&nbsp;&nbsp;&nbsp;&nbsp;<code>puts say_goodnight("JohnBoy")</code>

white_rabbit 19.09.10 в 11:15

содержит вызов двух методов, один вызов метода say_goodnight и другой вызов метода puts. Почему в одном случае аргументы метода заключены в скобки, а в другом - нет? Это дело вкуса. Нижеследующие строки эквивалентны:

aist 19.09.10 в 12:19

&nbsp;&nbsp;&nbsp;&nbsp;<code>puts say_goodnight("JohnBoy")</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code>puts(say_goodnight("JohnBoy"))</code>

white_rabbit 19.09.10 в 11:15

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

Droidos 14.10.10 в 19:10

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

Droidos 15.10.10 в 05:32

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

Droidos 17.10.10 в 08:22

<code>&nbsp;&nbsp;&nbsp;&nbsp;puts "And good night,\nGrandma"</code>

white_rabbit 19.09.10 в 11:16

Выводит:

Droidos 15.10.10 в 18:15

<code>&nbsp;&nbsp;&nbsp;&nbsp;And good night,
&nbsp;&nbsp;&nbsp;&nbsp;Grandma</code>

white_rabbit 19.09.10 в 11:16

Второе, что Ruby делает со строками в двойных кавычках это интерполяция выражения. В строке, последовательность #{выражение} заменяется значением выражения. Мы могли бы использовать это, чтобы переписать предыдущий метод:

Droidos 17.10.10 в 18:12

&nbsp;&nbsp;&nbsp;&nbsp;<code>def say_goodnight(name)</code>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<code>result = "Good night, #{name}"</code>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<code>return result</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code>end</code>

white_rabbit 19.09.10 в 11:17

&nbsp;&nbsp;&nbsp;&nbsp;<code>puts say_goodnight('Pa')</code>

Droidos 15.10.10 в 18:16

Выводит:

Droidos 15.10.10 в 18:15

&nbsp;&nbsp;&nbsp;&nbsp;<code>Good night, Pa</code>

white_rabbit 19.09.10 в 11:18

Когда Ruby строит этот строчный объект, он смотрит на текущее значение имени и его заменяет в строке. Какие угодно сложные выражения возможно в # {. . . } построить. В следующем примере мы вызываем метод перехода на заглавные буквы, определенные для всех строк, чтобы вывести наш параметр с заглавной буквы:

Droidos 17.10.10 в 18:36

&nbsp;&nbsp;&nbsp;&nbsp;<code>def say_goodnight(name)</code>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<code>result = "Good night, #{name.capitalize}"</code>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<code>return result</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code>end</code>
&nbsp;&nbsp;&nbsp;&nbsp;<code>puts say_goodnight('uncle')</code>

white_rabbit 19.09.10 в 11:19

Выводит:

Droidos 15.10.10 в 18:17

&nbsp;&nbsp;&nbsp;&nbsp;<code>Good night, Uncle</code>

white_rabbit 19.09.10 в 11:20