Plusieurs retours de fonction

Il n’y a aucun moyen de retourner 2 variables. Bien que vous puissiez propager un tableau et le renvoyer; créer un conditionnel pour retourner une variable dynamic, 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 les vouliez tous les deux, vous pourriez modifier la fonction un peu

 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 renvoyer plus d’une valeur. Cependant, il existe plusieurs façons de contourner cette limitation. La manière la plus proche de renvoyer plusieurs valeurs est d’ list mot-clé list :

 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 list pour stocker les éléments de ce tableau dans des valeurs différentes au lieu de stocker le tableau réel. En utilisant cette technique, vous aurez l’ impression de retourner plusieurs valeurs.

La solution de list est plutôt spécifique à PHP. Il y a quelques langues avec des structures similaires, mais plus de langues. Il existe une autre méthode couramment utilisée pour «renvoyer» plusieurs valeurs et elle est disponible dans presque toutes les langues (d’une manière ou d’une autre). Cependant, cette méthode aura un aspect très différent, il faudra donc 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 ). Cela peut sembler très différent de renvoyer des valeurs multiples, mais cela vaut au moins le savoir.

Une troisième méthode consiste à utiliser un object 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. Cela peut être logique, cependant, d’utiliser le même ensemble de variables à plusieurs endroits (ou, bien sûr, de travailler dans un langage qui ne prend pas en charge les méthodes ci-dessus ou vous permet de le faire sans saisie 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 manières de renvoyer plusieurs valeurs d’une fonction. Cependant, il existe des variations sur ces méthodes. Les variations les plus intéressantes à examiner sont celles dans lesquelles vous retournez un tableau, simplement parce qu’il ya beaucoup à faire avec les tableaux en PHP.

Tout d’abord, nous pouvons simplement retourner un tableau et ne pas le traiter comme 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 dans 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 que la fonction retourne.

On pourrait aussi 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 fonction compact qui vous permet de faire la même chose que ci-dessus mais en écrivant moins de code. (Eh bien, l’exemple n’aura pas moins de code, mais une application du monde réel le ferait probablement.) Cependant, je pense que la quantité 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 si compact a un équivalent dans extract qui pourrait être utilisé dans le code d’appel ici, mais comme c’est une mauvaise idée de l’utiliser (en particulier pour quelque chose d’aussi simple), je ne donnerai même pas d’échantillon pour il. 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 passer par d’autres parties du code.

Enfin, je voudrais mentionner que cette list ne joue pas vraiment bien avec le 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 avez utilisé une list avec un tableau associatif, et que quelqu’un d’autre doit changer le code dans la fonction appelée à l’avenir (ce qui peut se produire à peu près dans n’importe quelle situation), il peut se briser. Je déconseille donc de combiner la list avec 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 

En PHP 5.5, il y a aussi un nouveau concept: les generators , où 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 

Ce n’est pas possible d’avoir deux déclaration de retour. Cependant, il ne jette pas d’erreur mais lorsque la fonction est appelée, vous ne recevrez que la première valeur de déclaration de retour. Nous pouvons utiliser le retour de tableau pour obtenir plusieurs valeurs en retour. Par exemple:

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

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

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:

 $a,'bar'=>$b); } print_r(myfunc('baz','bork')); 

Cela dit, il est utile de prendre un moment pour réfléchir à ce que vous essayez de résoudre. Bien que le fait de renvoyer une valeur de résultat complexe (comme un tableau ou un object) soit parfaitement valide, si vous pensez que “je veux renvoyer deux valeurs”, la conception est peut-être médiocre. Sans plus de détails dans votre question, c’est difficile à dire, mais il ne faut jamais s’arrêter et réfléchir à deux fois.

oui, vous pouvez utiliser un object 🙂

mais le plus simple est de retourner un tableau:

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

J’ai implémenté comme ça pour la fonction PHP à valeur de retour multiple. Soyez gentil avec votre code. Je vous remercie.

Je sais que je suis assez 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']; } 

Maintenant, vous pouvez l’utiliser

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

extract crée une variable pour chaque membre du tableau, nommé d’après ce membre. Vous pouvez donc maintenant accéder à $model et $data

oui et non, vous ne pouvez pas renvoyer plus d’une variable / object, 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 pour pouvoir les empaqueter de cette façon revenir

Les fonctions en PHP ne peuvent renvoyer qu’une seule variable. Vous pouvez utiliser des variables avec une scope globale, vous pouvez retourner un tableau, ou vous pouvez passer une variable en référence à la fonction et changer la valeur, mais tout cela va diminuer la lisibilité de votre code. Je suggère que vous examiniez les classes.

Je pensais développer quelques 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; } ?> 
    

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 retournera l’indicateur d’erreur et un message. Si le champ de nom a une valeur, il retournera la valeur / nom et un indicateur d’erreur de 0 pour false = pas d’erreurs. J’espère que cela t’aides!

Certains peuvent préférer renvoyer plusieurs valeurs en tant qu’object:

 function test() { $object = new stdClass(); $object->x = 'value 1'; $object->y = 'value 2'; return $object; } 

Et appelez comme ceci:

 echo test()->x; 

Ou:

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

Depuis Php 7.1, nous avons une déstructuration appropriée pour les listes. Vous pouvez faire des choses comme ça:

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

Dans une fonction, cela ressemblerait à ceci:

 php > function multiple_return() { php { return ['this', 'is', 'a', 'test']; php { } php > [$first, $second, $third, $fourth] = multiple_return(); php > print($first); this php > print($fourth); test 

La destruction est un outil très puissant. Il est capable de déstructurer les paires clé => valeur aussi

 list("a" => $a, "b" => $b, "c" => $c) = array("a" => 1, "b" => 2, "c" => 3); 

Jetez un coup d’oeil à la nouvelle page de fonctionnalités: http://php.net/manual/de/migration71.new-features.php

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

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

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

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

Et alors

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

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

 '; echo "Subtract: " . $subt_result . '
'; ?> 

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

Par exemple, en python, vous pouvez renvoyer plusieurs valeurs, mais elles ne sont en réalité renvoyées que sous la forme de 1 tuple.

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

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

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

sortie:

 1 2 

  int(5) [1]=> int(10) } i think thats fine enough ?> 

Est-ce que php utilise toujours des “parameters de sortie”? Si c’est le cas, vous pouvez utiliser la syntaxe pour modifier un ou plusieurs des parameters entrant dans votre fonction, vous serez alors libre d’utiliser la variable modifiée après le retour de votre fonction.

Je pense que Eliego a expliqué la réponse clairement. Mais si vous voulez retourner les deux valeurs, mettez-les dans un tableau et renvoyez-le.

 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=$this->test($testvar); echo $testvar['var1']; echo $testvar['var2']; 

J’ai eu un problème similaire – alors j’ai essayé et googlé un peu (trouver ce fil). Après 5 minutes d’essais et d’erreurs, j’ai découvert que vous pouviez simplement utiliser “ET” pour renvoyer deux (peut-être plus – pas encore testés) 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 eu les deux valeurs que je m’attendais à obtenir / devrait avoir. J’espère que je pourrais aider quelqu’un à lire ce fil 🙂

utiliser des globaux comme:

Cela fera écho 1 2