A Ruby program can consist of one or more commands:

print('What is your name? ' )
myname = gets()
puts( "Welcome to Ruby, #{myname}" )

Unlike other programming languages, Ruby programs don't need to define a main program, don't enclose blocks of commands with curly brackets, and don't end statements with a semicolon. Type a command, and Ruby obeys without its syntax interfering with your thinking.

The preceding Ruby program simply asks the user to type in a name. Whatever name the user types gets stored in the myname variable. Then the last line prints the string "Welcome to Ruby," followed by the contents of the myname variable.

To write a comment in Ruby, use the # symbol. Anything that appears to the right of the # symbol is considered a comment, which the computer ignores.

# This is a comment
print('What is your name? ' )
myname = gets() # This is also a comment
puts( "Welcome to Ruby, #{myname}" )

If you want to write a comment over multiple lines, define the start and end of a comment block with =begin and =end, such as

=begin This is a block of comments
       that make it easy to comment
       out multiple lines. However,
       Ruby's block commenting is kind
       of ugly so it's rarely used.
=end
print('What is your name? ' )
myname = gets()
puts( "Welcome to Ruby, #{myname}" )

Defining comments with the =begin and =end lines is often cumbersome, so it's more common for programmers to use multiple # symbols in front of each line instead like this:

# This program was written by John Doe
# on January 24, 2009. It took him a

# long time to write so maybe he deserves
# a big fat raise or at least some extra
# sick days so he can look for a better job.
print('What is your name? ' )
myname = gets()
puts( "Welcome to Ruby, #{myname}" )

Ruby uses symbols to identify different types of variables:

In Ruby, constants are identified with an initial uppercase letter like Pi or Taxrate. To avoid confusing constants with local variables, it's best to use all uppercase letters to name constants like PI or TAXRATE.

To store data into a variable, define the variable name and set it equal to a value:

variableName = value

The name of your variables can be anything, but Ruby is a case-sensitive language so myAge is considered a completely different variable than myage.

The three types of operators used in Ruby are mathematical, relational, and logical operators. Mathematical operators calculate numeric results such as adding, multiplying, or dividing numbers, as shown in Table 5-1.

Relational operators compare two values and return a True or a False value. The seven comparison operators available are shown in Table 5-2.

Logical operators compare two Boolean values (True or False) and return a single True or False value, as shown in Table 5-3.

Most programming languages use the equal sign to assign values to variables, such as

i = 59

However, Ruby also includes combination assignment and mathematical operators, as shown in Table 5-4.

++i;

The equivalent increment operator in Ruby might look like this:

i += 1

The simplest branching statement is an IF statement that runs only one or more commands if a Boolean condition is True, such as

if condition
  Command
end

if condition then Command end

Ruby also includes a negated form of the IF statement called the UNLESS statement that looks like this:

unless condition
  Command
end

The UNLESS statement runs only if the condition is False.

a = 5
unless a < 1
  puts "This will print out."
End

Because the condition a < 1 is False, the preceding UNLESS statement runs the command sandwiched between the UNLESS keyword and the END keyword.

Both the IF and UNLESS statements can make the computer choose between two mutually exclusive sets of commands by including an ELSE keyword, such as

if condition
  Command1
Else
  Command2
end

Although the IF-ELSE statement can only give the computer a choice of two groups of commands to run, the IF-ELSIF statement can offer the computer multiple groups of commands to run, such as

if condition1
  Command
elseif condition2

Command
elseif condition3
  Command
end

As an alternative to the IF-ELSIF statement, you can also use the CASE statement to offer two or more choices, such as

case variable
when value1
  Command
when value2
  Command
Else
  Command;
end

Rather than check if a variable equals a specific value, the CASE statement can also check if a variable falls within a range of values by using the .. characters, such as

case variable
when value1..value4
  Command
when value5
  Command
else
  Command;
end

A looping statement repeats one or more commands for a fixed number of times or until a certain Boolean condition becomes True. To create a loop that repeats for a fixed number of times, use the FOR loop, which looks like this:

for variable in startvalue..endvalue
  Command
end

If you wanted the FOR loop to run four times, you could set the Start value to 1 and the End value to 4, such as

for i = 1..4
  Command
End

If you don't know how many times you need to repeat commands, use a WHILE loop, which looks like this

while condition
  Command
end

If the condition is True, the loop runs at least once. If this condition is False, then the loop doesn't run.

Ruby also offers a negated form of the WHILE loop called an UNTIL loop, which looks like this:

until condition
  Command
end

The UNTIL loop keeps running until a condition becomes True.

To break up programming problems, you can create subprograms that solve a specific task. Such subprograms are functions or methods. The format of a typical function looks like this:

def functionname (Parameter list)
  Commands
  return value
end

The two parts of a Ruby function are

If a function doesn't return a value or accept any parameters, it might look like this:

def myfunction
  Command
end

Ruby offers two built-in data structures: collections and hashes (also known as an associative array).

To create a collection, define a collection name and list the items to store in the collection inside square brackets like this:

collectionname = [data1, data2, data3]

So if you wanted to store the string "Ruby is cool" and the number 84.3 in the first and second elements of a collection, you could do the following:

mystuff = ["Ruby is cool", 84.3]

To retrieve data from a collection, specify the collection name and index number. So if you wanted to retrieve the first item in a collection, you could do this:

puts mystuff [0]

One problem with collections is that to retrieve specific data, you need to know its exact location in the collection. For greater flexibility, Ruby offers hashes so you can assign a unique value (a key) to each item. To create a hash and store data along with a key, do this:

hashname = {key => value, key => value}

If you wanted to assign the number 3.14 to the "pi" key, you could do this:

myhash = {"pi" => 3.14}

If you need to store multiple keys and values in a hash, you might prefer this alternate way of storing keys and data in a hash:

hashname = Hash.new
hashname[key] = value
hashname[key] = value

When defining a hash with multiple lines, use square brackets.

puts hashname["key"]

So if you wanted to retrieve data stored under the key "pi", you could do the following:

hashname = Hash.new
hashname["pi"] = 3.14
puts hashname["pi"]

The first line creates a hash data structure. The second line stores the value 3.14 into the hash using the key "pi" . The third line prints out the value identified by the "pi" key in the hash data structure.

Ruby supports object-oriented programming. To create an object, you must define a class, which specifies the properties and methods, such as

class Classname
  def propertyname
    @propertyname
  end
  def propertyname=(propertyname)
    @propertyname = propertyname
  end

  def methodname(parameter list)
    commands
  end
end

To create an object, you must use the following syntax:

objectname = Classname.new

To assign a value to an object's property, you need to specify the object name and the property you want to use, such as

objectname.propertyname = value

To tell an object to run a method, you need to specify the object name followed by the method name, such as

objectname.methodname(parameters)

Ruby allows single inheritance, where an object can inherit from one class (in contrast to multiple inheritance, which allows an object to inherit from two or more classes). To inherit from a class, use the < symbol followed by the class name you want to inherit from, such as

class Classname
  def propertyname
    @propertyname
  end
  def propertyname=(propertyname)
    @propertyname = propertyname
  end

  def methodname(parameter list)
    commands
  end
end

class Classname2 < Classname1
  # property and method definitions go here
end