Mais uma semana, mais um guia para desenvolver as vossas aptidões nos meandros do PHP. Esta semana, pelo facto do Pedro Pinto estar no Brasil em trabalho (sim sim nós acreditamos) o post fica inteiramente sob comando do nosso já conhecido visitante Nelson Rocha. Sigam com atenção as orientações e em caso de duvida o nrocha certamente responderá aos vosso comentários. OK, apertem as beatas e apaguem os cintos, aqui vamos nós.
Introdução Quase todas as linguagens de programação suportam funções. Em algumas linguagens usa-se o termo “sub-rotina” ou “procedimento”.
As funções permitem tornar o código reutilizável, ou seja, podemos agrupar instruções e chamar esse grupo de instruções apenas com um nome, isto permite ao programador focalizar funcionalidades.
É possível criar funções ou usar as funções já incorporadas (built-in) no PHP (consultar http://www.php.net/manual para a referência de funções built-in), mas neste artigo não vamos falar sobre as funções built-in mas sim na sua criação e o que podemos fazer com elas.
Básico Em PHP o nome das funções tem que começar com um underscore (_) ou uma letra (a-zA-Z) e tem que ser seguido por letras (a-zA-Z) ou números (0-9). O nome da função case-insensitive, ou seja, a função ola() é a mesma que OLA() ou oLa().
Exemplo de nomes válidos: _funcao func4o_que_faz_somAs func
Exemplo de nomes inválidos: 4funcao f-cao func!ao
Para criar uma função usamos a keyword “function” seguida do seu nome e da lista de parâmetros que essa função espera, é obrigatório criar um bloco de código para todas as funções, ou seja, é necessário usar “{ código }” para definir que instruções pertencem a essa função. É possível incluir todo o tipo de código dentro de uma função, desde declaração de variáveis, outras funções, classes ou até mesmo inclusão de ficheiros (require ou include).
Primeira função function primeira_funcao () { }
Para chamar esta função é necessário usar o seu nome seguida da lista de argumentos–> primeira_funcao(); Nota: O espaço entre o nome da função e os () não importa.
Esta função não faz nada.
Primeira função escreve o meu nome function primeira_funcao () { echo “Nelson”; }
––– Código: primeira_funcao(); –––
Parâmetros Definição de função com parâmetros É possível enviar variáveis para as funções, essas variáveis permitidas correspondem a lista de parâmetros definida após o nome da função, entre as ().
Exemplo: function funcao_com_parametros ($parametro1, $parametro2) {}
Para chamar a função usamos: funcao_com_parametros($argumento1, $argumento2);
De referir que eu costumo usar o nome parâmetros para a definição da função e para a chamada digo que são argumentos. Nas chamadas a função funcao_com_parametros() é necessário especificar obrigatoriamente dois argumentos, caso não se faça obtemos um erro.
— código — // definição function escreve_nome ($nome) { echo $nome; } // chamada da função escreve_nome(“Nelson”); —
— Output: Nelson —
Funções com parâmetros com valores pré-definidos É possível definir valores pré-definidos para os parâmetros, para definir esses valores usamos a atribuição (=), funciona como uma atribuição normal. Exemplo: — código — function func ($nome, $idade = 0, $planeta = “Terra”) { echo $nome . ” ” . $idade . ” ” . $planeta . “<br>”; } func(“Nelson”); /* se não especificarmos o argumento o PHP vai assumir o valor pré-definido para os parametros */ func(“Nelson”, 24); func(“Nelson”, 24, “Marte”);
— output — Nelson 0 Terra Nelson 24 Terra Nelson 24 Marte —
Funções com parâmetros “ilimitados” Existem casos em que podemos querer passar um número ilimitado de argumentos para uma função, no PHP é possível! Neste exemplo vamos deixar a lista de parâmetros vazia.
—código— function funcao () { $args = func_get_args();
foreach ($args as $arg) echo $arg . ” – “; }
funcao(“O”, “meu nome é”, “Nelson”); echo “<br>”; funcao(“Ola”); —
—output— O – meu nome é – Nelson – Ola – —
A função func_get_args() retorna um array com todos parâmetros enviados para a função.
Passagem de parâmetros por valor e por referência Existem dois tipos de passagem de variáveis, uma é passar por valor e a outra é por referência.
Quando se passa uma variável por valor estamos a dizer que a variável na lista de parâmetros vai ter o valor da correspondente nos argumentos mas não é a mesma variável. Caso se altere o seu valor dentro da função o valor da variável original vai-se manter.
É possível alterar o valor dessas variáveis e para isso usam-se as passagens por referência, para passar por referência basta colocar o operador & a frente do parâmetro pretendido, exemplo: &$nome
—código— function func ($nome, &$idade) { $nome = “Buh”; $idade++; } $n = “Nelson”; $i = 24; func($n, $i); —
Após a func() a variável $n mantém o valor “Nelson” mas a variável $i agora tem 25 e não 24, de referir que quando se passa por referência não estamos passar literalmente a variável, estamos a passar sim o seu endereço.
Scope O scope de uma função diz respeito a visibilidade de uma variável, função, classe etc etc que essa função tem acesso. Exemplos: —código— $a = 50; function func () { $a = 10; echo $a . “<br>”; }
echo $a . “<br>”; func(); echo $a; —
—output— 50 10 50 —
A variável $a que existe fora da função não é a mesma que esta dentro da func(), isto porque têm scopes diferentes. Também é possível criar funções ou classes dentro das funções e essas funções ou classes só estariam disponíveis dentro da função.
É possível dizer que uma variável tem scope global, ou seja, dizer que queremos usar uma variável definida no scope anterior dentro do scope corrente, para isso usamos a keyword “global” e a lista das variáveis globais que queremos ter acesso. Exemplo: —código— function func () { global $a, $b; } —
Não se deve abusar de variáveis globais pois podem tornar o código mais confuso, normalmente passamos as variáveis pela lista de parâmetros.
Dá jeito usar variáveis globais que contenham configurações já que são variáveis que normalmente precisamos em todo o lado.
Retornar valores É possível retornar valores de uma função, para isso usa-se a keyword “return”.
Sem o return o uso de funções para cálculos ou outras acções ia ser mais difícil e íamos deixar de ter a possibilidade de fazer código versátil e genérico.
É possível retornar tudo, desde valores escalares (normais), arrays, etc.
–código— function dobro ($v) { return $v*2; } $a = dobro(50); echo $a . “<br>”; echo dobro(10) . “<br>”; $b = $a + dobro(500); echo $b; —
—código— #esta função é identica ao array_merge() built-in no PHP e serve para juntar dois arrays, retornando o novo array function junta_arrays ($arr1, $arr2) { $ret = $arr1; foreach ($arr2 as $v) $ret[] = $v; return $ret; }
$arr1 = array(10, 20, 50); $arr2 = array(5, 25, 100, 2); $arr_res = junta_arrays($arr1, $arr2); $arr2_res = junta_arrays(array(“a”, “b”), junta_arrays($arr_res, array(1000, 1)));
echo “<pre>”; print_r($arr_res); print_r($arr2_res); echo “</pre>”; —
—output— Array ( [0] => 10 [1] => 20 [2] => 50 [3] => 5 [4] => 25 [5] => 100 [6] => 2 ) Array ( [0] => a [1] => b [2] => 10 [3] => 20 [4] => 50 [5] => 5 [6] => 25 [7] => 100 [8] => 2 [9] => 1000 [10] => 1 ) —
Variáveis funções e enviar funções como parâmetro É possível atribuir a uma variável o endereço de uma função e trabalhar com essa variável como se fosse uma função.
—código— function dobro ($a) { return $a*2; } function triplo ($a) { return $a*3; }
$func = FALSE; if ($_GET[“tipo_calc”] == “dobrar”) $func = “dobro”; elseif ($_GET[“tipo_calc”] == “triplicar”) $func = “triplo”;
if ($func) echo $func(50); —
Para o caso do $_GET[“tipo_calc”] for “dobrar” —output– 100 — Para o caso do $_GET[“tipo_calc”] for “triplicar” —output— 150 —
Sendo possível existir variáveis funções é possível enviar funções para funções. O seguinte code snippet demonstra isso mesmo fazendo de uma forma idêntica o que foi feito em cima.
—código— function dobro ($a) { return $a*2; } function triplo ($a) { return $a*3; } function select ($val, $func) { return $func($val); }
$func = FALSE; if ($_GET[“tipo_calc”] == “dobrar”) $func = “dobro”; elseif ($_GET[“tipo_calc”] == “triplicar”) $func = “triplo”;
if ($func) echo select(50, $func); —
O output é igual ao de cima.
Recursividade Uma função recursiva significa que essa função se chama a si mesmo, existem coisas que fazem mais sentido serem implementadas com recursividade, outras não.
A regra é usar ciclos em vez da recursividade e só quando realmente se vê que se vai obter uma vantagem significativa é que se usa recursividade.
Exemplos comuns são navegar em directórios, listas, árvores binárias. Para alguns cálculos também se costuma usar, como por exemplo implementar uma função que retorne o factorial de um número que é demonstrado no seguinte exemplo:
—código— function fact ($n) { if ($n < 2) return 1; return $n * fact($n – 1); }
echo fact(4) . “<br>”; echo fact(5); —
—output— 24 120 —
A função fact chama-se a si própria até que o $n for menor do que 2 (que naquele caso é igual 1), caso não seja menor do que 2 a função pega no valor do $n (inicialmente 4) e multiplica pelo valor retornado pela nova chamada ao fact() mas com o $n-1, ou seja, a cada chamada da função o $n decresce 1.
Na pratica ao finalizar a função é o mesmo que fazer 4*3*2*1 que é igual 24. É necessário colocar sempre alguma forma de a função não se chamar a si mesmo, se isso não for feito entramos em recursividade infinita (que é o mesmo que loop infinito) e salvo raríssimas ocasiões não queremos isso.
Conclusão Com este documento expliquei quase tudo que é possível fazer com funções criadas pelo programador em PHP, estas noções podem ser aplicadas em quase todas as linguagens de programação.
Caso seja necessário aconselho uma leitura mais aprofundada sobre funções.
Recomendo também a leitura sobre outros assuntos aqui falados: – variáveis; – arrays; – scope; – recursividade;