Re: Arrays with records as objects

On Nov 22, 2012 11:07 AM, "Steve Tucknott" <[e-mail]> wrote:
> I am 'playing'/'learning' at the moment - so what I have been doing is
> taking base examples and then adding how I could use them in the 'real
> world'.

This is great!! Experimenting with stuff that your learning is a great
thing, and no way would I want to discourage that. Checking in with
what your learning is a great thing, too.

> In an earlier array example, I had used the record Openstruct structure
> as:
>             # -- This is my test to see how arrays can be indexed.....a
> five element array
>             # -- for names and address/post code
>             addr        = []
>
>             for i in 0..5
>                 addr_rec        = OpenStruct.new
>                 addr_rec.name   = "Cust#{i+1}"
>                 addr_rec.line1  = "C#{i+1}Line1"
>                 addr_rec.line2  = "C#{i+1}Line2"
>                 addr_rec.line3  = "C#{i+1}Line3"
>                 addr_rec.line4  = "C#{i+1}Line4"
>                 addr_rec.pcode  = "C#{i+1}PCode"
>                 addr[i]         = addr_rec
>             end
>
>             for i in 0..(addr.length-1)
>                 `zenity --info --title="My Array" --text="Each Array
> Element:\n#{addr[i].name}\n#{addr[i].line1}\n#{addr[i].line2}\n#{addr[i].line3}\n#{addr[i].line4}\n#{addr[i].pcode}"`
>             end
>
> So, because that seemed to work ok,  I then wanted to try to represent
> the TodoList  file line contents as a 'record' (in general, that is how
> I'm used to handling file data). Hence then getting the 'line' record
> into the array.

It does work, yet it might not be the best way to do things in the
ruby world. Looking at the above, it seems to be borrowing idioms from
other 'less expressive' languages than ruby.

For instance, for loops are almost never needed in ruby. To approach a
more idiomatic ruby expression of the above, you would use the "each"
method:

0..5.each do |i|                        # a range creates an iterator,
usable by each
  addr_rec        = OpenStruct.new
  cnum = i+1                            # calculating the "customer number" once
                                        # rather than recalculating it for each
                                        # field below
  addr_rec.name   = "Cust#{cnum}"
  addr_rec.line1  = "C#{cnum}Line1"
  addr_rec.line2  = "C#{cnum}Line2"
  addr_rec.line3  = "C#{cnum}Line3"
  addr_rec.line4  = "C#{cnum}Line4"
  addr_rec.pcode  = "C#{cum}PCode"
  addr[i]         = addr_rec
  # this could also be written as:
  # addr << addr_rec
end

addr.each do |a|                        # an array also has an
iterator, also usable by each
  `zenity --info --title="My Array" --text="Each Array
Element:\n#{a.name}\n#{a.line1}\n#{a.line2}\n#{a.line3}\n#{a.line4}\n#{a.pcode}"`
end

Note the comment about calculating cnum; in general it's best to
calculate a local constant once, rather than several times. It
wouldn't surprise me if the above was optimized away under the hood,
but it's best not to rely on such things, and it's more expressive of
what you mean by giving it it's own variable name

> In between postings though, I did remove the record structure, and made
> the item three separate instance variables again.
> So I think I'll create two versions of this - the single variables and
> record structure options.
>
> All the STDOUTs are my debug lines (as well as the main zenity system
> calls) to see what is going on.

Another way to approach this, rather than inserting debug statements
you will later have to remove from code if you're going to use it in
an application, is to follow a technique known as Test Driven
Development. The ruby community has, more than any other I've
encountered, embraced testing as a way of life, and the best practice.
The idea that you write down how you are going to test something helps
tremendously in figuring out what you want the code to do. While
you're experimenting and just trying things out, it can seem like a
bit of a hindrance, yet establishing the habit early can be quite
beneficial.

Essentially, with the TodoItem class, instead of printing out the
debug statements, you could write test code that verified the
behaviour of the methods. There are some great ruby test gems, a lot
of people use RSpec because of the neat way you write tests, but even
a "poor man's" test program is possible, and in just starting out,
maybe more helpful.

In a test script, making a call like:

item = TodoItem.new("1<<>>a new item")

You can then debug/test that item was created successfully, doing
something like:

puts "done = #{item.done}"
puts "action = #{item.action}"
puts "name = #{item.name}"
puts "state is = #{item.state_getter}"
item.state_setter
puts "state is now #{item.state_getter}"

Also, if you haven't, do try out the ruby console, irb. You can
quickly throw ruby expressions like this at it and see what happens.

> Is there a separate forum that you know of for complete Ruby newbies
> like me?

Here is good -- we all learn from each other!

There are lots of great resources out there, but I think interacting
with real people is great way to learn the subtler nuances of things,
such as the each method if you're coming from a standard procedure
programming approach; in learning to use a language, the idioms that
are best used in that language are sometimes not that apparent. That's
where knocking heads with others helps a lot.

I'm also firmly of the belief that you can't *really* master something
unless you can teach it. So do me a favour and stick around. :)

(and, crikey, i'm having fun, too :) )