John Gibbons

The Concept of 'Self' in Ruby

Tue, 10 Jun 2014 12:59:51 -0700

The concept of self in Ruby is an important one. At any given point when a program is running, there is one and only one self. Let’s go over the various contexts that determine what self is:

puts "Self is #{self}"
=> "Self is main"

class C
    puts "Self is #{self}"
    => "Self is C"

    def self.class_method
        puts "Self is #{self}"
        => "Self is C"
    end

    def inst_method
        puts "Self is #{self}"
        => "Self is c (instance of C)"
    end

    module M
        puts "Self is #{self}"
        => "Self is C::M (nested module M)"
    end
end

obj = Object.new
def obj.singleton_method
    puts "Self is #{self}"
    => "Self is obj (method receiver object)"
end

class D < C
end

D.class_method
=> "Self is D"

As you can see self changes whenever we see class, module, or def. If within a class or module, self refers to the class or module. Within any method, self refers to the object that called the method. This means that within instance methods, self is referring to the instance it is being called on.

When a subclass calls a parent’s class method, self is still referring to the subclass, not the superclass, because it is the object that called the method.

So why should we care?

Well, because being self comes with some privileges.

One is that any methods called without an explicit receiver default to self. Here is an example:

class C
   
    def x
        puts "I'm in C#x"
        y
    end

    def y
        puts "Now in C#y"
    end

end

c = C.new
c.x
=> "I'm in C#x"
   "Now in C#y"

You can see that the instance method y is being called without an explicit receiver. Since self is an instance of C within x, this is equivalent to calling self.y, and y runs. Note that if you also had a local variable named y, it would take precedence, so it is best to avoid naming variables and methods the same.

The Ruby Here-doc

Sun, 25 May 2014 12:59:51 -0700

Here-docs in Ruby are a strange but sometimes useful beast. A subclass of String, they allow you to generate a set of data lines or a template using the << syntax. Here is a simple example:

text = <<EOM
Here is the first line of text.
You can put several lines of text as well.
They will all be saved with newlines intact.
EOM

The block begins with the << and any string as the delimiter, such as EOM (end of message). The ending delimiter has to be flush left and must be the only thing on its line.

The text block generated by the here-doc defaults to a double-quoted string, which allows for escape characters and interpolation. Putting the opening delimiter in single quotes: <<'EOM' generates the block as a single quoted string.

The opening << delimiter can be placed anywhere and will be replaced by the block that follows:

num = 5 * <<EOM.to_i
10
EOM
>> num
=> 50

It can also be used in a literal object constructor like so:

arr = [0, 5, <<EOM, 3]
This will be arr[3]
Check it out.
EOM

>> arr
=> [0, 5, "This will be arr[3]\nCheck it out.\n", 3]

The last possible use I will point out is in an argument list. This can be useful if you need to include a long string that might not fit well otherwise.

a_function_with_args(x, y, <<EOM)
This will be put into the function call as the third argument.
EOM

Which is equivalent to:

a_function_with_args(x, y, "This will be put into the function call as the third argument.")

Here-docs aren’t seen too often in Ruby, but used in the right context they can be a useful tool in the toolbelt.

Notes on Ruby String Manipulation

Thu, 15 May 2014 12:59:51 -0700

This is primarily a personal reference for Ruby string manipulation, but hopefully someone else finds it useful as well.

Retrieve the nth character using the [] notation:

>> string = "Follow along with Ruby string manipulation."
=> "Follow along with Ruby string manipulation."

>> string[5]
=> "w"

Adding a second argument m outputs the number m of characters starting at the first argument n:

>> string[7, 10]
=> "along with"

A range can also be used, with n..m inclusive of the m or n...m exclusive m:

>> string[7..11]
=> "along"

>> string[7...12]
=> "along"

Negative indices start from the right:

>> string[7..-15]
=> "along with Ruby string"

>> string[23..-1]
=> "string manipulation."

Grab substrings by inputting a string search, will return nil if not present in the string:

>> string["Ruby"]
=> "Ruby"

>> string["Java"]
=> nil

slice() works the same way, with slice!() destructively modifying the string:

>> string.slice!("along with ")
=> "along with "

>> string
=> "Follow Ruby string manipulation."

Use []= to set part of a string to a new value:

>> string["Ruby"] = "Javascript"
=> "Javascript"

>> string
=> "Follow along with Javascript string manipulation."

>> string[-1] = "!"
=> "!"

>> string
=> "Follow along with Ruby string manipulation!"

Addition with strings using + generates a new string and leaves the original untouched:

>> "a" + "b"
=> "ab"

>> str = "hello"
=> "hello"

>> str + " world!"
=> "hello world!"

>> str
=> "hello"

Use << to permanently add a string to the original:

>> str = "hello"
=> "hello"

>> str << " world!"
=> "hello world!"

>> str
=> "hello world!"

We can also combine strings using interpolation, which is non-destructive:

>> str = "hello"
=> "hello"
 
>> "#{str} world!"
=> "hello world!"

>> str
=> "hello"