That is a typical design pattern, and it works quite well when you need to process records that meet a certain criteria. It is not the only way to do so, however. You can also follow this design pattern:

sobject[] updates = new sobject[0];
for(sobject trigger_record:trigger.new) {
  if(trigger_record.some_field != some_value) {
    continue;
  }
  updates.add(new sobject(parent_id=trigger_record.id, more_data=something_else));
}
update updates;

The only difference is that the method you proposes has to loop through all records, then loop through the matching records, while this design pattern skips that second loop while still only processing records that match your criteria. This is an inverted test example, where if the condition is met, the rest of the code is skipped for that record (the continue keyword immediately skips the current iteration and moves to the next). You could also just as easily do the following instead:

for(sobject trigger_record:trigger.new) {
  if(trigger_record.some_field == some_condition) {
    updates.add(new sobject(parent_id=trigger_record.id, more_data=something_else));
  }
}

The difference here is that the former method might be more readable if the contents of the if block is complex or longer. In the end, all three methods will perform approximately equally well.

In order to minimize the script statements used using your design pattern, though, you'll have to reference the record directly through the map. In my code examples, trigger_record is the current record; your code has to instead do one of the following:

for(id record_id:recordids) {
  sobject o = trigger.newmap.get(record_id); // uses an extra script statement per row
}

for(id record_id:recordids) {
  updates.add(new sobject(parent_id=record_id, other_data=trigger.newmap.get(record_id).some_value)); // slightly more difficult to read, especially if there are many values
}

// uses slightly more memory, but only two more script statements per batch
map<id,sobject> trigger_clone = trigger.newmap.clone();
trigger_clone.keyset().retainall(recordids);
for(sobject trigger_record:trigger_clone.values()) {
  updates.add(...);
}

As I said, there are a number of equally valid ways to get the results you're looking for, and unless performance is really a major issue already, I'd just go with whatever you're most comfortable using instead of worrying about minor optimizations like this.