Getting Started With Ruby: A Tour of the Scripting Language

In the world of programming languages, sometimes you don’t need the overhead and performance of Java, C#, C++ and other power tools. Sometimes a scripting language, or Swiss army knife, will do.

Of Perl, Python and Ruby, only one was built from the ground up to combine scripting with object-oriented programming. If you don’t know one of them, let’s start with Ruby. (If you know Perl or Python, don’t worry; that will make Ruby even easier to learn.)

[ Analysis: 6 Emerging Programming Languages Career-Minded Developers Should Learn ]

[ More: Top 10 Programming Skills That Will Get You Hired ]

In this article, we’ll cover how to install and run a Ruby project, as well as the fundamentals of Ruby syntax and style. You’ll leave knowing how to run programs to do simple file I/O or Web access – and it will take about the length of a lunch break.

Getting Started With Ruby Right Now

You can download an open-source Ruby interpreter on ruby-lang.org. After getting the installer, let’s create a program called hello.rb in a text editor. Here’s the code:

print “What is your name? ”

name = gets

name = name.chomp() #removes the CRLF from name

if name == “cheesy”

puts “You don’t need this tutorial!”

else

puts “Hello ” + name

end

The code looks a bit like BASIC – and, to an extent, it might be. There are no parenthesis unless you want them, no semi-colons at the end of the line and, though curly braces can enclose a block, we generally use do/end.

A Bit About Ruby Style

We could keep going, showing syntax of Ruby semantics of Ruby – when to do a for loop, for example, and how to add two numbers together. If you’re like me, you’ll end up writing a program that happens to be Ruby but looks very much like your programming language of choice. While we don’t have time here to explore Ruby style in much depth, let me suggest one common approach to Ruby scripting.

Instead of solving the programming problem in the main routine, write an object. The main routine creates the object, passes input parameters into it, and perhaps prints something out. Once you’ve developed that habit, it’s easy enough to put the objects in a code library and learn how to unit test that library.

For now, let’s look at variables and control flow.

Variables: Strings, Integers, Floats and Arrays

Ruby is a strongly typed language, with integers, Boolean, decimal numbers and strings as basic data types. Data type is assigned implicitly; in the code below, “name” is a string, “val” a number and “inte” an integer:

     name = gets

     val = 5.5

     inte = 5

If you type “5” when “name” is requested, then try to add “inte” and “name,” you’ll get a conversion error. Although “name” is a string, it’s also an object, and has a “.to_i()” function that returns an integer. Putting the code together looks like this:

     added = name.to_i() + inte

Ruby uses other functions as well; “to_s()” converts to string, for example, and “to_f()” to float.

Meanwhile, there are a lot of ways to create and access an array in Ruby. For now, here are three:

     array1 = array.new(10) #Creates a size-ten empty array

     array2 = array[1, 2, 3, 4,5] #Array of 5 elements that increment

     array3 = array(0..9)#Array of 10 elements values 0 to 9

Arrays in Ruby are zero-based and automatically resize when you address memory out of bounds. To access the second element of array2, use “array[1].” Oh, and the # sign denotes a comment.

Control Structures: If, While, For

You’ve seen if before, but it’s about time I introduce the non-value, nil, which works something like this:

     array3 = Array[1,2,3,4,5]

     if (array3[5].nil?)

    puts “array3 has no fifth element!”

     else

    puts array3[5].to_s()

     end

The comparison operators are similar to other languages: for greater than,

“For” and “while” can work much like they do in most languages:

     #for loop through some fixed numbers

     for i in (0..5)

           puts i.to_s()

     end

     #For Through An Array

     array4 = Array[1,2,3,4,5]

     for i in 0..array4.size()-1 do

     puts array4[i].to_s()

     end

     #while Loop

     i=5

     while i>1

     puts i.to_s()

     i=i-1

     end

But that “for” loop through an array sure seems like a lot of work, doesn’t it? Instead, here’s how to do it with the built-in loop construct of an array:

     array4.each do |value|

    puts value.to_s()

     end

     for value in array

    puts value.to_s()

     end

File I/O and Regular Expressions

Let’s say we have a file with a large number of phone numbers. We want to change all the 616-3XX phone numbers to 269-3XX. To do that, we’ll loop through the file, read in each line, use a regular expression to change the values, print the line and redirect out to the new file. Here’s the sample file, data.txt:

     616-355-3000

     616-400-3333

     616-555-1212

     616-888-1221

     616-222-0000

     616-111-1111

     616-545-1111

     616-300-2222

There are a huge number of ways to open and process a Ruby file. We could use a one-liner to read the file into an array and then loop through the array, or we could read the file into a single (big) string, or we could read a byte at a time.

This code loops through a line of the file at a time, treating it as an array:

     File.open(“data.txt”, “r”) do |file|

    file.each_line do |line|

      puts line

    end

     end

To change the value of line, we’ll use Ruby’s “sub” function. Short for substitute, this takes a regular expression to match (set between forward slashes), then the string to replace it with:

This substitutes lines that begin with (the carrot) 616-3 with 269-3. To see if a given line contains 616-3, we’d do something like this:

     if line1 =~/^616-3/

     #code

     end if

Ruby Functions and Classes

 Here’s a simple function to roll a six-sided die:

   def roll

     result = 1+rand(6)

     return result

   end

To make it a class, wrap that in a class OneDeeSix above and an “end”below. (Ends always end things, with no need for curly braces.)

REST and Other URL Handling

The “open-uri” module gives us a method to grab the entire contents of a URL into a string. Let’s use the Thomas-Bayer website — a free, no-authentication REST API that converts a customer ID (a number from 1-50) into an XML payload.

     require “open-uri”

     print “What is your userid? ”

     STDOUT.flush

     customerid = gets

     customerid = customerid.chomp #Remove trailing newline

     url = “http://www.thomas-bayer.com/sqlrest/CUSTOMER/”

     data_from_url = URI.parse(url+ customerid.to_s()).read

     puts data_from_url

Putting It All Together

Let’s create a real Ruby program that uses a class to use the REST API to find your name given your customer ID. Type it in and run it:

require “open-uri”

require ‘rexml/document’

include REXML

class Customer

   attr_accessor :customerid

   attr_accessor :firstname

   attr_accessor :lastname

def initialize(customerid)

   @customerid=customerid

   url = “http://www.thomas-bayer.com/sqlrest/CUSTOMER/”

   data_from_url = URI.parse(url+ customerid.to_s()).read

   xmldoc = Document.new(data_from_url)

   @firstname = XPath.first(xmldoc, “//CUSTOMER/FIRSTNAME”).text

   @lastname = XPath.first(xmldoc, “//CUSTOMER/LASTNAME”).text

   end

end

#———————————–#

#           “Main Routine”         #

#———————————–#

print “What is your userid? ”

       customerid = gets

customer = Customer.new(customerid.chomp)

puts “Your name is ” + customer.firstname + ” ” + customer.lastname

Taking Ruby to the Next Level

Now that we’ve got a class to retrieve a name from a public URL, I suggest putting that in a module and learning to write a unit test for it. Learn what makes a “good”class, study parameters and structure, read up on inheritance and figure out how to tie classes together.

Start with the book Practical Object Oriented Design in Ruby but also consider Learn Ruby the Hard Way, which is available online, free and in HTML format. Also consider Codecademy. Start at the very beginning and you’ll learning by programming Ruby for free. (I do mean very beginning, though; if you haven’t created an account yet, you’ll need to do “Hello, world” in JavaScript first.)

This completes our whirlwind tour of Ruby. Now the real learning can begin.