Ist in PHP (>= 5.0) die Referenzübergabe schneller?

In PHP können Funktionsparameter per Referenz übergeben werden, indem dem Parameter in der Funktionsdeklaration ein kaufmännisches Und vorangestellt wird, wie folgt:

function foo(&$bar)
{
    // ...
}

Jetzt ist mir bewusst, dass dies der Fall ist nicht entwickelt, um die Leistung zu verbessern, aber Funktionen zu ermöglichen, Variablen zu ändern, die normalerweise außerhalb ihres Gültigkeitsbereichs liegen.

Stattdessen scheint PHP Copy On Write zu verwenden, um zu vermeiden, dass Objekte (und möglicherweise auch Arrays) kopiert werden, bis sie geändert werden. Bei Funktionen, die ihre Parameter nicht ändern, sollte der Effekt also derselbe sein, als hätten Sie sie per Referenz übergeben.

Ich habe mich jedoch gefragt, ob die Copy On Write-Logik möglicherweise bei Pass-by-Reference kurzgeschlossen ist und ob dies Auswirkungen auf die Leistung hat.

ETA: Sicherlich gehe ich davon aus, dass es nicht schneller geht, und ich bin mir bewusst, dass Referenzen dafür nicht da sind. Also denke ich, dass meine eigenen Vermutungen ziemlich gut sind, ich suche nur nach einer Antwort von jemandem, der wirklich weiß, was definitiv unter der Haube passiert. In fünf Jahren PHP-Entwicklung fand ich es immer schwierig, qualitativ hochwertige Informationen über PHP-Interna zu bekommen, ohne die Quelle gelesen zu haben.

In einem Test mit 100 000 Iterationen zum Aufrufen einer Funktion mit einer Zeichenfolge von 20 kB sind die Ergebnisse:

Funktion, die nur den Parameter liest / verwendet

pass by value:      0.12065005 seconds
pass by reference:  1.52171397 seconds

Funktion zum Schreiben / Ändern des Parameters

pass by value:      1.52223396 seconds
pass by reference:  1.52388787 seconds

Schlussfolgerungen

1. Übergeben Sie den Parameter als Wert ist immer schneller

2. Wenn die Funktion den Wert der übergebenen Variablen ändert, ist das praktisch dasselbe wie eine Referenzübergabe als eine Wertübergabe

Die Zend-Engine verwendet Copy-on-Write, und wenn Sie selbst eine Referenz verwenden, entsteht ein wenig zusätzlicher Overhead. Kann nur finden diese Erwähnung zum Zeitpunkt des Schreibens und Kommentare in das Handbuch weitere Links enthalten.

(EDIT) Die Handbuchseite auf Objekte und Referenzen enthält ein wenig mehr Informationen darüber, wie sich Objektvariablen von Referenzen unterscheiden.

Ich habe einige Tests dazu durchgeführt, weil ich mir der gegebenen Antworten nicht sicher war.

Meine Ergebnisse zeigen, dass das Übergeben großer Arrays oder Zeichenfolgen als Referenz wesentlich schneller ist.

Hier sind meine Ergebnisse:

Die Y-Achse (Runs) gibt an, wie oft eine Funktion in 1 Sekunde * 10 aufgerufen werden könnte

Der Test wurde für jede Funktion/Variable 8 mal wiederholt

Und hier sind die Variablen, die ich verwendet habe:

$large_array = array_fill(PHP_INT_MAX / 2, 1000, 'a');
$small_array = array('this', 'is', 'a', 'small', 'array');
$large_object = (object)$large_array;
$large_string = str_repeat('a', 100000);
$small_string = 'this is a small string';
$value = PHP_INT_MAX / 2;

Das sind die Funktionen:

function pass_by_ref(&$var) {
}

function pass_by_val($var) {
}

Ich habe mit Werten und Referenzen von 10k-Byte-Strings experimentiert, die an zwei identische Funktionen übergeben wurden. Man nimmt das Argument als Wert und das zweite als Referenz. Sie waren allgemeine Funktionen – nehmen Sie ein Argument, führen Sie eine einfache Verarbeitung durch und geben Sie einen Wert zurück. Ich habe 100.000 Aufrufe von beiden durchgeführt und herausgefunden, dass Referenzen nicht darauf ausgelegt sind, die Leistung zu steigern – der Referenzgewinn lag bei 4-5 % und wächst nur, wenn die Zeichenfolge groß genug wird (100.000 und länger, das führte zu einer Verbesserung von 6-7 %). . Also, mein Fazit ist Verwenden Sie keine Referenzen, um die Leistung zu steigern, dafür ist dieses Zeug nicht da.

Ich habe PHP Version 5.3.1 verwendet

Ich bin mir ziemlich sicher, dass nein, es ist nicht schneller. Darüber hinaus heißt es im Handbuch ausdrücklich, nicht zu versuchen, Referenzen zur Leistungssteigerung zu verwenden.

Edit: Ich kann nicht finden, wo das steht, aber es ist da!

Ich habe versucht, dies mit einem realen Beispiel zu vergleichen, das auf einem Projekt basiert, an dem ich arbeitete. Wie immer sind die Unterschiede trivial, aber die Ergebnisse waren etwas unerwartet. Bei den meisten Benchmarks, die ich gesehen habe, ändert die aufgerufene Funktion den übergebenen Wert nicht wirklich. Ich habe ein einfaches str_replace() darauf ausgeführt.

**Pass by Value Test Code:**

$originalString=''; // 1000 pseudo-random digits

function replace($string) {
    return str_replace('1', 'x',$string);
}
$output="";
/* set start time */
$mtime = microtime();
$mtime = explode(" ", $mtime);
$mtime = $mtime[1] + $mtime[0];
$tstart = $mtime;
set_time_limit(0);

for ($i = 0; $i < 10; $i++ ) {
    for ($j = 0; $j < 1000000; $j++) {
        $string = $originalString;
        $string = replace($string);
    }
}

/* report how long it took */
$mtime = microtime();
$mtime = explode(" ", $mtime);
$mtime = $mtime[1] + $mtime[0];
$tend = $mtime;
$totalTime = ($tend - $tstart);
$totalTime = sprintf("%2.4f s", $totalTime);
$output .= "\n" . 'Total Time' .
    ': ' . $totalTime;
$output .= "\n" . $string;
echo $output;

Übergeben Sie den Referenztestcode

Das gleiche außer

function replace(&$string) {
    $string = str_replace('1', 'x',$string);
}
/* ... */
replace($string);

Ergebnisse in Sekunden (10 Millionen Iterationen):

PHP 5
    Value:     14.1007
    Reference: 11.5564

PHP 7
    Value:     3.0799
    Reference: 2.9489

Der Unterschied beträgt einen Bruchteil einer Millisekunde pro Funktionsaufruf, aber für diesen Anwendungsfall ist die Übergabe per Referenz sowohl in PHP 5 als auch in PHP 7 schneller.

(Hinweis: Die PHP 7-Tests wurden auf einem schnelleren Rechner durchgeführt – PHP 7 ist schneller, aber wahrscheinlich nicht viel schneller.)

Es gibt nichts Besseres als ein Teststück Code

<?PHP
$r = array();

for($i=0; $i<500;$i++){
$r[]=5;
}

function a($r){
$r[0]=1;
}
function b(&$r){
$r[0]=1;
}

$start = microtime(true);
for($i=0;$i<9999;$i++){
  //a($r);
  b($r);
}
$end = microtime(true);

echo $end-$start;
?>

Endergebnis! Je größer das Array (oder je größer die Anzahl der Aufrufe), desto größer ist der Unterschied. In diesem Fall ist der Aufruf per Referenz also schneller, da der Wert innerhalb der Funktion geändert wird.

Ansonsten gibt es keinen wirklichen Unterschied zwischen “by reference” und “by value”, der Compiler ist schlau genug, nicht jedes Mal eine neue Kopie zu erstellen, wenn es nicht nötig ist.