index<--

Ruby Syntax

Unlike Python that has mandatory indentation, in Ruby the indentation is optional. Multiple statements can be separated using symbol ";" but this symbol is not required for single line statements.

Unlike other languages that have one single convention for a block of code, Ruby has 2 kind of block statements. One is enclose by curly brackets {...} other blocks are using keywords.

When you write Ruby code you actually create scripts. These are text files with extension *.rb. Most script files start with a special comment: #! as in example below:

First script:

#!/usr/bin/ruby -w
puts "Hello, Ruby!";

You can run this script using ruby interpreter:

>ruby hello.rb

Example:

This is just a fancy "hello world" script that I will explain next:

# The Greeter class
class Greeter
  def initialize(name)
    @name = name.capitalize
  end

  def salute
    puts "Hello #{@name}!"
  end
end

# Create a new object
g = Greeter.new("world")

# Output "Hello World!"
g.salute

Homework: open live demo and run it:  hello world

Notes:

• line of comment start with "#" like in Python,
• there is no ";" for end of statement,
• a class is a named block of code like in Python,
• a method of a class start with keyword "def" like in Python,
• block of code is ending with "end" like in Pascal,
• assign is using symbol "=" not ":=" that is used in Pascal, 
• call of function puts do not require (…), unlike Python,
• symbol @ is a "sigil" for an attribute,
• string is enclosed in double quotes: "…",
• notation #{@name} is: string interpolation.

Clarification: This is how we learn Ruby in this tutorial. I will show you an example or more, that may be overwhelming at first glance. Then you execute the example once or several times on-line using  repl.it website. Analyze the output an read the notes to understand the new concepts.

Block Comments

In most languages block comments are enclosed in this notation: /* … */. In Ruby this kind of comment is not available. Instead you can use =begin ... =end notation. Block comments are sometimes called "embedded documentation". It is a good practice to use these kind of comments to explain code purpose.

Example:

=begin
This demo does absolutely nothing.
In Ruby the null statement is nil
=end

# define a subroutine that does nothing
def pass
  nil # nothing expression
end

pass # call subroutine pass one time

=begin
Also the simple semicolumn ';'
does absolutely nothing 
=end

;;;  # call null statement 3 times

Block Statement

Example:

# block statement
for x in 1..10 do
    next if x % 2 == 0
    print x," " # 1 3 5 7 9
end

Notes:

• In previous example I have used statement "for" that is a block statement.
• Indentation is usually done with equal 2 or 4 number of spaces;
• Block statements are closed with "end" and can be nested.

Keywords

Most keywords are English words. Some keywords are using uppercase but most of them are using only lowercase letters. Ruby has about 40 keywords that I will introduce step by step using examples.

----------------------------------------------------------------
__FILE__  and    def       end     in      or      self   unless
__LINE__  begin  defined?  ensure  module  redo    super  until
BEGIN     break  do        false   next    rescue  then   when
END       case   else      for     nil     retry   true   while
alias     class  elsif     if      not     return  undef  yield
----------------------------------------------------------------

Code Line

In Ruby one statement is usually single code. However not all statement are on a single line. Sometimes one code line can have many statements separated by semicolumn (;). When a statement is too long, it can be continued on next lines.

There are two ways to break a statement in multiple code lines. Fitst, you can use backslash (\) at end of line the continue on the next line. Second, a code line that end with an operator like "+" may continue on next line. In this case the continuation operator "\" is not necessary.

Statements

Ruby is an imperative, object oriented language. Therefore, most statements are using a keyword to start, except the assign statement that start with an identifier.

Expressions

You should be familiar with this concept from mathematics. In Ruby you can use infix expressions. Here is a short reminder: Infix, Postfix and Prefix notations are three different but equivalent ways of writing expressions. It is easiest to demonstrate the differences by looking at examples of operators that take two operands:

1. x + y  : Infix
2. + x y  : Prefix
3. x y +  : Postfix

In these expressions x, y are operands while "+" is an operator. The most simple expressions are using one single operator and one operand. For example "-4" is an expression while "4" is not an expression but a single constant literal.  "2 + 4" however is an expression even if there is no variable involved.

Usually expressions are used in statements. In Ruby stand alone expressions can exist and can represent the result of a function or method. I personally don’t like this approach, it can make the script harder to understand.

Elements

The most simple expressions are called "elements". Elements and small expressions can be combined in larger expressions. Order of execution can be controlled using operator precedence and round parenthesis. We will investigate this in our next examples.

Identifiers

Variables

Constants

# predefined constants
TRUE, FALSE
NIL
STDIN, STDOUT
STDERR
ENV
ARGF, ARGV
DATA
RUBY_VERSION
RUBY_RELEASE_DATE
RUBY_PLATFORM

Literals

Example:

5
24
520
'a'
"test"
[1,2,3]

Numeric Operators:

Operators are data type dependent. So for each data type should have a different set of operators. However, Ruby is smart enaugh to make automatic conversion between different data types. We say numeric operators are polymorph. They can operate integers and float numbers.

Examples

# expressions demo:
puts (5 + 5) / 2   # 5
puts  5 + 5  / 2   # 7
puts  5 + 5  / 2.0 # 7.5
puts  5 + 2  * 2   # 9
puts (5 + 2) * 2   # 14

# unexpected result:
print [5 + 2] * 2 # [7, 7]

Notes:

1. In this example we have used 3 numeric operators: { +, /, *}. That should be familiar to you: Addition, division and multiplication. In computer science we have a scarce number of operators due to legacy ASCII notation. { ÷  · } are Unicode symbols for division and multiplication, not available in Ruby.
2. Square bracket […] and squiggly brackets {…} are used in mathematics to control the order of operations but not in Ruby. Notation [5 + 2] create an array with one element [7] that is replicated into [7, 7]. Totally unexpected result isn’t it?

Numeric Modifiers

Modifiers are in place operators that alter value associated to an identifier. Modifiers are also assignment statements. Python modifiers are inherited from C language. Modifiers can accept expressions not only constants.

#example of identity relation
x = 5    # create a test fixture
puts x;  # check x value
puts "is x equal to 5? ", x == 5;

# equal and different
1 == 0 # false
1 != 0 # true

# less than and greater than
4 < 5 # true
5 > 4 # true

# greater then or equal to
0 >= 0 #true
0 >= 1 #false

# less then or equal to
1 <= 1 #true
1 <= 0 #true

# combined comparison
0 <=> 1 # -1
1 <=> 0 # 0
1 <=> 0 # 1

# range include operator
(1..5)  === 5 # true
(1...5) === 5 # false

# range exclusion expression
!((1..5)  === 3) # false