4Debian.Info - Портал русскогоязычного сообщества Debian Карта сайта Контакты

Меню

Репозитории Debian

Скачать Debian

Установка Debian - Видео



Авторизация:

Новые статьи

Статьи в RSS

Новые комментарии

Новые уроки

Уроки в RSS


Ruby
Ruby-logo-R.svg
Класс языка:

мультипарадигмальный: динамический,
объектно-ориентированный,
рефлективный,
императивный,
функциональный

Тип исполнения:

интерпретируемый

Появился в:

1995

Автор(ы):

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

Расширение файлов:

.rb, .rbw

Релиз:

1.9.3-p125 (17 февраля 2012)

Типизация данных:

строгая, динамическая (утиная)

Основные реализации:

Ruby MRI (англ.), JRuby, IronRuby

Испытал влияние:

Perl, Smalltalk, Eiffel, Ada, Lisp, Python, Dylan, CLU (англ.), C++

Повлиял на:

Groovy, Amber, CoffeeScript, Perl 6

Лицензия

лицензия Ruby или GNU GPL v2

Сайт:

www.ruby-lang.org

Ruby (англ. ruby — рубин, произносится ['ɹu:bɪ] — руби) — динамический, рефлективный, интерпретируемый высокоуровневый язык программирования для быстрого и удобного объектно-ориентированного программирования. Язык обладает независимой от операционной системы реализацией многопоточности, строгой динамической типизацией, сборщиком мусора и многими другими возможностями. Ruby близок по особенностям синтаксиса к языкам Perl и Eiffel, по объектно-ориентированному подходу — к Smalltalk. Также некоторые черты языка взяты из Python, Lisp, Dylan и CLU (англ.).

Кроссплатформенная реализация интерпретатора языка является полностью свободной.

Содержание
История создания и развития

Создатель Ruby — Юкихиро Мацумото (Matz) — интересовался языками программирования, ещё будучи студентом, но идея о разработке нового языка появилась позже. Ruby начал разрабатываться 23 февраля 1993 года и вышел в свет в 1995 году.

Название навеяно языком Perl, многие особенности синтаксиса и семантики из которого заимствованы в Ruby: англ. pearl — «жемчужина», ruby — «рубин».

Целью разработки было создание «настоящего объектно-ориентированного», лёгкого в разработке, интерпретируемого языка программирования. Из письма автора:

Ruby родился 23 февраля 1993 года. В тот день я беседовал со своим коллегой о возможности существования объектно-ориентированного сценарного языка. Я знал Perl (Perl4, а не Perl5), но он мне не нравился — был в нём некий привкус игрушечного языка (да и поныне есть). А объектно-ориентированный интерпретируемый язык казался многообещающим. В то время я знал Python. Но он мне не нравился потому, что я не считал его настоящим объектно-ориентированным языком. Его OO свойства казались надстройкой над языком. Мне, как языковому маньяку и фанату объектно-ориентированного программирования с пятнадцатилетним стажем, очень, очень хотелось, чтобы был истинно объектно-ориентированный, простой в использовании язык. Я пытался найти такой язык, но его не было.

Тогда я решил его создать. Прошло несколько месяцев, прежде чем интерпретатор заработал. Я добавил в мой язык то, что мне хотелось — итераторы, обработку исключений, автоматическую сборку мусора. Затем я переорганизовал свойства Perl и реализовал их как библиотеку классов. В декабре 1995 года я опубликовал Ruby 0.95 в японских новостных группах. С тех пор появились сайты, списки рассылок. В списках рассылок идут жаркие обсуждения. Самый старый список сейчас содержит 14 789 писем.

В Японии Ruby стал популярным с момента появления первой общедоступной версии в 1995 году, однако наличие документации только на японском языке сдерживало его дальнейшее распространение. Лишь в 1997 году появилось описание Ruby на английском языке, а в 1998 году открылся форум «ruby-talk». Это положило начало росту известности языка в остальном мире. Издано несколько книг на различных языках, в том числе на русском. Сейчас Ruby входит в большинство дистрибутивов ОС Linux, доступен пользователям других операционных систем.

Хронология выхода версий

В списке ниже перечислены лишь наиболее крупные обновления.

Название версии Дата выхода Примечания
0.06 7 января 1994 Первая версия, указанная в Changelog’ах
1.0-961225 25 декабря 1996 Данная версия следовала сразу за версией 0.99.4-961224, выпущенной накануне. Номер после числа 1.0 — дата выпуска версии. Новые версии линейки 1.0 выходили ещё год (до 1.0-971225).
1.1 alpha0 13 августа 1997 Альфа-версии выходили вплоть до 7 октября 1997 (1.1 alpha9)
1.1b0 4 декабря 1997 Следующая версия после 1.1 alpha9. 27 февраля 1998 вышла версия 1.1b9, затем вплоть до середины 1998 выходили экспериментальные выпуски с обозначением вида 1.1b9_31 (версия 1.1b9_31 была выпущена, но в документации не отмечена).
1.1c0 17 июля 1998 Данная версия следовала за версией 1.1b9_31. Модификации этой версии выходили вплоть до 26 ноября 1998 (1.1c9).
1.1d0 (pre1.2) 16 декабря 1998 Данная версия следовала за версией 1.1c9. 22 декабря 1998 была выпущена экспериментальная версия 1.1d1, завершившая данную линейку.
1.2 (stable) 25 декабря 1998 В дальнейшем выходили модификации данной версии вплоть до версии 1.2.5, выпущенной 13 апреля 1999 года. 21 июня 1999 года была выпущена версия 1.2.6, объявленная как финальная версия 1.2 (1.2 final). 15 июля 1999 года вышла переупакованная (repacked) версия 1.2.6.
1.3 (development) 24 декабря 1998 Отдельная ветка модификаций, разрабатываемая независимо от линейки 1.2 (по аналогии с ядром ОС Linux). Первая версия была объявлена как версия для разработки (development version) и следовала за версией 1.1d1. В дальнейшем последовало множество промежуточных модификаций: ruby-1.3.1-990215 — ruby-1.3.4-990625, после чего от указания даты в номере отказались и выпустили 1.3.5 — 1.4 alpha (15 июля 1999), 1.3.6 — 1.4 alpha (28 июля 1999), 1.3.7 — 1.4 beta (6 августа 1999).
1.4.0 (stable) 13 августа 1999 Данная версия появилась через несколько дней после выхода 1.3.7 — 1.4 beta. В дальнейшем выходили новые модификации вплоть до версии 1.4.6, вышедшей 16 августа 2000 года.
1.5.0 (development) 20 ноября 1999 Данная линейка предназначалась исключительно для проверки различных нововведений при разработке. Модификации данной линейки доступны исключительно в репозитории проекта и, соответственно, сборки данной версии на официальный сервер не выкладывались.
1.6.0 (stable) 19 сентября 2000 В дальнейшем выпускались модификации этой версии вплоть до версии 1.6.8 (24 декабря 2002). 21 сентября 2005 года был выпущен патч для версии 1.6.8.
1.7.0 (development) 24 февраля 2001 Данная линейка предназначалась исключительно для проверки различных нововведений при разработке. Модификации данной линейки доступны исключительно в репозитории проекта и, соответственно, сборки данной версии на официальный сервер не выкладывались.
1.8.0 (stable) 4 августа 2003 В дальнейшем последовало большое число модификаций, которые выходят до сих пор (1 января 2011 года), например, промежуточная версия 1.8.7-p330 вышла 24 декабря 2010 года.
1.9.0 (development) 25 декабря 2007 Последняя ветка на данный момент (1 января 2012 года). Соответственно, модификации также выходят до сих пор.
Философия

Мацумото, фанат объектно-ориентированного программирования, мечтал о языке, более мощном, чем Perl, и более объектно-ориентированном, чем Python. Основное назначение Ruby — создание простых и в то же время понятных программ, где важна не скорость работы программы, а малое время разработки, понятность и простота синтаксиса.

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

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

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

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

Принципы программирования и дизайна языка иногда выделяются в термин «Путь Ruby» (англ. Ruby Way). Хэл Фултон выделяет такие принципы, как «просто, но не слишком просто», «принцип наименьшего удивления», вторичность скорости работы программы, динамичность, простые строгие правила, выполнение которых не доходит до педантизма, потребность создавать полезные и красивые программы как причина программирования. В целом они не имеют точной формулировки и иногда этот термин используется для критики .

Семантика

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

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

bash:
  1. a = "abcdefg"
  2. b = a
  3. b #=> "abcdefg"
  4. a[3] = 'R'
  5. b #=> "abcRefg"

то есть при изменении значения переменной a, неявно изменилось и значение b, так как они содержат ссылку на один объект. То есть механизм присваивания действует одинаково для всех объектов, в отличие от языков типа C, Object Pascal, где присваивание может означать как копирование значения, так и копирование ссылки на значение.

Ruby не поддерживает множественное наследование, но вместо него есть мощный механизм примесей. Все классы (напрямую или через другие классы) выведены из класса Object, следовательно, любой объект может использовать определённые в нём методы (например, class, to_s, nil?). Процедурный стиль также поддерживается, но все глобальные процедуры неявно являются закрытыми методами класса Object.

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

Возможности Ruby
  • Имеет лаконичный и простой синтаксис, частично разработанный под влиянием Ада, Eiffel и Python.
  • Позволяет обрабатывать исключения в стиле Java и Python.
  • Позволяет переопределять операторы, которые на самом деле являются методами.
  • Полностью объектно-ориентированный язык программирования. Все данные в Ruby являются объектами в понимании Smalltalk. Единственное исключение — управляющие конструкции, которые в Ruby в отличие от Smalltalk не являются объектами. Например, число «1» — это экземпляр класса Fixnum. Также поддерживается добавление методов в класс и даже в конкретный экземпляр во время выполнения программы.
  • Не поддерживает множественное наследование, но вместо него может использоваться концепция «примесей», основанная в данном языке на механизме модулей.
  • Содержит автоматический сборщик мусора. Он работает для всех объектов Ruby, в том числе для внешних библиотек.
  • Создавать расширения для Ruby на Си очень просто частично из-за сборщика мусора, частично из-за несложного и удобного API.
  • Поддерживает замыкания с полной привязкой к переменным.
  • Поддерживает блоки кода (код заключается в {} или doend). Блоки могут использоваться в методах или преобразовываться в замыкания.
  • Целые переменные в Ruby автоматически конвертируются между типами Fixnum (32-разрядные) и Bignum (больше 32 разрядов) в зависимости от их значения, что позволяет производить целочисленные математические расчёты со сколь угодно большой точностью.
  • Не требует предварительного объявления переменных, но для интерпретатора желательно, чтобы переменным присваивалось пустое значение nil (тогда интерпретатор знает, что идентификатор обозначает переменную, а не имя метода). Язык использует простые соглашения для обозначения области видимости. Пример: просто var — локальная переменная, @var — переменная экземпляра (член или поле объекта класса), @@var — переменная класса, $var — глобальная переменная.
  • В Ruby непосредственно в языке реализованы многие шаблоны проектирования, так, например, «одиночка» (singleton) может быть (хотя и не обязан) реализован добавлением необходимых методов к одному конкретному объекту (см. ниже).
  • Может динамически загружать расширения, если это позволяет операционная система.
  • Имеет независимую от ОС поддержку невытесняющей многопоточности.
  • Перенесён на множество платформ. Он разрабатывался на Linux, но работает на многих версиях Unix, DOS, Microsoft Windows (в частности, Win32), Mac OS, BeOS, OS/2 и т. д.
Примеры

В Ruby есть немало оригинальных решений, редко или вообще не встречающихся в распространённых языках программирования. Можно добавлять методы не только в любые классы, но и в любые объекты. Например, вы можете добавить к некоторой строке произвольный метод.

bash:
  1. # всё от символа # и до конца строки - комментарий
  2. # = является оператором присваивания,
  3. # символы в «"» - строка, которой можно манипулировать средствами языка
  4. str = "Привет" # здесь создаётся переменная str, типа String
  5. # def - ключевое слово для объявления функции
  6. def str.bye # str. указывает, кому принадлежит метод (по умолчанию Object)
  7. # bye - имя метода, за ним может следовать необязательный, заключённый в
  8. # круглые скобки список параметров функции
  9. "Пока!" # из метода возвращается последнее вычисленное значение (здесь - строка)
  10. end # ключевым словом end заканчиваются практически все инструкции Ruby
  11. # puts - метод,
  12. # str.bye - обращение к методу bye объекта str
  13. # значение, полученное из метода bye передаётся методу puts
  14. # который выводит на экран информацию
  15. puts str.bye #=> Пока!

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

Любая конструкция в Ruby возвращает значение. Например:

bash:
  1. # конструкция if вычисляет выражение после него, и, если оно истинно,
  2. # возвращает результат выражения между then и else, иначе между else и end
  3. puts( if 5 > 3 then "Одно" else "Другое" end ) #=> Одно
  4. # происходит присваивание значения переменной var, и операция присваивания
  5. # возвращает значение переменной var, которая выводится на экран
  6. puts( var = 5 ) #=> 5
Контейнеры

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

bash:
  1. # создаём массив
  2. a = [1, 'hi', 3.14, 1, 2, [4, 5] * 3]
  3. # => [1, "hi", 3.14, 1, 2, [4, 5, 4, 5, 4, 5]]
  4. # обращение по индексу
  5. a[2] # => 3.14
  6. # «разворачиваем» все внутренние массивы, удаляем одинаковые элементы
  7. a.flatten.uniq # => [1, 'hi', 3.14, 2, 4, 5]
  8. # пытаемся найти индекс элемента со значением 4
  9. a.index(4) # => nil
  10. # предыдущая попытка найти элемент неудачна - все предыдущие функции
  11. # возвращают копии, но Ruby почти для всех функций предоставляется
  12. # аналог с тем же названием, но заканчивающийся на «!»,
  13. # который модифицирует контейнер
  14. a.flatten! # => [1, "hi", 3.14, 1, 2, 4, 5, 4, 5, 4, 5]
  15. a.index(4) # => 5
Процедурные объекты и итераторы

В языке есть 2 эквивалентных способа записи блоков кода:

bash:
  1. { puts "Hello, World!" }
  2.  
  3. do puts "Hello, World!" end

Сопрограммы применяются с большинством встроенных методов:

bash:
  1. File.open('file.txt', 'w') {|file| # открытие файла «file.txt» для записи («w» - write)
  2. file.puts 'Wrote some text.'
  3. } # Конструкция устраняет неопределённость с закрытием файла: закрывается здесь при любом исходе

Следующий пример показывает использование сопрограмм и итераторов для работы с массивами, который показывает краткость записи на Ruby многих достаточно сложных действий (случайно выбираем из последовательности квадратов чисел от «0» до «10» и распечатываем вместе с индексами):

bash:
  1. # для работы требуется ruby 1.9
  2. (0..10).collect{|v| v ** 2 }.select{ rand(2).zero? }.map.with_index {|*v| v }
Классы, примеси, методы, перегрузка операторов

Следующий пример определяет класс с именем Person, предназначенный для хранения информации об имени и возрасте некоторой персоны.

bash:
  1. class Person # объявление класса начинается с ключевого слова class, за которым
  2. # следует имя
  3. include Comparable # подмешивается к классу
  4. # и добавляет методы <, <=, ==, >=, > и between?
  5. # с использованием нижеопределённого
  6. # в классе <=>
  7. #
  8. @@count_obj = 0 # переменная класса для подсчёта числа созданных объектов
  9. #
  10. # конструктор для создания объектов с помощью new
  11. def initialize(name, age) # name, age - параметры метода
  12. # название переменных объекта начинается с @
  13. @name, @age = name, age # создаём объекты и увеличиваем счётчик на 1
  14. @@count_obj += 1
  15. end
  16.  
  17. def <=>(person) # переопределение оператора <=>
  18. # (это даёт возможность использовать метод sort)
  19. @age <=> person.age # из метода возвращается последнее вычисленное выражение,
  20. end
  21.  
  22. def to_s # для форматированного вывода информации puts
  23. "#{@name} (#{@age})" # конструкция #{x} в 2-х кавычках замещается в Ruby значением x
  24. end
  25.  
  26. def inspect # похож на to_s, но используется для диагностического вывода
  27. "<#{@@count_obj}:#{to_s}>"
  28. end
  29. # пример метапрограммирования: добавляет методы для доступа к
  30. # переменным объекта
  31. attr_reader :name, :age
  32. end
  33. # создаём массив объектов
  34. group = [ Person.new("John", 20),
  35. Person.new("Markus", 63),
  36. Person.new("Ash", 16) ]
  37. # => [<3:John (20)>, <3:Markus (63)>, <3:Ash (16)>]
  38. # здесь при работе с irb автоматически вызывается метод inspect
  39. # вызываем методы массива сортировка и разворачивание его в обратном порядке
  40. puts group.sort.reverse # Печатает:
  41. # Markus (63)
  42. # John (20)
  43. # Ash (16)
  44. # обращаемся к функции, которая была добавлена
  45. # автоматически(используя <=>) при включении Comparable
  46. group[0].between?(group[2], group[1]) # => true
Исключения

Исключения возбуждаются с помощью конструкции raise (или fail), опционально могут быть добавлены текст с сообщением, тип исключения и информация о стеке вызовов:

bash:
  1. raise ArgumentError, "Неверный аргумент", caller # caller - метод, возвращающий текущий стек выполнения

Обрабатываются исключения с использованием конструкции rescue. Опционально можно указать тип обрабатываемого исключения (по умолчанию обрабатываются все) и получение информации. Также можно добавлять блоки else (выполняется если исключения отсутствовали) и ensure (выполняется в любом случае).

bash:
  1. begin
  2. # ...
  3. rescue RuntimeError => e
  4. # обрабатываем конкретный тип ошибок
  5. puts e # напечатаем сообщение об ошибке
  6. rescue
  7. # можно писать rescue => e чтобы получить объект исключения
  8. # обрабатываем все исключения
  9. else
  10. # сработает, если исключений не было
  11. ensure
  12. # сработает в любом случае
  13. end
Реализация

Для Ruby существуют несколько реализаций: официальный интерпретатор, написанный на Си, JRuby — реализация для Java, интерпретатор для платформы .NET IronRuby, Rubinius — написанная в основном на Ruby и базирующаяся на идеях Smalltalk-80 VM, MagLev — другая базирующаяся на Smalltalk разработка от компании Gemstone, Blue Ruby — реализация Ruby для виртуальной машины ABAP, MacRuby — реализация для Mac OS с фокусом на максимальную интеграцию с возможностями операционной системы.

Официальный интерпретатор портирован под большинство платформ, включая Unix, Microsoft Windows (в том числе Windows CE), DOS, Mac OS X, OS/2, Amiga, BeOS, Syllable, Acorn RISC OS и другие.

Для Windows существует RubyInstaller for Windows и есть возможность запуска под Cygwin для большей совместимости с Unix

Интерактивный Ruby

С официальной версией интерпретатора Ruby поставляется командная оболочка Ruby (Interactive Ruby Shell). Запускаемая командой irb в окне терминала (интерфейсе командной строки), она позволяет тестировать код программы очень быстро (построчно):

 $ irb
 irb(main):001:0> "Hello, World"
 => "Hello, World"
 irb(main):002:0> 2 ** 256             # ** - оператор возведения в степень
 => 115792089237316195423570985008687907853269984665640564039457584007913129639936

Программа irb выводит результат каждой строки после символов =>. В приведённых выше примерах для наглядности применяется аннотирование — результаты строк программы записываются в комментариях после =>. Имитацию irb можно запустить непосредственно в браузере.

В поставке дистрибутива One-Click Installer для Windows, начиная с версии 1.8.2-15, поставляется утилита fxri, которая включает в себя справочную систему (ri) и интерактивный интерпретатор (irb).

Поддержка IDE

Базовые возможности редактирования добавляются к многим редакторам (Emacs, vim, jEdit, nano, SciTE и др.), здесь перечислены только IDE, то есть предоставляющие обширный набор функций.

Название Лицензия Платформы Ссылка
ActiveState Komodo IDE Проприетарная Linux, Mac OS X, Solaris, Windows http://activestate.com/Products/komodo_ide/
Arachno Ruby IDE Проприетарная Win 2000/XP, Linux http://www.ruby-ide.com
Aptana (RadRails + RDT) GPL, APL + CPL Java http://www.aptana.com/
EasyEclipse for Ruby and Rails Win 2000/XP, Linux, Mac OS X http://www.easyeclipse.org/site/distributions/ruby-rails.html
Eclipse + RDT EPL + CPL Java RDT Homepage
Embarcadero TurboRuby Проприетарная Windows, OS X, Linux http://www.embarcadero.com/products/turboruby
FreeRIDE Ruby License Windows, OS X, POSIX http://rubyforge.org/projects/freeride/
IntelliJ IDEA + Ruby plugin Проприетарная (на IDEA), Apache 2.0 (на сам plugin) Java, JRuby Ruby plugin
KDevelop GNU GPL Linux http://kdevelop.org/
Komodo IDE 6 Проприетарная Windows, Mac, Linux http://www.activestate.com/komodo-ide
Mondrian Ruby IDE MIT Ruby (+ FOX toolkit) http://www.mondrian-ide.com/
NetBeans IDE (версия 6.9.1 и более ранние) CDDL Java http://www.netbeans.org/features/ruby/
RDE Ruby License Windows http://homepage2.nifty.com/sakazuki/rde_en/
Ruby in steel Проприетарная Visual Studio 2005 http://www.sapphiresteel.com/
RubyMine Проприетарная (на базе IDEA) Java http://www.jetbrains.com/ruby
Visual Studio (реализация IronRuby) Проприетарная Windows http://www.microsoft.com/visualstudio/en-us/products
Xcode 3.1 Проприетарная Mac OS X 10.5 http://developer.apple.com/tools/xcode/
Библиотеки Стандартная библиотека

Кроме мощных возможностей, встроенных в язык, Ruby поставляется с большой стандартной библиотекой. Это, прежде всего, библиотеки для работы с различными сетевыми протоколами на стороне сервера и клиента, средства для работы с различными форматами представления данных (XML, XSLT, YAML, PDF, RSS, CSV, WSDL). Кроме встроенных в язык средств отладки, с Ruby поставляются библиотеки для юнит-тестирования, профилирования. Также есть библиотеки для работы с архивами, датами, кодировками, матрицами, средства для системного администрирования, распределённых вычислений, поддержки многопоточности и т. д.

Расширения

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

Для унифицированного доступа к базам данных разработана библиотека Ruby DBI (поддерживает SQLite, Oracle, ODBC, MySQL, DB2, MS SQL, InterBase, ADO и др.). Также существуют библиотеки для конкретных баз данных, поддерживающих специфические для них операции. Для реализации ORM существуют несколько библиотек, такие как ActiveRecord, DataMapper или Sequel.

Из графических библиотек следует отметить FxRuby — интерфейс к графической библиотеке FOX, графический пакет разработчика wxRuby (интерфейс к кроссплатформенному пакету wxWidgets на C++), QtRuby/Korundum — привязка к Qt и KDE соответственно, графические библиотеки для работы с Tk и Gtk. Также реализована библиотека для работы с OpenGL, позволяющая программировать трёхмерную графику.

Win32utils — позволяет обращаться к специфическим возможностям Win32 API.

Rmagick — библиотека для работы с изображениями, поддерживающая более 90 форматов (основана на ImageMagick и GraphicsMagick).

Библиотека Ruport (Ruby reports) предназначена для лёгкой реализации отчётов и создания диаграмм на основе данных из БД или прямо из текстовых файлов CSV. Причём результаты можно сохранять в форматах PDF, HTML, CSV и TXT.

RuTils — обработчик русского текста на Ruby. Позволяет реализовать сумму прописью и выбор числительного. Например, 231.propisju(2) => «двести тридцать одна» или 341.propisju_items(1, «чемодан», «чемодана», «чемоданов») => «триста сорок один чемодан». А также перевод в транслит и работу с датами.

Для управления библиотеками и программами Ruby в виде самодостаточных пакетов предназначена система управления пакетами RubyGems (англ. gems, gem — драгоценный камень).

Существует всемирный репозиторий программного обеспечения Ruby RAA (Ruby Application Archive) [1]. Репозиторий по состоянию на сентябрь 2007 года насчитывает более полутора тысяч проектов. Большое количество программного обеспечения, написанного на Ruby, пользуются хостингом проекта RubyForge[2], созданного специально с этой целью.

FreeRIDE — IDE для Ruby, реализованная с использованием библиотеки FxRuby.

Большинство расширений распространяются под свободными лицензиями (LGPL, лицензия Ruby) и могут быть использованы в любом проекте практически без ограничений.

Документация

Система RDoc предназначена для автоматического извлечения документации из исходных кодов и программ на Ruby и её дальнейшей обработки. Является стандартом де-факто для подготовки документации по программному обеспечению, написанному на Ruby.

Для доступа к документации Ruby из командной строки Unix разработана программа ri. С её помощью можно получить информацию о модулях, классах и методах Ruby. Онлайн-документация доступна на сайте http://www.ruby-doc.org.

Использование

Ruby используется в NASA, NOAA (национальная администрация по океану и атмосфере), Motorola и других крупных организациях. Следующие программы используют Ruby как скриптовый язык для расширения возможностей программы или написаны на нём (частично или полностью).

  • RPG Maker (RPG Maker XP) — RGSS (Ruby Game Scripting System)
  • Amarok — [3]
  • SketchUp — [4]
  • Inkscape — скрипты для обработки векторных изображений
  • Metasploit
  • XChat
  • Для KOffice разрабатывается Kross[5], механизм для поддержки скриптов, который включает Ruby [6].
  • WATIR[7] (англ. Web Application Testing in Ruby) — свободное средство для автоматического тестирования веб-приложений в браузере.
Метапрограммирование на Ruby Argument Array

Преобразование списка аргументов метода в массив

bash:
  1. def my_method(*args)
  2. args.map {|arg| arg.reverse }
  3. end
  4.  
  5. my_method('abc' , 'xyz' , '123' ) # => ["cba", "zyx", "321"]
Around Alias

Использование псевдоимен (aliases). Вызов старой версии метода из переопределенного метода.

bash:
  1. class String
  2. alias :old_reverse :reverse
  3.  
  4. def reverse
  5. "x#{old_reverse}x"
  6. end
  7. end
  8.  
  9. "abc".reverse # => "xcbax"
Blank Slate

Удаление метода из объекта, чтобы сделать его Ghost Method

bash:
  1. class C
  2. def method_missing(name, *args)
  3. "a Ghost Method"
  4. end
  5. end
  6.  
  7. obj = C.new
  8. obj.to_s # => "#<C:0x357258>"
  9.  
  10. class C
  11. instance_methods.each do |m|
  12. undef_method m unless m.to_s =~ /method_missing|respond_to?|^__/
  13. end
  14. end
  15.  
  16. obj.to_s # => "a Ghost Method"
Class Extension

Определение новых методов класса добавлением методов (mixins) из другого модуля. В качестве холдера новых методов используется eigenclass целевого класса. Особый случай Object Extention.

bash:
  1. class C; end
  2. module M
  3. def my_method
  4. 'a class method'
  5. end
  6. end
  7.  
  8. class << C
  9. include M
  10. end
  11.  
  12. C.my_method # => "a class method"
Class Extension Mixin

Использование Hook методов для расширения класса.

bash:
  1. module M
  2. def self.included(base)
  3. base.extend(ClassMethods)
  4. end
  5.  
  6. module ClassMethods
  7. def my_method
  8. 'a class method'
  9. end
  10. end
  11. end
  12.  
  13. class C
  14. include M
  15. end
  16.  
  17. C.my_method # => "a class method"
Class Instance Variable

Сохранение состояния класса в экземплярных переменных объекта Class.

bash:
  1. class C
  2. @my_class_instance_variable = "some value"
  3.  
  4. def self.class_attribute
  5. @my_class_instance_variable
  6. end
  7. end
  8.  
  9. C.class_attribute # => "some value"
Class Macro

Вызов методов класса в определении класса.

bash:
  1. class C
  2. end
  3.  
  4. class << C
  5. def my_macro(arg)
  6. "my_macro(#{arg}) called"
  7. end
  8. end
  9.  
  10. class C
  11. my_macro :x # => "my_macro(x) called"
  12. end
Clean Room

Использование специального объекта, для безопасного выполнения внешнего блока кода. Используется для создания DSL.

bash:
  1. class CleanRoom
  2. def a_useful_method(x)
  3. x * 2
  4. end
  5. end
  6.  
  7. CleanRoom.new.instance_eval { a_useful_method(3) } # => 6
Code Processor

Выполнение строки кода из внешнего источника.

bash:
  1. File.readlines("a_file_containing_lines_of_ruby.txt" ).each do |line|
  2. puts "#{line.chomp} ==> #{eval(line)}"
  3. end
  4.  
  5. # >> 1 + 1 ==> 2
  6. # >> 3 * 2 ==> 6
  7. # >> Math.log10(100) ==> 2.0
Context Probe

Выполнение блока кода с доступом к внутреннему состоянию объекта.

bash:
  1. class C
  2. def initialize
  3. @x = "приватная переменная экземпляра"
  4. end
  5. end
  6.  
  7. obj = C.new
  8. obj.instance_eval { @x } # => “приватная переменная экземпляра”
Deferred Evaluation

Сохранение блока кода вместе с контекстом в proc или lambda для выполнения в будущем.

bash:
  1. class C
  2. def store(&block)
  3. @my_code_capsule = block
  4. end
  5.  
  6. def execute
  7. @my_code_capsule.call
  8. end
  9. end
  10.  
  11. obj = C.new
  12. obj.store { $X = 1 }
  13. $X = 0
  14. obj.execute
  15. $X # => 1
Dynamic Dispatch

Принятия решения, о том какой именно метод будет вызван в рантайме.

bash:
  1. method_to_call = :reverse
  2. obj = "abc"
  3. obj.send(method_to_call) # => "cba"
Dynamic Method

Определение нового метода на этапе исполнения.

bash:
  1. class C
  2. end
  3.  
  4. C.class_eval do
  5. define_method :my_method do
  6. "a dynamic method"
  7. end
  8. end
  9.  
  10. obj = C.new
  11. obj.my_method # => "a dynamic method"
Dynamic Proxy

Добавление дополнительного функционала (cross-cutting concerns) в методы класса.

bash:
  1. class MyDynamicProxy
  2. def initialize(target)
  3. @target = target
  4. end
  5.  
  6. def method_missing(name, *args, &block)
  7. "result: #{@target.send(name, *args, &block)}"
  8. end
  9. end
  10.  
  11. obj = MyDynamicProxy.new("a string" )
  12. obj.reverse # => "result: gnirts a"
Flat Scope

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

bash:
  1. class C
  2. def an_attribute
  3. @attr
  4. end
  5. end
  6.  
  7. obj = C.new
  8. a_variable = 100
  9.  
  10. # flat scope:
  11. obj.instance_eval do
  12. @attr = a_variable
  13. end
  14. obj.an_attribute # => 100
Ghost Method

Возврат результата для метода, который не найден в определении класса.

bash:
  1. class C
  2. def method_missing(name, *args)
  3. name.to_s.reverse
  4. end
  5. end
  6.  
  7. obj = C.new
  8. obj.my_ghost_method # => "dohtem_tsohg_ym"
Hook Method

Перехват событий объектной модели ruby, например, расширение класса, добавление метода, и т. д.

bash:
  1. $INHERITORS = []
  2. class C
  3. def self.inherited(subclass)
  4. $INHERITORS << subclass
  5. end
  6. end
  7.  
  8. class D < C
  9. end
  10.  
  11. class E < C
  12. end
  13.  
  14. class F < E
  15. end
  16.  
  17. $INHERITORS # => [D, E, F]
Kernel Method

Определение метода в модуле Kernel делает его доступным везде.

bash:
  1. module Kernel
  2. def a_method
  3. "a kernel method"
  4. end
  5. end
  6.  
  7. a_method # => "a kernel method"
Lazy Instance Variable

Ленивая инициализация переменной.

bash:
  1. class C
  2. def attribute
  3. @attribute = @attribute || "some value"
  4. # или
  5. # @attribute ||= "some value"
  6. end
  7. end
  8.  
  9. obj = C.new
  10. obj.attribute # => "some value"
Mimic Method

Метод как другая конструкция языка, например, метод как класс.

bash:
  1. def BaseClass(name)
  2. name == "string" ? String : Object
  3. end
  4.  
  5. class C << BaseClass "string" # метод, который выглядит, как класс
  6. attr_accessor :an_attribute # метод, который выглядит, как keyword
  7. end
  8.  
  9. obj = C.new
  10. obj.an_attribute = 1 # метод, который выглядит, как атрибут
Monkeypatch

Изменение функционала существующего класса.

bash:
  1. "abc".reverse # => "cba"
  2.  
  3. class String
  4. def reverse
  5. "override"
  6. end
  7. end
  8.  
  9. "abc".reverse # => "override"
Named Arguments

Упаковка аргументов метода в хэш массив.

bash:
  1. def my_method(args)
  2. args[:arg2]
  3. end
  4.  
  5. my_method(:arg1 => "A" , :arg2 => "B" , :arg3 => "C" ) # => "B"
Nil Guard

Замена nil на альтернативный объект (без проверки на nil)

bash:
  1. x = nil
  2. y = x || "a value" # => "a value"
Object Extension

Определение сингелтон-методов в конкретном объекте, путем подмешивания (mixing) методов из другого модуля.

bash:
  1. obj = Object.new
  2. module M
  3. def my_method
  4. 'a singleton method'
  5. end
  6. end
  7.  
  8. class << obj
  9. include M
  10. end
  11.  
  12. obj.my_method # => "a singleton method"
Open Class

Добавление новых методов в существующий класс.

bash:
  1. class String
  2. def my_string_method
  3. "my method"
  4. end
  5. end
  6.  
  7. "abc".my_string_method # => "my method"
Pattern Dispatch

Выбор метода, для вызова, основываясь на его имени.

bash:
  1. $x = 0
  2.  
  3. class C
  4. def my_first_method
  5. $x += 1
  6. end
  7.  
  8. def my_second_method
  9. $x += 2
  10. end
  11. end
  12.  
  13. obj = C.new
  14. obj.methods.each do |m|
  15. obj.send(m) if m.to_s =~ /^my_/
  16. end
  17.  
  18. $x # => 3
Sandbox

Выполнение небезопасного кода в безопасном окружении.

bash:
  1. def sandbox(&code)
  2. proc {
  3. $SAFE = 2
  4. yield
  5. }.call
  6. end
  7. begin
  8. sandbox { File.delete 'a_file' }
  9. rescue Exception => ex
  10. ex # => #<SecurityError: Insecure operation `delete' at level 2>
  11. end
Scope Gate

Изолирование переменных областью видимости. В ruby нет вложенных областей видимости!

bash:
  1. a = 1
  2. defined? a # => "local-variable"
  3.  
  4. module MyModule
  5. b = 1
  6. defined? a # => nil
  7. defined? b # => "local-variable"
  8. end
  9.  
  10. defined? a # => "local-variable"
  11. defined? b # => nil
Singleton Method

Определение cинглотон-метода в конкретном объекте.

bash:
  1. obj = "abc"
  2.  
  3. class << obj
  4. def my_singleton_method
  5. "x"
  6. end
  7. end
  8.  
  9. obj.my_singleton_method # => "x"

или

bash:
  1. obj = "abc"
  2.  
  3. def obj.my_singleton_method
  4. "x"
  5. end
  6.  
  7. obj.my_singleton_method # => "x"
Symbol To Proc

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

bash:
  1. [1, 2, 3, 4].map(&:even?) # => [false, true, false, true]


Яндекс.Метрика
4Debian.Info
При полной или частичной перепечатке текстов статей и публикаций гиперссылка на www.4debian.info обязательна. | "4Debian.Info" | © 2018