Ruby programming language
|
|
Ruby is an object-oriented programming language. It combines syntax inspired by Ada and Perl with Smalltalk-like object-oriented features, and also shares some features with Python, Lisp and CLU. Ruby is a single-pass interpreted language.
| Contents |
History
The language was created by Yukihiro "Matz" Matsumoto, who started working on Ruby on February 24, 1993 and released it to the public in 1995.
"Ruby" was named after a colleague's birthstone. Appropriately, the name reflects the language's Perl heritage. Pearl is the birthstone of June while the ruby is the birthstone of July (implying progression).
Ruby is said to follow the principle of least surprise, meaning that the language should be free from the traps and inconsistencies that plague other languages. Some people criticize Ruby when it does surprise them. Matz has responded that any design decision will surprise somebody, and the idea is for Ruby to have a consistent style and philosophy that remains the same throughout the language and its libraries.
As of June 2005, the latest stable version is 1.8.2. Ruby 1.8.3 is in beta, and 1.9 (with some major changes) is also in development.
Philosophy
Ruby is object-oriented: every bit of data is an object, including types other languages designate primitive such as integers. Every function is a method. Named values (variables) designate references to objects, not the objects themselves. Ruby supports inheritance with dynamic dispatch, mixins and singleton methods (belonging to a class rather than an instance). Though Ruby does not support multiple inheritance, classes can import modules as mixins. Procedural syntax is included, but everything done in Ruby procedurally (that is, outside of the scope of a particular object) is actually done to the Object class. Since this class is parent to every other class, the changes become visible to all classes and objects.
Ruby has been described as a multi-paradigm programming language: it allows you to program procedurally (defining functions/variables outside classes makes them part of the root, 'self' Object), with object orientation (everything is an object) or functionally (it has anonymous functions, closures, and continuations; statements all have values, and functions return the last evaluation). It has rich support for introspection, reflection and meta-programming.
According to the Ruby FAQ, "If you like Perl, you will like Ruby and be right at home with its syntax. If you like Smalltalk, you will like Ruby and be right at home with its semantics. If you like Python, you may or may not be put off by the huge difference in design philosophy between Python and Ruby/Perl."
Implementations
Ruby has three main implementations: the official Ruby interpreter, which is the most widely used, JRuby, a Java-based implementation, and RPG Maker XP, a Windows XP program used to create Role-Playing Games. The Ruby interpreter has been ported to many platforms, including Unix, Microsoft Windows, DOS, Mac OS X, OS/2, Amiga and many more. The Ruby distribution also includes "IRB", an interactive command-line interpreter which can be used to test code quickly.
Licensing terms
Ruby is distributed disjointedly under the free and open source licenses GPL and Ruby License [1] (http://www.ruby-lang.org/en/LICENSE.txt).
Features
- object-oriented
- exception handling
- iterators and closures (based on passing blocks of code)
- native, Perl-like regular expressions at the language level
- operator overloading
- automatic garbage collecting
- highly portable
- multi-threading on all platforms
- DLL/Shared Library dynamic loading on most platforms.
- introspection, reflection and meta-programming
- large standard library
- supports dependency injection
- continuations and generators (examples in RubyGarden: continuations (http://www.rubygarden.org/ruby?Continuations) and generators (http://www.rubygarden.org/ruby?RubyFromPython)
Ruby currently lacks support for Unicode, though it has partial support for UTF-8.
Possible surprises
Although Ruby's design is guided by the principle of least surprise, naturally, some features differ from languages such as C or Perl:
- Names that begin with a capital letter are treated as constants, so local variables should begin with a lowercase letter.
- Boolean evaluation of non-boolean data is strict: 0,
""and[]are all evaluated to true: In C, the expression0 ? 1 : 0evaluates to 0. In Ruby, however, it yields 1, because even the number 0 is considered a "something"; onlynilandfalseevaluate to false. A corollary to this rule is that by convention, Ruby methods -- for example, regular expression searches -- return numbers, strings, lists etc. on success, butnilon failure (eg., mismatch) or some other expression of the negative. - To denote floating point numbers, one must follow with a zero digit (
99.0) or an explicit conversion (99.to_f). It is insufficient to append a dot (99.) because numbers are susceptible to method syntax. - Lack of a character ("char") data type. This may cause surprises when slicing strings:
"abc"[0]yields 97 (an integer, representing the ASCII code of the first character in the string); use"abc"[0,1]to obtain"a"(a substring of length 1).
A good list of "gotchas" may be found in Hal Fulton's book The Ruby Way, pages 48–64. However, since the list in the book pertains to an older version of Ruby (version 1.6), some items been fixed since the book's publication. For example, retry now works with while, until and for, as well as iterators.
Examples
Some basic Ruby code:
# Everything, including literals, is an object, so this works:
-199.abs # 199
"ruby is cool".length # 12
"Rick".index("c") # 2
"Nice Day Isn't It?".split(//).uniq.sort.join # " '?DINaceinsty"
Collections
Constructing and using an array:
a = [1, 'hi', 3.14, 1, 2, [4, 5]] a[2] # 3.14 a.reverse # [[4, 5], 2, 1, 3.14, "hi", 1] a.flatten.uniq # [1, "hi", 3.14, 2, 4, 5]
Constructing and using a hash:
hash = {'water' => 'wet', 'fire' => 'hot'}
puts hash['fire']
hash.each_pair do |key, value|
puts "#{key} is #{value}"
end
# Prints: water is wet
# fire is hot
hash.delete_if {|key, value| key == 'water'} # Deletes 'water' => 'wet'
Blocks and iterators
The two syntaxes for creating a code block:
{ puts "Hello, World!" }
do puts "Hello, World!" end
Passing a block as a parameter (to be a closure):
def remember(&p)
@block = p
end
# Invoke the method, giving it a block that takes a name.
remember {|name| puts "Hello, " + name + "!"}
# When the time is right -- call the closure!
@block.call("Johnny")
# Prints "Hello, Johnny!"
Yielding program flow to a block provided at the location of the call
def bfs(e)
q = []
e.mark
yield e
q.push e
while not q.empty?
u = q.shift
u.edge_iterator do |v|
if not v.marked?
v.mark
yield v
q.push v
end
end
end
bfs(e) {|v| puts v}
Iterating over enumerations and arrays using blocks:
a = [1, 'hi', 3.14]
a.each {|item| puts item} # Prints each element
(3..6).each {|num| puts num} # Prints the numbers 3 through 6
Blocks work with many built-in methods:
IO.readlines('file.txt') do |line|
# Process each line, here.
end
Using an enumeration and a block to square 1 to 10:
(1..10).collect {|x| x*x} => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Classes
The following code defines a class named Person. In addition to 'initialize', the usual constructor to create new objects, it has two methods: one to override the <=> comparison operator (so Array#sort can sort by age) and the other to override the to_s method (so Kernel#puts can format its output). Here, "attr_reader" is an example of meta-programming in Ruby: "attr" defines getter and setter methods of instance variables; "attr_reader": only getter methods. Also, the last evaluated statement in a method is its return value, allowing the omission of an explicit 'return'.
class Person
def initialize(name, age)
@name, @age = name, age
end
def <=>(person)
@age <=> person.age
end
def to_s
"#{@name} (#{@age})"
end
attr_reader :name, :age
end
group = [ Person.new("John", 20),
Person.new("Markus", 63),
Person.new("Ash", 16)
]
puts group.sort.reverse
The above prints three names in reverse age order:
Markus (63) John (20) Ash (16)
More sample Ruby code is available as algorithms in the following articles:
Operating systems
Ruby is available for the following operating systems:
- Most flavours of Unix
- DOS
- Microsoft Windows 95/98/XP/NT/2000/2003
- Mac OS X
- BeOS
- Amiga
- Acorn RISC OS
- OS/2
- Syllable
Other ports may also exist.
See also
- Duck typing
- Ruby on Rails (a Ruby web application framework)
External links
- Ruby language home page (http://www.ruby-lang.org/en/)
- Ruby Garden (http://www.rubygarden.org/)
- Programming Ruby (http://www.rubycentral.com/book/)—Full text of first edition of the book by David Thomas & Andrew Hunt, ISBN 0-201-71089-7
- Why's Poignant Guide to Ruby (http://poignantguide.net/ruby/)
- About the name 'Ruby' (http://www.ruby-talk.org/cgi-bin/scat.rb/ruby/ruby-talk/394)
- Ruby FAQ (http://www.rubygarden.org/faq/)
- Quick Reference (http://www.zenspider.com/Languages/Ruby/QuickRef.html)
- Ruby Application Archive (http://raa.ruby-lang.org/) (RAA)
- JRuby (http://jruby.sourceforge.net/)
- The Ruby Documentation project (http://ruby-doc.org/)
- Ruby Forum (http://www.ruby-forum.org/bb/)
- RubyForge (http://rubyforge.org/)
- RedHanded (http://redhanded.hobix.com/)—Daily Ruby news and more
- Ruby on Rails (http://www.rubyonrails.org/)— an open-source web framework for Ruby
- Ruby Newcomers Advice (http://www.glue.umd.edu/~billtj/ruby.html)ca:Ruby
da:Ruby (programmeringssprog) de:Ruby es:Lenguaje de programación Ruby eo:Ruby (komputillingvo) fr:Ruby it:Ruby he:Ruby lt:Ruby nl:Programmeertaal Ruby ja:Ruby pl:Ruby (język programowania) ru:Руби fi:Ruby sv:Ruby zh:Ruby