ruby programming

RUBY PROGRAMMING

Course # TE3601 Rev. 3/25/2013

RUBY PROGRAMMING

2013 /training/etc Inc. REPRODUCTION OF THESE MATERIALS IS PROHIBITED. i

7150 Riverwood Drive, Suite J

Columbia, MD 21046 Tel: 410-290-8383

Fax: 410-290-9427 http://www.trainingetc.com

email: [email protected]

RUBY PROGRAMMING

Course # TE3601 Rev. 3/25/2013

RUBY PROGRAMMING

2013 /training/etc Inc. REPRODUCTION OF THESE MATERIALS IS PROHIBITED. ii

This Page Intentionally Left Blank

RUBY PROGRAMMING

2013 /training/etc Inc. REPRODUCTION OF THESE MATERIALS IS PROHIBITED. iii

Course Objectives

At the conclusion of this course, students will be able to: Distinguish and use various Ruby datatypes Master the use of arrays and hashes Build home grown classes Use the extensive pre bundled classes Use the I/O facilities of Ruby to read and write binary and text

files

Master the use of Iterators to loop through various data structures

Use Exceptions in handling various run time errors Create Ruby modules Use the wide variety of Ruby Modules that come with the Ruby

distribution

RUBY PROGRAMMING

2013 /training/etc Inc. REPRODUCTION OF THESE MATERIALS IS PROHIBITED. iv


RUBY PROGRAMMING

2013 /training/etc Inc. REPRODUCTION OF THESE MATERIALS IS PROHIBITED. v

Table of Contents

CHAPTER 1: AN INTRODUCTION TO RUBY What is Ruby? .............................................................................................. 1-2 Installing Ruby .............................................................................................. 1-3 Executing Ruby Code ................................................................................... 1-4 Getting Help.................................................................................................. 1-6 Dynamic Types ............................................................................................. 1-9 Ruby Reserved Words................................................................................ 1-10 Naming Conventions .................................................................................. 1-11 Comments .................................................................................................. 1-12

CHAPTER 2: STANDARD RUBY DATA TYPES Numbers ....................................................................................................... 2-2 Strings .......................................................................................................... 2-3 Simple Input and Output ............................................................................... 2-9 Converting String Input ............................................................................... 2-10 Regular Expressions................................................................................... 2-11 Time Methods............................................................................................. 2-14

CHAPTER 3: LANGUAGE COMPONENTS The if Statement......................................................................................... 3-2 The Logical Operators .................................................................................. 3-3 The case Construct...................................................................................... 3-4 Loops............................................................................................................ 3-5 Iterators ........................................................................................................ 3-9 Numeric Iterators ........................................................................................ 3-10 String Iterators ............................................................................................ 3-13 Methods...................................................................................................... 3-16 Odds and Ends........................................................................................... 3-18

CHAPTER 4: COLLECTIONS Arrays ........................................................................................................... 4-2 Array Operator Methods ............................................................................... 4-5 Array Equality Operator ................................................................................ 4-9 Arrays as Stacks and Queues .................................................................... 4-10 Higher Dimensional Arrays ......................................................................... 4-11 Other Useful Arrays Methods...................................................................... 4-12 Command Line Arguments ......................................................................... 4-13 Hashes ....................................................................................................... 4-14 Common Hash Methods ............................................................................. 4-17 Sorting Hashes ........................................................................................... 4-18 Iterators with Arrays and Hashes................................................................ 4-20 Arrays and Methods.................................................................................... 4-21 Hashes and Methods.................................................................................. 4-22 Named Parameters..................................................................................... 4-23 Symbols...................................................................................................... 4-24

RUBY PROGRAMMING

2013 /training/etc Inc. REPRODUCTION OF THESE MATERIALS IS PROHIBITED. vi

Procs .......................................................................................................... 4-26 Closures ..................................................................................................... 4-28

CHAPTER 5: CLASSES Objects ......................................................................................................... 5-2 Brief History of OOP ..................................................................................... 5-3 OOP Vocabulary........................................................................................... 5-4 Creating a New Class ................................................................................... 5-6 Using Objects ............................................................................................... 5-8 Defining Operator Methods......................................................................... 5-13 Inheritance.................................................................................................. 5-14 Ancestors.................................................................................................... 5-18 self ........................................................................................................... 5-20 Access Levels - public............................................................................. 5-23 Access Levels private.......................................................................... 5-25 Access Levels - protected ...................................................................... 5-26 Access Levels - Specification ..................................................................... 5-27 Class Data and Class Methods................................................................... 5-28 Adding Methods to Classes and Objects .................................................... 5-30 Special Global Variables............................................................................. 5-31 Scope of Variables...................................................................................... 5-32 Built-in Classes ........................................................................................... 5-33 The Math Class.......................................................................................... 5-34 The NilClass Class ................................................................................. 5-35 TrueClass and FalseClass ................................................................... 5-36 Built-in Class Hierarchy .............................................................................. 5-37

CHAPTER 6: INPUT AND OUTPUT Introduction................................................................................................... 6-2 Reading from the Standard Input.................................................................. 6-3 Writing to the Standard Output ..................................................................... 6-7 Reading and Writing Disk Files..................................................................... 6-8 Reading Files Using Iterators...................................................................... 6-10 I/O With Command Line Commands .......................................................... 6-12 Seeking About Files.................................................................................... 6-13 tell ........................................................................................................... 6-16 Capturing Data About Files......................................................................... 6-17 Processing Directories................................................................................ 6-18

CHAPTER 7: EXCEPTIONS Introduction................................................................................................... 7-2 Exception Hierarchy...................................................................................... 7-3 Handling Exceptions ..................................................................................... 7-4 Multiple Rescue Clauses .............................................................................. 7-7 Exceptions are Classes ................................................................................ 7-8 ensure......................................................................................................... 7-9 retry ......................................................................................................... 7-10

RUBY PROGRAMMING

2013 /training/etc Inc. REPRODUCTION OF THESE MATERIALS IS PROHIBITED. vii

raise ......................................................................................................... 7-11 Creating Your Own Exceptions................................................................... 7-13 catch and throw ...................................................................................... 7-14

CHAPTER 8: MODULES Introduction................................................................................................... 8-2 Using Core Ruby Classes............................................................................. 8-3 Ruby Standard Library.................................................................................. 8-5 require....................................................................................................... 8-6 Search Path.................................................................................................. 8-8 File Organization........................................................................................... 8-9 load ........................................................................................................... 8-12 Modules ...................................................................................................... 8-13 include..................................................................................................... 8-16 Mixins ......................................................................................................... 8-17 Using the Comparable Module ................................................................. 8-20 Collection Classes ...................................................................................... 8-22 yield ......................................................................................................... 8-23 Using the Enumerable Module.................................................................... 8-26

CHAPTER 9: ODDS AND ENDS Ruby Conventions ........................................................................................ 9-2 Bit Manipulation ............................................................................................ 9-5 Substituting................................................................................................... 9-8 Marshalling ................................................................................................... 9-9 Reflection.................................................................................................... 9-11 grep ........................................................................................................... 9-12 Classes are Objects.................................................................................... 9-13 Aliasing ....................................................................................................... 9-15 Testing........................................................................................................ 9-16 Test::Unit::TestCase......................................................................... 9-17 Testing Your Own Classes ......................................................................... 9-22 Freezing Objects......................................................................................... 9-24 Object Equality............................................................................................ 9-26

RUBY PROGRAMMING

2013 /training/etc Inc. REPRODUCTION OF THESE MATERIALS IS PROHIBITED. viii


RUBY PROGRAMMING CHAPTER 1: AN INTRODUCTION TO RUBY

2013 /training/etc Inc. REPRODUCTION OF THESE MATERIALS IS PROHIBITED. 1-1

Chapter 1: An Introduction to Ruby

1) What is Ruby?.......................................................................................................... 1-2

2) Installing Ruby......................................................................................................... 1-3

3) Executing Ruby Code .............................................................................................. 1-4

4) Getting Help ............................................................................................................. 1-6

5) Dynamic Types ......................................................................................................... 1-9

6) Ruby Reserved Words........................................................................................... 1-10

7) Naming Conventions.............................................................................................. 1-11

8) Comments ............................................................................................................... 1-12



What is Ruby?

In the mid 1990's, the Ruby programming language surfaced in Japan, the home of Ruby's creator, Yukihiro Matsumoto.

He is usually referred to as Matz.

Matz knew Python and Perl and thought that each of those languages left something to be desired.

In particular, he did not like that both Perl and Python were not fully object oriented.

Since that time, Python has become fully object oriented. Ruby is often compared to Python and Perl, and each language

community has their own arguments as to why their language is better.

Ruby has the following technical characteristics. Interpreted rather than compiled Dynamic typing rather than static typing Completely object oriented.

Like other languages, Ruby has undergone various revisions.

Version 1.9.3 was released in October of 2011. Version 2.0.0 was released in February of 2013.

All things concerning Ruby can be located at: http://www.ruby-lang.org/en



Installing Ruby

Instructions for downloading and installing Ruby can be found at the following URL.

http://www.ruby-lang.org/en/downloads/

Versions of Ruby are available for download for many different operating systems including:

Linux Windows Mac OS X

There are three ways of installing Ruby. Each of the following techniques is explained in more detail at

the URL listed above.

Compiling from source Package management systems Third party tools

One of the more popular tools for installing Ruby in a Linux or

Mac OS X environment is the Ruby Version Manager (RVM).

RubyInstaller is an application that can be used to easily install Ruby in a Windows environment.

RailsInstaller can be used if both Ruby and Rails are to be used in a Windows environment.

One major benefit of the third party tools is the ability to have different versions of Ruby installed side-by-side on the same computer.

It is for this reason that RVM has been chosen to install Ruby version 1.9.3 on the Linux machines in the classroom.



Executing Ruby Code

Since we will be using Linux here, all of the examples will demonstrate executing programs in a Linux environment.

To execute a Ruby program from the command line, we will first create an .rb file with your favorite text editor.

Although not required, the .rb file extension is the industry standard for files containing Ruby code.

example1.rb

1. #!/usr/bin/ruby 2. puts "This text is output to the screen when run"

Once the file is created, how it is executed depends upon the operating system being used.

In a Linux / Mac OS X environment, the first line of the file usually contains the path to the Ruby interpreter.

Although not necessary in a Windows environment, it is often used for cases when code developed in a Windows environment might be run in a different environment.

In a Linux / Mac OS X environment, the file can be made executable with the following command.

chmod 755 example1.rb

It can then simply be run with the following command. example1.rb

Alternatively, the script can be run on all platforms without the need to make it executable with the following command.

ruby example1.rb



Executing Ruby Code

The execution and output of the script on the previous page is shown below.

student@localhost:~/rubylabs/examples/1 $ ruby example1.rb This text is output to the screen when run $

Another way in which Ruby code can be executed is using the interactive Ruby utility named irb.

This tool (like many others) is automatically included when installing Ruby using third party tools.

Package management systems may require additional packages to be installed for all the tools to become available.

The irb utility is demonstrated below. Sample Ruby code, shown in bold below, is typed interactively

during the running of the irb session.

Typing exit will terminate the irb session. student@localhost:~/rubylabs/examples/1

$ irb 1.9.3p392 :001 > 2 + 2 => 4 1.9.3p392 :002 > puts "Hello" Hello => nil 1.9.3p392 :003 > "Hello".reverse => "olleH" 1.9.3p392 :004 > x = "Hello" => "Hello" 1.9.3p392 :005 > puts x Hello => nil 1.9.3p392 :006 > exit $

Each statement entered is executed, and the results are

displayed on the console. Some statements have the result of nil, the Ruby version of Python's None.



Getting Help

There are various ways in which a Ruby programmer can get help with the Ruby language.

A good starting point is the following URL. http://www.ruby-lang.org/en/documentation/

As shown above, there are links to navigate to places specific

to the various help topics.

The reference links listed below may be worth bookmarking in your browser for easy reference.

The Ruby Core Reference http://www.ruby-doc.org/core-1.9.3

The Ruby Standard Library Reference

http://www.ruby-doc.org/stdlib-1.9.3/



Getting Help

Another tool for getting help in Ruby is the Ruby Index (ri) command line tool.

The ri tool can be used to view the Ruby documentation off-line.

A closely related tool to ri is Ruby Documentation (RDoc).

RDoc is a documentation system that creates nicely formatted documentation from commented source files.

It is available through the rdoc command line tool. ri is used to display the information generated by rdoc from

the Ruby source files.

The documentation that is displayed is in the format of Unix/Linux man pages.,

The following example shows how to display documentation for the String.

student@localhost:~/rubylabs/examples/1

$ ri String $


= String < Object

------------------------------------------------------------------------------

= Includes: Comparable (from ruby site)

(from ruby site) ------------------------------------------------------------------------------

A String object holds and manipulates an arbitrary sequence of bytes, typically representing characters. String objects may be created using String::new or as literals.

Typing the letter q will quit out of the documentation.



Getting Help

The example below demonstrates how to get more specific information, like the length method of the String class.


$ ri String.length $


= String.length

(from ruby site) ------------------------------------------------------------------------------

str.length -> integer str.size -> integer

------------------------------------------------------------------------------

Returns the character length of str.

The RDoc files created during the installation of Ruby by RVM can be found at the following location on your hard drive. /home/student/.rvm/docs/ruby-1.9.3-p392/rdoc/index.html

The format of the HTML files located in the rdoc directory

listed above is similar, but not identical, to those found in the online documentation files for Ruby, specified earlier.



Dynamic Types

With the Ruby environment in place, the following program demonstrates the dynamic type system of the Ruby language.

Ruby programmers do not define the type of a variable. Its type varies with the data that it holds. The class method can be used to determine the type of the

object being referenced by the variable. class.rb

1. #!/usr/bin/ruby 2. w = "Hello" 3. x = 123 4. y = 249.35 5. z = true 6. puts w.class, x.class, y.class, z.class


$ruby class.rb String Fixnum Float TrueClass $

Note that each of the following will yield the data type of Class.

Fixnum.class String.class

You can also make a test to determine the class of a variable. x = 123 if ( x.class == Fixnum ) puts "It's an integer" end



Ruby Reserved Words

Several words we have seen are used for special purposes in the Ruby language.

These words are reserved and cannot be used as the names of variables or methods within your code.

The list of reserved words is shown below.

Ruby Reserved Words BEGIN class in super

END def module then

__ENCODING__ defined? next true

__END__ do nil undef

__FILE__ else not unless

__LINE__ elsif or until

alias end redo when

and ensure rescue while

begin false retry yield

break for return

case if self

Only a few of these reserved words have been used in the examples so far.

The majority of them will be explained as we proceed through the course.



Naming Conventions

Ruby is a case sensitive language. It means that name and Name are two different identifiers.

Identifiers in Ruby can be created from alphanumeric characters and the underscore (_) character.

An identifier cannot begin with a number.

Ruby enforces some naming conventions. If an identifier starts with a capital letter, it is a constant. If it starts with a dollar sign ($), it is a global variable. If it starts with @, it is an instance variable. If it starts with @@, it is a class variable.



Comments

A comment in Ruby starts with # and continues to the end of the line.

There are several comments in the code below. comments.rb

1. #!/usr/bin/ruby 2. # This program contains several comments 3. x = 10 # a Fixnum 4. y = "Hello There" # a String 5. z = "# This is NOT a comment"

When the above program is executed from the command

line, the shell will interpret the first line of the program and use the shebang to find the Ruby interpreter and run the script.

Otherwise, the Ruby interpreter will treat the first line as a Ruby comment just like the others in the file.

A multi-line or block comment can be used as follows. block.rb

1. #!/usr/bin/ruby 2. puts "Before" 3. =begin 4. This next line is not executed 5. puts "Inside of begin/end block 6. =end 7. puts "After"

The output from the above program is shown below.

Before After

Any lines between the =begin and the =end are not

executed by the Ruby interpreter.



Exercises

1. Start the irb command line tool and experiment with some Ruby expressions.

2. Use the ri command line tool to get information for the Fixnum datatype.

Next, use the ri tool again to get specific information about one of the instance methods listed in the documentation for Fixnum.

3. Locate the RDoc documenation for the Fixnum class in the local documentation.

Recall that local Ruby documentation can be found at: /home/student/.rvm/docs/ruby-1.9.3-p392/rdoc

4. Locate the online documentation for the Fixnum class.

Recall that the online Ruby Core Reference can be found at: http://www.ruby-doc.org/core-1.9.3/

5. Create a file named first.rb in the following directory.

/home/student/rubylabs/exercises/1 In that file, assign values to several variables. Perform a few operations with them. Print the values of the variables.

RUBY PROGRAMMING CHAPTER 2: STANDARD RUBY DATA TYPES


Chapter 2: Standard Ruby Data Types

1) Numbers.................................................................................................................... 2-2

2) Strings ....................................................................................................................... 2-3

3) Simple Input and Output ........................................................................................ 2-9

4) Converting String Input ........................................................................................ 2-10

5) Regular Expressions .............................................................................................. 2-11

6) Time Methods......................................................................................................... 2-14



Numbers

Ruby provides a number of built-in number classes. We will explore some of the more commonly used classes.

The Integer class is the basis for the two classes Fixnum and Bignum.

A Fixnum holds Integer values that can be represented natively.

If any operation on a Fixnum exceeds this range, the value is automatically converted to a Bignum.

The Float class represents inexact real numbers using the native architecture's double-precision floating point representation.

Almost all applications will involve some degree of integer and floating point arithmetic.

Ruby's Arithmetic Operators are shown in the table below. Operator Name Description

+ Addition Adds values on either side of the operator

- Subtraction Subtracts right operand from left operand

* Multiplication Multiplies values on either side of the operator

/ Division Divides left operand by right operand

% Modulus Divides left operand by right operand and returns remainder

** Exponent Performs exponential (power) calculation on operators



Strings

A string is a collection of zero or more characters. Support for strings is available in Ruby from the built-in String

class.

A String object holds and manipulates an arbitrary sequence of bytes, typically representing characters.

Users of strings should be aware of the methods that modify the contents of a String object.

Typically, methods with names ending in "!" modify their receiver.

Methods without a "!" typically return a new String.

Strings can be delimited using either double quotes (") or single quotes (').

The double quotes are designed to interpret escaped characters such as new lines and tabs so that they appear as actual new lines and tabs when the string is rendered for the user.

Single quotes, however, display the actual escape sequence (for example displaying \n instead of a new line).

The program on the following page demonstrates the difference between single and double quoted literal strings.



Strings quotes.rb

1. #!/usr/bin/ruby 2. s1 = "0 \t 1 \t 2 \t 3 \t 4 \n5 \t 6 \t 7 \t 8 \t 9" 3. s2 = '0 \t 1 \t 2 \t 3 \t 4 \n5 \t 6 \t 7 \t 8 \t 9' 4. puts "A double quoted String:" 5. puts s1 6. puts 7. puts "A single quoted String:" 8. puts s2


A double quoted String: 0 1 2 3 4 5 6 7 8 9

A single quoted String: 0 \t 1 \t 2 \t 3 \t 4 \n5 \t 6 \t 7 \t 8 \t 9

You can substitute the value of any Ruby expression into a double quoted string using the sequence #{} as demonstrated in the program below.

interpolation.rb

1. #!/usr/bin/ruby 2. x = 10 3. y = 20 4. puts "x = #{x} and y = #{y}" 5. puts "x + y = #{x + y}"


x = 10 and y = 20 x + y = 30

If single quotes were used in the code, the expressions

would not have been evaluated.



Strings

Several methods in the String class are shown below. strings.rb

1. #!/usr/bin/ruby 2. text = "this is some text" 3. puts "The original text is: " + text 4. puts "The length of the text is #{text.length}" 5. puts "Capitalized: " + text.capitalize 6. puts "Upper Case: " + text.upcase 7. puts "Reversed: " + text.reverse 8. puts "Hello " * 5


The original text is: this is some text The length of the text is 17 Capitalized: This is some text Upper Case: THIS IS SOME TEXT Reversed: txet emos si siht Hello Hello Hello Hello Hello

The String class also has a split method, which returns an array of strings based on the supplied delimiter.

splitting.rb

1. #!/usr/bin/ruby 2. text = "this,is,comma,separated" 3. result = text.split(",") 4. puts result


this is comma separated

Arrays will be covered in detail in a later chapter.



Strings

Strings are references, so even though assignment is simple, be aware of the following.

string_reference.rb

1. #!/usr/bin/ruby 2. message = "This is a string" 3. text = message 4. text.upcase! 5. puts message, text


THIS IS A STRING THIS IS A STRING

If you truly want a separate string, you can use the dup method as shown below.

string_dup.rb

1. #!/usr/bin/ruby 2. message = "This is a string" 3. text = message.dup 4. text.upcase! 5. puts message, text


This is a string THIS IS A STRING

The next page discusses some of the more common String methods.



Strings

The following two methods return the zero based position of one string within the "host" string.

index returns the left-most position. rindex returns the right-most position.

The special value of nil is returned by both methods if the host string does not contain the string.

indexes.rb

1. #!/usr/bin/ruby 2. txt = "More than 10 years ago"; 3. puts "Left a : #{txt.index("a")}" 4. puts "Middle a from Left: #{txt.index('a', 4)}" 5. puts "Right a: #{txt.rindex('a')}" 6. puts "Middle a from Right: #{txt.rindex('a', -9)}"


Left a : 7 Middle a from Left: 7 Right a: 19 Middle a from Right: 7

Stripping whitespace from a String can be done with the following methods.

strip and strip! Removes leading and trailing whitespace

lstrip and lstrip! Removes leading whitespace

rstrip and rstrip! Removes trailing whitespace



Strings

A string can also be accessed in whole or in parts using the element reference operator [] (square brackets).

As we will see later in the course, this operator (like most operators in Ruby) is implemented as a method of the data type.

The example below demonstrates the versatility embedded within the [] operator.

elements.rb

1. #!/usr/bin/ruby 2. s = "this is an example string" 3. puts s[0] # t in Ruby 1.9.x 4. # 116 in prior versions of Ruby 5. puts s[0].chr # t in all versions of Ruby 6. puts s[5,7] # start at pos 5 and get 7 chars 7. puts s[-6,3] # start 6 from the right end 8. s[0,0] = "Hello" #insert at position 9. puts s 10. 11. #start at position 0 replace 15 chars with something 12. s[0,15] = "something" 13. puts s


t t is an e str Hellothis is an example string something example string



Simple Input and Output

Below is a small program that illustrates how a program might get some simple input from a user.

input.rb

1. #!/usr/bin/ruby 2. print "Enter a line: " 3. line = gets 4. puts line.class, line.length


Enter a line: Michael String 8

There are a few things to notice about the program. The gets method gets a single line from the user.

The line contains the newline character. The returned data is of type String.

The puts method outputs data to the display.

print is like puts except that it does not display a newline.

If you wished to do some arithmetic with a line obtained with gets, you would have to convert the line to either an integer or a float.

The following methods are widely used in Ruby programs. to_i converts to integer to_f converts to float to_s converts to String



Converting String Input

A few conversion methods are shown below. convert.rb

1. #!/usr/bin/ruby 2. print "Enter a line: " 3. line = gets.chop 4. sum = line.to_i + line.to_i 5. puts line + " plus " + line + " is " + sum.to_s


Enter a line: 10 10 plus 10 is 20

The chop method removes the last character of a string. There is a similar method named chomp that removes the last

character of a string only if it is a newline character.

The to_i method will work fine for integer input but will truncate string or floating point data.

The + method is used to concatenate two strings. The to_s method may be needed to convert data to string data

before it is concatenated.

Below is a simplified version of the puts (or print) method, using interpolation.

puts "#{line} plus #{line} is #{sum}"



Regular Expressions

Often, a program needs to determine if a string matches a certain pattern.

Is it all digits? Is it all alphabetic? Is it an email address?

Modern programming languages deal with these problems by using regular expressions.

A regular expression is a way of representing a pattern by using special symbols.

Once a regular expression has been encoded, it is used to determine if a string matches the pattern expressed by the regular expression.

The regular expression matching operator is =~. A test to determine if a string matches a pattern might look like

this.

if string =~ /PATTERN/ do something end

A few of the special symbols used by Ruby in the formulation of regular expressions are shown on the next page.



Regular Expressions

The following characters are used to anchor the pattern. Symbol Meaning Example

^ At the beginning /^the/

$ at the end /the$/

Here is a simple example. regex1.rb

1. #!/usr/bin/ruby 2. puts "Please enter some text:" 3. line = gets.chomp 4. 5. result = line =~ /^the/ 6. print "result data type: ", result.class, "\n" 7. print "result value: ", result, "\n" 8. 9. result = "ends with the" =~ /the$/ 10. print "result data type: ", result.class, "\n" 11. print "result value: ", result, "\n"


Please enter some text: hello result data type: NilClass result value: result data type: Fixnum result value: 10

You can use the i character at the end of the pattern to ignore the case.

line =~ /^the/i



Regular Expressions

Other special symbols used to match patterns appear in the following table.

Symbol Meaning Example . Any character /A.B/ [ ] Alternatives /s[uoi]n/ \w Letter or digit / \w\w / \s Whitespace character /^\w\w\s/ \d Digit character / \d\d /

{m,n} m through n reps of preceding char /A{2,4}B/ ? Zero or one of preceding char /^[+-]?/ * Zero or more of preceding char /A.*B/ + One or more of preceding char /^\d+\s/



Time Methods

You can do various things with Time objects. Below is a sample program illustrating a Time object.

timestuff.rb

1. #!/usr/bin/ruby 2. d = Time.new # or Time.now 3. puts d.class 4. puts d

The output from the program is shown below:.

Time Sun Aug 15 09:57:48 -0400 2010 # UTC not GMT

As a historical side, with modern precision instruments, the

need for UTC was born. UTC stands for Coordinated Universal Time in English and

Temps universel coordonn in French. The acronym was abbreviated UTC as a compromise

between CUT and TUC in English and French, respectively.

Here are some other useful Time methods. moretime.rb

1. #!/usr/bin/ruby 2. t = Time.new 3. puts t 4. puts "DAY: #{t.day}" 5. puts "MON: #{t.month}" 6. puts "YR: #{t.year}" 7. puts "HR: #{t.hour}" 8. puts "MIN: #{t.min}" 9. puts "SEC: #{t.sec}" 10. puts "TOMORROW: #{Time.at(t + 60 * 60 * 24)}" 11. puts "USING CTIME: #{t.ctime}"



Exercises 1. Write a program that prompts the user to enter the radius

of a circle.

Accept the user input into a variable. Compute the area of the circle whose radius was input.

The formula for the area of a circle is pi times the square of the radius.

Use 3.14159 for pi. 2. Write a program that prompts the user for a string and a

number on separate lines.

The program should print the string replicated by the number. For example, if the string is "sample" and the number is 3,

then samplesamplesample should be printed. 3. Write a program that prompts the user for two numbers.

The first number will be the base. The second number will be the exponent. Print the result of raising the base to the exponent.

4. Write a program that accepts a string from the user.

Print the following about the string. Print the length of the string. Print the first five characters of the string. Look for and print the result of calling the method in the

String class that will convert the string to lower case.

RUBY PROGRAMMING CHAPTER 3: LANGUAGE COMPONENTS


Chapter 3: Language Components

1) The if Statement..................................................................................................... 3-2

2) The Logical Operators............................................................................................. 3-3

3) The case Construct ................................................................................................ 3-4

4) Loops ......................................................................................................................... 3-5

5) Iterators .................................................................................................................... 3-9

6) Numeric Iterators................................................................................................... 3-10

7) String Iterators....................................................................................................... 3-13

8) Methods................................................................................................................... 3-16

9) Odds and Ends ....................................................................................................... 3-18



The if Statement

Ruby has a rich set of control flow constructs, each of which typically uses a relational operator.

Operator Meaning == Equal != Not equal > Greater than < Less than >= Greater than or equal to



The Logical Operators

There are many cases where a compound condition must be evaluated.

This is where logical operators come into play. The table below lists these logical operators.

Operator Meaning ! Logical NOT&& Logical AND|| Logical OR not Logical NOTand Logical ANDor Logical OR

Below is a program that uses both the logical || operator and the elsif construction.

elsif.rb

1. #!/usr/bin/ruby 2. print "Enter a number: " 3. grade = gets.to_i 4. if grade < 0 || grade > 100 5. puts "ILLEGAL GRADE" 6. elsif grade < 60 7. puts "You got an F" 8. elsif grade < 70 9. puts "You got a D" 10. elsif grade < 80 11. puts "You got a C" 12. elsif grade < 90 13. puts "You got a B" 14. else 15. puts "You got an A" 16. end



The case Construct

Some decision making is coded more clearly if you use a case construction rather than a series of elsifs.

case.rb

1. #!/usr/bin/ruby 2. while true 3. print "Enter a number " 4. grade = gets 5. exit if grade =~ /exit|quit/i 6. case grade.to_i 7. when 90..100 8. puts "A" 9. when 80..89 10. puts "B" 11. when 70..79 12. puts "C" 13. when 60..69 14. puts "D" 15. when 0..59 16. puts "F" 17. else 18. puts "ILLEGAL" 19. end 20. end


Enter a number 85 B Enter a number 75 C Enter a number quit

Notice that the above code also illustrates the following. Modifier form of the if statement Regular expressions



Loops

The Ruby language offers the usual set of traditional looping constructs, as well as some special looping constructs known as iterators.

The example below demonstrates use of the traditional loops. loops.rb

1. #!/usr/bin/ruby 2. print "For loop using inclusive range: " 3. for i in 0..10 4. print i, " " 5. end 6. 7. print "\nFor loop using exclusive range: " 8. for i in 0...10 9. print i, " " 10. end 11. 12. print "\nWhile loop: " 13. i = 0 14. while i < 10 15. print i , " " 16. i += 1 17. end 18. 19. print "\nUntil loop: " 20. i = 0 21. until i > 9 # executes if condition is false 22. print i , " " 23. i += 1 24. end 25. puts


For loop using inclusive range: 0 1 2 3 4 5 6 7 8 9 10 For loop using exclusive range: 0 1 2 3 4 5 6 7 8 9 While loop: 0 1 2 3 4 5 6 7 8 9 Until loop: 0 1 2 3 4 5 6 7 8 9



Loops

Loop control can be altered by using the following statements.

break break out of the loop next perform the next iteration of this loop redo perform the same iteration again

The following example demonstrates the use of the break statement within a for loop.

Any looping construct could have been used, not just a for loop.

The break at the first value of the variable i that, when squared, is greater than 500.

break.rb

1. #!/usr/bin/ruby 2. for i in 1..100 3. squared = i ** 2 4. if squared > 500 5. break 6. end 7. print "#{i}:#{squared} " 8. puts if i % 5 == 0 # modifier form of an if 9. end 10. puts


1:1 2:4 3:9 4:16 5:25 6:36 7:49 8:64 9:81 10:100 11:121 12:144 13:169 14:196 15:225 16:256 17:289 18:324 19:361 20:400 21:441 22:484



Loops

The following example demonstrates the use of the next statement within a while loop.

next.rb

1. #!/usr/bin/ruby 2. total = 0; 3. while true 4. print "Please enter an integer: " 5. text = gets.chomp 6. break if text =~ /^quit$/i 7. next if text =~ /\D/ #contains a non-digit 8. total += text.to_i 9. puts " Subtotal is #{total}" 10. end 11. puts "Total is:", total

Sample output from the program is shown below.

Please enter an integer: 10 Subtotal is 10 Please enter an integer: 20 Subtotal is 30 Please enter an integer: asdf Please enter an integer: 50 Subtotal is 80 Please enter an integer: quit Total is: 80

Note that in addition to the next statement skipping input that is not all digits, it also includes a break statement to quit out of the loop.

The example on the following page demonstrates the use of the redo statement.



Loops redo.rb

1. #!/usr/bin/ruby 2. mistakes = 0 3. for i in 1..5 4. if mistakes == 2 5. puts "Too many mistakes" 6. break 7. end 8. puts "Please type the number shown: #{i}" 9. value = gets.to_i 10. if value != i 11. mistakes += 1 12. redo 13. end 14. puts " #{i} of 5 complete" 15. end 16. puts "Congrats - no mistakes" if mistakes == 0

Sample output from the program is shown below.

Please type the number shown: 1 3 Please type the number shown: 1 1 1 of 5 complete Please type the number shown: 2 2 2 of 5 complete Please type the number shown: 3 4 Too many mistakes



Iterators

Ruby also has a large set of looping constructs called iterators.

An iterator in Ruby is a method that can invoke a block of code repeatedly.

Ruby allows both {} and do/end iterator blocks. When the body of the iterator consists of a single statement, the

{} syntax is suggested.

When the body of the iterator consists of multiple statements, the do/end syntax is preferred.

Each value that is generated by the iterator can be referenced within the block of code by assigning it to a variable inside of vertical bars |variable_name|. The variable_name is an arbitrary name assigned to the

generated value that can then be accessed by that variable name each time through the iterator.

The next few pages will demonstrate iterators. The first three examples will be iterators called on Integer

objects and consist of the times, upto, and step iterators.

Next, there will be two more examples that are called on String objects and consist of the upto and each_line iterators.



Numeric Iterators

Below is an example of the times iterator that can be called on Integer objects.

times.rb

1. #!/usr/bin/ruby 2. 5.times { print "Hello " } 3. puts 4. 5. 5.times { |value| print "Hello#{value} " } 6. puts 7. 8. text = "a" 9. 5.times do 10. puts text 11. text += "a" 12. end 13. 14. 5.times do |val| 15. print val 16. print " squared is " 17. puts val**2 18. end


Hello Hello Hello Hello Hello Hello0 Hello1 Hello2 Hello3 Hello4 a aa aaa aaaa

aaaaa

0 squared is 0 1 squared is 1 2 squared is 4 3 squared is 9 4 squared is 16



Numeric Iterators

Below is an example of the upto iterator being called on Integer objects.

upto_numeric.rb

1. #!/usr/bin/ruby 2. 1.upto(5) { print "Hello " } 3. puts 4. 5. 5.upto(10) { |value| print "#{value} " } 6. puts 7. 8. text = "a" 9. 1.upto(5) do 10. puts text 11. text += "a" 12. end 13. 14. 2.upto(4) do |val| 15. print val 16. print " squared is " 17. puts val**2 18. end


Hello Hello Hello Hello Hello 5 6 7 8 9 10 a aa aaa aaaa

aaaaa 2 squared is 4 3 squared is 9 4 squared is 16



Numeric Iterators

Below is an example of the step iterator being called on Integer objects.

step.rb

1. #!/usr/bin/ruby 2. 1.step(10) { |i| print i, " " } 3. puts 4. 5. 1.step(10,2) { |i| print i, " " } 6. puts 7. 8. 10.step(1,-1) { |i| print i, " " } 9. puts 10. 11. a = 10 12. b = 1 13. c = -2 14. a.step(b,c) do |value| 15. puts value 16. end


1 2 3 4 5 6 7 8 9 10 1 3 5 7 9 10 9 8 7 6 5 4 3 2 1 10 8 6 4 2



String Iterators

Below is an example of the upto iterator being called on String objects.

The upto iterator for strings provides a way to generate other strings.

upto_text.rb

1. #!/usr/bin/ruby 2. chars = "" 3. 'a'.upto('z') { |val| chars += val} 4. puts chars 5. chars = "" 6. "0".upto("9") { |val| chars += val} 7. puts chars 8. chars = "" 9. counter = 1 10. "aa".upto("cc") do |val| 11. chars += val 12. chars += "\n" if counter % 13 == 0 13. counter += 1 14. end 15. puts chars


abcdefghijklmnopqrstuvwxyz 0123456789 aaabacadaeafagahaiajakalam anaoapaqarasatauavawaxayaz babbbcbdbebfbgbhbibjbkblbm bnbobpbqbrbsbtbubvbwbxbybz cacbcc



String Iterators

There may be occasions when a Ruby string contains many lines (i.e., many new line characters).

The default string iterator can process such a string a line at a time.

each_strings.rb

1. #!/usr/bin/ruby 2. lines = "this\nis\na simple\r\nexample" 3. lines.each_line do | aLine | 4. aLine.chomp! 5. print aLine + " " 6. puts aLine.length 7. end 8. puts 9. 10. lines = "Hello" 11. lines.each_char do | aChar | 12. print aChar, "\t" 13. end 14. puts 15. 16. lines.each_byte do | aByte | 17. print aByte, "\t" 18. end 19. puts "\n\n" 20. 21. lines = "\u03C0" # Greek lowercase pi 22. lines.each_char do | aChar | 23. print aChar, " " 24. end 25. puts 26. 27. lines.each_byte do | aByte | 28. print aByte, " " 29. end 30. puts

The output from the program is shown on the next page.



String Iterators

The output below was generated by the application on the previous page. this 4 is 2 a simple 8 example 7

H e l l o 72 101 108 108 111

207 128

There are several things to note from the previous program. The lowercase pi character is a String of a single

character. When iterated through using the each_byte iterator, it

consisted of two bytes. The chop and chomp methods treat both a \n and \r\n as

an end of line character that is removed.



Methods

In writing software, there is often the need to write the same logic and have it operate on different data.

A sound strategy is to encapsulate the code and feed to it the data on which it will operate.

Like other languages, this is accomplished in Ruby using methods.

An example of such a method is shown next. largest.rb

1. #!/usr/bin/ruby 2. def largest(a, b, c) 3. max = a > b ? a : b 4. max = c > max ? c : max 5. return max 6. end 7. print "input 3 numbers: " 8. a,b,c = gets.split 9. puts largest(a.to_i,b.to_i,c.to_i)


input 3 numbers: 3 2 10 10

The keyword def defines a method. This is followed by the method name, which is followed by (if

there are any) a set of parameters enclosed within parentheses.

The parameters are comma-separated. The entire method is terminated with the keyword end.



Methods

Parameters are local. If they happen to coincide with the name of a variable outside

the subroutine, they refer to different places in memory.

Variables defined within a method are also local. The same named variables referenced outside of a method are

references to different places in memory.

The last evaluated expression within a function is the value returned by the function.

Therefore, the previous function could have been written without a return statement.

def largest(a, b, c) max = a > b ? a : b max = c > max ? c : max end

A method can also have default parameters. If the programmer does not supply a parameter, the default

value is used.

default.rb

1. #!/usr/bin/ruby 2. def total(first = 1, last = 10) 3. result = 0 4. first.upto(last) do | i | 5. result = result + i 6. end 7. result 8. end 9. puts total() # prints 55 10. puts total(5) # prints 45 11. puts total(10,20) # prints 165



Odds and Ends

You can execute command line commands within a Ruby script. (Be careful if not on a Unix variant!)

datetime.rb

1. #!/usr/bin/ruby 2. puts "DATE: " + `date | cut -c1-10` 3. puts "TIME: " + `date | cut -c12-16`


Date: Wed June 21 Time: 12:51

You can also execute Ruby one-liners on the command line.

For example, the following code displays the lines from file matching the pattern the.

$ ruby -ne 'puts $_ if /the/' file

When a control structure contains one line, you can write it using the modifier form.

while true print "enter number or quit " line = gets.chomp exit if line == "quit" puts line.to_i * line.to_i end



Odds and Ends

There are various ways of assigning values. Variables are just references.

x = "hello" y = x x[0] = 'M' puts y # prints Mello

You can make multiple assignments.

x = y = z = 0 You can make parallel assignments.

a = 5 b = 10 c = 20 a,b,c = c,a,b puts a # 20 puts b # 5 puts c # 10

Code can be executed when your program is being loaded by using a BEGIN block. Likewise, code can be executed after your program has terminated by using an END block.

beginend.rb

1. #!/usr/bin/ruby 2. BEGIN { 3. puts "BEGIN: " + Time.now.to_s 4. } 5. sleep 5 6. END { 7. puts "END: " + Time.now.to_s 8. }



Odds and Ends

Ruby allows the __END__ directive so that you can exclude, from execution, the bottom part of your program.

Using this directive allows you to write large portions of code, while executing all but the last so many lines.

end.rb

1. #!/usr/bin/ruby 2. puts "line1" 3. puts "line2" 4. __END__ 5. puts "line3"


line1 line2

You can place data below the __END__ line and have your program read it with the pre-opened object DATA.

data.rb

1. #!/usr/bin/ruby 2. line = DATA.gets # read one line 3. x = DATA.read # read rest of lines 4. puts "FIRST LINE: " + line 5. x.each_line { | x | puts x } 6. __END__ 7. Hello there, how are 8. you doing today?


FIRST LINE: Hello there, how are you doing today?



Exercises 1. Write a program that inputs a number.

The program should print the square of the number and whether the number is positive, negative, or zero.

2. Write a program that inputs two numbers, one per line.

The program should determine which number is larger or if they are the same.

3. Write a program that prints out the numbers from zero to some higher limit (but only if the number is divisible by 7).

The limit should be supplied interactively. 4. Write a program that reads five lines entered by the user

and displays those lines that both begin with a capital letter and end with a lower case vowel.

5. Write a program that loops over lines entered by the user.

The program should print all those lines that represent .com domain names (i.e., www.trainingetc.com).

RUBY PROGRAMMING CHAPTER 4: COLLECTIONS


Chapter 4: Collections

1) Arrays........................................................................................................................ 4-2

2) Array Operator Methods ........................................................................................ 4-5

3) Array Equality Operator ........................................................................................ 4-9

4) Arrays as Stacks and Queues................................................................................ 4-10

5) Higher Dimensional Arrays .................................................................................. 4-11

6) Other Useful Arrays Methods............................................................................... 4-12

7) Command Line Arguments................................................................................... 4-13

8) Hashes ..................................................................................................................... 4-14

9) Common Hash Methods ........................................................................................ 4-17

10) Sorting Hashes........................................................................................................ 4-18

11) Iterators with Arrays and Hashes ........................................................................ 4-20

12) Arrays and Methods .............................................................................................. 4-21

13) Hashes and Methods.............................................................................................. 4-22

14) Named Parameters................................................................................................. 4-23

15) Symbols ................................................................................................................... 4-24

16) Procs ........................................................................................................................ 4-26

17) Closures................................................................................................................... 4-28



Arrays

This section builds on some of the rudimentary ideas covered in the previous chapter.

We are mostly concerned here with two collection types, arrays and hashes.

An array is an ordered set of values, each of which can be selected by using a subscript.

The subscript essentially "measures" the distance from the beginning of where the array is stored in memory.

(see negative subscripts later!)

Arrays are dynamic, meaning their size may vary during the running of the program.

Arrays can be created as shown below. values = [ 10, 20, 30 ] # create data = %W[ 5 10 15] # create print values # 102030 puts values.length # 3

Elements can be accessed by using a subscript. Notice the first element in the array will have subscript zero. values[0] # 10 values[1] # 20 values[3] # nil values[-1] # 30

You can add to an array as shown below. values[5] = 50



Arrays

Arrays are typically processed with loops. array_with_for_loop.rb

1. #!/usr/bin/ruby 2. values = [ 10, 20, 30 ] 3. values[5] = 50 4. for value in values 5. print value, " " 6. end


10 20 30 nil nil 50

You can also process an array by using the each method. The each method is another example of a Ruby iterator.

The set of curly braces in the line below is called a block. values.each { |value| print value + " " }

If the block contains more than one statement, you can use

the do end sequence rather than the curly braces. ct = 0 values.each do |item| if item > 0 ct += 1 end end puts ct

The variable inside the 'pipe' symbols obtains, in turn, each

item in the array.

Ruby arrays have a plethora of methods defined for them. You can create an array object and give its size and default

values with the new method.



Arrays For example, the array data will have 10 items, each with a

value of 0.

vals = Array.new(10) # 10 items, each nil data = Array.new(10, 0) # 10 items, each 0 puts data.empty? # false puts data.length # 10

Sometimes, it is necessary to create an empty array. mydata = Array.new puts mydata.empty? # true puts mydata.length # 0

The join method is convenient for taking an array and creating a String from it.

Each element in the resulting string is separated with your choice of a delimiter.

This is useful when you need to print the elements of an array on a single line.

printarray.rb

1. #!/usr/bin/ruby 2. data = [ 10, 20, 30, 40 ] 3. print data 4. puts data 5. p data 6. puts data.join(" ")


1020304010 20 30 40 [10, 20, 30, 40] 10 20 30 40



Array Operator Methods

The Array class also defines many operator methods. We are referring here to operations on arrays, which are

implemented as methods but can be invoked syntactically as operators.

The first few of these operators are used to simulate (although not exactly) mathematical set operations.

& set intersection | set union - set difference

Below is an example demonstrating these operators. sets.rb

1. #!/usr/bin/ruby 2. golf = %W[Bob Mike Joe Kevin Patti] 3. tennis = %W[Bob Patti Jason John] 4. puts "Golf: #{golf.join(' ')}" 5. puts "Tennis: #{tennis.join(' ')}" 6. both = tennis & golf 7. puts "Both (Intersection): #{both.join(' ')}" 8. players = tennis | golf 9. puts "All (Union): #{players.join(' ')}" 10. diff1 = tennis - golf 11. diff2 = golf - tennis 12. puts "Tennis - NOT Golf (Diff): #{diff1.join(' ')}" 13. puts "Golf - NOT Tennis (Diff): #{diff2.join(' ')}"


Golf: Bob Mike Joe Kevin Patti Tennis: Bob Patti Jason John Both (Intersection): Bob Patti All (Union): Bob Patti Jason John Mike Joe Kevin Tennis - NOT Golf (Diff): Jason John Golf - NOT Tennis (Diff): Mike Joe Kevin




Some other array operators are shown below. *, +, [],




The + operator simply concatenates two arrays. Since this is a simple operator, the example below melds other

array methods as well.

[ ] sort size, length

concat.rb

1. #!/usr/bin/ruby 2. teachers = %W[Dave alan Mike Barb] 3. sales = Array['bonnie', "sheri"] 4. susans = ['SusanD', 'SusanS', 'SusanL'] 5. others = %W[Marvin Charles] 6. staff = teachers + sales + others + susans 7. puts staff.length 8. puts staff.size 9. puts staff.sort


11 11 Barb Charles Dave Marvin Mike SusanD SusanL SusanS alan bonnie sheri




The



Array Equality Operator

For arrays, the == operator tests to see whether respective elements of an array are equal.

This method returns one of two Boolean values, true or false.

Here is an example that exhaustively covers the possibilities.

equal.rb

1. #!/usr/bin/ruby 2. one = [1, 2, 3] 3. two = [1, 2, 3] 4. three = [1,2, 4] 5. four = [1, 2, 3, 4] 6. puts one == two 7. puts one == three 8. puts one == four 9. puts [] == []


true false false true

The last line in the code above simply compares two empty

arrays.

The idea of two objects being equal is not a simple issue. At the heart of this matter is whether two object references are

equal vs. the objects to which they refer.



Arrays as Stacks and Queues

A stack is a data structure that allows for additions and deletions at the end.

Stacks are widely used in many computer problems.

You can use an array to implement a stack. The example below demonstrates several of the available

methods.

stack.rb

1. #!/usr/bin/ruby 2. data = [] 3. puts "Push a few numbers onto an array." 4. 1.upto(5) { |number| data.push(rand(100) ) } 5. puts data 6. puts "Now pop a few of them off the array." 7. 1.upto(3) do |item| 8. puts data.pop 9. sleep(1) 10. end 11. puts data.size.to_s + " elements remain." 12. puts "Now clear the array" 13. data.clear 14. puts data.size.to_s + " elements now remain."

There is no difference between



Higher Dimensional Arrays

Ruby does not support native two-dimensional arrays, but this is not a hazard.

You can simply build an array of arrays. The example below demonstrates various techniques for

looping through a multidimensional array. twodim.rb

1. #!/usr/bin/ruby 2. a = [ [1, 2], [3, 4], [5, 6] ] 3. puts "Use an iterator." 4. a.each { | x | p x } 5. puts "Now use nested iterators." 6. a.each do |x| 7. x.each { |y| print "#{y} " } 8. puts 9. end 10. puts "Now use subscripts." 11. i = 0 12. while ( i < a.length ) 13. j = 0; 14. while ( j < a[i].length ) 15. print "#{a[i][j]} " 16. j += 1 17. end 18. puts 19. i += 1 20. end

An array's flatten method can be used to extract all elements into a simple array.



Other Useful Arrays Methods

Other useful array methods are shown below. array_others.rb

1. #!/usr/bin/ruby 2. vals = [] 3. n = "\n" 4. 0.upto(10) {|i| vals[i] = rand(10)} 5. print "Values: ", vals.inspect, n 6. print "Unique Values: ", vals.uniq.inspect, n 7. print "Index of 4 from left: ", vals.index(4), n 8. print "Index of 4 from right: ", vals.rindex(4), n 9. print "Index NOT in the array: ", vals.index(30), n 10. print "Remove all occurrences of element: ", \ 11. vals.delete(4), n 12. print "Values after deletion: ", vals.inspect, n 13. print "Remove element from given index: ", \ 14. vals.delete_at(5), n 15. print "Values after deletion: ", vals.inspect, n 16. print "Insert into position 7 a value of 99: ", \ 17. vals.insert(7, 99).inspect, n 18. print "Values after insert: ", vals.inspect, n 19. print "Results of each_with_index:\n" 20. vals.each_with_index {|val, i| print "#{i}:#{val} "}

The output from the above program is shown below. Values: [8, 0, 5, 7, 1, 3, 0, 0, 7, 6, 1] Unique Values: [8, 0, 5, 7, 1, 3, 6] Index of 4 from left: nil Index of 4 from right: nil Index NOT in the array: nil Remove all occurrences of element: nil Values after deletion: [8, 0, 5, 7, 1, 3, 0, 0, 7, 6, 1] Remove element from given index: 3 Values after deletion: [8, 0, 5, 7, 1, 0, 0, 7, 6, 1] Insert into position 7 a value of 99: [8, 0, 5, 7, 1, 0, 0, 99, 7, 6, 1] Values after insert: [8, 0, 5, 7, 1, 0, 0, 99, 7, 6, 1] Results of each_with_index: 0:8 1:0 2:5 3:7 4:1 5:0 6:0 7:99 8:7 9:6 10:1



Command Line Arguments

Ruby has a built-in array named ARGV, which represents the arguments passed to the command from the command line.

This array does not include the command name.

Below is a simple program that displays the sum of the integers between the two arguments given on the command line.

sumfrom.rb

1. #!/usr/bin/ruby 2. if ARGV.length != 2 3. puts "Usage sumfrom.rb low high" 4. exit 1 5. end 6. low = ARGV[0].to_i 7. high = ARGV[1].to_i 8. sum = 0 9. low.upto(high) { | i | sum += i } 10. puts sum


$ sumfrom.rb usage: sumfrom.rb low high $ sumfrom.rb 1 10 55 $ sumfrom.rb 10 20 165

Most of the code above is self-explanatory. The strings from the command line need to be converted to

integers in order to compute with them.



Hashes

There are a many problems where software solutions involve paired data.

Arrays are not sufficient to handle these particular problems.

A hash solves this problem. A hash is a data structure of unordered pairs. Each pair consists of a key and a value. The key is used to fetch the value.

A hash effectively saves you the cost of a lookup. The following example demonstrates the use of a hash.

hash.rb

1. #!/usr/bin/ruby 2. caps = { 3. "Maryland" => "Annapolis", 4. "Virginia" => "Richmond", 5. "New Jersey" => "Trenton", 6. "Massachusetts" => "Boston" 7. } 8. while true 9. print "Enter a State " 10. st = gets.chop 11. next if st.length == 0 12. break if st == "quit" 13. if caps.has_key?(st) 14. puts "#{caps[st]} is capitol of #{st}" 15. else 16. puts "No such state as #{st}." 17. end 18. end



Hashes

The code from the previous example is discussed below in detail.

The code contains a hash of four pairs. The states are the keys and the capitols are the values. caps = { "Maryland" => "Annapolis", "Virginia" => "Richmond", "New Jersey" => "Trenton", "Massachusetts" => "Boston" }

If the length of the text from the user is the empty string, the

next iteration of the while loop will be executed.

next if st.length == 0 If the length of the text was not the empty string it is then

checked to see if the user wants to quit from the loop.

break if st == "quit" Next, we see whether this particular key is in the hash.

if caps.has_key?(st) puts "#{caps[st]} is capitol of #{st}" else puts "No such state as #{st}." end

If the key is present, we display the value for that key.

puts "#{caps[st]} is capitol of #{st}"



Hashes

Although the situation varies according to the problem, hashes are often built dynamically during the running of the program, rather than being initialized as in the previous program.

In the program that follows, name value pairs are entered at the program prompt, read by the program, and stored in a hash.

bank.rb

1. #!/usr/bin/ruby 2. bank = Hash.new(0) 3. while true 4. print "Enter name and amount of deposit: " 5. line = gets.chop 6. name, deposit = line.split 7. break if name == "quit" 8. bank[name] += deposit.to_i 9. end 10. bank.each { |n, v| puts "#{n}\t#{v}" }

Note that hash keys are unique, so in the following sequence, the value 10 will be printed.

bank['mike'] += 3 bank['mike'] += 4 bank['mike'] += 3 puts bank['mike'] The program above splits each line into two fields and then

adds the value in the second field to the value part of the pair whose key is given in the first field.



Common Hash Methods

Here are the most common methods used in connection with hashes.

Create an empty hash. caps = Hash.new

Create an empty hash with a default value for unseen keys. caps = Hash.new("Empty")

Access the keys. caps.each_key do | key | puts key end

Access the values. caps.each_value { | value | puts value }

Access the pairs. caps.each do | key, value | puts key + " => " + value end

Delete a pair. caps.delete('Maryland')

Get the keys. keys = caps.keys # array of keys

Get the values. keys = caps.values # array of values

Additionally, take note of clear and invert.



Sorting Hashes

If you wanted to print just the keys in sorted order, the following would work.

puts bank.keys.sort.join(" ")

If you just wanted to see the values in sorted order, you could code the following.

puts bank.values.sort.join(" ")

If you wanted to sort the pairs by keys, then the following would work.

puts score.sort.join(" ") Unlike sorting the keys and the values, this particular sort is on

the hash itself.

In this situation, the pairs are sorted on the keys, by default. However, in order to gain some insight into how that sort works,

examine the following.

score = { 'a' => 2, 'x' => 5, 'c' => 1 } score.sort.class # Array score.sort.size # 3 score.sort[0] # ['a', 2 ] score.sort[1] # ['c', 1 ]

You can see that the hash sort method returns an array of as

many two-element arrays as there were pairs in the hash.



Sorting Hashes

Each two-element array contains a name and a value pair. If you give the sort a block of code, you can compare whichever

part of the two-element array that you wish.

By default, the comparison is made on the keys. However, you can also compare on the values.

score.sort { | a,b |a[1] b[1] } The comparison operator , also known as the spaceship

operator, will be discussed in more detail in a later chapter.

In any case, the variables a and b each represent an array of two elements.

Each two-element pair represents a key and a value. In this case, we are comparing the values rather than the

keys.

If we had coded as shown below, then we would get the default behavior, shown on the previous page.

score.sort { | a,b |a[0] b[0] }



Iterators with Arrays and Hashes

One of the strengths of the Ruby language lies within the many iterators that operate on collections.

Below are a few array iterators that we have not yet seen. You can delete all the elements of an array for which a certain

block of code is true.

x = [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ,10] puts x.join(" ") y = x.delete_if { |item| item % 2 == 0 } puts y.join(" ") # 1 3 5 7 9

You can collect all the elements of an array and perform some

function on them.

x = [ 1, 2, 3, 4, 10] z = x.collect { | elem | elem * 2 } puts z.join(" ") # 2 4 6 8 20

Hashes also have some iterators defined. You can delete a pair if the following key, value pair is a match.

score = Hash.new score['John'] = 80 score['Alice'] = 97 score['Tim'] = 73 score['Peter'] = 83 score['Jake'] = 79 y = score.delete_if {| key, val | key =~ /^J/ } puts y # Alice97Tim73Peter83



Arrays and Methods

It is common to have a method operate on an array. arrfun.rb

1. #!/usr/bin/ruby 2. def subr(x) 3. sum = 0 4. for item in x 5. sum += item 6. end 7. sum 8. end 9. b = [5,6,7,8] 10. puts "TOTAL IS " + subr(b).to_s 11. a = [1,2,3,4,5,6,7,8] 12. puts "TOTAL IS " + subr(a).to_s 13. puts "TOTAL IS " + subr([1,2,3]).to_s


TOTAL IS 26 TOTAL IS 36 TOTAL IS 6



Hashes and Methods

Passing a hash to a method is also trivial. hash_total.rb

1. #!/usr/bin/ruby 2. def hash_total(aHash) 3. sum = 0 4. aHash.values.each { | item | sum += item } 5. sum 6. end 7. score = { 'a' => 2, 'x'=> 5, 'c' => 1 } 8. puts hash_total (score) 9. puts hash_total ( 'a' => 2, 'x'=> 5, 'c' => 1 )

If you need to send a simple value to a method, along with a hash, the hash parameter may be first or last.

It is usually more convenient to pass the hash as the last argument.

In this case, the {}'s are not necessary. hash_parameters.rb

1. #!/usr/bin/ruby 2. def hashfirst(aHash, any) 3. puts aHash 4. puts "-----------" 5. puts any 6. puts "===========" 7. end 8. 9. def hashlast(any, aHash) 10. puts any 11. puts "-----------" 12. puts aHash 13. puts "===========" 14. end 15. 16. hashfirst({'a' => 2, 'x'=> 5, 'c' => 1}, 10) 17. hashlast(10, 'a' => 2, 'x'=> 5, 'c' => 1 ) 18. hashlast(10, {'a' => 2, 'x'=> 5, 'c' => 1} )



Named Parameters

When you use a method, you usually need to know the order in which you pass arguments.

For example, if you were to write a method to raise a base to a power, you might proceed as follows.

def myraise(base, power) base ** power end

When users need to use this method, they need to know that

the base is the first argument and the power is the second argument.

Therefore, the first call below raises 2 to the 5th power but the second call raises 5 to the 2nd power. puts myraise(2,5) puts myraise(5,2)

Using hashes, you can name the parameter. I

ruby programming

Documents