Mehrere Rückgaben von einer Funktion

Ist es möglich, eine Funktion mit zwei Rückgaben wie folgt zu haben:

function test($testvar)
{
  // Do something

  return $var1;
  return $var2;
}

Wenn ja, wie könnte ich jede Rücksendung separat erhalten?

Es gibt keine Möglichkeit, 2 Variablen zurückzugeben. Sie können ein Array jedoch weitergeben und zurückgeben. Erstellen Sie eine Bedingung, um eine dynamische Variable usw. zurückzugeben.

Zum Beispiel würde diese Funktion zurückkehren $var2

function wtf($blahblah = true) {
    $var1 = "ONe";
    $var2 = "tWo";

    if($blahblah === true) {
      return $var2;
    }
    return $var1;
}

In der Anwendung:

echo wtf();
//would echo: tWo
echo wtf("not true, this is false");
//would echo: ONe

Wenn Sie beide möchten, können Sie die Funktion ein wenig ändern

function wtf($blahblah = true) {
    $var1 = "ONe";
    $var2 = "tWo";

    if($blahblah === true) {
      return $var2;
    }

    if($blahblah == "both") {
      return array($var1, $var2);
    }

    return $var1;
}

echo wtf("both")[0]
//would echo: ONe
echo wtf("both")[1]
//would echo: tWo

list($first, $second) = wtf("both")
// value of $first would be $var1, value of $second would be $var2

Technisch gesehen können Sie nicht mehr als einen Wert zurückgeben. Es gibt jedoch mehrere Möglichkeiten, um diese Einschränkung zu umgehen. Die Rückgabe mehrerer Werte erfolgt am häufigsten mit dem listSchlüsselwort:

function getXYZ()
{
    return array(4,5,6);
}

list($x,$y,$z) = getXYZ();

// Afterwards: $x == 4 && $y == 5 && $z == 6
// (This will hold for all samples unless otherwise noted)

Technisch gesehen geben Sie ein Array zurück und listspeichern die Elemente dieses Arrays in verschiedenen Werten, anstatt das eigentliche Array zu speichern. Wenn Sie diese Technik verwenden, haben Sie das Gefühl , mehrere Werte zurückzugeben.

Die listLösung ist eher PHP-spezifisch. Es gibt einige Sprachen mit ähnlichen Strukturen, aber mehr Sprachen, die dies nicht tun. Es gibt eine andere Möglichkeit, die üblicherweise verwendet wird, um mehrere Werte "zurückzugeben", und sie ist in nahezu jeder Sprache verfügbar (auf die eine oder andere Weise). Diese Methode sieht jedoch ganz anders aus und ist möglicherweise gewöhnungsbedürftig.

// note that I named the arguments $a, $b and $c to show that
// they don't need to be named $x, $y and $z
function getXYZ(&$a, &$b, &$c)
{
    $a = 4;
    $b = 5;
    $c = 6; 
}

getXYZ($x, $y, $z);

Diese Technik wird auch in einigen Funktionen verwendet, die von PHP selbst definiert werden (z. B. $countin str_replace , $matchesin preg_match ). Dies mag sich ganz anders anfühlen als die Rückgabe mehrerer Werte, aber es lohnt sich zumindest, darüber Bescheid zu wissen.

Eine dritte Methode besteht darin, ein Objekt zu verwenden, um die verschiedenen Werte zu speichern, die Sie benötigen. Dies ist mehr Eingabe, daher wird es nicht ganz so oft verwendet wie die beiden oben genannten Methoden. Es kann jedoch sinnvoll sein, dies zu verwenden, wenn Sie denselben Variablensatz an mehreren Stellen verwenden (oder natürlich in einer Sprache arbeiten, die die oben genannten Methoden nicht unterstützt oder dies ohne zusätzliche Eingabe ermöglicht).

class MyXYZ
{
    public $x;
    public $y;
    public $z;
}

function getXYZ()
{
    $out = new MyXYZ();

    $out->x = 4;
    $out->y = 5;
    $out->z = 6;

    return $out;
}

$xyz = getXYZ();

$x = $xyz->x;
$y = $xyz->y;
$z = $xyz->z;

Die obigen Methoden fassen die Hauptmethoden zum Zurückgeben mehrerer Werte von einer Funktion zusammen. Es gibt jedoch Variationen dieser Methoden. Die interessantesten Variationen sind diejenigen, bei denen Sie tatsächlich ein Array zurückgeben, einfach weil Sie mit Arrays in PHP so viel tun können.

Erstens können wir einfach ein Array zurückgeben und es nur als Array behandeln:

function getXYZ()
{
    return array(1,2,3);
}

$array = getXYZ();

$x = $array[1];
$y = $array[2];
$z = $array[3];

Das Interessanteste am obigen Code ist, dass der Code in der Funktion derselbe ist wie im ersten Beispiel, das ich bereitgestellt habe. Nur der Code, der die Funktion aufruft, hat sich geändert. Dies bedeutet, dass es an demjenigen liegt, der die Funktion aufruft, wie das von der Funktion zurückgegebene Ergebnis zu behandeln ist.

Alternativ könnte man ein assoziatives Array verwenden:

function getXYZ()
{
    return array('x' => 4,
                 'y' => 5,
                 'z' => 6);
}

$array = getXYZ();

$x = $array['x'];
$y = $array['y'];
$z = $array['z'];

PHP hat die compactFunktion, die es Ihnen ermöglicht, dasselbe wie oben zu tun, aber weniger Code zu schreiben. (Nun, das Beispiel wird nicht weniger Code enthalten, aber eine reale Anwendung würde es wahrscheinlich tun.) Ich denke jedoch, dass der Umfang der Tippersparnis minimal ist und das Lesen des Codes schwieriger wird, sodass ich es nicht selbst tun würde. Trotzdem hier ein Beispiel:

function getXYZ()
{
    $x = 4;
    $y = 5;
    $z = 6;

    return compact('x', 'y', 'z');
}

$array = getXYZ();

$x = $array['x'];
$y = $array['y'];
$z = $array['z'];

Es sollte beachtet werden, dass es compactzwar ein Gegenstück gibt extract, das hier im aufrufenden Code verwendet werden könnte, aber da es eine schlechte Idee ist, es zu verwenden (insbesondere für etwas so Einfaches wie dieses), werde ich nicht einmal ein Beispiel dafür geben. Das Problem ist, dass es "magisch" ist und Variablen für Sie erstellt, während Sie nicht sehen können, welche Variablen erstellt werden, ohne zu anderen Teilen des Codes zu wechseln.

Abschließend möchte ich erwähnen, dass listdies mit assoziativen Arrays nicht wirklich gut funktioniert . Folgendes wird das tun, was Sie erwarten:

function getXYZ()
{
    return array('x' => 4,
                 'y' => 5,
                 'z' => 6);
}

$array = getXYZ();

list($x, $y, $z) = getXYZ();

Folgendes bewirkt jedoch etwas anderes:

function getXYZ()
{
    return array('x' => 4,
                 'z' => 6,
                 'y' => 5);
}

$array = getXYZ();

list($x, $y, $z) = getXYZ();

// Pay attention: $y == 6 && $z == 5

Wenn Sie listmit einem assoziativen Array arbeiten und jemand anderes den Code in der aufgerufenen Funktion in Zukunft ändern muss (was in fast jeder Situation vorkommen kann), kann er plötzlich kaputt gehen. Ich würde daher empfehlen, nicht listmit assoziativen Arrays zu kombinieren .

In Ihrem Beispiel wird die zweite Rückgabe niemals stattfinden - die erste Rückgabe ist das letzte, was PHP ausführen wird. Wenn Sie mehrere Werte zurückgeben müssen, geben Sie ein Array zurück:

function test($testvar) {

    return array($var1, $var2);
}

$result = test($testvar);
echo $result[0]; // $var1
echo $result[1]; // $var2

Seit PHP 7.1 haben wir eine ordnungsgemäße Destrukturierung für Listen. Dabei können Sie folgende Dinge tun:

$test = [1, 2, 3, 4];
[$a, $b, $c, $d] = $test;
echo($a);
> 1
echo($d);
> 4

In einer Funktion würde dies so aussehen:

function multiple_return() {
    return ['this', 'is', 'a', 'test'];
}

[$first, $second, $third, $fourth] = multiple_return();
echo($first);
> this
echo($fourth);
> test

Destrukturierung ist ein sehr mächtiges Werkzeug. Es ist auch in der Lage, Schlüssel => Wertepaare zu zerstören:

["a" => $a, "b" => $b, "c" => $c] = ["a" => 1, "b" => 2, "c" => 3];

Schauen Sie sich die neue Feature-Seite für PHP 7.1 an:

Neue Eigenschaften

In PHP 5.5 gibt es auch ein neues Konzept: generatorsHier können Sie mehrere Werte aus einer Funktion ergeben:

function hasMultipleValues() {
    yield "value1";
    yield "value2";
}

$values = hasMultipleValues();
foreach ($values as $val) {
    // $val will first be "value1" then "value2"
}

Oder Sie können als Referenz übergeben:

function byRef($x, &$a, &$b)
{
    $a = 10 * $x;
    $b = 100 * $x;
}

$a = 0;
$b = 0;

byRef(10, $a, $b);

echo $a . "\n";
echo $b;

Dies würde ausgeben

100
1000

Ich weiß, dass ich ziemlich spät dran bin, aber es gibt eine schöne und einfache Lösung für dieses Problem.
Durch Destrukturierung können mehrere Werte gleichzeitig zurückgegeben werden.

function test()
{
    return [ 'model' => 'someValue' , 'data' => 'someothervalue'];
}

Jetzt können Sie dies verwenden

$result = test();
extract($result);

extractErstellt für jedes Mitglied im Array eine Variable, die nach diesem Mitglied benannt ist. Sie können daher jetzt auf $modelund zugreifen$data

Sie können mehrere Arrays und Skalare von einer Funktion zurückgeben

function x()
{
    $a=array("a","b","c");
    $b=array("e","f");
    return array('x',$a,$b);
}

list ($m,$n,$o)=x();

echo $m."\n";
print_r($n);
print_r($o);

Es ist nicht möglich, zwei return-Anweisungen zu haben. Es wird jedoch kein Fehler ausgegeben, aber wenn die Funktion aufgerufen wird, erhalten Sie nur den Wert der ersten return-Anweisung. Wir können die Rückgabe eines Arrays verwenden, um mehrere Werte zurückzugeben. Beispielsweise:

function test($testvar)
{
  // do something
  //just assigning a string for example, we can assign any operation result
  $var1 = "result1";
  $var2 = "result2";
  return array('value1' => $var1, 'value2' => $var2);
}

Funktionen geben per Definition nur einen Wert zurück.

Wie Sie angenommen haben, kann dieser Wert jedoch ein Array sein.

Sie können also sicherlich Folgendes tun:

<?PHP
function myfunc($a,$b){
   return array('foo'=>$a,'bar'=>$b);
}
print_r(myfunc('baz','bork'));

Trotzdem lohnt es sich, sich einen Moment Zeit zu nehmen und darüber nachzudenken, was Sie zu lösen versuchen. Während die Rückgabe eines komplexen Ergebniswerts (wie eines Arrays oder eines Objekts) durchaus gültig ist, können Sie möglicherweise schlecht entwerfen, wenn Sie der Meinung sind, dass "Ich möchte zwei Werte zurückgeben". Ohne mehr Details in Ihrer Frage ist es schwer zu sagen, aber es tut nie weh, anzuhalten und zweimal nachzudenken.

Best Practice ist Ihre zurück Variablen in einem Array zu setzen und dann verwenden , list()um assign Array von Werten zu Variablen.

<?php

function add_subt($val1, $val2) {
    $add = $val1 + $val2;
    $subt = $val1 - $val2;

    return array($add, $subt);
}

list($add_result, $subt_result) = add_subt(20, 7);
echo "Add: " . $add_result . '<br />';
echo "Subtract: " . $subt_result . '<br />';

?>

Ja, du kannst ein Objekt benutzen :-)

Am einfachsten ist es jedoch, ein Array zurückzugeben:

return array('value1', 'value2', 'value3', '...');

Für PHP 7.1 <= können Sie eine neue Syntax verwenden (anstelle der Listenfunktion ):

/**
* @return  array  [foo, bar]
*/
function getFooAndBar(): array {
    return ['foo', 'bar'];
}

[$foo, $bar] = getFooAndBar();

print 'Hello '. $foo . ' and ' . $bar;

Für mich ist es in Ordnung, wenn Sie 2-3 Variablen zurückgeben möchten, andernfalls sollten Sie ein Objekt mit den gewünschten Eigenschaften verwenden.

Ich habe so für die PHP-Funktion mit mehreren Rückgabewerten implementiert. Sei nett mit deinem Code. Danke.

 <?php
    function multi_retun($aa)
    {
        return array(1,3,$aa);
    }
    list($one,$two,$three)=multi_retun(55);
    echo $one;
    echo $two;
    echo $three;
    ?>

Die Antwort, die oben mit dem grünen Häkchen versehen ist, ist tatsächlich falsch. Sie können in PHP mehrere Werte zurückgeben, wenn Sie ein Array zurückgeben. Ein Beispiel finden Sie im folgenden Code:

<?php

function small_numbers()
{
    return array (0, 1, 2);
}

list ($zero, $one, $two) = small_numbers();

Dieser Code wird tatsächlich von der folgenden Seite auf der PHP-Website kopiert: http://php.net/manual/en/functions.returning-values.php Ich habe dieselbe Art von Code auch oft selbst verwendet, kann dies also bestätigen es ist gut und dass es funktioniert.

Funktionen in PHP können nur eine Variable zurückgeben. Sie können Variablen mit globalem Gültigkeitsbereich verwenden, ein Array zurückgeben oder eine Variable unter Bezugnahme auf die Funktion übergeben und dann den Wert ändern. All dies verringert jedoch die Lesbarkeit Ihres Codes. Ich würde vorschlagen, dass Sie sich die Klassen ansehen.

Ich dachte, ich würde auf einige der Antworten von oben eingehen ...

class nameCheck{

public $name;

public function __construct(){
    $this->name = $name;
}

function firstName(){
            // If a name has been entered..
    if(!empty($this->name)){
        $name = $this->name;
        $errflag = false;
                    // Return a array with both the name and errflag
        return array($name, $errflag);
            // If its empty..
    }else if(empty($this->name)){
        $errmsg = 'Please enter a name.';
        $errflag = true;
                    // Return both the Error message and Flag
        return array($errmsg, $errflag);
    }
}

}


if($_POST['submit']){

$a = new nameCheck;
$a->name = $_POST['name'];
//  Assign a list of variables from the firstName function
list($name, $err) = $a->firstName();

// Display the values..
echo 'Name: ' . $name;
echo 'Errflag: ' . $err;
}

?>
<form method="post" action="<?php $_SERVER['PHP_SELF']; ?>" >
<input name="name"  />
<input type="submit" name="submit" value="submit" />
</form>

Dies gibt Ihnen ein Eingabefeld und eine Senden-Schaltfläche, sobald das Namenseingabefeld leer ist, gibt es das Fehlerflag und eine Nachricht zurück. Wenn das Namensfeld einen Wert hat, werden der Wert / Name und das Fehlerflag 0 für false = keine Fehler zurückgegeben. Hoffe das hilft!

Einige bevorzugen möglicherweise die Rückgabe mehrerer Werte als Objekt:

function test() {
    $object = new stdClass();

    $object->x = 'value 1';
    $object->y = 'value 2';

    return $object;
}

Und nenne es so:

echo test()->x;

Oder:

$test = test();
echo $test->y;

Ja und nein. Sie können nicht mehr als eine Variable / ein Objekt zurückgeben, aber wie Sie vorschlagen, können Sie sie in ein Array einfügen und dieses zurückgeben.

Die Verschachtelung von Arrays ist unbegrenzt. Sie können sie also einfach so verpacken, dass sie zurückkehren.

Sie können immer nur eine Variable zurückgeben, bei der es sich möglicherweise um ein Array handelt. Sie können jedoch globale Variablen innerhalb der Funktion ändern. Das ist meistens kein sehr guter Stil, aber es funktioniert. In Klassen ändern Sie normalerweise Klassenvariablen innerhalb von Funktionen, ohne sie zurückzugeben.

Die Antwort ist nein. Wenn der Parser die erste return-Anweisung erreicht, leitet er die Steuerung zurück an die aufrufende Funktion - Ihre zweite return-Anweisung wird niemals ausgeführt.

Fügen Sie alle Variablen in einem Array hinzu und geben Sie schließlich die zurück array.

function test($testvar)
{
  // do something
  return array("var1" => $var1, "var2" => @var2);
}

Und dann

$myTest = test($myTestVar);
//$myTest["var1"] and $myTest["var2"] will be usable

Ich denke, Eliego hat die Antwort klar erklärt. Wenn Sie jedoch beide Werte zurückgeben möchten, fügen Sie sie in ein Array ein und geben Sie sie zurück.

function test($testvar)
{
  // do something

  return array('var1'=>$var1,'var2'=>$var2);
//defining a key would be better some times   
}

// um auf Rückgabewerte zuzugreifen

$returned_values = test($testvar);

echo $returned_values['var1'];
echo $returned_values['var2'];

<?php
function foo(){
  $you = 5;
  $me = 10;
  return $you;
  return $me;
}

echo foo();
//output is just 5 alone so we cant get second one it only retuns first one so better go with array


function goo(){
  $you = 5;
  $me = 10;
  return $you_and_me =  array($you,$me);
}

var_dump(goo()); // var_dump result is array(2) { [0]=> int(5) [1]=> int(10) } i think thats fine enough

?>

Sprachen, die mehrere Rückgaben ermöglichen, konvertieren normalerweise nur die mehreren Werte in eine Datenstruktur.

In Python können Sie beispielsweise mehrere Werte zurückgeben. Sie werden jedoch nur als ein Tupel zurückgegeben.

Sie können also mehrere Werte in PHP zurückgeben, indem Sie einfach ein einfaches Array erstellen und dieses zurückgeben.

Sie können die Werte von zwei oder mehr Variablen abrufen, indem Sie sie als Referenz festlegen:

function t(&$a, &$b) {
    $a = 1;
    $b = 2;
}


t($a, $b);

echo $a . '  ' . $b;

Ausgabe:

1 2

Verwendet PHP immer noch "out-Parameter"? In diesem Fall können Sie die Syntax verwenden, um einen oder mehrere der Parameter zu ändern, die dann in Ihre Funktion eingehen. Sie können die geänderte Variable dann verwenden, nachdem Ihre Funktion zurückgegeben wurde.

Dies ist der einfachste Weg:

public function selectAllUsersByRole($userRole, $selector) {

    $this->userRole = $userLevel;
    $this->selector = $selector;

    $sql = "SELECT * FROM users WHERE role <= ? AND del_stat = 0";
    $stm = $this->connect()->prepare($sql); // Connect function in Dbh connect to database file
    $stm->execute([$this->userRole]); // This is PHP 7. Use array($this->userRole) for PHP 5

    $usersIdArray = array();
    $usersFNameArray = array();
    $usersLNameArray = array();

    if($stm->rowCount()) {
        while($row = $stm->fetch()) {

            array_push($usersIdArray,    $row['id']);
            array_push($usersFNameArray, $row['f_name']);
            array_push($usersLNameArray, $row['l_name']);

            // You can return only $row['id'] or f_name or ...
            // I used the array because it's most used.
        }
    }
    if($this->selector == 1) {
        return $usersIdArray;
    }elseif($this->selector == 2) {
        return $usersFNameArray;
    }elseif($this->selector == 3) {
        return $usersLNameArray;
    }

}

Wie können wir diese Funktion aufrufen?

$idData = $selectAllUsers->selectAllUsersByLevel($userRole, 0);
print_r($idData);
$idFName = $selectAllUsers->selectAllUsersByLevel($userRole, 1);
print_r($idFname);

Das ist es. Sehr leicht.

$var1 = 0;
$var2 = 0;

function test($testvar, &$var1 , &$var2)
{
  $var1 = 1;
  $var2 = 2;
  return;
}
test("", $var1, $var2);

// var1 = 1, var2 = 2 

Es ist kein guter Weg, aber ich denke, wir können zwei Variablen gleichzeitig in einer Funktion setzen.

Ich hatte ein ähnliches Problem - also habe ich es versucht und ein bisschen gegoogelt (diesen Thread gefunden). Nach 5 Minuten Versuch und Irrtum stellte ich fest, dass Sie einfach "UND" verwenden können, um zwei (möglicherweise mehr - noch nicht getestet) in einer Rückgabezeile zurückzugeben.

Mein Code:

  function get_id(){
    global $b_id, $f_id;
    // stuff happens
    return $b_id AND $f_id;
  }
  //later in the code:
  get_id();
  var_dump($b_id);
  var_dump($f_id); // tested output by var_dump

Es klappt. Ich habe beide Werte bekommen, die ich erwartet hatte / bekommen sollte. Ich hoffe ich konnte jedem helfen der diesen Thread liest :)