In PHP, how do you destructure an array into separate variables with [] or list(), both by position and by key?
answer
- an array pattern on the left of =
- positional reads keys 0, 1, 2
- 'lat' => $lat picks by key
- empty slot skips an element
- [$a, $b] = [$b, $a] swaps
basics
~20 sPut an array pattern on the left of =: [$lat, $lng] = $point copies the elements at keys 0 and 1, and ['lat' => $lat] = $point copies by key. list() is the older spelling of the same construct.
solid answer
~40 sDestructuring assigns several variables from one array in a single statement. The short form `[$lat, $lng] = $point;` and the older `list($lat, $lng) = $point;` are the same construct. A **positional** pattern reads keys `0`, `1`, `2`, … in that order, not "the first and second elements". A **keyed** pattern names the keys: `['lat' => $lat, 'lng' => $lng] = $point;`, and the keys can be any expression. Leave a slot empty to skip an element (`[, $lng] = $point`), nest patterns for nested arrays, and swap two variables with `[$a, $b] = [$b, $a];`. One pattern cannot mix keyed and unkeyed entries, and a missing key yields `null` plus an `E_WARNING` in PHP 8.
code
php · 14 lines<?php
declare(strict_types=1);
// One track point from a hiking-route API: [lat, lng, elevation]
$trackPoint = [46.5580, 7.9812, 2061];
[$lat, $lng] = $trackPoint; // positional: keys 0 and 1
[, , $elevation] = $trackPoint; // skip two slots
$start = ['lat' => 46.5580, 'lng' => 7.9812];
['lng' => $lng2, 'lat' => $lat2] = $start; // keyed, any order
[$lat, $lng] = [$lng, $lat]; // swap
echo "$lat $lng $elevation $lat2", PHP_EOL; // 7.9812 46.558 2061 46.558go deeper
Recall both spellings, [] and list(), the keyed form with =>, skipping with an empty slot and the one-line swap.
Explain that positional patterns read keys 0, 1, 2 rather than the first elements, why keyed and unkeyed entries cannot mix, and what a missing key does.
Use keyed patterns for external payloads so a shape change fails visibly, and review positional unpacking of associative data as a latent null bug.
Decide where arrays stop and typed objects begin: destructuring is fine at the edge, but a shape used across many functions deserves a named class the tooling can check.
## What destructuring is **Destructuring** (also called unpacking) assigns several variables from one array in one statement. You write an array-shaped **pattern** on the left of `=` and an array on the right; each variable in the pattern receives the element at the matching key. PHP has two spellings for the pattern: - `[$lat, $lng] = $point;` — the short square-bracket form, the usual choice in modern code. - `list($lat, $lng) = $point;` — the older `list()` construct. It is not a function, and it behaves exactly the same. The whole assignment expression evaluates to the right-hand array, which is why the old idiom `while ([$a, $b] = nextRow())` works: when the call returns `null`, the loop condition is falsy. ## Positional patterns read keys 0, 1, 2 A pattern without keys is positional, and it is easy to misread. It does **not** take "the first two elements"; it takes the elements whose keys are `0` and `1`: | Right-hand side | `[$lat, $lng] = …` gives | |---|---| | `[46.55, 7.98]` | `$lat = 46.55`, `$lng = 7.98` | | `[1 => 7.98, 0 => 46.55]` | `$lat = 46.55`, `$lng = 7.98` (keys win over order) | | `['lat' => 46.55, 'lng' => 7.98]` | both `null`, plus two `Undefined array key` warnings | So a positional pattern suits **lists**, such as the `[lat, lng]` pairs a hiking-route API returns for each track point, or the result of `explode()`. ## Keyed patterns For associative arrays, name the keys: ```php ['lat' => $lat, 'lng' => $lng] = $point; ``` - Keys can be strings, integers or any expression, such as a constant or a variable. - Order does not matter, and you can pick only the keys you need. - Integer keys let you pick from a list by position: `[2 => $elevation] = $trackPoint;`. Keyed patterns are the self-documenting choice for API payloads: the code says which field goes into which variable. ## Skipping, nesting and swapping 1. **Skip** an element by leaving its slot empty: `[, $lng] = $point;` or `[$lat, , $elevation] = $trackPoint;`. 2. **Nest** patterns to reach into nested arrays: `['start' => [$lat, $lng]] = $route;`. 3. **Swap** two variables without a temporary: `[$a, $b] = [$b, $a];`. The right-hand array is built from the old values first, then unpacked. 4. **Bind by reference** with `&`: after `[$lat, &$lng] = $point;`, writing to `$lng` changes `$point[1]`. ## Rules the compiler enforces Some patterns are rejected before the script runs: - **Mixing keyed and unkeyed entries** in one pattern, as in `[$id, 'name' => $name] = $row;`, is a fatal compile error: "Cannot mix keyed and unkeyed array entries in assignments". Nested patterns may each choose their own style. - **A pattern with no variables at all**, only empty slots such as `list(, ,) = $point;`, fails with "Cannot use empty list". - **A rest element** such as `[$head, ...$tail] = $items;` fails with "Spread operator is not supported in assignments"; the spread operator only works when *building* arrays. ## What happens when the data does not fit In PHP 8 a key missing from the right-hand array raises an `E_WARNING` ("Undefined array key") and assigns `null`; before PHP 8.0 it was an `E_NOTICE`. The code keeps running with `null` in the variable, so a pattern that does not match the data's shape is a quiet bug rather than a crash. Checking the shape at the boundary, or using keyed patterns against a documented payload, keeps that from spreading. ## Why interviewers ask about it Destructuring shows up in everyday modern PHP: splitting `explode()` results, unpacking pairs returned from a helper, iterating over rows. The screening version checks that a candidate knows the syntax; the follow-ups check that they know positional patterns read keys `0`, `1`, `2`, and that a mismatch yields `null` rather than an exception. ## Choosing a style - Positional `[$a, $b]` for true lists whose order is the contract: coordinate pairs, `explode()` results, rows fetched as numeric arrays. - Keyed `['lat' => $lat]` for associative data: decoded JSON objects, configuration arrays, database rows fetched by column name. - A small typed object instead, when the same shape travels through many functions and deserves a name.
- Why does [$lat, $lng] = ['lat' => 46.55, 'lng' => 7.98] leave both variables null?A positional pattern reads the keys `0` and `1`, and this array has only the string keys `lat` and `lng`. Each lookup misses, PHP 8 raises an `Undefined array key` warning and assigns `null`. Use a keyed pattern, `['lat' => $lat, 'lng' => $lng] = $point;`, for associative data.
- Can you destructure an object into variables?Only if it implements `ArrayAccess`; the pattern then calls `offsetGet()` for each key. A plain object such as `stdClass` throws an `Error` ("Cannot use object of type stdClass as array"). For ordinary objects, read the properties directly or convert the data to an array first.
- A positional pattern takes the first elements whatever their keys
- list() is a function that returns the unpacked values
- One pattern can mix keyed and positional entries
- Swapping two variables with destructuring needs a temporary variable
- [$head, ...$tail] = $items collects the remaining elements
Assumes PHP 8.5; a missing key raises E_WARNING (Undefined array key) since PHP 8.0, where earlier versions raised E_NOTICE.