Para criar uma função a palavra-chave “function” é usada seguido por um nome, um conjunto de parênteses e um bloco de código. A convenção de nomenclatura para as funções é o mesmo que para as variáveis ​​- para usar um nome descritivo a cada palavra a primeira letra maiúscula, com exceção da primeira.

<?php
    function myFunc() {
        echo "Hello World";
    }
?>

Um bloco de código da função pode conter qualquer código PHP válido, incluindo outras definições de funções.

Chamando Funções

Uma vez definida a função pode ser chamada (invocada) de qualquer lugar da página, digitando seu nome seguido por um conjunto de parênteses. Nomes de funções são case sensitiva.

<?php
    function myFunc() {
        echo "Hello World";
    }
    myFunc(); // Resultado: "Hello World"
?>

A função pode ser chamado, mesmo se a definição da função aparece mais abaixo no arquivo de script.

<?php
    foo(); // ok
    function foo() { }
?>

Uma exceção a isso é que a função só é definida quando uma determinada condição for satisfeita. Esse código condicional deve então ser executado antes de chamar a função.

<?php
    bar(); // error
    if (true) {
      function bar() { } 
    }
    bar(); // ok
?>

Parâmetros de Funções

Os parênteses que seguem o nome da função são usados ​​para passar argumentos para a função. Para isso os parâmetros correspondentes devem ser previamente especificado na definição da função, na forma de uma lista de variáveis ​​separadas por vírgula. Os parâmetros podem, então, ser usado na função.

<?php
    function myFunc($x,$y)
    {
        echo $x . $y;
    }
?>

Com os parâmetros especificados a função pode ser chamada com o mesmo número de argumentos.

<?php
    function myFunc($x,$y)
    {
        echo $x . $y;
    }
    myFunc('Hello', ' World'); // "Hello World"
?>

Para ser mais preciso, os parâmetros aparecem em definições de função, enquanto que os argumentos aparecem em chamadas de função. No entanto, os dois termos são por vezes usados ​​como sinônimos.

Os parâmetros padrão

É possível especificar valores padrão para os parâmetros, atribuindo-lhes um valor dentro da lista de parâmetros. Então, se esse argumento não é especificado quando a função é chamada o valor padrão será usado. Para que isso funcione como o esperado, é importante que os parâmetros com valores padrão são declarados à direita do que aqueles sem valores padrão.

<?php
    function myFunc($x, $y = " Earth")
    {
        echo $x . $y;
    }
    myFunc("Hello"); // "Hello Earth"
?>

Lista de parâmetros variável

A função não pode ser chamada com menos argumentos do que é especificado na sua declaração, mas pode ser chamado com mais argumentos. Isto permite a passagem de um número variável de argumentos, que pode ser acessado usando um par de funções embutidas. Para a obtenção de um argumento de cada vez que há a função func_get_arg. Esta função recebe um único argumento, que é o parâmetro a ser devolvido começando com zero.

<?php
    function myFunc()
    {
       $x = func_get_arg(0); // obter argumento especificado
       $y = func_get_arg(1);
       $z = func_get_arg(2);
          echo $x . $y . $z;
     }
     myFunc('Fee', 'Fi', 'Fo'); // "FeeFiFo"
?>

Há mais duas funções relacionadas com a lista de argumentos. A função func_num_args obtém o número de argumentos passados ​​e func_get_args retorna um array contendo todos os argumentos.

<?php
     function myFunc()
     {
         $num = func_num_args();
         $args = func_get_args();
         for ($i = 0; $i < $num; $i++)
            echo $args[$i] . ' ';
     }
     myFunc('Fee', 'Fi', 'Fo'); // "Fee Fi Fo"
?>

Declaração Return

Return é uma declaração que faz com que a função termine sua execução e retornar ao local onde foi chamado.

<?php
    function myFunc()
    {
        return; // fim da função
    }
?>

Ele pode, opcionalmente, ser dado um valor para voltar, caso em que ele vai fazer a chamada de função avaliar a esse valor.

<?php
    function myFunc()
    {
        return 'Hello'; // fim da função e retorna um valor
    }
    echo myFunc(); // "Hello"
?>

Uma função sem um valor de retorno será avaliada como nula(null).

Escopo e tempo de vida

Normalmente, o escopo de uma variável PHP começa onde é declarada e dura até o final da página. No entanto, um escopo local é introduzido dentro de funções. Qualquer variável utilizada dentro de uma função é, por padrão, limitado a este escopo local. Uma vez que o âmbito da função termina, a variável local é destruída.

<?php
    $x = 'Hello'; // variável global
    function myFunc()
    {
        $y = ' World'; // variável local
    }
?>

Em PHP, tentando acessar uma variável global de uma função não vai funcionar e, ao contrário, criar uma nova variável local. Para tornar uma variável acessível no escopo global dessa variável deve ser estendido para a função, declarando-o com a palavra-chave “global”.

<?php
    $x = 'Hello'; // global $x
    function myFunc()
    {
         global $x; // Usando global $x nesta função
         $x .= ' World'; // change global $x
    }
    myFunc();
    echo $x; // "Hello World"
?>

Uma forma alternativa de acessar variáveis ​​do escopo global é utilizando o array $GLOBALS. Note que a variável é especificada como uma string sem o cifrão.

<?php
    $x = 'Hello'; // global $x
    function myFunc()
    {
         $GLOBALS['x'] .= ' World'; // mudança no global $x
    }
    myFunc();
    echo $x; // "Hello World"
?>

Em contraste com muitas outras linguagens, a estruturas de controle – como o laço e instruções condicionais – não têm o seu próprio escopo de variáveis​​. Uma variável definida em tal bloco de código não vai, portanto, ser destruída quando o bloco de código termina.

<?php
    if(true)
    {
        $x = 10; // global $x
    }
    echo $x; // "10"
?>

Além das variáveis ​​globais e locais o PHP tem variáveis ​​de propriedade, que serão analisados ​​no próximo capítulo.

Funções anônimas

Funções anônimas foram introduzidas na versão PHP 5.3, permitem que as funções podem ser passados ​​como argumentos e atribuídos a variáveis​​. Uma função anônima é definida como uma função normal, exceto que ela não tem um nome específico. A função pode ser atribuído a uma variável usando a sintaxe de atribuição normal, incluindo o ponto e vírgula.

<?php
    $say = function($name)
    {
        echo "Hello " . $name;
    };
    $say("World"); // "Hello World"
?>

Uma função anônima pode herdar variáveis ​​do escopo onde está definido. Tais variáveis ​​herdadas são especificados com uma cláusula de uso no cabeçalho da função.

<?php
     $x = 1;
     $y = 2;
     $callback = function($z) use ($x, $y)
     {
         return $x + $y + $z;
     };
     echo $callback(3); // "6"
?>

Sobrecarga de funções

Ao contrário de muitas outras línguas, PHP não permite que uma função a ser definida várias vezes com parâmetros diferentes. Esta característica, chamada de função de sobrecarga, tem a vantagem de permitir uma função de lidar com uma variedade de parâmetros de forma transparente para o utilizador.

Embora o PHP não tem sobrecarga de funções, é possível alcançar um comportamento semelhante. PHP não tem tipagem forte, um parâmetro de função já aceita qualquer tipo de dados. Esta tipificação fraca – juntamente com os valores de parâmetro padrão e listas de parâmetros variáveis ​​- torna possível duplicar o efeito de sobrecarga de funções.

<?php
// Imprime um número variável de parâmetros
    function myprint()
    {
        $a = func_get_args();
        foreach ($a as $v) { echo $v; }
    }
    myprint(1,2,3); // "123"
?>

Funções internas

PHP vem com um grande número de funções internas que estão sempre disponíveis, tais como funções de string e de manipulação de arrays. Outras funções dependem dos requisitos e problemas para solucionar, por exemplo, a extensão MySQL para a comunicação com bancos de dados MySQL.

Links Importantes

Para uma referência completa das funções PHP embutidos consulte a Referência Função PHP. http://php.net/manual/pt_BR/funcref.php

Dúvidas e Sugestões, comente!