Множественные возвраты из функции

Для PHP 7.1 < = можно использовать новый синтаксис (вместо этого функция списка):

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

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

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

для меня хорошо, если Вы хотите возвратить 2-3 переменные, иначе необходимо использовать объект с желаемыми свойствами.

Вы можете получить значения двух или более переменных, установив их по ссылке

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


t($a,$b);

echo $a . '  ' . $b;

output:

1 2

Языки, допускающие многократный возврат, обычно просто преобразуют несколько значений в структуру данных.

Например, в python вы можете возвращать несколько значений, однако на самом деле они просто возвращаются как 1 кортеж.

Таким образом, вы можете вернуть несколько значений в PHP, просто создав простой массив и вернув его.

В вашем примере второго возврата никогда не будет - первое возвращение - это последнее, что выполнит PHP. Если вам нужно вернуть несколько значений, верните массив:

function test($testvar) {

    return array($var1, $var2);
}

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

Ответ - нет. Когда синтаксический анализатор достигнет первого оператора возврата, он передаст управление обратно вызывающей функции - ваш второй оператор возврата никогда не будет выполнен.

Вы всегда можете вернуть только одну переменную, которая может быть массивом. Но вы можете изменить глобальные переменные внутри функции. В большинстве случаев это не очень хороший стиль, но он работает. В классах вы обычно изменяете переменные класса внутри функций, не возвращая их.

да, можно использовать объект :-)

но проще всего вернуть массив:

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

Или вы можете пройти по ссылке:

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

$a = 0;
$b = 0;

byRef(10, $a, $b);

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

Это выведет

100
1000

Технически вы не можете вернуть более одного значения. Однако есть несколько способов обойти это ограничение. Способ, который больше всего похож на возврат нескольких значений, заключается в использовании ключевого слова 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)

Технически вы возвращаете массив и используете list для хранения элементов этого массива в различные значения вместо сохранения фактического массива. Использование этой техники будет ощущать возврат нескольких значений.

Решение list довольно специфично для php. Есть несколько языков с похожей структурой, но больше языков нет. Есть еще один способ, который обычно используется для «возвращения» нескольких значений, и он доступен практически на каждом языке (так или иначе). Однако этот метод будет выглядеть совершенно по-другому, поэтому, возможно, потребуется некоторое время, чтобы привыкнуть к нему.

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

Этот метод также используется в некоторых функциях, определенных самим php (например, $count в str_replace, $matches в preg_match ). Это может сильно отличаться от возврата нескольких значений, но об этом стоит хотя бы знать.

Третий метод заключается в использовании объекта для хранения различных значений, которые вам нужны. Это требует большего набора текста, поэтому он используется не так часто, как два описанных выше метода.Однако это может иметь смысл при использовании одного и того же набора переменных в нескольких местах (или, конечно, при работе с языком, который не поддерживает описанные выше методы или позволяет вам делать это без дополнительного ввода).

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;

Приведенные выше методы суммируют основные способы возврата нескольких значений из функции. Однако существуют вариации этих методов. Наиболее интересные варианты, на которые стоит обратить внимание, это те, в которых вы на самом деле возвращаете массив просто потому, что с массивами в PHP можно делать так много.

Во-первых, мы можем просто вернуть массив и не рассматривать его как нечто иное, кроме массива:

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

$array = getXYZ();

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

Самое интересное в приведенном выше коде заключается в том, что код внутри функции такой же, как и в самом первом приведенном мной примере. ; изменился только код, вызывающий функцию. Это означает, что тот, кто вызывает функцию, решает, как обрабатывать результат, возвращаемый функцией.

В качестве альтернативы можно использовать ассоциативный массив:

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

$array = getXYZ();

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

В Php есть функция compact, которая позволяет вам делать то же самое, что и выше, но при написании меньшего количества кода. (Ну, код в примере не будет меньше, но в реальном приложении, вероятно, будет.) Тем не менее, я думаю, что объем экономии при наборе текста минимален, и это затрудняет чтение кода, поэтому я бы не стал делать это сам. Тем не менее, вот пример:

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

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

$array = getXYZ();

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

Следует отметить, что хотя compact имеет аналог в extract, который можно использовать в вызывающем коде здесь, но поскольку это плохая идея чтобы использовать его (особенно для чего-то столь же простого), я даже не буду давать образец для него.Проблема в том, что он будет делать «волшебство» и создавать переменные за вас, при этом вы не сможете увидеть, какие переменные созданы, не переходя к другим частям кода.

Наконец, я хотел бы отметить, что список не очень на самом деле работает с ассоциативным массивом. Следующее будет делать то, что вы ожидаете:

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

$array = getXYZ();

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

Однако следующее сделает что-то другое:

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

$array = getXYZ();

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

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

Если вы использовали список с ассоциативным массивом, и кто-то другой должен изменить код в вызываемой функции в будущем (что может произойти практически в любой ситуации) он может внезапно сломаться, поэтому я бы не рекомендовал объединять список с ассоциативными массивами.

да и нет, вы не можете вернуть более одной переменной/объекта, но, как вы предлагаете, вы можете поместить их в массив и вернуть его, нет ограничений на вложенность массивов, поэтому вы можете просто их упаковать туда, чтобы вернуться

Функции по определению возвращают только одно значение.

Однако, как вы и предполагали, это значение может быть массивом.

Таким образом, вы, безусловно, можете сделать что-то вроде:

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

Тем не менее, стоит уделить минутку и подумать о том, что вы пытаетесь решить. Хотя возврат сложного результирующего значения (например, массива или объекта) вполне допустим, если вы думаете, что «я хочу вернуть два значения», возможно, вы плохо проектируете. Без подробностей в вашем вопросе трудно сказать, но никогда не помешает остановиться и дважды подумать.

Функции в PHP могут возвращать только одну переменную. вы можете использовать переменные с глобальной областью видимости, вы можете вернуть массив или передать переменную по ссылке в функцию, а затем изменить значение,.. но все это уменьшит читаемость вашего кода. Я бы посоветовал вам заглянуть в классы.