Retours multiples d'une fonction

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

function test($testvar)
{
  // Do something

  return $var1;
  return $var2;
}

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

Il n'y a aucun moyen de renvoyer 2 variables. Cependant, vous pouvez propager un tableau et le renvoyer; créer une conditionnelle pour renvoyer une variable dynamique, etc.

Par exemple, cette fonction retournerait $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 les vouliez tous les deux, vous pourriez 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

Techniquement, vous ne pouvez pas retourner plus d'une valeur. Cependant, il existe plusieurs façons de contourner cette limitation. La façon qui agit le plus comme retourner plusieurs valeurs, c'est avec le listmot - 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 retournez un tableau et utilisez listpour stocker les éléments de ce tableau dans différentes valeurs au lieu de stocker le tableau réel. L'utilisation de cette technique donnera l' impression de renvoyer plusieurs valeurs.

La listsolution est plutôt spécifique à php. Il existe quelques langues avec des structures similaires, mais d'autres langues qui n'en ont pas. Il existe un autre moyen couramment utilisé pour "renvoyer" plusieurs valeurs et il est disponible dans presque toutes les langues (d'une manière ou d'une autre). Cependant, cette méthode sera très différente et il faudra peut-être 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 $countdans str_replace , $matchesdans preg_match ). Cela peut sembler tout à fait différent de renvoyer plusieurs valeurs, mais cela vaut au moins la peine d'être connu.

Une troisième méthode consiste à utiliser un objet pour contenir les différentes valeurs dont vous avez besoin. Ceci est plus typé, donc il n'est pas utilisé aussi souvent que les deux méthodes ci-dessus. Cependant, il peut être judicieux de l'utiliser lorsque vous utilisez le même ensemble de variables à plusieurs endroits (ou bien sûr, en travaillant dans un langage qui ne prend pas en charge les méthodes ci-dessus ou vous permet de le faire sans taper supplémentaire).

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 principales façons de renvoyer plusieurs valeurs à partir d'une fonction. Cependant, il existe des variations sur ces méthodes. Les variations les plus intéressantes à regarder sont celles dans lesquelles vous retournez réellement un tableau, simplement parce qu'il y a tellement de choses que vous pouvez faire avec les tableaux en PHP.

Tout d'abord, nous pouvons simplement retourner un tableau et ne pas le traiter comme autre chose qu'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 du code ci-dessus est que le code à l'intérieur de la fonction est le même que dans le tout premier exemple que j'ai fourni; seul le code appelant la fonction a changé. Cela signifie que c'est à celui qui appelle la fonction comment traiter le résultat renvoyé par la fonction.

Alternativement, on pourrait 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 la compactfonction qui vous permet de faire la même chose que ci-dessus mais en écrivant moins de code. (Eh bien, l'échantillon n'aura pas moins de code, mais une application réelle le ferait probablement.) Cependant, je pense que la quantité d'économie de frappe est minime et rend le code plus difficile à lire, donc je ne le ferais pas moi-même. Néanmoins, voici un exemple:

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

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

$array = getXYZ();

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

Il convient de noter que bien compactqu'il y ait un homologue extractqui pourrait être utilisé dans le code appelant ici, mais comme c'est une mauvaise idée de l'utiliser (en particulier pour quelque chose d'aussi simple que cela), je ne donnerai même pas d'échantillon pour cela. Le problème est qu'il fera de la "magie" et créera des variables pour vous, alors que vous ne pouvez pas voir quelles variables sont créées sans aller dans d'autres parties du code.

Enfin, je voudrais mentionner que listcela ne fonctionne pas vraiment bien avec un tableau associatif. Ce qui suit fera 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 fera 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 l'avez utilisé listavec un tableau associatif et que quelqu'un d'autre doit changer le code dans la fonction appelée à l'avenir (ce qui peut arriver dans n'importe quelle situation), il peut soudainement se casser, donc je vous déconseille de le combiner listavec des tableaux associatifs.

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

Depuis PHP 7.1, nous avons une bonne déstructuration des listes. Vous pouvez ainsi faire des choses comme ceci:

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

Dans une fonction, cela ressemblerait à ceci:

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

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

La déstructuration est un outil très puissant. Il est également capable de déstructurer des paires clé => valeur:

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

Jetez un œil à la nouvelle page de fonctionnalités de PHP 7.1:

Nouvelles fonctionnalités

En PHP 5.5, il existe également un nouveau concept:, generatorsoù 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"
}

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

Je sais que je suis en retard, mais il existe une solution simple et agréable à ce problème.
Il est possible de renvoyer plusieurs valeurs à la fois en utilisant la déstructuration.

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

Vous pouvez maintenant utiliser ceci

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

extractcrée une variable pour chaque membre du tableau, nommée d'après ce membre. Vous pouvez donc désormais accéder $modelet$data

Vous pouvez renvoyer plusieurs tableaux et scalaires à partir d'une fonction

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

Il n'est pas possible d'avoir deux déclarations de retour. Cependant, il ne génère pas d'erreur, mais lorsque la fonction est appelée, vous ne recevrez que la première valeur de l'instruction return. Nous pouvons utiliser return of array pour obtenir plusieurs valeurs en retour. Par exemple:

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

Les fonctions, par définition, ne renvoient qu'une seule valeur.

Cependant, comme vous l'avez supposé, cette valeur peut être un tableau.

Vous pouvez donc certainement faire quelque chose comme:

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

Cela dit, cela vaut la peine de prendre un moment et de réfléchir à tout ce que vous essayez de résoudre. Bien que renvoyer une valeur de résultat complexe (comme un tableau ou un objet) soit parfaitement valide, si vous pensez que "je veux retourner deux valeurs", vous risquez de mal concevoir. Sans plus de détails dans votre question, c'est difficile à dire, mais ça ne fait jamais de mal de s'arrêter et de réfléchir à deux fois.

La meilleure pratique consiste à placer vos variables renvoyées dans un tableau, puis à utiliser list()pour attribuer des valeurs de tableau à des variables.

<?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 />';

?>

Oui, vous pouvez utiliser un objet :-)

Mais la manière la plus simple est de renvoyer un tableau:

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

Pour PHP 7.1 <= vous pouvez utiliser une nouvelle syntaxe (au lieu de la fonction de liste ):

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

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

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

C'est OK pour moi si vous voulez retourner 2-3 variables, sinon vous devez utiliser un objet avec les propriétés souhaitées.

J'ai implémenté comme ceci pour la fonction PHP à plusieurs valeurs de retour. soyez gentil avec votre code. Merci.

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

La réponse qui est donnée la coche verte ci-dessus est en fait incorrecte. Vous pouvez renvoyer plusieurs valeurs en PHP, si vous retournez un tableau. Voir le code suivant pour un exemple:

<?php

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

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

Ce code est en fait copié à partir de la page suivante sur le site Web de PHP: http://php.net/manual/en/functions.returning-values.php J'ai également utilisé le même type de code plusieurs fois moi-même, je peux donc confirmer que c'est bon et ça marche.

Les fonctions en PHP ne peuvent renvoyer qu'une seule variable. vous pouvez utiliser des variables avec une portée globale, vous pouvez renvoyer un tableau, ou vous pouvez passer une variable par référence à la fonction et changer la valeur, .. mais tout cela diminuera la lisibilité de votre code. Je vous suggère de regarder dans les classes.

Je pensais développer quelques-unes des réponses ci-dessus ...

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>

Cela vous donnera un champ de saisie et un bouton de soumission une fois soumis, si le champ de saisie du nom est vide, il renverra l'indicateur d'erreur et un message. Si le champ de nom a une valeur, il renverra la valeur / le nom et un indicateur d'erreur de 0 pour faux = aucune erreur. J'espère que cela t'aides!

Certains pourraient préférer renvoyer plusieurs valeurs en tant qu'objet:

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

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

    return $object;
}

Et appelez-le comme ceci:

echo test()->x;

Ou:

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

Oui et non. Vous ne pouvez pas renvoyer plus d'une variable / objet, mais comme vous le suggérez, vous pouvez les placer dans un tableau et les renvoyer.

Il n'y a pas de limite à l'imbrication des tableaux, vous pouvez donc simplement les empaqueter de cette façon pour revenir.

Vous ne pouvez toujours renvoyer qu'une seule variable qui peut être un tableau. Mais vous pouvez changer les variables globales depuis l'intérieur de la fonction. C'est la plupart du temps pas un très bon style, mais ça marche. Dans les classes, vous modifiez généralement les variables de classe dans les fonctions sans les renvoyer.

La réponse est non. Lorsque l'analyseur atteint la première instruction de retour, il redirige le contrôle vers la fonction appelante - votre deuxième instruction de retour ne sera jamais exécutée.

Ajoutez toutes les variables dans un tableau, puis retournez enfin le array.

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

Puis

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

Je pense qu'Eliego a clairement expliqué la réponse. Mais si vous souhaitez renvoyer les deux valeurs, placez-les dans un tableau et renvoyez-les.

function test($testvar)
{
  // do something

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

// pour accéder aux valeurs de retour

$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

?>

Les langages qui autorisent plusieurs retours convertissent généralement les valeurs multiples en une structure de données.

Par exemple, en Python, vous pouvez renvoyer plusieurs valeurs. Cependant, ils ne sont en fait retournés que comme un tuple.

Vous pouvez donc retourner plusieurs valeurs en PHP en créant simplement un tableau simple et en le renvoyant.

Vous pouvez obtenir les valeurs de deux ou plusieurs variables en les définissant par référence:

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


t($a, $b);

echo $a . '  ' . $b;

Production:

1 2

PHP utilise-t-il toujours des paramètres de sortie? Si c'est le cas, vous pouvez alors utiliser la syntaxe pour modifier un ou plusieurs des paramètres entrant dans votre fonction. Vous seriez alors libre d'utiliser la variable modifiée après le retour de votre fonction.

C'est la façon la plus simple de le faire:

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;
    }

}

Comment pouvons-nous appeler cette fonction?

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

C'est tout. Très facile.

$var1 = 0;
$var2 = 0;

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

// var1 = 1, var2 = 2 

Ce n'est pas un bon moyen, mais je pense que nous pouvons définir deux variables dans une fonction en même temps.

J'ai eu un problème similaire - j'ai donc essayé et googlé un peu (trouver ce fil). Après 5 minutes d'essais et d'erreurs, j'ai découvert que vous pouvez simplement utiliser "ET" pour renvoyer deux (peut-être plus - pas encore testé) dans une seule ligne de retour.

Mon 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

Ça marche. J'ai obtenu les deux valeurs que j'attendais / devrais obtenir. J'espère pouvoir aider quiconque à lire ce fil :)