Plusieurs retours de fonction

Question

Est-il possible d'avoir une fonction avec 2 retours comme ceci:

 function test($testvar)
{
  // do something

  return $var1;
  return $var2;
}
 

Si oui, comment pourrais-je obtenir chaque déclaration séparément?

Answer 1

Techniquement, vous ne pouvez pas retourner qu'une seule valeur. Cependant, il existe plusieurs façons de contourner cette limitation. Le chemin qui agit plus comme retourner plusieurs valeurs, est à l' list mot-clé:

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)

Techniquement, vous êtes de retour d'un tableau et à l'aide de list pour stocker les éléments de ce tableau dans les différentes valeurs au lieu de stocker le tableau réel. En utilisant cette technique vous faire sentir plus comme retourner plusieurs valeurs.

L' list solution est plutôt php-spécifique. Il y a un peu de langues avec des structures similaires, mais plus de langues qui ne. Il y a une autre façon qui est couramment utilisé pour "retourner" les valeurs multiples et il est disponible dans à peu près toutes les langues (d'une manière ou d'une autre). Cependant, cette méthode seront très différentes, donc peut avoir besoin de s'y habituer.

// 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);

Cette technique est également utilisée dans certaines fonctions définies par php lui-même (par exemple, $count dans str_replace, $matches dans preg_match). Ceci peut sembler tout à fait différente de retourner plusieurs valeurs, mais il vaut la peine au moins de savoir à propos.

Une troisième méthode consiste à utiliser un objet pour contenir les différentes valeurs que vous avez besoin. C'est plus de la dactylographie, de sorte qu'il n'est pas utilisé aussi souvent que les deux méthodes ci-dessus. Il peut faire sens pour l'utiliser, cependant, lorsque vous utilisez le même ensemble de variables dans un certain nombre de lieux (ou, bien entendu, de travailler dans une langue qui ne prend pas en charge les méthodes ci-dessus ou vous permet de faire cela sans supplément de la frappe).

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;

Les méthodes ci-dessus résument les principaux moyens de retourner plusieurs valeurs à partir d'une fonction. Cependant, il ya des variations sur ces méthodes. La plupart des variations intéressantes à regarder, sont ceux qui vous sont effectivement renvoyer un tableau, tout simplement parce que il ya tellement de choses que vous pouvez faire avec des tableaux en PHP.

Tout d'abord, nous pouvons simplement retourner un tableau et de ne pas le traiter comme rien, mais un tableau:

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

$array = getXYZ();

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

La partie la plus intéressante sur le code ci-dessus est que le code de la fonction est la même que dans le premier exemple que j'ai fourni; seul le code de l'appel de la fonction a changé. Cela signifie que c'est à l'appel de la fonction à la façon de traiter le résultat de la fonction renvoie.

Alternativement, on peut utiliser un tableau associatif:

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

$array = getXYZ();

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

Php a l' compact fonction qui permet de faire la même que ci-dessus mais tout en écrire moins de code. (Eh bien, l'échantillon n'aurez pas moins de code, mais une application du monde réel serait probablement le cas.) Cependant, je pense que la quantité de saisie d'économie est minime et il rend le code plus difficile à lire, je ne voudrais pas le faire moi-même. Néanmoins, voici un échantillon:

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

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

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

Il convient de noter qu' compact n'ont une contrepartie en extract qui pourraient être utilisés dans le code appelant ici, mais comme c'est une mauvaise idée de l'utiliser (surtout pour quelque chose d'aussi simple que cela) je ne vais même pas donner un exemple pour elle. Le problème, c'est qu'il va faire "magie" et de créer des variables pour vous, alors vous ne pouvez pas voir les variables sont créées sans aller à d'autres parties du code.

Enfin, je tiens à mentionner qu' list n'est pas vraiment bien jouer avec tableau associatif. La suite à faire ce que vous attendez:

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

$array = getXYZ();

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

Cependant, ce qui suit va faire quelque chose de différent:

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

$array = getXYZ();

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

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

Si vous avez utilisé list avec un tableau associatif, et quelqu'un d'autre a changer le code dans la fonction appelée dans le futur (ce qui peut se produire juste au sujet de n'importe quelle situation), il peut se briser, donc je vous conseille de contre combinant list avec des tableaux associatifs.

Answer 2

Il n'y a aucun moyen de retourner 2 variables. Bien que vous puissiez propager un tableau et le renvoyer; créer une condition pour renvoyer une variable dynamique, etc.

Par exemple, cette fonction renverrait $var2

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

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

En application:

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

Si vous vouliez les deux, vous pouvez modifier un peu la fonction

 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
 

Answer 3

Dans votre exemple, le deuxième retour ne se produira jamais - le premier retour est la dernière chose que PHP exécutera. Si vous devez renvoyer plusieurs valeurs, renvoyez un tableau:

 function test($testvar) {

    return array($var1, $var2);
}

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

Answer 4

En PHP 5.5, il existe également un nouveau concept: generators , dans lequel vous pouvez générer plusieurs valeurs à partir d'une fonction:

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

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

Answer 5

Ou vous pouvez passer par référence:

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

$a = 0;
$b = 0;

byRef(10, $a, $b);

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

Cela produirait

 100
1000