Rule #1 of programming: Write good code first, then measure performance.

Premature optimization is the root of all evil.

Use:

items=[...]
for o in items:
    ...

This is the most direct way of doing what you want. The first option might allocate a new array each iteration, which is unnecessary. The match statement is both a pain in the ass to write and less direct, which at best compiles to the same thing and at worst has you doing a bunch of totally unneeded comparisons.

If this ‘i’ variable you used isn’t just an incrementing counter, use the last option. If it is though, it’s an extra counter you don’t actually need.

The performance difference here would be so small I doubt you could even observe it. So, you really shouldn’t worry about this particular pattern. Compiler optimizations are more likely to trigger on simple, direct code, so writing it as directly as possible is probably the fastest option anyway.

What is the purpose of the loop?

Speaking generally, I’d prefer the first option as long as ‘i’ is actually an index or other valid key. I’m not sure what the overhead is in godot, but in general you should avoid conditional statements when you have a direct access method like a key or index.

I don’t think you need the for loop in the last one

1. They don’t do the same thing so I’m assuming you’re trying to iterate over something like in n3
2. n3 should theoretically be the fastest as there’s only one allocation and less branches
3. Time it with get_ticks_usec() over a significant number of samples https://docs.godotengine.org/en/stable/classes/class_time.html#class-time-method-get-ticks-usec
4. None of this will matter because GDScript is interpreted and the execution times vary wildly based on how the moon is aligned
5. Premature optimization, yada yada

For the first case, it’s probably better to use Dictionary instead of a match on an array, or matrix as you presented.

var dictio = {"key":value, "key2":value2}

Unless you’re dealing with over 1k elements, any performance difference between Dict and Array might as well be a margin of error. https://docs.godotengine.org/en/stable/classes/class_dictionary.html

For that for you presented later, it should be for i in items:, i then will point directly to the value in that position of the array. o = i

What you are doing, or attempting to, isn’t clear

At face value, none of those things are “apples to apples”, the first thing is a matrix or Vector2. The second is simply a match, which is “a series of if/elif”. Efficiency here comes mainly from the type of of the object being matched: bool is the fastest, int probably second, then float, then string. The third you’re just running through the array. All different things, each useful for a different purpose and none directly equivalent to another, thus it’s impossible to say which is the most efficient.

deleted by creator

I might be wrong, but the 2nd case looks like an anti pattern, the loop switch sequence .

The last case looks the most readable to me. Always start with that unless there’s a clear reason not to (eg inefficient multiple nested loops).

If speed is actually important then I would consider writing it in another language looking for someone else’s implementation (personally). I try to focus on readability and doing the simplest implementation. I’ve been trying to use better function/variable names to explain what is happening at a glance instead of reading the whole thing. Have you considered using map for array iteration? I am hoping even if people don’t know how this works the intended result is even more readable than an equivalent for loop:

func _show_only_first_layer_dots():
	var set_dots_visibility = func(layer): layer.get_node("Dots").visible = (layer == $Layers.get_child(0))
	$Layers.get_children().map(set_dots_visibility)