Wiele zwrotów z funkcji

Czy można mieć funkcję z dwoma zwrotami takimi jak to:

function test($testvar)
{
  // Do something

  return $var1;
  return $var2;
}

Jeśli tak, to w jaki sposób mógłbym uzyskać każdy zwrot osobno?

Nie ma możliwości zwrócenia 2 zmiennych. Chociaż możesz propagować tablicę i zwracać ją; utwórz warunek zwrócenia zmiennej dynamicznej itp.

Na przykład funkcja ta zwróci $var2

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

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

W aplikacji:

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

Jeśli chcesz ich obu, możesz nieco zmodyfikować funkcję

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

Technicznie nie można zwrócić więcej niż jednej wartości. Istnieje jednak wiele sposobów obejścia tego ograniczenia. Sposób, który najbardziej przypomina zwracanie wielu wartości, to listsłowo kluczowe:

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)

Technicznie rzecz biorąc, zwracasz tablicę i używasz listdo przechowywania elementów tej tablicy w różnych wartościach zamiast przechowywania rzeczywistej tablicy. Korzystanie z tej techniki sprawi, że poczujesz się jak w przypadku zwracania wielu wartości.

listRozwiązaniem jest rozwiązanie raczej specyficzny php. Istnieje kilka języków o podobnych strukturach, ale więcej języków nie. Istnieje inny sposób, który jest powszechnie używany do „zwracania” wielu wartości i jest dostępny w prawie każdym języku (w taki czy inny sposób). Jednak ta metoda będzie wyglądać zupełnie inaczej, więc może być konieczne przyzwyczajenie się.

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

Ta technika jest również używana w niektórych funkcjach zdefiniowanych przez sam php (np. $countW str_replace , $matchesw preg_match ). Może to wydawać się zupełnie inne niż zwracanie wielu wartości, ale warto przynajmniej wiedzieć o tym.

Trzecią metodą jest użycie obiektu do przechowywania różnych potrzebnych wartości. To jest więcej pisania, więc nie jest używane tak często, jak dwie powyższe metody. Może to mieć sens, gdy używasz tego samego zestawu zmiennych w wielu miejscach (lub oczywiście pracujesz w języku, który nie obsługuje powyższych metod lub pozwala ci to zrobić bez dodatkowego pisania).

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;

Powyższe metody podsumowują główne sposoby zwracania wielu wartości z funkcji. Istnieją jednak różne metody tych metod. Najbardziej interesujące warianty do obejrzenia, to te, w których zwracasz tablicę, po prostu dlatego, że tak wiele możesz zrobić z tablicami w PHP.

Po pierwsze, możemy po prostu zwrócić tablicę i nie traktować jej jak nic innego jak tablicę:

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

$array = getXYZ();

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

Najbardziej interesującą częścią powyższego kodu jest to, że kod wewnątrz funkcji jest taki sam jak w pierwszym przykładzie, który podałem; zmienił się tylko kod wywołujący funkcję. Oznacza to, że to od wywołania funkcji zależy, jak traktować wynik, który zwraca funkcja.

Alternatywnie można użyć tablicy asocjacyjnej:

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

$array = getXYZ();

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

Php ma compactfunkcję, która pozwala robić to samo co powyżej, ale pisząc mniej kodu. (Cóż, próbka nie będzie miała mniej kodu, ale prawdopodobnie byłaby to aplikacja w prawdziwym świecie). Myślę jednak, że oszczędność na pisaniu jest minimalna i sprawia, że ​​kod jest trudniejszy do odczytania, więc nie zrobiłbym tego sam. Niemniej jednak oto próbka:

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

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

$array = getXYZ();

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

Należy zauważyć, że chociaż compactma odpowiednik, extractktóry może być użyty w kodzie wywołującym tutaj, ale ponieważ jest to zły pomysł, aby go użyć (szczególnie w przypadku czegoś tak prostego), nie podam nawet próbki. Problem polega na tym, że wykona „magię” i utworzy dla ciebie zmienne, podczas gdy nie możesz zobaczyć, które zmienne są tworzone bez przechodzenia do innych części kodu.

Na koniec chciałbym wspomnieć, że listtak naprawdę nie gra dobrze z tablicą asocjacyjną. Następujące czynności spełnią Twoje oczekiwania:

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

$array = getXYZ();

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

Jednak następujące czynności zrobią coś innego:

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

$array = getXYZ();

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

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

Jeśli użyjesz listtablicy asocjacyjnej, a ktoś inny będzie musiał zmienić kod w wywoływanej funkcji w przyszłości (co może się zdarzyć niemal w każdej sytuacji), może się nagle zepsuć, więc odradzam łączenie listz tablicami asocjacyjnymi.

W twoim przykładzie drugi zwrot nigdy nie nastąpi - pierwszy zwrot jest ostatnią rzeczą, którą PHP uruchomi. Jeśli chcesz zwrócić wiele wartości, zwróć tablicę:

function test($testvar) {

    return array($var1, $var2);
}

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

Od PHP 7.1 mamy odpowiednią destrukcję list. W ten sposób możesz robić takie rzeczy:

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

W funkcji wyglądałoby to tak:

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

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

Destrukturyzacja to bardzo potężne narzędzie. Potrafi także niszczyć pary klucz => pary wartości:

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

Spójrz na nową stronę funkcji dla PHP 7.1:

Nowe funkcje

W PHP 5.5 istnieje również nowa koncepcja: generatorsgdzie można uzyskać wiele wartości z funkcji:

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

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

Lub możesz przekazać przez odniesienie:

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

$a = 0;
$b = 0;

byRef(10, $a, $b);

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

To by dało wynik

100
1000

Wiem, że jestem spóźniony, ale istnieje przyjemne i proste rozwiązanie tego problemu.
Możliwe jest zwracanie wielu wartości jednocześnie za pomocą destrukcji.

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

Teraz możesz tego użyć

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

extracttworzy zmienną dla każdego elementu w tablicy, nazwaną na cześć tego elementu. Możesz teraz uzyskać dostęp $modeli$data

Możesz zwrócić wiele tablic i skalarów z funkcji

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

Nie jest możliwe, aby zawierały dwie instrukcje return. Nie generuje to jednak błędu, ale po wywołaniu funkcji otrzymasz tylko pierwszą wartość instrukcji return. Możemy użyć return tablicy, aby uzyskać w zamian wiele wartości. Na przykład:

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

Funkcje z definicji zwracają tylko jedną wartość.

Jednak, jak zakładałeś, ta wartość może być tablicą.

Więc na pewno możesz zrobić coś takiego:

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

To powiedziawszy, warto poświęcić chwilę i zastanowić się nad tym, co próbujesz rozwiązać. Chociaż zwracanie złożonej wartości wynikowej (takiej jak tablica lub obiekt) jest całkowicie poprawne, jeśli myślisz, że „chcę zwrócić dwie wartości”, być może projektujesz źle. Bez bardziej szczegółowego pytania trudno jest powiedzieć, ale nigdy nie boli zatrzymać się i pomyśleć dwa razy.

Najlepszą praktyką jest umieszczenie zwracanych zmiennych w tablicy, a następnie użycie ich list()do przypisania wartości tablicy do zmiennych.

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

?>

Tak, możesz użyć obiektu :-)

Ale najprostszym sposobem jest zwrócenie tablicy:

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

Dla PHP 7.1 <= możesz użyć nowej składni (zamiast funkcji listy ):

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

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

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

Dla mnie jest OK, jeśli chcesz zwrócić 2-3 zmienne, w przeciwnym razie powinieneś użyć obiektu o pożądanych właściwościach.

Zaimplementowałem tak dla funkcji PHP z wieloma wartościami zwracanymi. bądź miły ze swoim kodem. Dziękuję Ci.

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

Odpowiedź, która jest podana powyżej zielonym ptaszkiem, jest właściwie nieprawidłowa. Możesz zwrócić wiele wartości w PHP, jeśli zwrócisz tablicę. Zobacz następujący kod na przykład:

<?php

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

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

Ten kod jest w rzeczywistości kopiowany z następującej strony na stronie PHP: http://php.net/manual/en/functions.returning-values.php Sam również użyłem tego samego kodu, więc mogę to potwierdzić jest dobre i działa.

Funkcje w PHP mogą zwracać tylko jedną zmienną. możesz użyć zmiennych o zasięgu globalnym, możesz zwrócić tablicę lub możesz przekazać zmienną przez odwołanie do funkcji, a następnie zmienić wartość, ale wszystko to zmniejszy czytelność twojego kodu. Proponuję zajrzeć do klas.

Pomyślałem, że rozwinę kilka odpowiedzi z góry ....

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>

To da ci pole wejściowe i przycisk wysyłania po przesłaniu, jeśli pole wprowadzania nazwy jest puste, zwróci flagę błędu i komunikat. Jeśli pole nazwy ma wartość, zwróci wartość / nazwę i flagę błędu 0 dla false = brak błędów. Mam nadzieję że to pomoże!

Niektórzy wolą zwracać wiele wartości jako obiekt:

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

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

    return $object;
}

I nazwij to tak:

echo test()->x;

Lub:

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

Tak i nie. Nie możesz zwrócić więcej niż jednej zmiennej / obiektu, ale jak sugerujesz, możesz umieścić je w tablicy i zwrócić.

Nie ma ograniczeń co do zagnieżdżania tablic, więc możesz po prostu spakować je w ten sposób, aby zwrócić.

Zawsze możesz zwrócić tylko jedną zmienną, która może być tablicą. Ale możesz zmieniać zmienne globalne z wnętrza funkcji. To przez większość czasu niezbyt dobry styl, ale działa. W klasach zwykle zmieniasz zmienne klasowe z funkcji, nie zwracając ich.

Odpowiedź brzmi nie. Kiedy parser osiągnie pierwszą instrukcję return, skieruje sterowanie z powrotem do funkcji wywołującej - druga instrukcja return nigdy nie zostanie wykonana.

Dodaj wszystkie zmienne do tablicy, a następnie w końcu zwróć array.

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

I wtedy

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

Myślę, że Eliego wyjaśnił odpowiedź jasno. Ale jeśli chcesz zwrócić obie wartości, umieść je w tablicy i zwróć.

function test($testvar)
{
  // do something

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

// aby uzyskać dostęp do zwracanych wartości

$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

?>

Języki, które umożliwiają wielokrotne zwroty, zwykle po prostu przekształcają wiele wartości w strukturę danych.

Na przykład w Pythonie możesz zwrócić wiele wartości. Jednak w rzeczywistości są one zwracane jako jedna krotka.

Możesz więc zwrócić wiele wartości w PHP, po prostu tworząc prostą tablicę i zwracając ją.

Możesz uzyskać wartości dwóch lub więcej zmiennych, ustawiając je przez odniesienie:

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


t($a, $b);

echo $a . '  ' . $b;

Wynik:

1 2

Czy PHP nadal używa „parametrów wyjściowych”? Jeśli tak, możesz użyć składni, aby zmodyfikować jeden lub więcej parametrów wchodzących w skład funkcji. Będziesz wtedy mógł używać zmodyfikowanej zmiennej po powrocie funkcji.

To najłatwiejszy sposób na zrobienie tego:

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

}

Jak możemy wywołać tę funkcję?

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

Otóż ​​to. Bardzo łatwe.

$var1 = 0;
$var2 = 0;

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

// var1 = 1, var2 = 2 

To nie jest dobry sposób, ale myślę, że możemy ustawić dwie zmienne w funkcji jednocześnie.

Miałem podobny problem - więc rozejrzałem się i trochę googlowałem (znajdując ten wątek). Po 5 minutach prób i błędów odkryłem, że możesz po prostu użyć „ORAZ”, aby zwrócić dwie (może więcej - jeszcze nie przetestowane) w jednej linii zwrotu.

Mój kod:

  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

to działa. Mam obie wartości, które spodziewałem się uzyskać / otrzymać. Mam nadzieję, że mógłbym pomóc każdemu czytającemu ten wątek :)