better coding style?

just a small question about coding style:

basically I want to delete all objects with a specific prefix.

All works fine but I saw someone using a slightly different approach and wanted to know what is the preferred way to do it:


This is what I did till now:
Now I saw something similar to this:

Is the second option to be preferred ( e.g. faster ect..) over my present one.

Just want to learn from the more experienced once if anyone is so kind to share their knowledge.

i often do it the second way. sometimes things lend themselves better towards one way or another, but i can't think of a single one off the top of my head.

i probably tend to always try and iterate positively, simply because it's a habit and as such when i change things up i forget and still assume i'm going forwards instead of reverse and so my code gets all fucked up.

also, it's not always a case of deleting something from a list. sometimes you might be changing something in a list and still need to retest it for one reason or another, possibly against other things in the list or even a separate list entirely. in that case, a while loop is the only choice. again, i can't think of when i have done something like this, but i know i have.

there's nothing inherently wrong about either approach, unless of course it's actually wrongly coded and wrong for the situation.

Thanks a lot for the feedback.


Anyone know if there is a speed difference using the:
vs. using Find

actually, i just remembered the reason i have wanted to retest an index and therefore the while loop and forcing a retest by decrementing the index value was totally useful and practical. it's been ages since i looked at it, but i wrote a basic 3d engine. dealing with clipping simple triangles against potentially numerous ambiguous planes would involve splitting the triangle into smaller triangles or completely remove the triangle if it was fully clipped... in both cases it's cheaper and simpler to use the current index as one of the newly created sub-triangles and then add the remaining sub-triangles onto the end of the list, or in the case of a fully clipped and removed triangle it's cheaper to simply copy the last triangle in the list into this now 'vacant' (read : deleted / clipped) triangles position and then decrement the used array size by 1 spot.

in this way the triangle list was always the visible list by the end of the process and i didn't have to shuffle data in and out of a separate array. if i was using a for loop i would be stuck with either a list of triangles that would require a visible or not visible tag, and therefore be a big list filled with mostly non-visible triangles that was only making each iteration an exercise in stepping over multiples of wasted and pointless items, or using a for loop would require creating a secondary list that you would populate with references to the original list of only the visible triangles. it's cleaner to just have one list, and overwrite pointless clipped triangles with potentially valid triangles and just retest the same index as required until proceeding to the next index.

it saves a lot of shuffling or literal array resizing when you actually don't shrink the physical array and instead keep a count on how much of the array is actually in use versus the true array size. trying to resize arrays that hold a few thousand items 30 times each second is a slow process.

...

as for your new question. just find out yourself. record the computer tick count before doing one of the checks a million times then check the tick count after... then do the same for the second test. compare times. you'll find a winner.

this is how you can simply test any routine you might create yourself if you aren't sure if it's optimized or worse than some other way you were doing something.

Thanks