The reason is that your metaphor about arrays being like a 2x2 matrix
is wrong, specially in the cases where the contents of the array are
not arrays themselves. It's better if you think of it this way:
array1 = [['a','b'],[1, 2],['x','y']]
array1 is an array with three elements, with indexes 0, 1 and 2. At
index 0, there is an object, which happens to be another array. At
index 1 there is an object that happens to be another array. The same
for index 2. So:
first_array = array1[0]
first array is now ['a', 'b'], which is an array. At position 0 there
is a String object, so first_array[0] => 'a'. At position 1 there's
another string, so first_array[1] => 'b'
The confusion might come because you can "chain" method calls like this:
array1[0][0] #=> 'a'
but in reality this are two different steps. First, method with
argument 0 is called on array1. This returns a different array. Then,
method with argument 0 is called on the returned array. This method
call returns a String, which is 'a'.
When you move to array2, though, your assumptions break, because:
array2 = ['a', [1,2], 'x']
array2[0] calls method on the array, with argument 0, which returns
the first object of the array. It happens that in this case, this
object is not an array, but the string 'a'. You have the object
directly when you do that. This is not a 2x2 array. It's just an array
in which the second element is itself an array, but that's not the
case for the first or third objects, which are just strings. So:
array2[0] => 'a', a String
If you do
array2[0][0], this calls method with argument 0 of the array,
returning a String. You then call method with argument 0 of the
String (yes, String also has a method , which returns a section of
the string), in this case returning 'a', because you asked for the
first character of the String.
Later in the code, you do array2[0][1], which is thus calling the
method with argument 1 on the string 'a', which is asking the
string for the second character, which doesn't exist, and so you get
nil (empty when puts'ed).
You should play a little bit in irb to see the different steps.
Jesus.
···
On Tue, Oct 2, 2012 at 5:35 PM, Richard D. <lists@ruby-forum.com> wrote:
after some experimenting, I understand but still have a bit of fog.
Basically, the idea was to see how data would be pulled from slight
different arrays. But I'm getting two completely different results. I
was expecting to be the same, except my "=====" break to tell the
different outputs.
program 1
--------------------------------------------------------------------
array1 = [['a','b'],[1, 2],['x','y']]
array2 = ['a',[1,2],'x']
array1.each do |ray|
test1 = ray[0]
puts test1
end
puts '======='
array1.each do |ray|
test2 = ray[1]
puts test2
end
puts '======='
array2.each do |ray2|
test3 = ray2[0]
puts test3
end
puts '====='
array2.each do |ray2|
test4 = ray2[1]
puts test4
end
puts '====='
puts array1[0].to_s + ' ' + array2[0].to_s
puts
puts array1[1].to_s + ' ' + array2[1].to_s
puts
puts array1[2].to_s + ' ' + array2[2].to_s
OUTPUT
a
1
x
b
2
y
a
1
x
2
=====
["a","b"] a
[1, 2] [1, 2]
["x", "y"] x
Program 2
------------------------------------------------------------------
{same as above, excpet)
array1.each do |ray|
test1 = ray[0]
test2 = ray[1]
puts test1
puts '****'
puts test2
end
puts '======='
array2.each do |ray2|
test3 = ray2[0]
test4 = ray2[1]
puts test3
puts '****'
puts test4
end
OUTPUT
a
****
b
1
****
2
x
****
y
a
****
1
****
2
x
****
======
["a","b"] a
[1, 2] [1, 2]
["x", "y"] x
So I think I got what the arrays do. I just don't think I'm
understanding how things are being located. What I"m thinking is this
array1 = [['a','b'],[1, 2],['x','y']]
array1: a is slot0-0, b is slot0-1, 1 is slot1-0, 2 is slot 1-1, x is
slot2-0, and y is slot 2-1
array2 = ['a',[1,2],'x']
a is slot1-0-0, 1 is 1-0, 2 is 1-1, and x is 2-0
I thought in both programs the ray(x)[0] would output all x-0 slots, and
ray(x)[1] would out put all -1 slots