Add Array Items

PHP arrays grow dynamically — you never declare a size. New elements can be added at the end, at the beginning, at a specific position, or under a specific key. This lesson covers each technique, how PHP chooses keys for new elements, and how to add items safely.

Adding to the End: $array[] = ...

Example

<?php
$cart = ['Gel Pen'];

$cart[] = 'Notebook';
$cart[] = 'Eraser';

print_r($cart);

Output

Array
(
    [0] => Gel Pen
    [1] => Notebook
    [2] => Eraser
)

Empty brackets mean "append with the next available integer key". This is the most common and fastest way to add a single element.

How the Next Key Is Chosen

PHP uses the largest integer key the array has ever had, plus one — even if that key has since been removed:

<?php
$numbers = [3 => 'three'];
$numbers[] = 'four';

$letters = ['a', 'b'];
unset($letters[1]);
$letters[] = 'c';

print_r($numbers);
print_r($letters);

Output

Array
(
    [3] => three
    [4] => four
)
Array
(
    [0] => a
    [2] => c
)

• After key 3, the next key is 4.
• After removing key 1, PHP does not reuse it; the next key is 2. Use array_values() if you need continuous indexes again.

Adding Several Items: array_push()

<?php
$cart = ['Gel Pen', 'Notebook'];

$newCount = array_push($cart, 'Eraser', 'Ruler');

echo "Items: $newCount\n";
echo implode(', ', $cart) . "\n";

Output

Items: 4
Gel Pen, Notebook, Eraser, Ruler

• array_push() modifies the array in place (it takes it by reference) and returns the new number of elements.
• It can add several values in one call.
• For a single value, $cart[] = 'Eraser'; is preferred: it is shorter and avoids a function call.

Adding to the Beginning: array_unshift()

<?php
$queue = ['ORD-12', 'ORD-13'];

array_unshift($queue, 'ORD-URGENT');

print_r($queue);

Output

Array
(
    [0] => ORD-URGENT
    [1] => ORD-12
    [2] => ORD-13
)

array_unshift() inserts values at the start and re-numbers all integer keys. (String keys are kept.) Because every element moves, it is slower than appending for very large arrays — when you build a list in reverse order, it is usually better to append and call array_reverse() once at the end.

Adding at a Specific Position: array_splice()

<?php
$checkoutSteps = ['Cart', 'Address', 'Payment', 'Confirm'];

array_splice($checkoutSteps, 2, 0, ['Verify OTP']);

echo implode(' → ', $checkoutSteps) . "\n";

Output

Cart → Address → Verify OTP → Payment → Confirm

array_splice($array, $offset, $length, $replacement) with a length of 0 removes nothing and inserts the replacement at position $offset. The list is re-indexed automatically.

Adding Under a Specific Key

For associative arrays, assigning to a new key adds an element:

<?php
$user = ['name' => 'Asha', 'email' => 'asha@example.com'];

$user['phone'] = '+91 98765 43210';
$user['verified'] = true;

print_r($user);

Output

Array
(
    [name] => Asha
    [email] => asha@example.com
    [phone] => +91 98765 43210
    [verified] => 1
)

New keys are added at the end. If the key already exists, its value is replaced instead — the same syntax adds or updates. To add only when the key is missing, use ??=:

<?php
$settings = ['theme' => 'dark'];

$settings['theme'] ??= 'light';      // already set: unchanged
$settings['language'] ??= 'en';      // missing: added

print_r($settings);

Output

Array
(
    [theme] => dark
    [language] => en
)

Adding to Nested Arrays

<?php
$order = ['id' => 501, 'items' => [['name' => 'Gel Pen', 'qty' => 10]]];

$order['items'][] = ['name' => 'Notebook', 'qty' => 3];
$order['notes'][] = 'Gift wrap requested';   // 'notes' did not exist

echo count($order['items']) . " items\n";
print_r($order['notes']);

Output

2 items
Array
(
    [0] => Gift wrap requested
)

Appending to a nested key that does not exist ($order['notes'][]) creates that inner array automatically. This makes grouping data very concise (see the practical example below).

Creating a New Array Instead of Modifying

The spread operator and array_merge() build a new array, leaving the original unchanged:

<?php
$basics = ['Variables', 'Strings'];

$withArrays = [...$basics, 'Arrays'];
$withIntro = ['Introduction', ...$basics];
$combined = array_merge($basics, ['Loops', 'Functions']);

echo implode(', ', $withArrays) . "\n";
echo implode(', ', $withIntro) . "\n";
echo implode(', ', $combined) . "\n";
echo implode(', ', $basics) . "\n";

Output

Variables, Strings, Arrays
Introduction, Variables, Strings
Variables, Strings, Loops, Functions
Variables, Strings

This style is useful when the original must stay intact — for example, when building variations of a base configuration. See Array Spread Operator and Merge Arrays.

Adding Only Unique Values

Checking Before Adding

<?php
$tags = ['php', 'mysql'];

foreach (['laravel', 'php', 'api'] as $tag) {
    if (!in_array($tag, $tags, true)) {
        $tags[] = $tag;
    }
}

echo implode(', ', $tags) . "\n";

Output

php, mysql, laravel, api

Using Keys as a Set

in_array() searches the whole array each time, which becomes slow for large lists. Using the values as keys gives fast, automatic uniqueness:

<?php
$seen = [];

foreach (['php', 'mysql', 'php', 'api', 'mysql'] as $tag) {
    $seen[$tag] = true;
}

echo implode(', ', array_keys($seen)) . "\n";

Output

php, mysql, api

Assigning the same key twice simply overwrites it, so each tag appears once. Key lookups are fast regardless of array size.

What Can Be Appended To

<?php
$fresh = [];
$fresh[] = 'works';            // empty array: fine

$fromNull = null;
$fromNull[] = 'also works';    // null becomes an array

print_r($fresh);
print_r($fromNull);

Output

Array
(
    [0] => works
)
Array
(
    [0] => also works
)

• Appending to null (or an undefined variable) creates a new array.
• Appending to false also creates an array, but this has been deprecated since PHP 8.1 ("Automatic conversion of false to array is deprecated"). This often happens with functions that return false on failure.
• Appending to a non-empty string, an integer, or an object is an error.

Initializing arrays explicitly with $list = []; avoids all of these cases.

Practical Example: Grouping Products by Category

<?php
$products = [
    ['name' => 'Desk Lamp', 'category' => 'Home'],
    ['name' => 'Notebook', 'category' => 'Stationery'],
    ['name' => 'Cushion', 'category' => 'Home'],
    ['name' => 'Gel Pen', 'category' => 'Stationery'],
    ['name' => 'Headphones', 'category' => 'Electronics'],
];

$byCategory = [];

foreach ($products as $product) {
    $byCategory[$product['category']][] = $product['name'];
}

ksort($byCategory);

foreach ($byCategory as $category => $names) {
    echo "$category (" . count($names) . "): " . implode(', ', $names) . "\n";
}

Output

Electronics (1): Headphones
Home (2): Desk Lamp, Cushion
Stationery (2): Notebook, Gel Pen

Step-by-Step Explanation

1. $byCategory starts empty.
2. $byCategory[$product['category']][] = $product['name']; does two things at once:
   • If the category key does not exist yet, PHP creates it with an empty array.
   • The product name is appended to that category's list.
3. ksort() sorts the categories alphabetically by key.
4. Products keep their original order within each category.

This one-line grouping pattern is used constantly — for example, to group orders by status, students by class, or log entries by date.

Common Mistakes

Assigning the Result of array_push()

$cart = array_push($cart, 'Pen');   // $cart becomes an integer!

Effect: array_push() returns the new count, so the array is replaced by a number.

Fix: Call it as a statement: array_push($cart, 'Pen');, or use $cart[] = 'Pen';.

Using + to Append to a List

Effect: [1, 2] + [3] gives [1, 2], because key 0 already exists.

Fix: Use [...$a, ...$b] or array_merge().

Expecting Removed Indexes to Be Reused

Effect: Gaps remain after unset(), even when new items are appended.

Fix: Re-index with array_values() when continuous indexes matter.

Appending to Unchecked Function Results

Effect: Deprecation notices (for false) or errors (for strings).

Fix: Initialize arrays explicitly and check function results.

Using array_unshift() in a Loop on Large Arrays

Effect: Every call re-indexes the entire array.

Fix: Append, then reverse once.

Best Practices

• Use $array[] = $value; to append a single item.
• Use array_push() only to append several items at once, and never assign its result to the array.
• Use array_splice() to insert at a position and array_unshift() for the occasional prepend.
• Use the $groups[$key][] = $value; pattern for grouping.
• Use keys as a set for fast uniqueness checks.
• Initialize arrays with [] before adding to them.

Official reference: https://www.php.net/manual/en/function.array-push.php