How to Add Elements to an Empty Array in PHP

By the end of this page, you will understand how to add elements to arrays in PHP, the difference between [] and array_push(), why PHP arrays do not use an add() method, and how this works in real code.

In PHP, arrays are dynamic, which means you usually do not declare a fixed size ahead of time. You can start with an empty array and append values whenever you need.

The most common way to add an item to the end of an array is:

$cart[] = 13;

When PHP sees empty square brackets [], it automatically places the value at the next available numeric index.

For example:

$cart = array();
$cart[] = 13;
$cart[] = "foo";

This becomes:

array(
    0 => 13,
    1 => "foo"
)

PHP arrays do not have an instance method like add(). In other words, this is not valid PHP:

$cart->add(13); // not how PHP arrays work

That style is common in some other languages or collection classes, but a plain PHP array is a built-in language type, not an object with methods.

PHP also provides the function array_push() to append one or more values:

array_push($cart, 13);

However, for adding a single item, $cart[] = 13; is usually simpler and more common.

This matters because arrays are used everywhere in PHP: storing query results, building lists of items, collecting form data, and preparing JSON responses. Knowing the standard way to append values helps you read and write normal PHP code confidently.

Think of a PHP array like a shopping list written on paper.

• You start with a blank list: array()
• Each time you use [], PHP writes the new item on the next empty line
• You do not need to manually track the line number unless you want to

Example:

$cart = array();
$cart[] = "Apples";
$cart[] = "Bread";

PHP is effectively doing this for you:

• Put "Apples" at index 0
• Put "Bread" at index 1

So [] means: append this value at the end.

The main ways to add elements to an array in PHP are:

Append to the end with []

$cart = array();
$cart[] = 13;
$cart[] = "foo";
$cart[] = $obj;

This is the most common approach.

Using short array syntax

In modern PHP, this is equivalent and more commonly written as:

$cart = [];
$cart[] = 13;
$cart[] = "foo";

Append with array_push()

$cart = [];
array_push($cart, 13);
array_push($cart, "foo", "bar");

array_push() is useful when adding multiple items in one call.

Assign to a specific key

PHP arrays can also use custom keys:

$cart = [];
$cart["product"] = "Book";
$cart["quantity"] = 2;

This creates an associative array.

Example: mixed values

PHP arrays can contain different types:

$cart = [];
$cart[] = 13;
$cart[] = "foo";
$cart[] = true;
$cart[] = ["name" => "Pen", "price" => 1.50];

This is valid, although in real applications it is often better to keep array contents consistent when possible.

Consider this example:

$cart = [];
$cart[] = 13;
$cart[] = "foo";
$cart[] = "bar";

print_r($cart);

Step by step:

1. $cart = [];

   • Creates an empty array.
   • Current value:

   []
   

2. $cart[] = 13;

   • PHP finds the next numeric index, which is 0.
   • Current value:

   [0 => 13]
   

3. $cart[] = "foo";

   • PHP appends at index 1.
   • Current value:

   [0 => 13, 1 => "foo"]
   

4. $cart[] = "bar";

   • PHP appends at index 2.
   • Current value:

   [0 => 13, 1 => "foo", 2 => "bar"]
   

5. print_r($cart);

   • Output:

   Array
   (
       [0] => 13
       [1] => foo
       [2] => bar
   )
   

Now compare it with array_push():

$cart = [];
array_push($cart, 13, "foo", "bar");
print_r($cart);

The final array is the same.

Here are common situations where appending to arrays is used in PHP:

Building a shopping cart

$cart = [];
$cart[] = ["id" => 101, "name" => "T-shirt", "qty" => 2];
$cart[] = ["id" => 205, "name" => "Shoes", "qty" => 1];

Collecting validation errors

$errors = [];

if (empty($email)) {
    $errors[] = "Email is required.";
}

if (strlen($password) < 8) {
    $errors[] = "Password must be at least 8 characters.";
}

Preparing API response data

$items = [];
$items[] = ["id" => 1, "title" => "First post"];
$items[] = ["id" => 2, "title" => "Second post"];

Grouping database results

$names = [];
while ($row = fetchRow()) {
    $names[] = $row['name'];
}

Logging events during a script

$log = [];
$log[] = "Script started";
$log[] = "User loaded";
$log[] = "Email sent";

In real PHP projects, developers usually append to arrays in a few common patterns.

1. Collecting results in loops

$products = [];
foreach ($rows as $row) {
    $products[] = [
        'id' => $row['id'],
        'name' => $row['name']
    ];
}

This is very common when transforming data.

2. Collecting validation errors

$errors = [];

if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
    $errors[] = 'Invalid email address';
}

if ($age < 18) {
    $errors[] = 'You must be at least 18';
}

3. Building configuration arrays

$config = [];
$config['debug'] = true;
$config['timezone'] = 'UTC';

This uses named keys instead of numeric append.

4. Returning structured data from functions

function buildResponse(array $users): array {
    $result = [];

    foreach ($users as $user) {
        $result[] = [
            'id' => $user['id'],
            'name' => $user['name']
        ];
    }

    return $result;
}

5. Guard clauses with error arrays

$errors = [];

if (empty($title)) {
    $errors[] = 'Title is required';
}

if (!empty($errors)) {
    return $errors;
}

Even though arrays do not have methods like add(), they are still extremely flexible and central to day-to-day PHP development.

Beginners often make these mistakes when working with PHP arrays.

Mistake 1: Expecting an add() method

Broken code:

$cart = [];
$cart.add(13);

Why it is wrong:

• PHP arrays are not used with dot syntax
• PHP does not provide an array instance method called add()

Correct code:

$cart = [];
$cart[] = 13;

Mistake 2: Forgetting the $ on variables

Broken code:

cart[] = 13;

Correct code:

$cart[] = 13;

Mistake 3: Using an undefined constant instead of a string

Broken code:

$cart[] = obj;

If obj is meant to be a variable, it must be written with $.

Correct code:

$cart[] = $obj;

If it is meant to be text, quote it:

$cart[] = "obj";

Mistake 4: Confusing numeric arrays and associative arrays

$cart = [];
$cart[] = 'Book';
$cart['quantity'] = 2;

This is valid PHP, but mixing styles can make code harder to understand.

A clearer structure might be:

$item = [
    'name' => 'Book',
    'quantity' => 2
];

Mistake 5: Using array_push() for a single item everywhere

This works:

array_push($cart, 13);

But for one item, this is usually clearer:

$cart[] = 13;

Mistake 6: Assuming arrays have fixed size

In PHP, arrays grow as needed. You do not usually predefine their size like in some other languages.

Here is how the main options compare:

[] vs array_push()

PHP arrays vs arrays in some other languages

This is why cart.add(13) feels familiar if you come from another language, but it is not how plain PHP arrays work.

Quick reference

Create an empty array

$cart = array();

or:

$cart = [];

Append one item

$cart[] = 13;

Append multiple items

array_push($cart, 13, "foo", "bar");

Set a specific key

$cart['name'] = 'Book';

Store objects or arrays

$cart[] = $obj;
$cart[] = ['id' => 1, 'name' => 'Pen'];

Rules to remember

• PHP arrays are dynamic
• You do not need to declare a size first
• [] appends to the end of the array
• There is no add() method for plain PHP arrays
• Use $variable, not variable
• Use quotes for strings

Common choice

For one item:

$cart[] = $value;

For many items at once:

array_push($cart, $a, $b, $c);

Is $array[] = $value the normal way to add to an array in PHP?

Yes. It is the most common way to append a single value to the end of a PHP array.

Does PHP have an add() method for arrays?

No. Plain PHP arrays do not have an add() method. Use [] or array_push() instead.

What is the difference between [] and array_push() in PHP?

Both can append values. [] is simpler for one item, while array_push() can add multiple items in one call.

Can a PHP array contain different data types?

Yes. A PHP array can contain integers, strings, booleans, arrays, objects, and more.

Do I need to define the size of an array first in PHP?

No. PHP arrays grow automatically as you add items.

Can I add an object to a PHP array?

Yes, as long as you use a variable such as $obj.

$cart[] = $obj;

Should I use array() or []?

Both work. [] is shorter and more common in modern PHP code.

• Indexed arrays — Related because appending with [] usually creates numeric indexes like 0, 1, and 2.
• Associative arrays — Related because PHP arrays can also use named keys such as 'name' and 'price'.
• array_push() — Related because it is the built-in function for appending one or more items.
• Variables in PHP — Related because every array variable and object variable must use the $ prefix.
• Objects in PHP — Related because objects can be stored inside arrays, but arrays themselves are not object instances with methods like add().
• foreach loops — Related because arrays are often built and then iterated using foreach.
• print_r() and var_dump() — Related because they help inspect array contents while learning or debugging.
• Multidimensional arrays — Related because real applications often store arrays inside arrays, such as carts, API data, or grouped records.