Ruby arrays are ordered, integer-indexed collections of any object. Each element in an array is associated with and referred to by an index.
Array indexing starts at 0, as in C or Java. A negative index is assumed relative to the end of the array — that is, an index of -1 indicates the last element of the array, -2 is the next to last element in the array, and so on.
Ruby arrays can hold objects such as String, Integer, Fixnum, Hash, Symbol, even other Array objects. Ruby arrays are not as rigid as arrays in other languages. Ruby arrays grow automatically while adding elements to them.
Creating Arrays
There are many ways to create or initialize an array. One way is with the new class method −
names =Array.new
You can set the size of an array at the time of creating array −
names =Array.new(20)
The array names now has a size or length of 20 elements. You can return the size of an array with either the size or length methods −
You can also use a block with new, populating each element with what the block evaluates to −
#!/usr/bin/ruby
nums =Array.new(10){|e| e = e *2}
puts "#{nums}"
This will produce the following result −
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
There is another method of Array, []. It works like this −
nums =Array.[](1,2,3,4,5)
One more form of array creation is as follows −
nums =Array[1,2,3,4,5]
The Kernel module available in core Ruby has an Array method, which only accepts a single argument. Here, the method takes a range as an argument to create an array of digits −
We need to have an instance of Array object to call an Array method. As we have seen, following is the way to create an instance of Array object −
Array.[](...) [or] Array[...] [or] [...]
This will return a new array populated with the given objects. Now, using the created object, we can call any available instance methods. For example −
#!/usr/bin/ruby
digits =Array(0..9)
num = digits.at(6)
puts "#{num}"
This will produce the following result −
6
Following are the public array methods (assuming array is an array object) −
Array pack Directives
Following table lists the pack directives for use with Array#pack.
Example
Try the following example to pack various data.
a =["a","b","c"]
n =[65,66,67]
puts a.pack("A3A3A3")#=> "a b c "
puts a.pack("a3a3a3")#=> "a\000\000b\000\000c\000\000"
puts n.pack("ccc")#=> "ABC"
A String object in Ruby holds and manipulates an arbitrary sequence of one or more bytes, typically representing characters that represent human language.
The simplest string literals are enclosed in single quotes (the apostrophe character). The text within the quote marks is the value of the string −
'This is a simple Ruby string literal'
If you need to place an apostrophe within a single-quoted string literal, precede it with a backslash, so that the Ruby interpreter does not think that it terminates the string −
'Won\'t you read O\'Reilly\'s book?'
The backslash also works to escape another backslash, so that the second backslash is not itself interpreted as an escape character.
Following are the string-related features of Ruby.
Expression Substitution
Expression substitution is a means of embedding the value of any Ruby expression into a string using #{ and } −
#!/usr/bin/ruby
x, y, z =12,36,72
puts "The value of x is #{ x }."
puts "The sum of x and y is #{ x + y }."
puts "The average was #{ (x + y + z)/3 }."
This will produce the following result −
The value of x is 12.
The sum of x and y is 48.
The average was 40.
General Delimited Strings
With general delimited strings, you can create strings inside a pair of matching though arbitrary delimiter characters, e.g., !, (, {, <, etc., preceded by a percent character (%). Q, q, and x have special meanings. General delimited strings can be −
%{Ruby is fun.} equivalent to "Ruby is fun."
%Q{ Ruby is fun. } equivalent to " Ruby is fun. "
%q[Ruby is fun.] equivalent to a single-quoted string
%x!ls! equivalent to back tick command output ls
Escape Characters
Following table is a list of escape or non-printable characters that can be represented with the backslash notation.
Character Encoding
The default character set for Ruby is ASCII, whose characters may be represented by single bytes. If you use UTF-8, or another modern character set, characters may be represented in one to four bytes.
You can change your character set using $KCODE at the beginning of your program, like this −
$KCODE = 'u'
Following are the possible values for $KCODE.
String Built-in Methods
We need to have an instance of String object to call a String method. Following is the way to create an instance of String object −
new [String.new(str = "")]
This will return a new string object containing a copy of str. Now, using str object, we can all use any available instance methods. For example −
#!/usr/bin/ruby
myStr =String.new("THIS IS TEST")
foo = myStr.downcase
puts "#{foo}"
This will produce the following result −
this is test
Following are the public String methods ( Assuming str is a String object ) −
String unpack Directives
Following table lists the unpack directives for method String#unpack.
Modules are a way of grouping together methods, classes, and constants. Modules give you two major benefits.
Modules provide a namespace and prevent name clashes.
Modules implement the mixin facility.
Modules define a namespace, a sandbox in which your methods and constants can play without having to worry about being stepped on by other methods and constants.
Syntax
module Identifier
statement1
statement2
...........
end
Module constants are named just like class constants, with an initial uppercase letter. The method definitions look similar, too: Module methods are defined just like class methods.
As with class methods, you call a module method by preceding its name with the module’s name and a period, and you reference a constant using the module name and two colons.
Example
#!/usr/bin/ruby# Module defined in trig.rb filemoduleTrigPI=3.141592654defTrig.sin(x)# ..enddefTrig.cos(x)# ..endend
We can define one more module with the same function name but different functionality −
#!/usr/bin/ruby# Module defined in moral.rb filemoduleMoralVERY_BAD=0BAD=1defMoral.sin(badness)# ...endend
Like class methods, whenever you define a method in a module, you specify the module name followed by a dot and then the method name.
Ruby require Statement
The require statement is similar to the include statement of C and C++ and the import statement of Java. If a third program wants to use any defined module, it can simply load the module files using the Ruby require statement −
Syntax
require filename
Here, it is not required to give .rb extension along with a file name.
Example
$LOAD_PATH<<'.'require'trig.rb'require'moral'
y =Trig.sin(Trig::PI/4)
wrongdoing =Moral.sin(Moral::VERY_BAD)
Here we are using $LOAD_PATH << ‘.’ to make Ruby aware that included files must be searched in the current directory. If you do not want to use $LOAD_PATH then you can use require_relative to include files from a relative directory.
IMPORTANT − Here, both the files contain the same function name. So, this will result in code ambiguity while including in calling program but modules avoid this code ambiguity and we are able to call appropriate function using module name.
Ruby include Statement
You can embed a module in a class. To embed a module in a class, you use the include statement in the class −
Syntax
include modulename
If a module is defined in a separate file, then it is required to include that file using require statement before embedding module in a class.
Example
Consider the following module written in support.rb file.
Now, you can include this module in a class as follows −
#!/usr/bin/ruby
$LOAD_PATH << '.'
require "support"
class Decade
include Week
no_of_yrs = 10
def no_of_months
puts Week::FIRST_DAY
number = 10*12
puts number
end
end
d1 = Decade.new
puts Week::FIRST_DAY
Week.weeks_in_month
Week.weeks_in_year
d1.no_of_months
This will produce the following result −
Sunday
You have four weeks in a month
You have 52 weeks in a year
Sunday
120
Mixins in Ruby
Before going through this section, we assume you have the knowledge of Object Oriented Concepts.
When a class can inherit features from more than one parent class, the class is supposed to show multiple inheritance.
Ruby does not support multiple inheritance directly but Ruby Modules have another wonderful use. At a stroke, they pretty much eliminate the need for multiple inheritance, providing a facility called a mixin.
Mixins give you a wonderfully controlled way of adding functionality to classes. However, their true power comes out when the code in the mixin starts to interact with code in the class that uses it.
Let us examine the following sample code to gain an understand of mixin −
Module A consists of the methods a1 and a2. Module B consists of the methods b1 and b2. The class Sample includes both modules A and B. The class Sample can access all four methods, namely, a1, a2, b1, and b2. Therefore, you can see that the class Sample inherits from both the modules. Thus, you can say the class Sample shows multiple inheritance or a mixin.
You have seen how Ruby defines methods where you can put number of statements and then you call that method. Similarly, Ruby has a concept of Block.
A block consists of chunks of code.
You assign a name to a block.
The code in the block is always enclosed within braces ({}).
A block is always invoked from a function with the same name as that of the block. This means that if you have a block with the name test, then you use the function test to invoke this block.
You invoke a block by using the yield statement.
Syntax
block_name {
statement1
statement2
..........
}
Here, you will learn to invoke a block by using a simple yield statement. You will also learn to use a yield statement with parameters for invoking a block. You will check the sample code with both types of yield statements.
The yield Statement
Let’s look at an example of the yield statement −
#!/usr/bin/rubydeftest
puts "You are in the method"yield
puts "You are again back to the method"yieldend
test {puts "You are in the block"}
This will produce the following result −
You are in the method
You are in the block
You are again back to the method
You are in the block
You also can pass parameters with the yield statement. Here is an example −
#!/usr/bin/rubydeftestyield5
puts "You are in the method test"yield100end
test {|i| puts "You are in the block #{i}"}
This will produce the following result −
You are in the block 5
You are in the method test
You are in the block 100
Here, the yield statement is written followed by parameters. You can even pass more than one parameter. In the block, you place a variable between two vertical lines (||) to accept the parameters. Therefore, in the preceding code, the yield 5 statement passes the value 5 as a parameter to the test block.
Now, look at the following statement −
test {|i| puts "You are in the block #{i}"}
Here, the value 5 is received in the variable i. Now, observe the following puts statement −
puts "You are in the block #{i}"
The output of this puts statement is −
You are in the block 5
If you want to pass more than one parameters, then the yield statement becomes −
yield a, b
and the block is −
test {|a, b| statement}
The parameters will be separated by commas.
Blocks and Methods
You have seen how a block and a method can be associated with each other. You normally invoke a block by using the yield statement from a method that has the same name as that of the block. Therefore, you write −
This example is the simplest way to implement a block. You call the test block by using the yield statement.
But if the last argument of a method is preceded by &, then you can pass a block to this method and this block will be assigned to the last parameter. In case both * and & are present in the argument list, & should come later.
#!/usr/bin/rubydeftest(&block)
block.call
end
test { puts "Hello World!"}
This will produce the following result −
Hello World!
BEGIN and END Blocks
Every Ruby source file can declare blocks of code to be run as the file is being loaded (the BEGIN blocks) and after the program has finished executing (the END blocks).
#!/usr/bin/rubyBEGIN{# BEGIN block code
puts "BEGIN code block"}END{# END block code
puts "END code block"}# MAIN block code
puts "MAIN code block"
A program may include multiple BEGIN and END blocks. BEGIN blocks are executed in the order they are encountered. END blocks are executed in reverse order. When executed, the above program produces the following result −
Ruby methods are very similar to functions in any other programming language. Ruby methods are used to bundle one or more repeatable statements into a single unit.
Method names should begin with a lowercase letter. If you begin a method name with an uppercase letter, Ruby might think that it is a constant and hence can parse the call incorrectly.
Methods should be defined before calling them, otherwise Ruby will raise an exception for undefined method invoking.
You can represent a method that accepts parameters like this −
def method_name (var1, var2)
expr..
end
You can set default values for the parameters, which will be used if method is called without passing the required parameters −
def method_name (var1 = value1, var2 = value2)
expr..
end
Whenever you call the simple method, you write only the method name as follows −
method_name
However, when you call a method with parameters, you write the method name along with the parameters, such as −
method_name 25, 30
The most important drawback to using methods with parameters is that you need to remember the number of parameters whenever you call such methods. For example, if a method accepts three parameters and you pass only two, then Ruby displays an error.
Example
#!/usr/bin/rubydeftest(a1 ="Ruby", a2 ="Perl")
puts "The programming language is #{a1}"
puts "The programming language is #{a2}"end
test "C","C++"
test
This will produce the following result −
The programming language is C
The programming language is C++
The programming language is Ruby
The programming language is Perl
Return Values from Methods
Every method in Ruby returns a value by default. This returned value will be the value of the last statement. For example −
deftest
i =100
j =10
k =0end
This method, when called, will return the last declared variable k.
Ruby return Statement
The return statement in ruby is used to return one or more values from a Ruby Method.
Syntax
return [expr[`,' expr...]]
If more than two expressions are given, the array containing these values will be the return value. If no expression given, nil will be the return value.
Example
returnORreturn12ORreturn1,2,3
Have a look at this example −
#!/usr/bin/rubydeftest
i =100
j =200
k =300return i, j, k
end
var = test
puts var
This will produce the following result −
100
200
300
Variable Number of Parameters
Suppose you declare a method that takes two parameters, whenever you call this method, you need to pass two parameters along with it.
However, Ruby allows you to declare methods that work with a variable number of parameters. Let us examine a sample of this −
#!/usr/bin/rubydefsample(*test)
puts "The number of parameters is #{test.length}"for i in0...test.length
puts "The parameters are #{test[i]}"endend
sample "Zara","6","F"
sample "Mac","36","M","MCA"
In this code, you have declared a method sample that accepts one parameter test. However, this parameter is a variable parameter. This means that this parameter can take in any number of variables. So, the above code will produce the following result −
The number of parameters is 3
The parameters are Zara
The parameters are 6
The parameters are F
The number of parameters is 4
The parameters are Mac
The parameters are 36
The parameters are M
The parameters are MCA
Class Methods
When a method is defined outside of the class definition, the method is marked as private by default. On the other hand, the methods defined in the class definition are marked as public by default. The default visibility and the private mark of the methods can be changed by public or private of the Module.
Whenever you want to access a method of a class, you first need to instantiate the class. Then, using the object, you can access any member of the class.
Ruby gives you a way to access a method without instantiating a class. Let us see how a class method is declared and accessed −
See how the method return_date is declared. It is declared with the class name followed by a period, which is followed by the name of the method. You can access this class method directly as follows −
Accounts.return_date
To access this method, you need not create objects of the class Accounts.
Ruby alias Statement
This gives alias to methods or global variables. Aliases cannot be defined within the method body. The alias of the method keeps the current definition of the method, even when methods are overridden.
Making aliases for the numbered global variables ($1, $2,…) is prohibited. Overriding the built-in global variables may cause serious problems.
Syntax
alias method-name method-name
alias global-variable-name global-variable-name
Example
alias foo bar
alias $MATCH $&
Here we have defined foo alias for bar, and $MATCH is an alias for $&
Ruby undef Statement
This cancels the method definition. An undef cannot appear in the method body.
By using undef and alias, the interface of the class can be modified independently from the superclass, but notice it may be broke programs by the internal method call to self.
Syntax
undef method-name
Example
To undefine a method called bar do the following −
Loops in Ruby are used to execute the same block of code a specified number of times. This chapter details all the loop statements supported by Ruby.
Ruby while Statement
Syntax
while conditional [do]
code
end
Executes code while conditional is true. A while loop’s conditional is separated from code by the reserved word do, a newline, backslash \, or a semicolon ;.
Example
#!/usr/bin/ruby$i =0$num =5while$i <$num do
puts("Inside the loop i = #$i")$i +=1end
This will produce the following result −
Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4
Ruby while modifier
Syntax
code while condition
OR
begin
code
end while conditional
Executes code while conditional is true.
If a while modifier follows a begin statement with no rescue or ensure clauses, code is executed once before conditional is evaluated.
Example
#!/usr/bin/ruby$i =0$num =5begin
puts("Inside the loop i = #$i")$i +=1endwhile$i <$num
This will produce the following result −
Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4
Ruby until Statement
until conditional [do]
code
end
Executes code while conditional is false. An until statement’s conditional is separated from code by the reserved word do, a newline, or a semicolon.
Example
#!/usr/bin/ruby$i =0$num =5until$i >$num do
puts("Inside the loop i = #$i")$i +=1;end
This will produce the following result −
Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4
Inside the loop i = 5
Ruby until modifier
Syntax
code until conditional
OR
begin
code
end until conditional
Executes code while conditional is false.
If an until modifier follows a begin statement with no rescue or ensure clauses, code is executed once before conditional is evaluated.
Example
#!/usr/bin/ruby$i =0$num =5begin
puts("Inside the loop i = #$i")$i +=1;enduntil$i >$num
This will produce the following result −
Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4
Inside the loop i = 5
Ruby for Statement
Syntax
for variable [, variable ...] in expression [do]
code
end
Executes code once for each element in expression.
Example
#!/usr/bin/rubyfor i in0..5
puts "Value of local variable is #{i}"end
Here, we have defined the range 0..5. The statement for i in 0..5 will allow i to take values in the range from 0 to 5 (including 5). This will produce the following result −
Value of local variable is 0
Value of local variable is 1
Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5
A for…in loop is almost exactly equivalent to the following −
(expression).each do |variable[, variable...]| code end
except that a for loop doesn’t create a new scope for local variables. A for loop’s expression is separated from code by the reserved word do, a newline, or a semicolon.
Example
#!/usr/bin/ruby(0..5).eachdo|i|
puts "Value of local variable is #{i}"end
This will produce the following result −
Value of local variable is 0
Value of local variable is 1
Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5
Ruby break Statement
Syntax
break
Terminates the most internal loop. Terminates a method with an associated block if called within the block (with the method returning nil).
Example
#!/usr/bin/rubyfor i in0..5if i >2thenbreakend
puts "Value of local variable is #{i}"end
This will produce the following result −
Value of local variable is 0
Value of local variable is 1
Value of local variable is 2
Ruby next Statement
Syntax
next
Jumps to the next iteration of the most internal loop. Terminates execution of a block if called within a block (with yield or call returning nil).
Example
#!/usr/bin/rubyfor i in0..5if i <2thennextend
puts "Value of local variable is #{i}"end
This will produce the following result −
Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5
Ruby redo Statement
Syntax
redo
Restarts this iteration of the most internal loop, without checking loop condition. Restarts yield or call if called within a block.
Example
#!/usr/bin/rubyfor i in0..5if i <2then
puts "Value of local variable is #{i}"redoendend</pre>
This will produce the following result and will go in an infinite loop −
Value of local variable is 0
Value of local variable is 0
............................
Ruby retry Statement
Syntax
retry
If retry appears in rescue clause of begin expression, restart from the beginning of the begin body.
begin
do_something # exception raisedrescue# handles errorretry# restart from beginningend
If retry appears in the iterator, the block, or the body of the for expression, restarts the invocation of the iterator call. Arguments to the iterator is re-evaluated.
for i in1..5retryif some_condition # restart from i == 1end
Example
#!/usr/bin/rubyfor i in0..5retryif i >2
puts "Value of local variable is #{i}"end
This will produce the following result and will go in an infinite loop −
Value of local variable is 1
Value of local variable is 2
Value of local variable is 1
Value of local variable is 2
Value of local variable is 1
Value of local variable is 2
.................
Ruby offers conditional structures that are pretty common to modern languages. Here, we will explain all the conditional statements and modifiers available in Ruby.
Ruby if…else Statement
Syntax
if conditional [then]
code...
[elsif conditional [then]
code…]…
[else
code…]
end
if expressions are used for conditional execution. The values false and nil are false, and everything else are true. Notice Ruby uses elsif, not else if nor elif.
Executes code if the conditional is true. If the conditional is not true, code specified in the else clause is executed.
An if expression’s conditional is separated from code by the reserved word then, a newline, or a semicolon.
Example
#!/usr/bin/ruby
x =1if x >2
puts "x is greater than 2"elsif x <=2and x!=0
puts "x is 1"else
puts "I can't guess the number"end
x is 1
Ruby if modifier
Syntax
code if condition
Executes code if the conditional is true.
Example
#!/usr/bin/ruby$debug=1
print "debug\n"if$debug
This will produce the following result −
debug
Ruby unless Statement
Syntax
unless conditional [then]
code
[else
code ]
end
Executes code if conditional is false. If the conditional is true, code specified in the else clause is executed.
Example
#!/usr/bin/ruby
x =1unless x>=2 puts "x is less than 2"else puts "x is greater than 2"end
This will produce the following result −
x is less than 2
Ruby unless modifier
Syntax
code unless conditional
Executes code if conditional is false.
Example
#!/usr/bin/ruby$var=1 print "1 -- Value is set\n"if$var print "2 -- Value is set\n"unless$var$var=false print "3 -- Value is set\n"unless$var
This will produce the following result −
1 -- Value is set
3 -- Value is set
Ruby case Statement
Syntax
case expression
[when expression [, expression ...] [then]
code ]...
[else
code ]
end
Compares the expression specified by case and that specified by when using the === operator and executes the code of the when clause that matches.
The expression specified by the when clause is evaluated as the left operand. If no when clauses match, case executes the code of the else clause.
A when statement’s expression is separated from code by the reserved word then, a newline, or a semicolon. Thus −
case expr0
when expr1, expr2
stmt1
when expr3, expr4
stmt2
else
stmt3
end
Comments are lines of annotation within Ruby code that are ignored at runtime. A single line comment starts with # character and they extend from # to the end of the line as follows −
#!/usr/bin/ruby -w# This is a single line comment.
puts "Hello, Ruby!"
When executed, the above program produces the following result −
Hello, Ruby!
Ruby Multiline Comments
You can comment multiple lines using =begin and =end syntax as follows −
#!/usr/bin/ruby -w
puts "Hello, Ruby!"=begin
This is a multiline comment and con spwan as many lines as you
like. But =begin and =end should come in the first line only.
=end
When executed, the above program produces the following result −
Hello, Ruby!
Make sure trailing comments are far enough from the code and that they are easily distinguished. If more than one trailing comment exists in a block, align them. For example −
@counter# keeps track times page has been hit@siteCounter# keeps track of times all pages have been hit
Ruby supports a rich set of operators, as you’d expect from a modern language. Most operators are actually method calls. For example, a + b is interpreted as a.+(b), where the + method in the object referred to by variable a is called with b as its argument.
For each operator (+ – * / % ** & | ^ << >> && ||), there is a corresponding form of abbreviated assignment operator (+= -= etc.).
Ruby Arithmetic Operators
Assume variable a holds 10 and variable b holds 20, then −
Operator
Description
Example
+
Addition − Adds values on either side of the operator.
a + b will give 30
−
Subtraction − Subtracts right hand operand from left hand operand.
a – b will give -10
*
Multiplication − Multiplies values on either side of the operator.
a * b will give 200
/
Division − Divides left hand operand by right hand operand.
b / a will give 2
%
Modulus − Divides left hand operand by right hand operand and returns remainder.
b % a will give 0
**
Exponent − Performs exponential (power) calculation on operators.
a**b will give 10 to the power 20
Ruby Comparison Operators
Assume variable a holds 10 and variable b holds 20, then −
Operator
Description
Example
==
Checks if the value of two operands are equal or not, if yes then condition becomes true.
(a == b) is not true.
!=
Checks if the value of two operands are equal or not, if values are not equal then condition becomes true.
(a != b) is true.
>
Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true.
(a > b) is not true.
<
Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true.
(a < b) is true.
>=
Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true.
(a >= b) is not true.
<=
Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true.
(a <= b) is true.
<=>
Combined comparison operator. Returns 0 if first operand equals second, 1 if first operand is greater than the second and -1 if first operand is less than the second.
(a <=> b) returns -1.
===
Used to test equality within a when clause of a case statement.
(1…10) === 5 returns true.
.eql?
True if the receiver and argument have both the same type and equal values.
1 == 1.0 returns true, but 1.eql?(1.0) is false.
equal?
True if the receiver and argument have the same object id.
if aObj is duplicate of bObj then aObj == bObj is true, a.equal?bObj is false but a.equal?aObj is true.
Ruby Assignment Operators
Assume variable a holds 10 and variable b holds 20, then −
Operator
Description
Example
=
Simple assignment operator, assigns values from right side operands to left side operand.
c = a + b will assign the value of a + b into c
+=
Add AND assignment operator, adds right operand to the left operand and assign the result to left operand.
c += a is equivalent to c = c + a
-=
Subtract AND assignment operator, subtracts right operand from the left operand and assign the result to left operand.
c -= a is equivalent to c = c – a
*=
Multiply AND assignment operator, multiplies right operand with the left operand and assign the result to left operand.
c *= a is equivalent to c = c * a
/=
Divide AND assignment operator, divides left operand with the right operand and assign the result to left operand.
c /= a is equivalent to c = c / a
%=
Modulus AND assignment operator, takes modulus using two operands and assign the result to left operand.
c %= a is equivalent to c = c % a
**=
Exponent AND assignment operator, performs exponential (power) calculation on operators and assign value to the left operand.
c **= a is equivalent to c = c ** a
Ruby Parallel Assignment
Ruby also supports the parallel assignment of variables. This enables multiple variables to be initialized with a single line of Ruby code. For example −
a = 10
b = 20
c = 30
This may be more quickly declared using parallel assignment −
a, b, c = 10, 20, 30
Parallel assignment is also useful for swapping the values held in two variables −
a, b = b, c
Ruby Bitwise Operators
Bitwise operator works on bits and performs bit by bit operation.
Assume if a = 60; and b = 13; now in binary format they will be as follows −
The following Bitwise operators are supported by Ruby language.
Operator
Description
Example
&
Binary AND Operator copies a bit to the result if it exists in both operands.
(a & b) will give 12, which is 0000 1100
|
Binary OR Operator copies a bit if it exists in either operand.
(a | b) will give 61, which is 0011 1101
^
Binary XOR Operator copies the bit if it is set in one operand but not both.
(a ^ b) will give 49, which is 0011 0001
~
Binary Ones Complement Operator is unary and has the effect of ‘flipping’ bits.
(~a ) will give -61, which is 1100 0011 in 2’s complement form due to a signed binary number.
<<
Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand.
a << 2 will give 240, which is 1111 0000
>>
Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand.
a >> 2 will give 15, which is 0000 1111
Ruby Logical Operators
The following logical operators are supported by Ruby language
Assume variable a holds 10 and variable b holds 20, then −
Operator
Description
Example
and
Called Logical AND operator. If both the operands are true, then the condition becomes true.
(a and b) is true.
or
Called Logical OR Operator. If any of the two operands are non zero, then the condition becomes true.
(a or b) is true.
&&
Called Logical AND operator. If both the operands are non zero, then the condition becomes true.
(a && b) is true.
||
Called Logical OR Operator. If any of the two operands are non zero, then the condition becomes true.
(a || b) is true.
!
Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true, then Logical NOT operator will make false.
!(a && b) is false.
not
Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true, then Logical NOT operator will make false.
not(a && b) is false.
Ruby Ternary Operator
There is one more operator called Ternary Operator. It first evaluates an expression for a true or false value and then executes one of the two given statements depending upon the result of the evaluation. The conditional operator has this syntax −
Operator
Description
Example
? :
Conditional Expression
If Condition is true ? Then value X : Otherwise value Y
Ruby Range Operators
Sequence ranges in Ruby are used to create a range of successive values – consisting of a start value, an end value, and a range of values in between.
In Ruby, these sequences are created using the “..” and “…” range operators. The two-dot form creates an inclusive range, while the three-dot form creates a range that excludes the specified high value.
Operator
Description
Example
..
Creates a range from start point to end point inclusive.
1..10 Creates a range from 1 to 10 inclusive.
…
Creates a range from start point to end point exclusive.
1…10 Creates a range from 1 to 9.
Ruby defined? Operators
defined? is a special operator that takes the form of a method call to determine whether or not the passed expression is defined. It returns a description string of the expression, or nil if the expression isn’t defined.
There are various usage of defined? Operator
Usage 1
defined? variable # True if variable is initialized
defined? method_call # True if a method is defined
For Example
defined? puts # => "method"defined? puts(bar)# => nil (bar is not defined here)defined? unpack # => nil (not defined here)
Usage 3
# True if a method exists that can be called with super userdefined?super
For Example
defined?super# => "super" (if it can be called)defined?super# => nil (if it cannot be)
Usage 4
defined?yield# True if a code block has been passed
For Example
defined?yield# => "yield" (if there is a block passed)defined?yield# => nil (if there is no block)
Ruby Dot “.” and Double Colon “::” Operators
You call a module method by preceding its name with the module’s name and a period, and you reference a constant using the module name and two colons.
The :: is a unary operator that allows: constants, instance methods and class methods defined within a class or module, to be accessed from anywhere outside the class or module.
Remember in Ruby, classes and methods may be considered constants too.
You need to just prefix the :: Const_name with an expression that returns the appropriate class or module object.
If no prefix expression is used, the main Object class is used by default.
Here are two examples −
MR_COUNT=0# constant defined on main Object classmoduleFooMR_COUNT=0::MR_COUNT=1# set global count to 1MR_COUNT=2# set local count to 2end
puts MR_COUNT# this is the global constant
puts Foo::MR_COUNT# this is the local "Foo" constant
Variables are the memory locations, which hold any data to be used by any program.
There are five types of variables supported by Ruby. You already have gone through a small description of these variables in the previous chapter as well. These five types of variables are explained in this chapter.
Ruby Global Variables
Global variables begin with $. Uninitialized global variables have the value nil and produce warnings with the -w option.
Assignment to global variables alters the global status. It is not recommended to use global variables. They make programs cryptic.
Here is an example showing the usage of global variable.
Here, @cust_id, @cust_name and @cust_addr are instance variables. This will produce the following result −
Customer id 1
Customer name John
Customer address Wisdom Apartments, Ludhiya
Customer id 2
Customer name Poul
Customer address New Empire road, Khandala
Ruby Class Variables
Class variables begin with @@ and must be initialized before they can be used in method definitions.
Referencing an uninitialized class variable produces an error. Class variables are shared among descendants of the class or module in which the class variables are defined.
Overriding class variables produce warnings with the -w option.
Here is an example showing the usage of class variable −
#!/usr/bin/rubyclassCustomer@@no_of_customers=0definitialize(id, name, addr)@cust_id= id
@cust_name= name
@cust_addr= addr
enddefdisplay_details()
puts "Customer id #@cust_id"
puts "Customer name #@cust_name"
puts "Customer address #@cust_addr"enddeftotal_no_of_customers()@@no_of_customers+=1
puts "Total number of customers: #@@no_of_customers"endend# Create Objects
Here @@no_of_customers is a class variable. This will produce the following result −
Total number of customers: 1
Total number of customers: 2
Ruby Local Variables
Local variables begin with a lowercase letter or _. The scope of a local variable ranges from class, module, def, or do to the corresponding end or from a block’s opening brace to its close brace {}.
When an uninitialized local variable is referenced, it is interpreted as a call to a method that has no arguments.
Assignment to uninitialized local variables also serves as variable declaration. The variables start to exist until the end of the current scope is reached. The lifetime of local variables is determined when Ruby parses the program.
In the above example, local variables are id, name and addr.
Ruby Constants
Constants begin with an uppercase letter. Constants defined within a class or module can be accessed from within that class or module, and those defined outside a class or module can be accessed globally.
Constants may not be defined within methods. Referencing an uninitialized constant produces an error. Making an assignment to a constant that is already initialized produces a warning.
puts "Value of first Constant is #{VAR1}"
puts "Value of second Constant is #{VAR2}"endend# Create Objects
object =Example.new()
object.show
Here VAR1 and VAR2 are constants. This will produce the following result −
Value of first Constant is 100
Value of second Constant is 200
Ruby Pseudo-Variables
They are special variables that have the appearance of local variables but behave like constants. You cannot assign any value to these variables.
self − The receiver object of the current method.
true − Value representing true.
false − Value representing false.
nil − Value representing undefined.
__FILE__ − The name of the current source file.
__LINE__ − The current line number in the source file.
Ruby Basic Literals
The rules Ruby uses for literals are simple and intuitive. This section explains all basic Ruby Literals.
Integer Numbers
Ruby supports integer numbers. An integer number can range from -230 to 230-1 or -262 to 262-1. Integers within this range are objects of class Fixnum and integers outside this range are stored in objects of class Bignum.
You write integers using an optional leading sign, an optional base indicator (0 for octal, 0x for hex, or 0b for binary), followed by a string of digits in the appropriate base. Underscore characters are ignored in the digit string.
You can also get the integer value, corresponding to an ASCII character or escape the sequence by preceding it with a question mark.
Example
123# Fixnum decimal1_234 # Fixnum decimal with underline-500# Negative Fixnum0377# octal0xff# hexadecimal0b1011 # binary?a # character code for 'a'?\n # code for a newline (0x0a)12345678901234567890# Bignum
NOTE − Class and Objects are explained in a separate chapter of this tutorial.
Floating Numbers
Ruby supports floating numbers. They are also numbers but with decimals. Floating-point numbers are objects of class Float and can be any of the following −
Example
123.4# floating point value1.0e6# scientific notation4E20# dot not required4e+20# sign before exponential
String Literals
Ruby strings are simply sequences of 8-bit bytes and they are objects of class String. Double-quoted strings allow substitution and backslash notation but single-quoted strings don’t allow substitution and allow backslash notation only for \\ and \’
Example
#!/usr/bin/ruby -w
puts 'escape using "\\"';
puts 'That\'s right';
This will produce the following result −
escape using "\"
That's right
You can substitute the value of any Ruby expression into a string using the sequence #{ expr }. Here, expr could be any ruby expression.
#!/usr/bin/ruby -w
puts "Multiplication Value : #{24*60*60}";
This will produce the following result −
Multiplication Value : 86400
Backslash Notations
Following is the list of Backslash notations supported by Ruby −
Notation
Character represented
\n
Newline (0x0a)
\r
Carriage return (0x0d)
\f
Formfeed (0x0c)
\b
Backspace (0x08)
\a
Bell (0x07)
\e
Escape (0x1b)
\s
Space (0x20)
\nnn
Octal notation (n being 0-7)
\xnn
Hexadecimal notation (n being 0-9, a-f, or A-F)
\cx, \C-x
Control-x
\M-x
Meta-x (c | 0x80)
\M-\C-x
Meta-Control-x
\x
Character x
For more detail on Ruby Strings, go through Ruby Strings.
Ruby Arrays
Literals of Ruby Array are created by placing a comma-separated series of object references between the square brackets. A trailing comma is ignored.
Example
#!/usr/bin/ruby
ary =["fred",10,3.14,"This is a string","last element",]
ary.eachdo|i|
puts i
end
This will produce the following result −
fred
10
3.14
This is a string
last element
For more detail on Ruby Arrays, go through Ruby Arrays.
Ruby Hashes
A literal Ruby Hash is created by placing a list of key/value pairs between braces, with either a comma or the sequence => between the key and the value. A trailing comma is ignored.
For more detail on Ruby Hashes, go through Ruby Hashes.
Ruby Ranges
A Range represents an interval which is a set of values with a start and an end. Ranges may be constructed using the s..e and s…e literals, or with Range.new.
Ranges constructed using .. run from the start to the end inclusively. Those created using … exclude the end value. When used as an iterator, ranges return each value in the sequence.
A range (1..5) means it includes 1, 2, 3, 4, 5 values and a range (1…5) means it includes 1, 2, 3, 4 values.
Example
#!/usr/bin/ruby(10..15).eachdo|n|
print n,' 'end
This will produce the following result −
10 11 12 13 14 15
For more detail on Ruby Ranges, go through Ruby Ranges.