Switch Case与Array Key Lookup：哪种方式空间复杂度更低？

Great question—since you’re dealing with 100 branches, space complexity becomes a valid concern, especially if this code runs in memory-constrained environments. Let’s break down how each approach stacks up in PHP:

Switch Case Space Overhead #

Switch statements in PHP are optimized differently based on your case values:

• Contiguous integer cases (e.g., 0 to 99): The PHP engine can compile this into a jump table—a small, fixed-size array that maps case values directly to the corresponding code block. The space here is negligible (just a few hundred bytes) because the jump table only needs to cover the range of integers, not each individual case. The code blocks themselves are part of your program’s bytecode regardless of the switch structure, so no extra heap memory is used at runtime.
• Non-contiguous integers, strings, or mixed cases: For these, PHP either evaluates cases in order (using sequential comparisons) or uses an internal hash map to optimize lookups. Even here, the overhead is minimal: the case values are stored as part of the compiled opcode, and there’s no separate runtime data structure eating up heap memory. The only extra space is the metadata needed to track each case entry, which is far smaller than an equivalent array.

Array Key Lookup Space Overhead #

Associative arrays in PHP have significant per-entry overhead:

• Each key-value pair in a PHP array uses two zval structures (one for the key, one for the value) plus a hash bucket entry to manage the hash table. Depending on your PHP version, each of these structures takes 20–40 bytes. For 100 entries, that’s roughly 6–12 KB just for the array’s internal structure, not counting the actual values (like function references or large strings).
• If you create the array dynamically each time the code runs, you’re allocating and deallocating this memory repeatedly, which adds to overhead. Even if you use a static array (allocated once), the heap memory remains occupied for the lifetime of the process.
• If your array values are anonymous functions or objects, you’re adding even more overhead—each function/object has its own memory footprint, whereas switch case uses inline code that’s part of the parent function’s bytecode.

Direct Comparison for 100 Branches #

In almost all scenarios, switch case will have lower space complexity than array key lookup when dealing with 100 branches:

• Switch case’s overhead is either a tiny jump table or minimal opcode metadata—no heap memory allocation required at runtime.
• Array lookup requires a full hash table with 100 entries, which occupies measurable heap memory. Even with static arrays, this memory is tied up for as long as the process runs.

The only exception might be if your switch uses highly non-optimized cases (e.g., thousands of non-contiguous string cases) and your array uses primitive values that are already stored elsewhere—but for 100 branches, this edge case doesn’t apply.

内容的提问来源于stack exchange，提问作者Watan