A .NET Guy Looking at Some Ruby (Part 2)

This is me continuing scribbling down notes as I go along relearning lost Ruby skills and at the same time comparing the Ruby syntax and way of writing code to .NET. In my previous post I very briefly went through the basics of variables, loops, iterators, conditionals and basic sorting. This post will look at classes, methods, inheritance and how to reuse Ruby code with include (require) statements.

Methods

Method or function declaration in Ruby is simple, perhaps even simpler than how VB does it:

def my_method(name)
    puts "Hello " + name.to_s
end

my_method "johan"
my_method("johan")

As you can see, you may call the method with or without parenthesis, to Ruby it doesn’t matter. I’ll have to read some more Ruby code to see if there are any exceptions or aesthetic rules to using parenthesis or not, but it seems that many Rubians use parenthesis when calling functions or methods on objects/classes, but leaving it when calling simple methods like puts and similar:

Oh, and Ruby doesn’t support method overloading! There are ways around this with default method parameters, add-ons to the language and so on, but basically – no method overloading. I’ll show some sample code later on when I get to class initialization.

Classes, Constructors and Properties

Ruby is of course object oriented, and very much so (without going into the “where everything is an object” speech). So, of course you can declare objects with properties and methods on them. Declaring a class is familiar:

class MyClass
end

You instantiate a class using a built in static “new” method on the class:

a_class = MyClass.new

Adding a (instance) method to the class is straight forward:

class MyClass
  def hello(name)
    puts name
  end
end

Static methods, or class methods, are declared by prefixing the method with “self.”, like this:

  def self.reverse_upcase(name)
    name.reverse.upcase
  end 

Adding a constructor or initializer to the class is done by declaring an initialize function:

  def initialize(name)
    @name = name
  end

As constructor overloading is not possible, you’ll have to add a default value to the parameter, making it optional in a VB-style of way:

  def initialize(name = "Anonymous")
    @name = name
  end

The @name variable is called an object variable and it is distinguished by the use of the ‘@’ sign. There is no need to declare the object variable in any other way, but to access the object variable (or property or attribute or…) you have to add property accessor code to the class:

  def name
    @name
  end

  def name=(name)
    @name = name
  end 

Now, class properties is used so much that there is a so called attribute accessor keyword available for you in Ruby, making things a bit simple to type:

attr_accessor :name

There are also other attribute keywords like attr_reader and attr_writer available for your pleasure.

Inheritance

Last thing to say about the basics around classes in Ruby is how to handle inheritance. The syntax is similar to c#, but instead of a colon (:), use the less than (<) operator. A very simple example of where the class Employee inherits from Person could look like this:

class Person
  attr_accessor :name

  def initialize(name)
    @name = name
    end
end

class Employee < Person
  attr_accessor :number

  def initialize(name, number)
    @name = name
    @number = number
  end

  def to_s
    @name + " (emp# " + @number + ")"
  end

end

e = Employee.new("Johan","123")

puts e
puts e.is_a?(Person)
puts e.is_a?(Employee)

Would print:

Johan (emp# 123)
true
true

Class Reuse

If you want to “use” or “include” Ruby code you’ve already written? Save your code (class) into a MyClass.rb file (as an example) and add a “require” statement to the top of your code where you want to reuse the MyClass class:

require "MyClass"

and classes in the MyClass.rb file will become available for you.

Wrapping Up

I guess that’s enough for now. I think this will be enough to be able to understand some Ruby code if you come across it, unless it contains too many weird class methods like Array#flatten and such J. Then there are a bunch of modules available to Ruby for doing a number of things. I may get into that in a later blog post, I’ll see.

All in all I think Ruby is cool. I’ve used dynamic languages and scripting languages before, but nothing as sleek as Ruby. Ruby is minimal code, fast to type and there’s a flow to the code which makes it quite easy to read.

Next

Next I’ll blog about downloading and building IronRuby and using it to call on .NET libraries, WPF and perhaps Silverlight (which seems to be all the buzz right now). I think I’ll look at exceptions and error handling after that and see if I can get some time to look at Rails again.