5 Statements and Control Structures

Deepak H B
Full-Stack Developer
Gmail: deepakhb2@gmail.com
Linkedin: http://in.linkedin.com/in/deepakhb
GitHub: https://github.com/deepakhb2

Statements and Control
Structures

Introduction
• Ruby’s control structure, which alter the sequential
execution or flow-of-control of a program.
• Conditionals
• Loops
• Iterators and blocks
• Flow altering statements like return and break

Conditionals
• The most common control structure, in any
programming language, is the conditional.
• The condition is the expression, if it evaluates to any
value other than false or nil, then the condition is
satisfied.

If
• The simplest form, it looks like
if expression
code
end
• The code between if and end is executed if the expression is evaluated
other than false or nil.
• The code must be separated from the expression with a newline or
semicolon or the keyword then.
• Parentheses are not required around the conditional expression.
• The end keyword is required even if the code to be executed consists for
single statement.
• The return value of an if “statement” is the value of the last expression in
the code that was executed or nil if no block of code was executed.

Else
• If statement may include an else clause to specify code to be
executed if the condition is not true.
if expression
code
else
code
end
• The else and end keywords fully delimit the second chunk of
code.

Elsif
• If you want to test more than one condition within a conditional, you can add one
or more elsif clause between an if and an else.
if expression1
code1
elsif expresion2
code2
.
.
elsif expression
codeN
else
code
end
• If expression1 evaluates to anything other than false or nil, then code1 is executed.
Otherwise, expression2 is evaluated. This continuous till last elsif.
• Finally, if else clause is not present, than no code is executed at all.
• elsif is like if: the expression must be separated from the code by a newline, a
semicolon, or a then keyword.

if as a Modifier
• The if expression can also be written as:
$code if expression
• When used in this form, if is known as a statement
modifier.
• Even though the condition is written last, it is evaluated
first.
• Code is evaluated depending on the condition evaluation
and expression value is returned (value or nil).

Unless
• A statement or a modifier, is the opposite of if: It executes code only if an
associated expression evaluates to false or nil.
• Its syntax is just like if, except that elsif clause is not allowed.
unless condition
code
end
#two ways unless statement
unless condition
Code
else
Code
end
#unless modifier
code unless condition
• Like if, unless statements are expressions and return the value of the code
they execute or nil if they execute nothing.

Case
• The case statement is a multiway conditional.
• These two side by side expressions are equivalent
name = case
when x==1 then “one”
when x ==2 then “two”
when x==3 then “three”
when x ==4 then “four”
else “many”
end
name = if x==1 then “one”
elsif x ==2 then “two”
elsif x==3 then “three”
elsif x==4 then “four”
else “many”
end

Contd..
• The case statement returns value of the expression just like
if statement does.
• The then keyword following when can be replaced with
‘newline’ or “colon”
• The case statement tests each of its when expressions in
the order they are written until it finds one that evaluates
to true.
• The case statement may have more than one comma-
separated expression associated with it.
when x==1, y==2

Contd..
• The other way of writing case statement:
name = case x
when 1
“one”
when 2 then “two”
when 3; “three”
else “many”
end
• In this form of case statement, the expression associated with the
case is evaluated first and then its compared to the value obtained
by evaluating the when expression.
• This comparison is done using the === (case equality operator). This
operation is invoked on the value of the when expression and is
passed the value of the case expression.
• When multiple expressions are separated by comma, and the “===”
operator is invoked on each one.

The ?: Operator
• The conditional operator ?: behaves much like
an if statement, with ? replacing then and :
replacing else.
(n==1) ? “message1” : “message2”

Loops
While and until
• While and until will execute a chunk of code while a certain
condition is true or until the condition becomes true.
x=10
while x >= 0 do
puts x
x=x-1
end
x=0
until x>10 do
puts x
x=x+1
end

Contd..
• Loop condition is the Boolean expression that appears
between the while and until and do keywords.
• The loop body is the ruby code that appears between the
do and the end keyword.
• The while loop evaluates its condition. If the value is
anything other than false or nil it executes its body and
loops to evaluate its condition again.
• The until loop is the reverse. The condition is tested and the
body is executed if the condition evaluates to false or nil.
• The do keyword in a while or until loop is like the then
keyword in an if statement.

While and until as modifier
• These modifier syntax uses while keyword itself to separate the
loop body from the loop condition and avoids the need of do and
end keywords.
X=0
Puts x=x+1 while x<10
• Contrast this code with the more traditional while loop written on a
single line.
x=0
while x<10 do puts x=x+1 end
• Until can be used as a modifier just like while.
• When while and until are used as modifier, they must appear on the
same line as the loop body that they modify.
• The compound expression delimited by begin and end keywords,
then the body is executed first before the condition is tested.
x=10
begin
puts x
x=x-1
end until x==0

The for/in loop
• The for loop or for/in loop, iterates through the elements of
an enumerable object such as array.
for var in collection do
Body
End
• var is a variable or comma-separated list of variables,
collection is any object that has an each iterator method.
Arrays and Hashes define the each iterator method.
• The for/in loop will call the each method of the specified
object.
• The loop variable or variables of a for loop are not local to
the loop; then remain defined even after the loop exits.

Contd..
• As the iterator yields the values , the for loop assigns each value to
the specified variable and then executes the code in body.
array = [1,2,3,4]
for element in array
puts element
end
hash = {:a=>1, :b=>2, :c=>3}
for key,value in hash
puts “#{key} => #{value}”
End
• Similarly new variables defined in loop body continue to exists after
the loop exits.
• The values of the hash & array can be iterated using each iteratore
array.each do |v|
puts v
end

Iterators and Enumerable objects
• Its common in ruby to write loops using special methods
known as iterators.iterators.
3.times {puts “Thank you”}
data.each {|x| puts x}
[1,2,3].map {|x| x*x}
• The times, each, map and upto methods are all iterators and
they interact with the block of code that follows them.
• The complex control structure behind this is yield.
• The yield statement temporarily returns control from the
interator method to method that invoked the iterator.

Numeric Iterators
• The Integer class defines three commonly used iterators upto,
downto and times.
• The upto method invokes its associated block once for each
integer between the integer on which it is invoked and the integer
which is passed as an argument.
4.upto(6) {|x| puts x} # => prints “456”
• The downto method is just like upto but iterates from a larger
number down to a smaller number.
• The times method is invoked on the integer n, and it invokes its
block n times, passing values 0 through n-1 on successive
iterations.
• The step method is used to iterate through floating point numbers.
0.step(1, 0.1){|x| puts x}

Enumerable Iterators
• Array, Hash, Range and a number of other classes define an
each iterator that passes each element of the collection to
associated block.
• This is perhaps most commonly used iterator in Ruby.
[1,2,3].each {|x| print x}
• Ruby’s IO class defines an each iterator that yields lines of
text read from the Input/Output object.
• Most classes define an each method also include the
Enumerable module. The other iterator is each_with_index.
• Some of the most commonly used Enumerable iterators are
collect, select, reject, and inject.

Contd..
• The collect method executes its associated block for each element of the
enumerable object and collects the return values of the block to an array.
[1,2,3].collect{|x| x*x} #=> [1,4,9]
• The select method invokes the block for each element in an enumerable
object and returns an array of elements for which the block returns a
value other than false or nil.
(0..10).select{|x| x%2 == 0} #=> [2,4,6,8,10]
• The reject method is simply opposite of select.
(0..10).reject{|x| x%2==0} #=> [1,3,5,7,9]
• The inject method invokes the associated block with two arguments. The
first argument is accumulated value of some sort form previous iterations.
The second argument is the next element of the enumerable object. The
return value of the block will be the first block argument for the next
iteration or becomes the return value of the iterator after the last
iteration.
data = [2,5,3,4]
sum = data.inject{|sum, x| sum+x} # => 14

Writing Custom Iterators
• The defining feature of the iterator method is that it invokes a
block of code associated with the method invocation.
• You do this with the yield statement.
def twice
yield
yield
End
• To pass argument values to the block, follow the yield
statement with a comma separated list of expressions.
• Using the yield keyword is really is a lot like invoking a
method.

Altering Control Flow
Ruby supports a number of statements that alter the flow-of-control in a
Ruby program.
Return
• The return statement causes the enclosing method to return to its caller.
• Return may optionally followed by an expression or a comma-separated
list of expressions.
• If there is no expression, then the return value of a method is nil.
• If there is more than one expression after the return keyword, then the
return value of a method is an array containing the values of those
expressions.
• The method will automatically returns the last statement of the method if
there is no return statement.

Contd..
Break
• When used with loop, the break statement transfers the control out of the
loop to the first expression following the loop.
while(line = gets.chop)
break if line == “quit”
puts eval(line)
end
• When used in block, break transfers the control out of block, out of
iterator that invoked the block.
f.each do |line|
break if line == “puitn”
puts eval(line)
End
• The break statement can return the value when break is followed with
expression or comma separated expressions.

Contd..
Next
• The next statement causes a loop or iterator to end the current
iteration and begin the next.
while(line = gets.chop)
next if line[0,1] == “#”
puts eval(line)
End
• The next may be used alone or it may be followed by an expression
or a comma separated list of expressions. In loops the expressions
following next are ignored.
• In block, the expression or expressions become the “return value”
of the yield statement that invoked the block.

Contd..
Redo
• The redo statement restarts the current iteration of a loop or iterator.
• The redo will return the control back to the top of the loop or block so
the iteration can start over.
• It does not reset the loop condition and it does not fetch the next
element from an iterator. Its not normally used statement.
i=0
while(i<3)
print i
i+=1
redo if i==3
end

5 Statements and Control Structures

More Related Content

What's hot (20)

Similar to 5 Statements and Control Structures (20)

More from Deepak Hagadur Bheemaraju (8)

Recently uploaded (20)

5 Statements and Control Structures