Question

Possible Duplicate:
Array slicing in Ruby: looking for explanation for illogical behaviour (taken from Rubykoans.com)

In one of the Ruby koans, there’s the following problem:

def test_slicing_arrays
  array = [:peanut, :butter, :and, :jelly]

  assert_equal _, array[0,1]
  assert_equal _, array[0,2]
  assert_equal _, array[2,2]
  assert_equal _, array[2,20]
  assert_equal _, array[4,0]
  assert_equal _, array[4,100]
  assert_equal _, array[5,0]
end

You must fill in the _ with the correct statement. The first four asserts work how I’d expect them to, but I’m confused about the last three.

array[4,0] gives back [], as does array[4,100]. At this point I figured that ranges outside of the array (greater than 3 in this case) simply return an empty array.

But array[5,0] returns nil which has now confused me completely.

Can anyone explain this behaviour?

Answer 1

Ruby is not a static language, forcing you to pre-declare the size of the array. It expands arrays as you assign to a particular element.

Normally we’d append to the end of the array:

array = []       # => []
array << 1       # => [1]
array += [2]     # => [1, 2]
array.push(3)    # => [1, 2, 3]

Or push onto the front of it:

array.unshift(0) # => [0, 1, 2, 3]

to add elements, which keeps the array accumulating the values without gaps.

We can do it randomly too, which can be useful:

array[10] = 10 # => 10
array          # => [0, 1, 2, 3, nil, nil, nil, nil, nil, nil, 10]

And that’s what you’ve encountered.

---

You can predefine the array to a size, but it remains dynamic:

ary = Array.new(10, nil) # => [nil, nil, nil, nil, nil, nil, nil, nil, nil, nil]
ary[0] = 0               # => 0
ary[10] = 10             # => 10
ary                      # => [0, nil, nil, nil, nil, nil, nil, nil, nil, nil, 10]
ary[12]=12               # => 12
ary                      # => [0, nil, nil, nil, nil, nil, nil, nil, nil, nil, 10, nil, 12]