YashLabs

In this section, we’ll see how to write classes in Ruby. We will also see how Ruby helps greatly to reduce class development time thanks to symbols. And lastly, we will see how to reuse our classes.

Note here that I am not covering object-oriented principles. I assume you are already somewhat familiar with these.

5.1 Creating Classes and Accessing Internal Variables

We will create a simple Car class in Ruby with an internal variable for its brand. Note that the class name must begin with a capital letter.

In your favourite editor, type the following:

class Car
def initialize(brandname)
@brand = brandname
end
end

Now that we’ve written the contents for the initialize method, you can create new car objects by passing an initial argument for the brand:

myCar = Car.new("Lamborghini") or myCar2 = Car.New "Lamborghini"

Now, note here that because of encapsulation (an important principle in Object-Oriented programming), the internal variable @brand of your object is not directly accessible.

You cannot yet type:
1. To access the value: puts myCar.brand
nor
2. To write a new value into it: myCar.brand = "Vektor"

Before you can do this in any OO language, you must write what are called “getter” and “setter” methods. For example, in the above Car class, we would write a getter method for the brand thus:

def brand
return @brand #This is a comment: in fact, you could even omit the return keyword ;p
end

Try it in your IDE (add this “getter” method after the initialize one) and see that this time around, you can get the brand name by invoking: puts myCar.brand

Similarly, for the “setter” method, we would add this to the class:
def brand= (brandname)
@brand = brandname
end

Add the above to your Car class and try it by changing the brand of myCar:
myCar.brand = "Vektor"
puts myCar.brand

So, your Car class should now look like this:
class Car
def initialize(brandname)
@brand = brandname
end

def brand= (brandname)
@brand = brandname
end
end

5.2 Attribute Symbols: Ruby’s shortcuts for Rapid Development and Prototyping

Now, it would be more interesting if we could input a more complete set of details about our cars. Let’s say we would like also to be able to get and set the Model, the Year, the Colour, the Maximum speed, etc… But this entails having to write a getter method and a setter method for each of these attributes! Not very interesting, isn’t it? Time-consuming? Certainly!

In Ruby there is a shortcut that allows us to do the same thing but much more rapidly and succinctly.

In your Car class, instead of writing the getter method, just type this:
attr_reader :brand

This makes :brand a symbol which will be expanded internally and automatically into a getter method for you! attr_reader specifies that the internal variable @brand will be read only.

Similarly, the setter method is written thus:
attr_writer :brand

Fantastic isn’t it? No need to write those pesky getter and setter methods.

So now, your Car class would rather be:

class Car
def initialize(brandname)
@brand = brandname
end

attr_reader :brand
attr_writer :brand
end

But wouldn’t it be interesting if we also had another way to easily specify that several attributes should be both readable and writable?

Another shortcut does just that in Ruby: attr_accessor

Therefore, here is how to rapidly prototype a class in Ruby:
class Car
attr_accessor :brand, :model, :year, :colour, :maxspeed

def initialize(brandname, modelname, year, colour, maxspeed)
@brand = brandname
@model = nodelname
@year = year
@colour = colour
@maxspeed = maxspeed
end
end

or if you don’t need to initialize your object with values right away, simply:
class Car
attr_accessor :brand, :model, :year, :colour, :maxspeed
end

Now, to use this Car class you would simply type:
myCar3 = Car.new

and then, you could manipulate its attributes like brand and model as usual:
myCar3.brand = "Vektor"

Can you see how symbols help to drastically reduce design and development time in Ruby as compared to other languages?

5.3 Reusing classes as modules

Let’s assume that you wrote a great Person class and that several of your programs must use this class. It is good practice to reuse your existing code (er… especially if it is GOOD code, ok?).

Ruby provide an easy way to do just this.

Just save your Person class as person.rb. Then, when you wish to reuse that class in any new program, you invoke the file which contains the Person class fist, and subsequently use the class as you would normally:

require "person.rb" # Note I am assuming the person.rb file
# is in the same directory as your new program

p1= Person.new

Try it with your Car class, for instance.

Note that if you have many constants and classes that you want to reuse, then use the ‘module’ and ‘end’ keywords to enclose all these into a reusable file.

This concludes the introduction to Ruby. You do not need classes to write Ruby scripts, but if you do you will find that your code is better, more readable and maintainable. In other words, you will be benefiting from all the advantages of Object-Oriented programming.

If you have come this far, I urge you to continue to explore programming in Ruby by perusing the various resources on the web. You can access a free version of the “Pickaxeâ€? book online and also “Why’s poignant guide to Rubyâ€?, replete with fox cartoons.

When you are comfortable with Ruby programing, you can also try your hand at Ruby on Rails, the fantastic framework for easily developing database-driven web-applications.

Happy programming with Ruby!

This is the first part of a quick and easy 5-part tutorial for the Ruby programming language. I initially sent it to Rubidius, the local Ruby User Group I founded, as well as to my Local Linux User Group. It’s free as in free beer. Learn Ruby in one hour. At least the basics. Seriously, it will take you about an hour for the whole. Enjoy.

———————————————————————-

One-hour Ruby
An introduction to the Ruby language in 5 easy pieces

by

Josh Nursing

Introduction

This is a very brief introduction to some of Ruby’s syntax. This tutorial is designed to get you up and running with Ruby and writing scripts as rapidly as possible. It is not intended as a complete Ruby course nor as a course for Object-oriented principles. You will find it especially useful if you already know programming in some language other than Ruby and want to see how it is to program in Ruby. And it only takes an hour of your spare time.

Part 1: Variables

If you haven’t yet installed Ruby and would like to try it, it is readily available for Linux, Mac, and Windows:

http://www.ruby-lang.org/en/20020102.html

A nice install for Windows is Curt Hibbs’ one-click installer. It comes with a good IDE called FreeRIDE, but for learning, I recommend RDE as it contains Autocomplete and shows you the methods of a class, etc…

Let’s see briefly how variable are declared in Ruby.

In Ruby, part of the syntax denotes the type of locality of a variable.

1. A global variable starts with a $, like in $MaxItems
2. A local variable starts with lowercase, like in myval

Similarly, constants are defined in Ruby by using a name which starts with an UPPERCASE, like PI = 3.141592653 or Pi = 3.141592653.

Note here that we never had to define the actual type of variable. It isn’t necessary for us to define that $MaxItems is an integer. Ruby will infer this automatically. This saves a lot of time and makes you more productive.

Now, let’s see the cases of variables when you are writing classes and using objects (instances of classes).

1. A class variable starts with @@, like in @@name
2. An object instance variable starts with @, like in @address

Don’t worry about classes and objects right now as we’ll see them again in the last section.

Part 2