PHP by-reference Parameter und Standard null

Question

Lassen Sie uns sagen, dass wir eine Methodensignatur wie

haben

public static function explodeDn($dn, array &$keys = null, array &$vals = null,
    $caseFold = self::ATTR_CASEFOLD_NONE)

Wir können einfach die Methode aufrufen, indem Sie alle Parameter nach $dn Weglassen:

$dn=Zend_Ldap_Dn::explodeDn('CN=Alice Baker,CN=Users,DC=example,DC=com');

Wir können auch die Methode mit 3 Parametern aufrufen:

$dn=Zend_Ldap_Dn::explodeDn('CN=Alice Baker,CN=Users,DC=example,DC=com', $k, $v);

und mit 4 Parametern:

$dn=Zend_Ldap_Dn::explodeDn('CN=Alice Baker,CN=Users,DC=example,DC=com', $k, $v, 
    Zend_Ldap_Dn::ATTR_CASEFOLD_UPPER);

Aber warum ist es unmöglich, das Verfahren mit der folgenden Parameter Kombination zum Beispiel zu nennen:

$dn=Zend_Ldap_Dn::explodeDn('CN=Alice Baker,CN=Users,DC=example,DC=com', $k, null, 
    Zend_Ldap_Dn::ATTR_CASEFOLD_UPPER);
$dn=Zend_Ldap_Dn::explodeDn('CN=Alice Baker,CN=Users,DC=example,DC=com', null, $v);

Was ist der Unterschied null das Verfahren und unter Berufung auf dem Standardwert zwischen vorbei? Ist diese Einschränkung im Handbuch geschrieben? Kann es umgangen werden?

Answer 1

Es ist, weil Sie nicht einen Verweis auf null.

können Sie haben einen Verweis auf eine Variable, die null enthält - das ist genau das, was der Standardwert der Fall ist. Oder Sie können in null als wörtlichen Wert übergeben -. Aber da Sie ein Out-Parameter wollen dies ist hier nicht möglich

Answer 2

Während Sie ein Dummy-Variable für by-ref Argumente erstellen müssen, wenn Sie NULL mögen ausdrücklich passieren, müssen Sie sie nicht, dass der Variable in einer separaten Zeile erstellen. Sie können einen Auftrag Ausdruck wie $ dummy = NULL direkt als Funktionsargument verwenden:

function foo (&$ref = NULL) {

    if (is_null($ref)) $ref="bar";
    echo "$ref\n";        
}

foo($dummy = NULL); //this works!

Answer 3

Ich habe gerade herausgefunden, diese selbst, und ich bin ziemlich geschockt o_O!

Dies ist, was die PHP-Dokumentation sagt:

function makecoffee($type = "cappuccino")
{
    return "Making a cup of $type.\n";
}
echo makecoffee(); // returns "Making a cup of cappuccino."
echo makecoffee(null); // returns "Making a cup of ."
echo makecoffee("espresso"); // returns "Making a cup of espresso."

Ich würde makecoffee(null) hätte erwarten zurückzukehren „um eine Tasse Cappuccino zu machen.“. Eine Behelfslösung habe ich verwendet, ist innerhalb der Funktion zu überprüfen, ob das Argument null:

function makecoffee($type = null)
{
    if (is_null($type)){ 
       $type = "capuccino";
    }
    return "Making a cup of $type.\n";
}

Jetzt makecoffee(null) returns "Ich mache eine Tasse Cappuccino."

(Ich weiß, das ist eigentlich nicht die Zend-bezogene Frage zu lösen, aber es könnte einige nützlich sein ...)

Answer 4

@ Tomalak

Tatsächlich schafft der Standardwert eine Variable ohne beteiligt Referenz. Welches ist etwas, das man einfach nicht beginnen kann, wenn man etwas passieren.

Was ich finde, die Gründe zu erläutern ist das folgende Beispiel (was ich testen nicht):

function foo (&$ref = NULL) {
  $args = func_get_args();
  echo var_export($ref, TRUE).' - '.var_export($args, TRUE);
}
$bar = NULL;
foo();     // NULL - array()
foo($bar); // NULL - array(0 => NULL)

Meiner Meinung nach, sollte PHP bietet eine Möglichkeit, nicht bestimmte Parameter zu übergeben, wie mit
foo($p1, , , $p4); oder ähnliche Syntax anstelle des Führens NULL.
Aber es funktioniert nicht, so müssen Sie Dummy-Variablen verwenden.

Answer 5

Nur um zu bestätigen, was Tomalak angegeben hier :

Die folgenden Werke:

$k=array();
$v=null;
$dn=Zend_Ldap_Dn::explodeDn('CN=Alice Baker,CN=Users,DC=example,DC=com', $k, $v, 
    Zend_Ldap_Dn::ATTR_CASEFOLD_UPPER);

Nicht schön -. Aber die Erklärung ist klar und verständlich

Answer 6

Wie @aschmecher auf in einem Kommentar darauf hingewiesen, @ Szczepan Antwort hier , func($var = null) tun erzeugt ein strenger Standard bemerken.

Eine Lösung

Hier ist eine Methode, die keine solche Warnungen generiert:

<?php
error_reporting(E_ALL | E_STRICT);

function doIt(&$x = null) {
    if($x !== null) echo "x not null: $x\n";
    $x = 2;
}

function &dummyRef() {
    $dummyRef = null;
    return $dummyRef;
}

doIt(dummyRef());

doIt(dummyRef());

Erklärung

An der Stelle des in einer Variablen vorbei, passieren wir im Ergebnis einer Funktion eine Referenz zurück. Der zweite Aufruf von doIt(dummy()) ist zu überprüfen, ob die Referenz $dummy Wert nicht zwischen Anruf hält an. Dies steht im Gegensatz zu einem variablen explizit zu schaffen, in dem man jeden akkumulierten Wert erinnern, muss klar:

$dummyRef = null;
doIt($dummyRef);
doIt($dummyRef); // second call would print 'x not null: 2'

Anwendung

So in dem Beispiel des OP, es sei:

$dn = Zend_Ldap_Dn::explodeDn(
    'CN=Alice Baker,CN=Users,DC=example,DC=com',
    $k,
    dummyRef(),
    Zend_Ldap_Dn::ATTR_CASEFOLD_UPPER
);

Weitere Überlegungen

Eine Sache, die ich befürchten könnte, ist, ob diese Methode ein Speicherleck verursacht. Der folgende Test zeigt, dass dies nicht der Fall:

<?php
function doItObj(&$x = null) {
    if(gettype($x) !== "object") echo "x not null: $x\n";
    $x = 2;
}

function &dummyObjRef() {
    $dummyObjRef = new StdClass();
    return $dummyObjRef;
}

echo "memory before: " . memory_get_usage(true) .  "\n";

for($i = 0; $i < 1000000; $i++) {
    doItObj(dummyObjRef());
}

echo "memory after: " . memory_get_usage(true) . "\n";

echo "\n$i\n";

Auf meinem System (mit PHP 5.6.4), rufen beide zeigte auf memory_get_usage ~ 262 KB.