Vários retornos de uma função

É possível ter uma função com dois retornos como este:

function test($testvar)
{
  // Do something

  return $var1;
  return $var2;
}

Se sim, como eu seria capaz de obter cada retorno separadamente?

Não há como retornar 2 variáveis. Embora você possa propagar uma matriz e retorná-la; crie um condicional para retornar uma variável dinâmica etc.

Por exemplo, essa função retornaria $var2

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

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

Na aplicação:

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

Se você quisesse os dois, poderia modificar um pouco a função

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

Tecnicamente, você não pode retornar mais de um valor. No entanto, existem várias maneiras de contornar essa limitação. A maneira que funciona mais como retornar vários valores é com a listpalavra-chave:

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)

Tecnicamente, você está retornando uma matriz e usando listpara armazenar os elementos dessa matriz em valores diferentes, em vez de armazenar a matriz real. O uso dessa técnica fará com que pareça mais com o retorno de vários valores.

A listsolução é bastante específica para php. Existem alguns idiomas com estruturas semelhantes, mas outros não. Existe outra maneira que é comumente usada para "retornar" vários valores e está disponível em praticamente todos os idiomas (de uma maneira ou de outra). No entanto, esse método terá uma aparência bem diferente, portanto, pode ser necessário se acostumar.

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

Esta técnica também é usada em algumas funções definidas pelo próprio php (por exemplo, $countem str_replace , $matchesem preg_match ). Isso pode parecer bem diferente do retorno de vários valores, mas vale a pena conhecer pelo menos.

Um terceiro método é usar um objeto para armazenar os diferentes valores necessários. Como é mais digitado, não é usado com tanta frequência quanto os dois métodos acima. Pode fazer sentido usar isso, porém, ao usar o mesmo conjunto de variáveis ​​em vários locais (ou, é claro, trabalhar em um idioma que não suporta os métodos acima ou permite que você faça isso sem digitar mais).

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;

Os métodos acima resumem as principais maneiras de retornar vários valores de uma função. No entanto, existem variações nesses métodos. As variações mais interessantes a serem observadas são aquelas nas quais você realmente está retornando uma matriz, simplesmente porque há muito que você pode fazer com matrizes em PHP.

Primeiro, podemos simplesmente retornar uma matriz e não tratá-la como algo além de uma matriz:

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

$array = getXYZ();

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

A parte mais interessante sobre o código acima é que o código dentro da função é o mesmo que no primeiro exemplo que forneci; somente o código que chama a função foi alterado. Isso significa que cabe a quem chama a função como tratar o resultado que a função retorna.

Como alternativa, pode-se usar uma matriz associativa:

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

$array = getXYZ();

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

Php tem a compactfunção que permite fazer o mesmo que o descrito acima, mas enquanto escreve menos código. (Bem, o exemplo não terá menos código, mas provavelmente um aplicativo do mundo real.) No entanto, acho que a quantidade de economia de digitação é mínima e torna o código mais difícil de ler, então eu não faria isso sozinho. No entanto, aqui está uma amostra:

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

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

$array = getXYZ();

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

Note-se que, embora compacttenha uma contrapartida emextract poderia ser usado no código de chamada aqui, mas como é uma má idéia usá-lo (especialmente para algo tão simples como este), nem mesmo darei uma amostra. O problema é que ele fará "mágica" e criará variáveis ​​para você, enquanto você não pode ver quais variáveis ​​são criadas sem ir para outras partes do código.

Finalmente, gostaria de mencionar que realmentelist não funciona bem com o array associativo. O seguinte fará o que você espera:

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

$array = getXYZ();

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

No entanto, o seguinte fará algo diferente:

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

$array = getXYZ();

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

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

Se você usou listcom uma matriz associativa e alguém tiver que alterar o código na função chamada no futuro (o que pode acontecer em qualquer situação), ela poderá se romper repentinamente, por isso eu recomendaria não combinar listcom matrizes associativas.

No seu exemplo, o segundo retorno nunca acontecerá - o primeiro retorno é a última coisa que o PHP executará. Se você precisar retornar vários valores, retorne uma matriz:

function test($testvar) {

    return array($var1, $var2);
}

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

Desde o PHP 7.1, temos a destruição adequada das listas. Dessa forma, você pode fazer coisas assim:

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

Em uma função, seria assim:

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

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

A reestruturação é uma ferramenta muito poderosa. Também é capaz de desestruturar pares chave => valor:

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

Dê uma olhada na nova página de recursos do PHP 7.1:

Novas características

No PHP 5.5, há também um novo conceito:, generatorsonde você pode gerar vários valores a partir de uma função:

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

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

Ou você pode passar por referência:

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

$a = 0;
$b = 0;

byRef(10, $a, $b);

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

Isso produziria

100
1000

Sei que estou muito atrasado, mas existe uma solução simples e agradável para esse problema.
É possível retornar vários valores ao mesmo tempo usando a desestruturação.

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

Agora você pode usar isso

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

extractcria uma variável para cada membro da matriz, nomeada após esse membro. Agora você pode acessar $modele$data

Você pode retornar várias matrizes e escalares de uma função

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

Não é possível ter duas declarações de retorno. No entanto, ele não gera erro, mas quando a função é chamada, você receberá apenas o primeiro valor da instrução de retorno. Podemos usar o retorno da matriz para obter vários valores em troca. Por exemplo:

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

As funções, por definição, retornam apenas um valor.

No entanto, como você supôs, esse valor pode ser uma matriz.

Então você certamente pode fazer algo como:

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

Dito isto, vale a pena tomar um momento e pensar sobre o que você está tentando resolver. Embora o retorno de um valor de resultado complexo (como uma matriz ou um objeto) seja perfeitamente válido, se você pensa que "eu quero retornar dois valores", você pode estar com um design ruim. Sem mais detalhes na sua pergunta, é difícil dizer, mas nunca é demais parar e pensar duas vezes.

A melhor prática é colocar as variáveis ​​retornadas na matriz e, em seguida, usar list()para atribuir valores de matriz às variáveis.

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

?>

Sim, você pode usar um objeto :-)

Mas a maneira mais simples é retornar uma matriz:

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

Para o PHP 7.1 <= você pode usar a nova sintaxe (em vez da função list ):

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

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

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

Tudo bem para mim se você deseja retornar 2-3 variáveis, caso contrário, você deve usar um objeto com as propriedades desejadas.

Eu implementei assim para a função PHP com vários valores de retorno. seja legal com seu código. obrigado.

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

A resposta que recebeu o visto verde acima está incorreta. Você pode retornar vários valores no PHP, se retornar uma matriz. Veja o código a seguir para um exemplo:

<?php

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

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

Na verdade, esse código é copiado da página a seguir no site do PHP: http://php.net/manual/en/functions.returning-values.php Também usei o mesmo tipo de código muitas vezes, para confirmar que é bom e funciona.

Funções no PHP podem retornar apenas uma variável. você pode usar variáveis ​​com escopo global, retornar uma matriz ou passar uma variável por referência à função e alterar o valor, mas tudo isso diminuirá a legibilidade do seu código. Eu sugeriria que você olhasse para as aulas.

Pensei em expandir algumas das respostas de cima ....

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>

Isso fornecerá um campo de entrada e um botão de envio, uma vez enviado, se o campo de entrada do nome estiver vazio, ele retornará o sinalizador de erro e uma mensagem. Se o campo de nome tiver um valor, ele retornará o valor / nome e um sinalizador de erro 0 para false = sem erros. Espero que isto ajude!

Alguns podem preferir retornar vários valores como objeto:

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

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

    return $object;
}

E chame assim:

echo test()->x;

Ou:

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

Sim e não. Você não pode retornar mais de uma variável / objeto, mas como sugere, você pode colocá-los em uma matriz e retornar isso.

Não há limite para o aninhamento de matrizes, então você pode empacotá-las dessa maneira para retornar.

Você sempre pode retornar apenas uma variável que pode ser uma matriz. Mas você pode alterar variáveis ​​globais de dentro da função. Na maioria das vezes, esse estilo não é muito bom, mas funciona. Nas aulas, você geralmente altera as variáveis ​​de classe de dentro das funções sem retorná-las.

A resposta é não. Quando o analisador alcança a primeira instrução de retorno, ele direcionará o controle de volta para a função de chamada - sua segunda instrução de retorno nunca será executada.

Adicione todas as variáveis ​​em uma matriz e, finalmente, retorne o array.

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

E depois

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

Acho que eliego explicou a resposta claramente. Mas se você quiser retornar os dois valores, coloque-os em uma matriz e retorne-os.

function test($testvar)
{
  // do something

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

// para acessar valores de retorno

$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

?>

Idiomas que permitem retornos múltiplos geralmente convertem os valores múltiplos em uma estrutura de dados.

Por exemplo, em Python, você pode retornar vários valores. No entanto, eles realmente estão sendo retornados como uma tupla.

Assim, você pode retornar vários valores no PHP criando apenas uma matriz simples e retornando isso.

Você pode obter os valores de duas ou mais variáveis, definindo-as por referência:

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


t($a, $b);

echo $a . '  ' . $b;

Resultado:

1 2

O PHP ainda usa "parâmetros fora"? Nesse caso, você pode usar a sintaxe para modificar um ou mais dos parâmetros que entram na sua função. Você seria livre para usar a variável modificada após o retorno da sua função.

Esta é a maneira mais fácil de fazer isso:

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

}

Como podemos chamar essa função?

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

É isso aí. Muito fácil.

$var1 = 0;
$var2 = 0;

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

// var1 = 1, var2 = 2 

Não é uma boa maneira, mas acho que podemos definir duas variáveis ​​em uma função ao mesmo tempo.

Eu tive um problema semelhante - então tentei e pesquisei um pouco (encontrando este tópico). Após 5 minutos de tentativa e erro, descobri que você pode simplesmente usar "AND" para retornar dois (talvez mais - ainda não testados) em uma linha de retorno.

Meu código:

  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

funciona. Eu obtive os dois valores que esperava obter / deveria obter. Espero poder ajudar alguém a ler este tópico :)