It might be almost similar but relatively different in a big way for blocks may appear only in the source adjacent to a method call which means it should be written on the same line as the method’s last parameter and it is not implemented once it is encountered but, Ruby rather remembers the context by which the block of code appears then enters the method. Within the method itself, the block of code may be called as if it were a block in itself by using the ‘yield’ statement. After the block of code has been executed, control returns immediately right after the call to the yield statement. Sample use of ‘yield’:

def threeTimes
yield
yield
yield
end
threeTimes {puts “Hi There”}

The above code giving the output:
Hi There
Hi There
Hi There

The code between the curly braces is associated to the method threeTimes and within that ‘yield is called three times in succession, each time calling the code contained within the block giving the three greeting statements. We will discuss the concepts behind the ‘yield’ statement in the next posts as we continue to build-up up our skills.

As stated in the past post, we aim to simplify further the code we have just created with the following shorter version of the same program.

class BookList
def [](key)
if key.kind_of?(integer)
result = @Books[key]
else
result = @Books.find { |aBooks| key == sBooks.name}
end
return result
end
end

Further shortening the code we have above by using the ‘if’ statement as a modifier it becomes a shorter version of its former self as:

class Booklist
def [](key)
return @Books[key] if key.kind_of?(Integer)
return @Books.find { |aBooks| aBooks.name == key }
end
end

The use of the ‘find’ command in Ruby is simply a call to a function that is executed and it can be compared to a block call in many other languages such as Perl, C++ or Java.

We now go through a process which implements the code on the [] method we just showed where we will take a string, searches for the book with the same title. The method would go through the whole table one at a time to get a match as shown with the following:

class BookList
def [](key)
if key.kind_of?(integer)
return @Books[key]
else
for C in 0…@Books.length
return @Books[i] if key == @Book[i].name
end
end
return nil
end
end

The above method is a bit too close for comfort for it asks the array which one is a match and does so while going through each and every member of the list. The find method shown below is faster and easier and more natural to do this by simply using the find command shown in the next post.

We now check if the book titles are deleted from the first and end of the list which should give us ‘nil’ when and if the list becomes void of contents.

list.deleteFirst >> Books: ABDC–Author1 (1)
list.deleteFirst >> Books: EFGH–Author2 (2)
list.deleteLast >> Books: MNOP–Author1 (1)
list.deleteLast >> Books: IJKL–Author3 (3)
list.deleteLast >> nil

We now include the use of the square brackets which allows us to acces the specific elements by the index instead of having to define each item specifically.

class BookList
def[](key)
if key.kind_of?(Integer)
@Books[key]
else
# …
end
end
end

Testing the code is also very straightforward:

list[0] >> Books: ABCD — Author1 (1)
list[2] >> Books: IJKL — Author (3)
list[9] >> nil

The next posts will add more functions and operators to further simplify our code making it shorter and making you more familiar with the syntax of Ruby.

Using the append command/method, we can add an element to the end of the table which in turn returns a reference to the current BookList object.The deleteFirst and deleteLast command allows us to delete the first and last records respectively in the following form/s:

For Append:
class BookList
def append(aBook)
@books.push(aBook)
self
end
end

For deleteFirst and deleteLast

class BookList
def deleteFirts
@books.shift
end
def deleteLast
@books.pop
end
end

Now we test the code we have just created to show if the right operations are being performed and if we are getting the results we desire:

list = BookList.new
list.
append(Books.new(‘ABCD’, ‘Author1′,1)).
append(Books.new(‘EFGH’, ‘Author2′,2)).
append(Books.new(‘IJKL’, ‘Author3′,3)).
append(Books.new(‘MNOP’, ‘Author4′,4))

In the next posts, we get to check and simplify the code we have just executed.

Below, we find sample code which uses block to return the values of the Fibonacci number Series.

def fibMax(max)
a1, a2 =1,1 # variables that are assigned parallel values
while a1 <= max
yield a1
a1, a2 = a2, a1+a2
end
end
fibMax(1000) {|f| print f, ” “}

The above code gives us the value of the Fibonacci series numbers till the number 1000 which is the set maximum number to reach.

Sample Code Output:
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

The above example shows how the block(chunk of code) processed the Fibonacci Series of numbers, returning only those that fell within the set limit of 1000.

To initialize a container we will do the same steps showing code to support the things that have to be done. We create a table where we can add elements to the contents delete objects from either the beginning or the last entries and display an entry using the index or content on the index. We initialize/create the array with the following syntax:

class BookList
def initialize
@books = Array.new
end
end

We now have a table of book titles to which to add, delete and move data from. In the next post we will use the ‘append’ command to input data into the container we have just created.