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 = 'hi', 3.14, 1, 2, ^* a^* # 3.14 a.reverse # 5, 2, 1, 3.14, 'hi', 1" target="_blank" >^* a.flatten.uniq # 'hi', 3.14, 2, 4, 5

Constructing and using a hash: hash = {:water => 'wet', :fire => 'hot'} puts hash^* # Prints: hot 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("John") # Prints "Hello, John!"

Returning closures from a method: def foo(initial_value=0) var = initial_value return Proc.new {|x| var = x}, Proc.new { var } end setter, getter = foo setter.call(21) getter.call # => 21

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 end bfs(e) {|v| puts v}

Iterating over enumerations and arrays using blocks: a = 'hi', 3.14 a.each {|item| puts item} # Prints each element (3..6).each {|num| puts num} # Prints the numbers 3 through 6 ^*.inject(0) {|sum, element| sum+element} # 9, (you can pass both a parameter and a block)

Blocks work with many built-in methods: File.open('file.txt', 'w+b') do |file| file.puts 'Wrote some text.' end # File automatically closed here

Or: File.readlines('file.txt').each do |line| # Process each line, here. end

Using an enumeration and a block to square 1 to 10: (1..10).collect {|x| x*x} => 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)

Exceptions

An exception is raised with a raise call: raise

An optional message can be added to the exception: raise "This is a message"

You can also specify which type of exception you want to raise: raise ArgumentError, "Illegal arguments!"

Exceptions are handled by the rescue clause. Such a clause can catch exceptions that inherit from StandardError: begin # Do something rescue # Handle exception end Note that it is a common mistake to attempt to catch all exceptions with a simple rescue clause. To catch all exceptions one must write: begin # Do something rescue Exception # Handle exception end Or particular exceptions: begin # ... rescue RuntimeError # handling end Finally, it is possible to specify that the exception object be made available to the handler clause: begin # ... rescue RuntimeError => e # handling, possibly involving e end Alternatively, the most recent exception is stored in the magic global $!.

More examples

More sample Ruby code is available as algorithms in the following articles:

• Exponentiating by squaring
• Associative_array#Ruby

Implementations

Operating systems

Ruby is available for the following operating systems:

• Most flavors of Unix, including Linux
• 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.

Licensing terms

Applications

See also

• Duck typing
• RubyGems (a Ruby package manager)
• Ruby on Rails (a Ruby web application framework)
• Ruby Application Archive
• Interactive Ruby Shell
• Comparison of programming languages

Notes