GDScript Arrays & Loops Practice

1. Loop Over Values

var items: Array[String] = ["sword", "shield", "potion"]

for item in items:
    print(item)

2. Loop With Index

for i in range(items.size()):
    print(i, ": ", items[i])

3. Early Break When Found

func find_item(target: String) -> int:
    for i in range(items.size()):
        if items[i] == target:
            return i  # Found it, stop searching
    return -1  # Not found

Sorting is O(n log n). If you just need the closest, do it in O(n):

func get_closest_enemy() -> Node2D:
    var enemies := get_tree().get_nodes_in_group(&"enemy")
    var closest: Node2D = null
    var min_dist_sq := INF

    for node in enemies:
        var enemy := node as Node2D
        if enemy == null:
            continue
        # distance_squared_to avoids sqrt—faster for comparisons
        var dist_sq := global_position.distance_squared_to(enemy.global_position)
        if dist_sq < min_dist_sq:
            min_dist_sq = dist_sq
            closest = enemy

    return closest

In real games: Prefer one-pass closest target if you do this every frame. Save sorting for when you need the full ordered list.

When you need enemies sorted (e.g., chain lightning, splash damage falloff):

func get_enemies_sorted_by_distance() -> Array[Node2D]:
    var enemies := get_tree().get_nodes_in_group(&"enemy")

    # Sort using distance_squared_to (faster, same ordering)
    enemies.sort_custom(func(a: Node, b: Node) -> bool:
        var dist_a := global_position.distance_squared_to((a as Node2D).global_position)
        var dist_b := global_position.distance_squared_to((b as Node2D).global_position)
        return dist_a < dist_b
    )

    # Cast to typed array
    var result: Array[Node2D] = []
    for e in enemies:
        if e is Node2D:
            result.append(e)
    return result

Note: get_nodes_in_group() returns Array[Node], not Array[Node2D]. Filter/cast before using global_position.

Godot warns: Erasing while iterating is unsupported and can behave unpredictably. Use one of these safe patterns:

# WRONG: Skips elements, unpredictable behavior
for enemy in enemies:
    if enemy.is_dead:
        enemies.erase(enemy)  # Don't do this!

Option 1: Iterate Over a Copy

for enemy in enemies.duplicate():
    if enemy.is_dead:
        enemies.erase(enemy)

Option 2: Backward Index Loop (fastest, no allocation)

for i in range(enemies.size() - 1, -1, -1):
    if enemies[i].is_dead:
        enemies.remove_at(i)

Option 3: filter() for Clean Code

# Rebuild the list with only living enemies
enemies = enemies.filter(func(e): return not e.is_dead)

Trade-offs: Backward loop is fastest (no allocations). filter() is most readable. duplicate() is a safe middle ground.

In real games: Use Array[T] for gameplay collections (enemies, items, projectiles). Use Packed arrays for raw numeric buffers like navigation paths or vertex data where you iterate thousands of elements. Each element in a generic Array is a Variant (20+ bytes overhead per element), while PackedFloat32Array stores raw 4-byte floats—a significant memory difference at scale.

For a printable reference of collection methods, see the GDScript arrays & dictionaries cheat sheet. For real-world dictionary patterns in Godot 4, see our dictionary map blog post.

# Array: ordered collection
var inventory: Array[String] = ["sword", "potion", "key"]

# Dictionary: key-value mapping
var stats: Dictionary = { "hp": 100, "attack": 10, "defense": 5 }

Note: Dictionaries preserve insertion order when adding entries, but they're not automatically sorted. If you need sorted keys, extract and sort explicitly.

• Previous: Foundations — Script structure, lifecycle
• Next: Timers & Signals — Event-driven patterns
• See also: Groups & Pickups, Projectiles