Question

I’ve made a very small ruby script today that makes use of regexes to track down certain content in files with a specific name and removes that content before adding its replacement. (Or else stuff would go wrong during iterations).

I’m not very used to ruby (only been using it since my vacation job started which is 1-2 weeks ago), but one of my habits is to avoid touching lists (or most other ADT’s using indexes) while iterating over them (to remove the certain content), doesn’t matter which language I’m using.

After some searching I found out about a few Array functions that could help. Right now, I’m using Array.reject! and the script works like I want it to work, but I honestly can’t figure out why Array.reject! {|line| line =~ regex } does not have trouble with skipping objects in the array. These sources, ruby-docs & some random website, confirm that the changes are applied instantly while iterating, which makes me wonder how it does not mess up… The lines that are being removed have no space/words between them, only \n brings the next one to its own line of course (but that’s just part of the end of the strings).

Has anyone got a great explanation for this?

Answer 1

Array#reject! uses a for loop to iterate over the array’s elements. Here’s the C code:

for (i = 0; i < RARRAY_LEN(ary); ) {
  VALUE v = RARRAY_PTR(ary)[i];
  if (RTEST(rb_yield(v))) {
    rb_ary_delete_at(ary, i);
    result = ary;
  } 
  else {
    i++;
  }
}

The interesting part is that i is not incremented in the for statement. If the block given to reject! evaluates to true the current element is removed and ary[i] automatically points to the next element. Only if it evaluates to false, i is incremented.

[a b c d].reject! {|x| x == b}

 0 <------- i # doesn't match => i++
[a b c d]

   1 <----- i # matches => delete ary[i]
[a b c d]

   1 <----- i # doesn't match => i++
[a c d]

     2 <--- i # doesn't match => finished
[a c d]