Usando argumentos padrão em uma função

Estou confuso sobre valores padrão para funções PHP. Digamos que eu tenho uma função como esta:

function foo($blah, $x = "some value", $y = "some other value") {
    // code here!
}

E se eu quiser usar o argumento padrão para $ x e definir um argumento diferente para $ y?

Tenho experimentado maneiras diferentes e estou ficando cada vez mais confusa. Por exemplo, eu tentei estes dois:

foo("blah", null, "test");
foo("blah", "", "test");

Mas ambos não resultam em um argumento padrão adequado para $ x. Eu também tentei defini-lo pelo nome da variável.

foo("blah", $x, $y = "test");   

Eu esperava que algo assim funcionasse. Mas não funciona como eu esperava. Parece que não importa o que eu faça, terei que digitar os argumentos padrão de qualquer maneira, toda vez que invocar a função. E devo estar perdendo algo óbvio.

Eu proporia alterar a declaração da função da seguinte maneira para que você possa fazer o que deseja:

function foo($blah, $x = null, $y = null) {
    if (null === $x) {
        $x = "some value";
    }

    if (null === $y) {
        $y = "some other value";
    }

    code here!

}

Dessa forma, você pode fazer uma chamada como foo('blah', null, 'non-default y value');e fazê-la funcionar como quiser, onde o segundo parâmetro $xainda obtém seu valor padrão.

Com esse método, passar um valor nulo significa que você deseja o valor padrão para um parâmetro quando deseja substituir o valor padrão para um parâmetro que vem depois dele.

Como indicado em outras respostas,

parâmetros padrão funcionam apenas como os últimos argumentos para a função. Se você deseja declarar os valores padrão na definição da função, não há como omitir um parâmetro e substituir outro após ele.

Se eu tenho um método que pode aceitar números variáveis ​​de parâmetros e parâmetros de tipos variados, geralmente declaro a função semelhante à resposta mostrada por Ryan P.

Aqui está outro exemplo (isso não responde à sua pergunta, mas é esperançosamente informativo:

public function __construct($params = null)
{
    if ($params instanceof SOMETHING) {
        // single parameter, of object type SOMETHING
    } else if (is_string($params)) {
        // single argument given as string
    } else if (is_array($params)) {
        // params could be an array of properties like array('x' => 'x1', 'y' => 'y1')
    } else if (func_num_args() == 3) {
        $args = func_get_args();

        // 3 parameters passed
    } else if (func_num_args() == 5) {
        $args = func_get_args();
        // 5 parameters passed
    } else {
        throw new InvalidArgumentException("Could not figure out parameters!");
    }
}

Argumentos opcionais funcionam apenas no final de uma chamada de função. Não há como especificar um valor para $ y em sua função sem especificar também $ x. Algumas linguagens suportam isso por meio de parâmetros nomeados (VB / C # por exemplo), mas não PHP.

Você pode emular isso se usar uma matriz associativa para parâmetros em vez de argumentos - ou seja,

function foo(array $args = array()) {
    $x = !isset($args['x']) ? 'default x value' : $args['x'];
    $y = !isset($args['y']) ? 'default y value' : $args['y'];

    ...
}

Em seguida, chame a função da seguinte maneira:

foo(array('y' => 'my value'));

É realmente possível:

foo( 'blah', (new ReflectionFunction('foo'))->getParameters()[1]->getDefaultValue(), 'test');

Se você gostaria de fazer isso é outra história :)

ATUALIZAR:

Os motivos para evitar essa solução são:

• é (sem dúvida) feio
• tem uma sobrecarga óbvia.
• como as outras respostas comprovam, existem alternativas

Mas na verdade pode ser útil em situações em que:

• você não quer / não pode alterar a função original.

• você pode alterar a função, mas:

  • usar null(ou equivalente) não é uma opção (consulte o comentário de DiegoDD )
  • você não quer ir com uma associativa ou com func_num_args()
  • sua vida depende de salvar alguns LOCs

Sobre o desempenho, um teste muito simples mostra que o uso da API do Reflection para obter os parâmetros padrão torna a chamada de função 25 vezes mais lenta , enquanto ainda leva menos de um microssegundo . Você deve saber se pode viver com isso.

Obviamente, se você quiser usá-lo em um loop, deverá obter o valor padrão antecipadamente.

function image(array $img)
{
    $defaults = array(
        'src'    => 'cow.png',
        'alt'    => 'milk factory',
        'height' => 100,
        'width'  => 50
    );

    $img = array_merge($defaults, $img);
    /* ... */
}

A única maneira que eu sei de fazê-lo é omitindo o parâmetro. A única maneira de omitir o parâmetro é reorganizar a lista de parâmetros para que o que você deseja omitir seja após os parâmetros que você PRECISA definir. Por exemplo:

function foo($blah, $y = "some other value", $x = "some value")

Então você pode chamar foo como:

foo("blah", "test");

Isso resultará em:

$blah = "blah";
$y = "test";
$x = "some value";

Recentemente, tive esse problema e encontrei esta pergunta e respostas. Enquanto as perguntas acima funcionam, o problema é que elas não mostram os valores padrão para os IDEs que os suportam (como PHPStorm).

se você usar null, não saberá qual seria o valor se deixá-lo em branco.

A solução que prefiro é colocar também o valor padrão na definição da função:

protected function baseItemQuery(BoolQuery $boolQuery, $limit=1000, $sort = [], $offset = 0, $remove_dead=true)
{
    if ($limit===null) $limit =1000;
    if ($sort===null) $sort = [];
    if ($offset===null) $offset = 0;
    ...

A única diferença é que preciso garantir que eles sejam iguais - mas acho que é um preço pequeno a pagar pela clareza adicional.

Você não pode fazer isso diretamente, mas um pouco de manipulação de código torna possível emular.

function foo($blah, $x = false, $y = false) {
  if (!$x) $x = "some value";
  if (!$y) $y = "some other value";

  // code
}

<?php
function info($name="George",$age=18) {
echo "$name is $age years old.<br>";
}
info();     // prints default values(number of values = 2)
info("Nick");   // changes first default argument from George to Nick
info("Mark",17);    // changes both default arguments' values

?>

Meus 2 centavos com operador coalescente nulo ?? (desde PHP 7)

function foo($blah, $x = null, $y = null) {
    $varX = $x ?? 'Default value X';
    $varY = $y ?? 'Default value Y';
    // ...
}

Você pode conferir mais exemplos no meu repl.it

Nesse caso, quando o objeto é melhor - porque você pode configurá-lo para conter xey, configurar padrões etc.

A abordagem com o array está próxima de criar o objeto (de fato, o objeto é um monte de parâmetros e funções que trabalharão sobre o objeto, e o array de tomada de função funcionará sobre alguns parâmetros do grupo)

Certamente, você sempre pode fazer alguns truques para definir nulo ou algo assim como padrão

Você também pode verificar se possui uma sequência vazia como argumento para poder chamar como:

foo('blah', "", 'non-default y value', null);

Abaixo da função:

function foo($blah, $x = null, $y = null, $z = null) {
    if (null === $x || "" === $x) {
        $x = "some value";
    }

    if (null === $y || "" === $y) {
        $y = "some other value";
    }

    if (null === $z || "" === $z) {
        $z = "some other value";
    }

    code here!

}

Não importa se você preencher nullou "", você ainda obterá o mesmo resultado.

Passe uma matriz para a função, em vez de parâmetros individuais e use o operador coalescente nulo (PHP 7+).

Abaixo, estou passando uma matriz com 2 itens. Dentro da função, estou verificando se o valor do item1 está definido, se não for atribuído o cofre padrão.

$args = ['item2' => 'item2',
        'item3' => 'value3'];

    function function_name ($args) {
        isset($args['item1']) ? $args['item1'] : 'default value';
    }