Which is faster in PHP, $array[] = $value or array_push($array, $value)?
PhpArraysPerformancePhp Problem Overview
What's better to use in PHP for appending an array member,
$array[] = $value;
or
array_push($array, $value);
?
Though the manual says you're better off to avoid a function call, I've also read $array[]
is much slower than array_push()
. What are some clarifications or benchmarks?
Php Solutions
Solution 1 - Php
I personally feel like $array[]
is cleaner to look at, and honestly splitting hairs over milliseconds is pretty irrelevant unless you plan on appending hundreds of thousands of strings to your array.
I ran this code:
$t = microtime(true);
$array = array();
for($i = 0; $i < 10000; $i++) {
$array[] = $i;
}
print microtime(true) - $t;
print '<br>';
$t = microtime(true);
$array = array();
for($i = 0; $i < 10000; $i++) {
array_push($array, $i);
}
print microtime(true) - $t;
The first method using $array[]
is almost 50% faster than the second one.
Some benchmark results:
Run 1
0.0054171085357666 // array_push
0.0028800964355469 // array[]
Run 2
0.0054559707641602 // array_push
0.002892017364502 // array[]
Run 3
0.0055501461029053 // array_push
0.0028610229492188 // array[]
This shouldn't be surprising, as the PHP manual notes this:
> If you use array_push() to add one element to the array it's better to use $array[] = because in that way there is no overhead of calling a function.
The way it is phrased I wouldn't be surprised if array_push
is more efficient when adding multiple values. Out of curiosity, I did some further testing, and even for a large amount of additions, individual $array[]
calls are faster than one big array_push
. Interesting.
Solution 2 - Php
The main use of array_push() is that you can push multiple values onto the end of the array.
It says in the documentation:
> If you use array_push() to add one > element to the array it's better to > use $array[] = because in that way > there is no overhead of calling a > function.
Solution 3 - Php
From the PHP documentation for array_push
:
> Note: If you use array_push() to add one element to the array it's better to use $array[] = because in that way there is no overhead of calling a function.
Solution 4 - Php
Word on the street is that [] is faster because no overhead for the function call. Plus, no one really likes PHP's array functions...
"Is it...haystack, needle....or is it needle haystack...ah, f*** it...[] = "
Solution 5 - Php
One difference is that you can call array_push() with more than two parameters, i.e. you can push more than one element at a time to an array.
$myArray = array();
array_push($myArray, 1,2,3,4);
echo join(',', $myArray);
prints 1,2,3,4
Solution 6 - Php
A simple $myarray[] declaration will be quicker as you are just pushing an item onto the stack of items due to the lack of overhead that a function would bring.
Solution 7 - Php
Since "array_push" is a function and it called multiple times when it is inside the loop, it will allocate memory into the stack.
But when we are using $array[] = $value then we are just assigning a value to the array.
Solution 8 - Php
Second one is a function call so generally it should be slower than using core array-access features. But I think even one database query within your script will outweight 1000000 calls to array_push()
.
See here for a quick benchmark using 1000000 inserts: https://3v4l.org/sekeV
Solution 9 - Php
I just wan't to add : int array_push(...)
returns
the new number of elements in the array (PHP documentation). which can be useful and more compact than $myArray[] = ...; $total = count($myArray);
.
Also array_push(...)
is meaningful when variable is used as a stack.