Ruby programming language

History

Philosophy

Ruby has also 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

Licensing terms

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
• 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 (for examples see: http://www.rubygarden.org/ruby?Continuations and http://www.rubygarden.org/ruby?RubyFromPython respectively)

Possible surprises

Although Ruby's design has been guided by the principle of least surprise, naturally there are features differing from languages such as C or Perl:

• Local variable names may not begin with a capital letter, otherwise they are treated as constants.
• 0, "" and [] are true: In C, the expression 0 ? 1 : 0 is evaluated as 0. In Ruby, however, it yields 1. Reasoning: In Ruby, many expressions (e.g., regular expression tests) return either a numeric value, string or array, or "nil". When such a return value is evaluated in a boolean context, only "nil" is evaluated as "false": every numeric (string or array) value, including zero (0, empty string, "", or array, []) is considered "true". Coincidently, as in Java, C- and Perl-style automatic conversion from numerics, strings and arrays to boolean "false" does not work.
• To indicate floating point numbers, it is insufficient to append a dot (99.). Because numbers are susceptible to method syntax, one must follow with a zero digit (99.0) or an explicit conversion (99.to_f).
• There is no 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).

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 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

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!"

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

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: