PHP é uma linguagem de programação bastante popular.

Estatísticas indicam que ela é usada por 80% de todos os sites. É a linguagem que alimenta o WordPress, o sistema de gerenciamento de conteúdo amplamente utilizado para sites.

E também impulsionou diversos frameworks que facilitam o desenvolvimento web, como o Laravel. Falando em Laravel, pode ser um dos motivos mais convincentes para aprender PHP atualmente.

Por que aprender PHP?

PHP é uma linguagem bastante polarizadora. Algumas pessoas gostam de atividades, outras odeiam. Se dermos um passo além das emoções e encararmos a linguagem como uma ferramenta, o PHP tem muito a oferecer.

Claro que não é perfeito. Mas deixa eu te contar uma coisa: nenhuma língua é.

Neste manual, vou ajudá-lo a aprender PHP.

Este livro é uma introdução perfeita se você é novo na linguagem. Também é perfeito se você já praticou "um pouco de PHP" no passado e quer voltar a praticá-lo.

Explicarei o PHP moderno, versão 8+.

O PHP evoluiu muito nos últimos anos. Então, se na última vez que você experimentou foi com o PHP 5 ou mesmo com o PHP 4, você ficará surpreso com todas as coisas boas que o PHP agora oferece.

Vamos!

Veja o que abordaremos neste manual:

1. Introdução ao PHP
2. Que tipo de linguagem é PHP?
3. Como configurar o PHP
4. Como codificar seu primeiro programa PHP
5. Noções básicas de linguagem PHP
6. Como trabalhar com strings em PHP
7. Como usar funções integradas para números em PHP
8. Como funcionam os arrays em PHP
9. Como funcionam os condicionais em PHP
10. Como funcionam os loops em PHP
11. Como as funções funcionam em PHP
12. Como fazer um loop em arrays com  map(),  filter(), e  reduce()em PHP
13. Programação Orientada a Objetos em PHP
14. Como incluir outros arquivos PHP
15. Constantes, funções e funções úteis para sistema de arquivos em PHP
16. Como lidar com erros em PHP
17. Como lidar com abordagens em PHP
18. Como trabalhar com dados em PHP
19. Como usar constantes e enumerações em PHP
20. Como usar PHP como uma plataforma de desenvolvimento de aplicativos da Web
21. Como usar o Composer e o Packagist
22. Como implantar um aplicativo PHP
23. Conclusão

Observe que você pode obter um  em PDF, ePub ou Mobi  deste manual para facilitar a consulta ou para leitura na sua versão Kindle ou tablet.

Introdução ao PHP

PHP é uma linguagem de programação que muitos desenvolvedores usam para criar aplicativos da Web, entre outras coisas.

Como linguagem, teve um começo humilde. Foi criado em 1994 por Rasmus Lerdorf para construir seu site pessoal. Ele não imaginava, na época, que ela se tornaria uma das linguagens de programação mais populares do mundo. Tornou-se popular mais tarde, em 1997/8, e explodiu nos anos 2000, com o lançamento do PHP 4.

Você pode usar PHP para adicionar um pouco de interatividade em uma página HTML.

Ou você pode usá-lo como um mecanismo de aplicativo Web que cria páginas HTML dinamicamente e envia ao navegador.

Pode atingir milhões de visualizações de página.

Você sabia que o Facebook é baseado em PHP? Já ouviu falar da Wikipédia? Fazer folga? Faça Etsy?

Que tipo de linguagem é PHP?

Vamos falar de um pouco de jargão técnico.

As linguagens de programação são divididas em grupos de acordo com suas características. Por exemplo, interpretadas/compiladas, fortemente/fracamente tipadas, dinamicamente/estaticamente tipadas.

PHP é frequentemente chamado de "linguagem de script" e é uma  linguagem interpretada  . Se você já usou linguagens compiladas como C, Go ou Swift, a principal diferença é que você não precisa compilar um programa PHP antes de repeti-lo.

Essas linguagens são compiladas e o compilador gera um programa extremamente avançado que você então executa. É um processo de duas etapas.

O interpretador PHP   é responsável por interpretar as instruções escritas em um programa PHP quando ele é executado. É apenas uma etapa. Você diz ao interpretador para executar o programa. É um fluxo de trabalho completamente diferente.

PHP é uma  linguagem de tipagem dinâmica . Os tipos de variáveis são verificados em tempo de execução, em vez de antes da execução do código, como acontece com linguagens de tipagem estática. (Estas também são compiladas – as duas características geralmente andam de mãos dadas.)

O PHP também é fracamente tipado. Comparado a linguagens fortemente tipadas como Swift, Go, C ou Java, você não precisa declarar os tipos das suas variáveis.

Ser interpretado e tipado de forma flexível/dinâmica tornará os bugs mais difíceis de encontrar antes que aconteçam em tempo de execução.

Em linguagens compiladas, muitas vezes você pode detectar erros em tempo de compilação, algo que não acontece em linguagens interpretadas.

Mas, por outro lado, uma linguagem interpretada tem mais flexibilidade.

Curiosidade: o PHP é escrito internamente em C, uma linguagem compilada e estaticamente tipada.

Em sua natureza, o PHP é semelhante ao JavaScript, outra linguagem de tipagem dinâmica, fraca e interpretada.

O PHP suporta programação orientada a objetos e também programação funcional. Você pode usá-lo como preferir.

Como configurar o PHP

Há muitas maneiras de instalar o PHP na sua máquina local.

A maneira mais conveniente que encontrei de instalar o PHP localmente é usar o MAMP.

O MAMP é uma ferramenta disponível gratuitamente para todos os sistemas operacionais – Mac, Windows e Linux. É um pacote que oferece todas as ferramentas necessárias para começar a usar.

O PHP é executado por um servidor HTTP, responsável por responder às requisições HTTP, aquelas feitas pelo navegador. Assim, você acessa uma URL com seu navegador, Chrome, Firefox ou Safari, e o servidor HTTP responde com algum conteúdo HTML.

O servidor normalmente é Apache ou NGINX.

Então, para fazer qualquer coisa não trivial, você precisará de um banco de dados, como o MySQL.

O MAMP é um pacote que fornece tudo isso e muito mais, além de oferecer uma interface agradável para iniciar/parar tudo de uma vez.

Claro, você pode configurar cada peça individualmente, se quiser, e muitos tutoriais explicam como fazer isso. Mas eu gosto de ferramentas simples e práticas, e o MAMP é uma delas.

Você pode seguir este manual com qualquer tipo de método de instalação do PHP, não apenas o MAMP.

Dito isso, se você ainda não tem o PHP instalado e quer usar o MAMP, acesse  https://www.mamp.info  e instale-o.

O processo dependerá do seu sistema operacional, mas quando terminar a instalação, você terá um aplicativo “MAMP” instalado.

Inicie isso e você verá uma janela semelhante a esta:

Certifique-se de que a versão do PHP selecionada seja a mais recente disponível.

No momento em que este artigo foi escrito, o MAMP permite que você escolha 8.0.8.

NOTA: Notei que o MAMP tem uma versão um pouco desatualizada, mas não é a mais recente. Você pode instalar uma versão mais recente do PHP ativando a versão demo do MAMP PRO e, em seguida, instalar a versão mais recente nas configurações do MAMP PRO (no meu caso, era a 8.1.0). Em seguida, feche-o e abra novamente o MAMP (versão não Pro). O MAMP PRO tem mais recursos, então você pode querer usá-lo, mas não é necessário seguir este manual.

Pressione o botão Iniciar no canto superior direito. Isso iniciará o servidor HTTP Apache, com PHP habilitado, e o banco de dados MySQL.

Acesse a URL  http://localhost:8888  e você verá uma página semelhante a esta:

Estamos prontos para escrever algum PHP!

Abra a pasta listada como "Raiz do documento". Se você estiver usando o MAMP em um Mac, o padrão é  /Applications/MAMP/htdocs.

No Windows é  C:MAMPhtdocs.

O seu pode ser diferente dependendo da sua configuração. Usando o MAMP, você pode encontrá-lo na interface do usuário do aplicativo.

Lá, você encontrará um arquivo chamado  index.php.

Que é responsável por imprimir a página mostrada acima.

Como codificar seu primeiro programa PHP

Ao aprender uma nova linguagem de programação, temos a tradição de criar um aplicativo "Olá, Mundo!". Algo que imprima essas strings.

Certifique-se de que o MAMP esteja em execução e abra a  htdocs pasta conforme explicado acima.

Abra o  index.php arquivo em um editor de código.

Recomendo usar  o VS Code , pois é um editor de código muito simples e poderoso. Você pode conferir  https://flaviocopes.com/vscode/  para uma introdução.

Este é o código que gera a página “Bem-vindo ao MAMP” que você viu no navegador.

Exclua tudo e substitua por:

<?php
echo 'Hello World';
?>

Salve, atualize a página em  http://localhost:8888 , você deverá ver isto:

Ótimo! Esse foi seu primeiro programa em PHP.

Vamos explicar o que está acontecendo aqui.

Temos o servidor HTTP Apache escutando na porta  8888 do host local, seu computador.

Quando acessamos  http://localhost:8888  com o navegador, estamos fazendo uma requisição HTTP, solicitando o conteúdo da rota  /, a URL base.

O Apache, por padrão, está configurado para servir essa rota, servindo o  index.html arquivo incluído na  htdocs pasta. Esse arquivo não existe – mas como configuramos o Apache para funcionar com PHP, ele então procurará por um  index.php arquivo.

Este arquivo existe, e o código PHP é executado no lado do servidor antes que o Apache envie a página de volta ao navegador.

No arquivo PHP, temos uma  <?php abertura que diz “aqui começa algum código PHP”.

Temos um final  ?> que fecha o trecho de código PHP e, dentro dele, usamos a  echo instrução para imprimir a string entre aspas no HTML.

É necessário um ponto e vírgula no final de cada instrução.

Temos essa estrutura de abertura/fechamento porque podemos incorporar PHP dentro de HTML. PHP é uma linguagem de script e seu objetivo é poder "decorar" uma página HTML com dados dinâmicos.

Observe que, com o PHP moderno, geralmente evitamos misturar PHP com HTML. Em vez disso, usamos PHP como uma "estrutura para gerar o HTML" – por exemplo, usando ferramentas como o Laravel. Mas discutiremos  PHP puro  neste livro, então faz sentido começar do básico.

Por exemplo, algo assim lhe dará o mesmo resultado no navegador:

Hello
<?php
echo 'World';
?>

Para o usuário final, que olha o navegador e não tem ideia do código nos bastidores, não há diferença alguma.

A página é tecnicamente uma página HTML, embora não contenha tags HTML, mas apenas uma  Hello World string. Mas o navegador consegue descobrir como exibi-la na janela.

Noções básicas da linguagem PHP

Após o primeiro “Hello World”, é hora de mergulhar nos recursos da linguagem com mais detalhes.

Como funcionam as variáveis em PHP

Variáveis em PHP começam com o cifrão  $, seguido por um identificador, que é um conjunto de caracteres alfanuméricos e o  _ caractere sublinhado.

Você pode atribuir a uma variável qualquer tipo de valor, como strings (definidas usando aspas simples ou duplas):

$name = 'Flavio';

$name = "Flavio";

Ou números:

$age = 20;

ou qualquer outro tipo que o PHP permita, como veremos mais tarde.

Depois que uma variável recebe um valor, por exemplo, uma string, podemos reatribuir a ela um tipo diferente de valor, como um número:

$name = 3;

O PHP não reclamará que agora o tipo é diferente.

Os nomes de variáveis diferenciam maiúsculas de minúsculas.  $name é diferente de  $Name.

Não é uma regra rígida, mas geralmente os nomes de variáveis são escritos no formato camelCase, assim:  $brandOfCar ou  $ageOfDog. Mantemos a primeira letra minúscula e as letras das palavras subsequentes maiúsculas.

Como escrever comentários em PHP

Uma parte muito importante de qualquer linguagem de programação é como você escreve comentários.

Você escreve comentários de linha única em PHP desta maneira:

// single line comment

Comentários multilinha são definidos desta forma:

/*

this is a comment

*/

//or

/*
 *
 * this is a comment
 *
 */

//or to comment out a portion of code inside a line:

/* this is a comment */

O que são tipos em PHP?

Mencionei sequências e números.

O PHP possui os seguintes tipos:

• bool valores booleanos (verdadeiro/falso)
• int números inteiros (sem decimais)
• float números de ponto flutuante (decimais)
• string cordas
• array matrizes
• object objetos
• null um valor que significa “nenhum valor atribuído”

e alguns outros mais avançados.

Como imprimir o valor de uma variável em PHP

Podemos usar a  var_dump() função interna para obter o valor de uma variável:

$name = 'Flavio';

var_dump($name);

A  var_dump($name) instrução será impressa  string(6) "Flavio" na página, o que nos informará que a variável é uma sequência de 6 caracteres.

Se usássemos este código:

$age = 20;

var_dump($age);

teríamos  int(20) de volta, dizendo que o valor é 20 e é um inteiro.

var_dump() é uma das ferramentas essenciais no seu kit de ferramentas de depuração de PHP.

Como os operadores funcionam em PHP

Depois de ter algumas variáveis, você pode fazer operações com elas:

$base = 20;
$height = 10;

$area = $base * $height;

O que  * eu usei para multiplicar $base por $height é o operador de multiplicação.

Temos vários operadores, então vamos fazer um rápido resumo dos principais.

Para começar, aqui estão os operadores aritméticos:  +,  -,  *,  / (divisão),  % (resto) e  ** (exponencial).

Temos o operador de atribuição  =, que já usamos para atribuir um valor a uma variável.

Em seguida, temos operadores de comparação, como  <,  >,  <=,  >=. Eles funcionam como na matemática.

2 < 1; //false
1 <= 1; // true
1 <= 2; // true

== retorna verdadeiro se os dois operandos forem iguais.

=== retorna verdadeiro se os dois operandos forem idênticos.

Qual é a diferença?

Você descobrirá isso com a experiência, mas por exemplo:

1 == '1'; //true
1 === '1'; //false

Também temos  != que detectar se os operandos  não são  iguais:

1 != 1; //false
1 != '1'; //false
1 != 2; //true

//hint: <> works in the same way as !=, 1 <> 1

e  !== para detectar se os operandos não são idênticos:

1 !== 1; //false
1 !== '1'; //true

Operadores lógicos trabalham com valores booleanos:

// Logical AND with && or "and"

true && true; //true
true && false; //false
false && true; //false
false && false; //false

true and true; //true
true and false; //false
false and true; //false
false and false; //false

// Logical OR with || or "or"

true || true; // true
true || false //true
false || true //true
false || false //false

true or true; // true
true or false //true
false or true //true
false or false //false

// Logical XOR (one of the two is true, but not both)

true xor true; // false
true xor false //true
false xor true //true
false xor false //false

Também temos o  operador not  :

$test = true

!$test //false

Usei os valores booleanos  true e  false aqui, mas na prática você usará expressões que são avaliadas como verdadeiro ou falso, por exemplo:

1 > 2 || 2 > 1; //true

1 !== 2 && 2 > 2; //false

Todos os operadores listados acima são  binários , o que significa que envolvem 2 operandos.

O PHP também tem 2 operadores unários:  ++ e  --:

$age = 20;
$age++;
//age is now 21

$age--;
//age is now 20

Como trabalhar com strings em PHP

Já apresentei o uso de strings antes, quando falamos sobre variáveis, e definimos uma string usando esta notação:

$name = 'Flavio'; //string defined with single quotes

$name = "Flavio"; //string defined with double quotes

A grande diferença entre usar aspas simples e duplas é que com aspas duplas podemos expandir variáveis desta maneira:

$test = 'an example';

$example = "This is $test"; //This is an example

e com aspas duplas podemos usar  caracteres de escape  (pense em novas linhas   ou tabulações  ):

$example = "This is a line
This is a line";

/*
output is:

This is a line
This is a line
*/

O PHP oferece funções muito completas em sua biblioteca padrão (a biblioteca de funcionalidades que a linguagem oferece por padrão).

Primeiro, podemos concatenar duas strings usando o  . operador:

$firstName = 'Flavio';
$lastName = 'Copes';

$fullName = $firstName . ' ' . $lastName;

Podemos verificar o comprimento de uma string usando a  strlen() função:

$name = 'Flavio';
strlen($name); //6

Esta é a primeira vez que usamos uma função.

Uma função é composta por um identificador ( strlen neste caso) seguido por parênteses. Dentro desses parênteses, passamos um ou mais argumentos para a função. Neste caso, temos um argumento.

A função faz  algo  e, quando termina, pode retornar um valor. Nesse caso, ela retorna o número  6. Se nenhum valor for retornado, a função retorna  null.

Veremos como definir nossas próprias funções mais tarde.

Podemos obter uma parte de uma string usando  substr():

$name = 'Flavio';
substr($name, 3); //"vio" - start at position 3, get all the rest
substr($name, 2, 2); //"av" - start at position 2, get 2 items

Podemos substituir uma parte de uma string usando  str_replace():

$name = 'Flavio';
str_replace('avio', 'ower', $name); //"Flower"

Claro que podemos atribuir o resultado a uma nova variável:

$name = 'Flavio';
$itemObserved = str_replace('avio', 'ower', $name); //"Flower"

Há muito mais funções integradas que você pode usar para trabalhar com strings.

Aqui está uma breve lista não abrangente apenas para mostrar as possibilidades:

• trim() remove espaços em branco no início e no fim de uma string
• strtoupper() transforma uma string em maiúscula
• strtolower() torna uma string minúscula
• ucfirst() torna o primeiro caractere maiúsculo
• strpos() encontra a primeira ocorrência de uma substring na string
• explode() dividir uma string em uma matriz
• implode() para unir elementos de uma matriz em uma string

Você pode encontrar uma lista completa  aqui .

Como usar funções integradas para números em PHP

Anteriormente listei algumas funções que usamos comumente para strings.

Vamos fazer uma lista das funções que usamos com números:

• round() para arredondar um número decimal, para cima/baixo dependendo se o valor é > 0,5 ou menor
• ceil() arredondar um número decimal para cima
• floor() arredondar um número decimal para baixo
• rand() gera um inteiro aleatório
• min() encontra o menor número entre os números passados como argumentos
• max() encontra o maior número entre os números passados como argumentos
• is_nan() retorna verdadeiro se o número não for um número

Há uma infinidade de funções diferentes para todos os tipos de operações matemáticas, como seno, cosseno, tangentes, logaritmos e assim por diante. Você pode encontrar uma lista completa  aqui .

Como funcionam os arrays em PHP

Matrizes são listas de valores agrupados sob um nome comum.

Você pode definir um array vazio de duas maneiras diferentes:

$list = [];

$list = array();

Uma matriz pode ser inicializada com valores:

$list = [1, 2];

$list = array(1, 2);

Matrizes podem conter valores de qualquer tipo:

$list = [1, 'test'];

Até mesmo outras matrizes:

$list = [1, [2, 'test']];

Você pode acessar o elemento em uma matriz usando esta notação:

$list = ['a', 'b'];
$list[0]; //'a' --the index starts at 0
$list[1]; //'b'

Depois que uma matriz é criada, você pode acrescentar valores a ela desta maneira:

$list = ['a', 'b'];
$list[] = 'c';

/*
$list == [
  "a",
  "b",
  "c",
]
*/

Você pode usar  array_unshift() para adicionar o item no início do array:

$list = ['b', 'c'];
array_unshift($list, 'a');

/*
$list == [
  "a",
  "b",
  "c",
]
*/

Conte quantos itens há em uma matriz usando a função interna  count() :

$list = ['a', 'b'];

count($list); //2

Verifique se uma matriz contém um item usando a  in_array() função interna:

$list = ['a', 'b'];

in_array('b', $list); //true

Se além de confirmar a existência, você precisar do índice, use  array_search():

$list = ['a', 'b'];

array_search('b', $list) //1

Funções úteis para matrizes em PHP

Assim como acontece com strings e números, o PHP oferece diversas funções úteis para arrays. Vimos  count(),  in_array(),  array_search() – vamos ver mais algumas:

• is_array() para verificar se uma variável é uma matriz
• array_unique() para remover valores duplicados de uma matriz
• array_search() para pesquisar um valor na matriz e retornar a chave
• array_reverse() para reverter uma matriz
• array_reduce() para reduzir uma matriz a um único valor usando uma função de retorno de chamada
• array_map() para aplicar uma função de retorno de chamada a cada item do array. Normalmente usada para criar um novo array modificando os valores de um array existente, sem alterá-lo.
• array_filter() para filtrar uma matriz para um único valor usando uma função de retorno de chamada
• max() para obter o valor máximo contido na matriz
• min() para obter o valor mínimo contido na matriz
• array_rand() para obter um item aleatório da matriz
• array_count_values() para contar todos os valores na matriz
• implode() transformar uma matriz em uma string
• array_pop() para remover o último item do array e retornar seu valor
• array_shift() o mesmo que  array_pop() , mas remove o primeiro item em vez do último
• sort() para classificar uma matriz
• rsort() para classificar uma matriz em ordem reversa
• array_walk() semelhante a  array_map() faz algo para cada item na matriz, mas além disso pode alterar valores na matriz existente

Como usar matrizes associativas em PHP

Até agora usamos matrizes com um índice numérico incremental: 0, 1, 2…

Você também pode usar matrizes com índices nomeados (chaves), e nós as chamamos de matrizes associativas:

$list = ['first' => 'a', 'second' => 'b'];

$list['first'] //'a'
$list['second'] //'b'

Temos algumas funções que são especialmente úteis para matrizes associativas:

• array_key_exists() para verificar se uma chave existe na matriz
• array_keys() para obter todas as chaves do array
• array_values() para obter todos os valores da matriz
• asort() para classificar uma matriz associativa por valor
• arsort() para classificar uma matriz associativa em ordem decrescente por valor
• ksort() para classificar uma matriz associativa por chave
• krsort() para classificar uma matriz associativa em ordem decrescente por chave

Você pode ver todas as funções relacionadas à matriz  aqui .

Como funcionam os condicionais em PHP

Anteriormente, apresentei operadores de comparação:  <,  >,  <=,  >=,  ==,  === ,  !=,  !==... e assim por diante.

Esses operadores serão muito úteis para uma coisa:  condicionais .

Condicionais são a primeira estrutura de controle que vemos.

Podemos decidir fazer algo, ou outra coisa, com base em uma comparação.

Por exemplo:

$age = 17;

if ($age > 18) {
  echo 'You can enter the pub';
}

O código dentro dos parênteses só é executado se a condição for avaliada como  true.

Use  else para fazer  outra coisa  caso a condição seja  false:

$age = 17;

if ($age > 18) {
  echo 'You can enter the pub';
} else {
  echo 'You cannot enter the pub';
}

OBSERVAÇÃO: Usei  cannot em vez de  can't porque as aspas simples encerrariam minha string antes do previsto. Neste caso, você poderia escapar o comando  ' desta forma: echo 'You can't enter the pub';

Você pode ter várias  if instruções encadeadas usando  elseif:

$age = 17;

if ($age > 20) {
  echo 'You are 20+';
} elseif ($age > 18) {
  echo 'You are 18+';
} else {
  echo 'You are <18';
}

Além de  if, temos a  switch declaração.

Usamos isso quando temos uma variável que pode ter alguns valores diferentes e não precisamos ter um bloco if / elseif longo:

$age = 17

switch($age) {
  case 15:
        echo 'You are 15';
    break;
  case 16:
        echo 'You are 16';
    break;
  case 17:
        echo 'You are 17';
    break;
  case 18:
        echo 'You are 18';
    break;
  default:
    echo "You are $age";
}

Sei que o exemplo não tem lógica, mas acho que pode ajudar você a entender como  switch funciona.

A  break; declaração após cada caso é essencial. Se você não a adicionar e a idade for 17, verá isto:

You are 17
You are 18
You are 17

Em vez de apenas isto:

You are 17

como seria de esperar.

Como funcionam os loops em PHP

Loops são outra estrutura de controle super útil.

Temos alguns tipos diferentes de loops em PHP:  while,  do while,  fore  foreach.

Vamos ver todos eles!

Como usar um  while loop em PHP

Um  while loop é o mais simples. Ele continua iterando enquanto a condição é avaliada como  true:

while (true) {
  echo 'looping';
}

Isso seria um loop infinito, e é por isso que usamos variáveis e comparações:

$counter = 0;

while ($counter < 10) {
  echo $counter;
  $counter++;
}

Como usar um  do while loop em PHP

do while é semelhante, mas ligeiramente diferente na forma como a primeira iteração é executada:

$counter = 0;

do {
  echo $counter;
  $counter++;
} while ($counter < 10);

No  do while loop, primeiro fazemos a primeira iteração e  depois  verificamos a condição.

No  while loop,  primeiro  verificamos a condição e depois fazemos a iteração.

Faça um teste simples definindo  $counter como 15 nos exemplos acima e veja o que acontece.

Você vai querer escolher um tipo de loop ou outro, dependendo do seu caso de uso.

Como usar um  foreach loop em PHP

Você pode usar o  foreach loop para iterar facilmente sobre um array:

$list = ['a', 'b', 'c'];

foreach ($list as $value) {
  echo $value;
}

Você também pode obter o valor do índice (ou chave em uma matriz associativa) desta maneira:

$list = ['a', 'b', 'c'];

foreach ($list as $key => $value) {
  echo $key;
}

Como usar um  for loop em PHP

O  for loop é semelhante ao while, mas em vez de definir a variável usada no condicional antes do loop, e em vez de incrementar a variável de índice manualmente, tudo é feito na primeira linha:

for ($i = 0; $i < 10; $i++) {
  echo $i;
}

//result: 0123456789

Você pode usar o loop for para iterar sobre um array desta maneira:

$list = ['a', 'b', 'c'];

for ($i = 0; $i < count($list); $i++) {
  echo $list[$i];
}

//result: abc

Como usar as  instruções break and  continue em PHP

Em muitos casos, você deseja ter a capacidade de interromper um loop sob demanda.

Por exemplo, você deseja interromper um  for loop quando o valor da variável na matriz for  'b':

$list = ['a', 'b', 'c'];

for ($i = 0; $i < count($list); $i++) {
    if ($list[$i] == 'b') {
    break;
  }
  echo $list[$i];
}

//result: a

Isso faz com que o loop pare completamente naquele ponto, e a execução do programa continua na próxima instrução após o loop.

Se você quiser apenas pular a iteração do loop atual e continuar procurando, use  continue :

$list = ['a', 'b', 'c'];

for ($i = 0; $i < count($list); $i++) {
    if ($list[$i] == 'b') {
    continue;
  }
  echo $list[$i];
}

//result: ac

Como as funções funcionam em PHP

Funções são um dos conceitos mais importantes em programação.

Você pode usar funções para agrupar várias instruções ou várias linhas de código e dar um nome a elas.

Por exemplo, você pode criar uma função que envia um e-mail. Vamos chamá-la de  sendEmail, e vamos defini-la assim:

function sendEmail() {
  //send an email
}

E você pode  chamá-lo  em qualquer outro lugar usando esta sintaxe:

sendEmail();

Você também pode passar argumentos para uma função. Por exemplo, quando você envia um e-mail, você quer enviá-lo para alguém – então você adiciona o e-mail como o primeiro argumento:

sendEmail('test@test.com');

Dentro da definição da função, obtemos esse parâmetro desta forma (nós os chamamos de  parâmetros  dentro da definição da função e  argumentos  quando chamamos a função):

function sendEmail($to) {
  echo "send an email to $to";
}

Você pode enviar vários argumentos separando-os com vírgulas:

sendEmail('test@test.com', 'subject', 'body of the email');

E podemos obter esses parâmetros na ordem em que foram definidos:

function sendEmail($to, $subject, $body) {
  //...
}

Podemos  opcionalmente  definir o tipo de parâmetros:

function sendEmail(string $to, string $subject, string $body) {
  //...
}

Os parâmetros podem ter um valor padrão, então se eles forem omitidos, ainda podemos ter um valor para eles:

function sendEmail($to, $subject = 'test', $body = 'test') {
  //...
}

sendEmail('test@test.com')

Uma função pode retornar um valor. Apenas um valor pode ser retornado por uma função, não mais de um. Isso é feito usando a  return palavra-chave . Se omitida, a função retorna  null.

O valor retornado é muito útil, pois informa o resultado do trabalho realizado na função e permite que você use o resultado após chamá-la:

function sendEmail($to) {
    return true;
}

$success = sendEmail('test@test.com');

if ($success) {
  echo 'email sent successfully';
} else {
  echo 'error sending the email';
}

Podemos  opcionalmente  definir o tipo de retorno de uma função usando esta sintaxe:

function sendEmail($to): bool {
    return true;
}

Quando você define uma variável dentro de uma função, essa variável é  local  para a função, o que significa que não é visível de fora. Quando a função termina, ela simplesmente deixa de existir:

function sendEmail($to) {
    $test = 'a';
}

var_dump($test); //PHP Warning:  Undefined variable $test

Variáveis definidas fora da função  não são  acessíveis dentro da função.

Isso reforça uma boa prática de programação, pois podemos ter certeza de que a função não modifica variáveis externas e causa “efeitos colaterais”.

Em vez disso, você retorna um valor da função, e o código externo que chama a função se responsabilizará por atualizar a variável externa.

Assim:

$character = 'a';

function test() {
  return 'b';
}

$character = test();

Você pode passar o valor de uma variável passando-o como um argumento para a função:

$character = 'a';

function test($c) {
  echo $c;
}

test($character);

Mas você não pode modificar esse valor de dentro da função.

Ele é  passado por valor , o que significa que a função recebe uma cópia dele, não a referência à variável original.

Isso ainda é possível usando esta sintaxe (observe que usei  & na definição do parâmetro):

$character = 'a';

function test(&$c) {
  $c = 'b';
}

test($character);

echo $character; //'b'

As funções que definimos até agora são  denominadas funções .

Eles têm um nome.

Também temos  funções anônimas , que podem ser úteis em muitos casos.

Eles não têm um nome propriamente dito, mas são atribuídos a uma variável. Para chamá-los, você invoca a variável com parênteses no final:

$myfunction = function() {
  //do something here
};

$myfunction()

Observe que você precisa de um ponto e vírgula após a definição da função, mas elas funcionam como funções nomeadas para valores de retorno e parâmetros.

Curiosamente, eles oferecem uma maneira de acessar uma variável definida fora da função por meio de  use():

$test = 'test';

$myfunction = function() use ($test) {
  echo $test;
  return 'ok';
};

$myfunction()

Outro tipo de função é a  função de seta .

Uma função de seta é uma função anônima que é apenas uma expressão (uma linha) e retorna implicitamente o valor dessa expressão.

Você define desta forma:

fn (arguments) => expression;

Aqui está um exemplo:

$printTest = fn() => 'test';

$printTest(); //'test'

Você pode passar parâmetros para uma função de seta:

$multiply = fn($a, $b) => $a * $b;

$multiply(2, 4) //8

Observe que, como mostra o próximo exemplo, as funções de seta têm acesso automático às variáveis do escopo envolvente, sem a necessidade de  use().

$a = 2;
$b = 4;

$multiply = fn() => $a * $b;

$multiply()

Funções de seta são muito úteis quando você precisa passar uma função de retorno de chamada. Veremos como usá-las para realizar algumas operações de array mais tarde.

Portanto, temos no total 3 tipos de funções:  funções nomeadas ,  funções anônimas e  funções de seta .

Cada um deles tem seu lugar, e você aprenderá a usá-los corretamente com o tempo e a prática.

Como fazer um loop em arrays com  map(),  filter(), e  reduce() em PHP

Outro conjunto importante de estruturas de loop, frequentemente usado em programação funcional, é o conjunto de  array_map() /  array_filter() /  array_reduce().

Essas 3 funções PHP integradas recebem um array e uma função de retorno de chamada que, em cada iteração, recebe cada item do array.

array_map() retorna uma nova matriz que contém o resultado da execução da função de retorno de chamada em cada item da matriz:

$numbers = [1, 2, 3, 4];
$doubles = array_map(fn($value) => $value * 2, $numbers);

//$doubles is now [2, 4, 6, 8]

array_filter() gera um novo array obtendo apenas os itens cuja função de retorno de chamada retorna  true:

$numbers = [1, 2, 3, 4];
$even = array_filter($numbers, fn($value) => $value % 2 === 0)

//$even is now [2, 4]

array_reduce() é usado para  reduzir  uma matriz a um único valor.

Por exemplo, podemos usá-lo para multiplicar todos os itens em uma matriz:

$numbers = [1, 2, 3, 4];

$result = array_reduce($numbers, fn($carry, $value) => $carry * $value, 1)

Observe o último parâmetro – é o valor inicial. Se você omiti-lo, o valor padrão será ,  0 mas isso não funcionaria para o nosso exemplo de multiplicação.

Observe que  array_map() a ordem dos argumentos é invertida. Primeiro, temos a função de retorno de chamada e, em seguida, o array. Isso ocorre porque podemos passar vários arrays usando vírgulas ( array_map(fn($value) => $value * 2, $numbers, $otherNumbers, $anotherArray);). Idealmente, gostaríamos de mais consistência, mas é isso que acontece.

Programação Orientada a Objetos em PHP

Vamos agora mergulhar de cabeça em um grande tópico: programação orientada a objetos com PHP.

A programação orientada a objetos permite que você crie abstrações úteis e torne seu código mais simples de entender e gerenciar.

Como usar classes e objetos em PHP

Para começar, você tem classes e objetos.

Uma classe é um projeto, ou tipo, de objeto.

Por exemplo, você tem a classe  Dog, definida desta maneira:

class Dog {

}

Observe que a classe deve ser definida em letras maiúsculas.

Então você pode criar objetos dessa classe – cães específicos e individuais.

Um objeto é atribuído a uma variável e é instanciado usando a  new Classname() sintaxe:

$roger = new Dog();

Você pode criar vários objetos da mesma classe, atribuindo cada objeto a uma variável diferente:

$roger = new Dog();
$syd = new Dog();

Como usar propriedades em PHP

Todos esses objetos compartilharão as mesmas características definidas pela classe. Mas, uma vez instanciados, eles terão vida própria.

Por exemplo, um cachorro tem um nome, uma idade e uma cor de pelo.

Então podemos defini-las como propriedades na classe:

class Dog {
  public $name;
  public $age;
  public $color;
}

Elas funcionam como variáveis, mas são anexadas ao objeto, uma vez instanciado a partir da classe. A  public palavra-chave é o  modificador de acesso  e define a propriedade como publicamente acessível.

Você pode atribuir valores a essas propriedades desta maneira:

class Dog {
  public $name;
  public $age;
  public $color;
}

$roger = new Dog();

$roger->name = 'Roger';
$roger->age = 10;
$roger->color = 'gray';

var_dump($roger);

/*
object(Dog)#1 (3) {
  ["name"]=> string(5) "Roger"
    ["age"]=> int(10)
    ["color"]=> string(4) "gray"
}
*/

Observe que a propriedade é definida como  public.

Isso é chamado de modificador de acesso. Você pode usar dois outros tipos de modificadores de acesso:  private e  protected. Private torna a propriedade inacessível de fora do objeto. Somente métodos definidos dentro do objeto podem acessá-la.

Veremos mais sobre protected quando falarmos sobre herança.

Como usar métodos em PHP

Eu disse método? O que é um método?

Um método é uma função definida dentro da classe e é definida desta maneira:

class Dog {
  public function bark() {
    echo 'woof!';
  }
}

Métodos são muito úteis para atribuir um comportamento a um objeto. Neste caso, podemos fazer um cachorro latir.

Observe que eu uso a  public palavra-chave . Isso significa que você pode invocar um método de fora da classe. Assim como para propriedades, você pode marcar métodos como  private too, ou  protected, para restringir seu acesso.

Você invoca um método na instância do objeto assim:

class Dog {
  public function bark() {
    echo 'woof!';
  }
}

$roger = new Dog();

$roger->bark();

Um método, assim como uma função, pode definir parâmetros e um valor de retorno também.

Dentro de um método, podemos acessar as propriedades do objeto usando a variável interna especial  $this , que, quando referenciada dentro de um método, aponta para a instância atual do objeto:

class Dog {
  public $name;

  public function bark() {
    echo $this->name . ' barked!';
  }
}

$roger = new Dog();
$roger->name = 'Roger';
$roger->bark();

Observe que eu usei  $this->name para definir e acessar a  $name propriedade, e não  $this->$name.

Como usar o método construtor em PHP

Um tipo especial de método  __construct() é chamado de  construtor .

class Dog {
    public function __construct() {

  }
}

Use esse método para inicializar as propriedades de um objeto ao criá-lo, pois ele é invocado automaticamente ao chamar  new Classname().

class Dog {
  public $name;

    public function __construct($name) {
        $this->name = $name;
  }

  public function bark() {
    echo $this->name . ' barked!';
  }
}

$roger = new Dog('Roger');
$roger->bark();

Isso é tão comum que o PHP (a partir do PHP 8) inclui algo chamado  promoção de construtor  , que automaticamente faz isso:

class Dog {
  public $name;

    public function __construct($name) {
        $this->name = $name;
  }

  //...

Ao utilizar o modificador de acesso, a atribuição do parâmetro do construtor para a variável local acontece automaticamente:

class Dog {
    public function __construct(public $name) {
  }

  public function bark() {
    echo $this->name . ' barked!';
  }
}

$roger = new Dog('Roger');
$roger->name; //'Roger'
$roger->bark(); //'Roger barked!'

Propriedades podem ser  digitadas .

Você pode exigir que o nome seja uma string usando  public string $name:

class Dog {
  public string $name;

    public function __construct($name) {
        $this->name = $name;
  }

  public function bark() {
    echo $this->name . ' barked!';
  }
}

$roger = new Dog('Roger');
$roger->name; //'Roger'
$roger->bark(); //'Roger barked!'

Agora tudo funciona bem neste exemplo, mas tente mudar isso para  public int $name exigir que seja um inteiro.

O PHP gerará um erro se você inicializar  $name com uma string:

TypeError: Dog::__construct():
Argument #1 ($name) must be of type int,
string given on line 14

Interessante, não é?

Podemos impor que propriedades tenham um tipo específico entre  string,  int,  float,  string,  object,  array,  bool e  outros .

O que é herança em PHP?

A diversão na programação orientada a objetos começa quando permitimos que classes herdem propriedades e métodos de outras classes.

Suponha que você tenha uma  Animal classe:

class Animal {

}

Cada animal tem uma idade e pode comer. Então, adicionamos uma  age propriedade e um  eat() método:

class Animal {
  public $age;

  public function eat() {
    echo 'the animal is eating';
  }
}

Um cão é um animal, tem uma idade e também pode comer, então a  Dog classe – em vez de reimplementar as mesmas coisas que temos  Animal – pode estender essa classe:

class Dog extends Animal {

}

Agora podemos instanciar um novo objeto de classe  Dog e temos acesso às propriedades e métodos definidos em  Animal:

$roger = new Dog();
$roger->eat();

Neste caso, chamamos a  classe filha de Cachorro  e a  classe pai de Animal .

Dentro da classe filha, podemos usar  $this para referenciar qualquer propriedade ou método definido na classe pai, como se estivessem definidos dentro da classe filha.

Vale ressaltar que, embora possamos acessar as propriedades e métodos do pai a partir do filho, não podemos fazer o inverso.

A classe pai não sabe nada sobre a classe filha.

protected Propriedades e Métodos em PHP

Agora que introduzimos a herança, podemos discutir  protected. Já vimos como podemos usar o  public modificador de acesso para definir propriedades e métodos que podem ser chamados de fora de uma classe, pelo  público.

private propriedades e métodos só podem ser acessados de dentro da classe.

protected Propriedades e métodos podem ser acessados de dentro da classe e de classes filhas.

Como substituir métodos em PHP

O que acontece se tivermos um  eat() método em  Animal e quisermos personalizá-lo em  Dog? Podemos  sobrescrever  esse método.

class Animal {
  public $age;

  public function eat() {
    echo 'the animal is eating';
  }
}

class Dog extends Animal {
  public function eat() {
    echo 'the dog is eating';
  }
}

Agora, qualquer instância de  Dog usará a  Dogimplementação do  eat() método 's.

Propriedades e métodos estáticos em PHP

Vimos como definir propriedades e métodos que pertencem  à instância de uma classe , um objeto.

Às vezes é útil atribuí-los à própria classe.

Quando isso acontece, nós os chamamos  de estáticos e, para referenciá-los ou chamá-los, não precisamos criar um objeto da classe.

Vamos começar com propriedades estáticas. Definimos essas propriedades com a  static palavra-chave:

class Utils {
  public static $version = '1.0';
}

Nós os referenciamos de dentro da classe usando a palavra-chave  self, que aponta para a classe:

self::$version;

e de fora da classe usando:

Utils::version

Isso é o que acontece com métodos estáticos:

class Utils {
  public static function version() {
    return '1.0';
  }
}

De fora da classe podemos chamá-los desta forma:

Utils::version();

De dentro da classe, podemos referenciá-los usando a  self palavra-chave, que se refere à classe atual:

self::version();

Como comparar objetos em PHP

Quando falamos sobre operadores, mencionei que temos o  == operador para verificar se dois valores são iguais e  === para verificar se eles são idênticos.

A principal diferença é que  == verifica o conteúdo do objeto, por exemplo, a  '5' string é igual ao número  5, mas não é idêntica a ele.

Quando usamos esses operadores para comparar objetos,  == verificaremos se os dois objetos têm a mesma classe e se os mesmos valores atribuídos a eles.

=== por outro lado verificará se eles também se referem à mesma instância (objeto).

Por exemplo:

class Dog {
  public $name = 'Good dog';
}

$roger = new Dog();
$syd = new Dog();

echo $roger == $syd; //true

echo $roger === $syd; //false

Como iterar sobre propriedades de objetos em PHP

Você pode percorrer todas as propriedades públicas em um objeto usando um  foreach loop, assim:

class Dog {
  public $name = 'Good dog';
  public $age = 10;
  public $color = 'gray';
}

$dog = new Dog();

foreach ($dog as $key => $value) {
  echo $key . ': ' . $value . '<br>';
}

Como clonar objetos em PHP

Quando você tem um objeto, você pode cloná-lo usando a  clone palavra-chave:

class Dog {
  public $name;
}

$roger = new Dog();
$roger->name = 'Roger';

$syd = clone $roger;

Isso executa um  clone superficial , o que significa que referências a outras variáveis serão copiadas como referências – não haverá uma “clonagem recursiva” delas.

Para fazer uma  clonagem profunda  , você precisará trabalhar mais um pouco.

O que são métodos mágicos em PHP?

Métodos mágicos são métodos especiais que definimos em classes para executar algum comportamento quando algo especial acontece.

Por exemplo, quando uma propriedade é definida ou acessada, ou quando o objeto é clonado.

Já vimos isso  __construct() antes.

Esse é um método mágico.

Existem outros. Por exemplo, podemos definir uma propriedade booleana "clonada" como verdadeira quando o objeto é clonado:

class Dog {
  public $name;

  public function __clone() {
    $this->cloned = true;
  }
}

$roger = new Dog();
$roger->name = 'Roger';

$syd = clone $roger;
echo $syd->cloned;

Outros métodos mágicos incluem  __call(),  __get(),  __set(),  __isset(),  __toString() e outros.

Você pode ver a lista completa  aqui

Como incluir outros arquivos PHP

Agora terminamos de falar sobre os recursos orientados a objetos do PHP.

Vamos agora explorar outros tópicos interessantes!

Dentro de um arquivo PHP, você pode incluir outros arquivos PHP. Temos os seguintes métodos, todos usados para este caso de uso, mas todos ligeiramente diferentes:  include,  include_once,  requiree  require_once.

include carrega o conteúdo de outro arquivo PHP, usando um caminho relativo.

require faz o mesmo, mas se houver algum erro, o programa para.  include irá gerar apenas um aviso.

Você pode optar por usar um ou outro, dependendo do seu caso. Se quiser que o programa feche caso não consiga importar o arquivo, use  require.

include_once e  require_once fazem a mesma coisa que suas funções correspondentes sem  _once, mas garantem que o arquivo seja incluído/necessário apenas uma vez durante a execução do programa.

Isso é útil se, por exemplo, você tiver vários arquivos carregando algum outro arquivo e normalmente quiser evitar carregá-lo mais de uma vez.

Minha regra geral é nunca usar  include ou  require porque você pode carregar o mesmo arquivo duas vezes.  include_once e  require_once ajudar você a evitar esse problema.

Use  include_once quando quiser carregar um arquivo condicionalmente, por exemplo, "carregar este arquivo em vez daquele". Em todos os outros casos, use  require_once.

Aqui está um exemplo:

require_once('test.php');

//now we have access to the functions, classes
//and variables defined in the `test.php` file

A sintaxe acima inclui o  test.php arquivo da pasta atual, o arquivo onde este código está.

Você pode usar caminhos relativos:

require_once('../test.php');

para incluir um arquivo na pasta pai ou colocá-lo em uma subpasta:

require_once('test/test.php');

Você pode usar caminhos absolutos:

require_once('/var/www/test/file.php');

Em bases de código PHP modernas que usam um framework, os arquivos geralmente são carregados automaticamente, então você terá menos necessidade de usar as funções acima.

Constantes, funções e variáveis úteis para sistema de arquivos em PHP

Falando em caminhos, o PHP oferece vários utilitários para ajudar você a trabalhar com caminhos.

Você pode obter o caminho completo do arquivo atual usando:

• __FILE__, uma  constante mágica
• $_SERVER['SCRIPT_FILENAME'] (mais sobre isso  $_SERVER depois!)

Você pode obter o caminho completo da pasta onde o arquivo atual está usando:

• a  getcwd() função embutida
• __DIR__, outra constante mágica
• combine  __FILE__ com  dirname() para obter o caminho completo da pasta atual: dirname(__FILE__)
• usar $_SERVER['DOCUMENT_ROOT']

Como lidar com erros em PHP

Todo programador comete erros. Afinal, somos humanos.

Podemos esquecer um ponto e vírgula. Ou usar o nome de variável errado. Ou passar o argumento errado para uma função.

Em PHP temos:

• Avisos
• Avisos
• Erros

Os dois primeiros são erros menores e não interrompem a execução do programa. O PHP imprimirá uma mensagem e pronto.

Erros encerram a execução do programa e exibem uma mensagem informando o motivo.

Existem muitos tipos diferentes de erros, como erros de análise, erros fatais de tempo de execução, erros fatais de inicialização e muito mais.

São todos erros.

Eu disse “O PHP imprimirá uma mensagem”, mas... onde?

Isso depende da sua configuração.

No modo de desenvolvimento, é comum registrar erros de PHP diretamente na página da Web, mas também em um log de erros.

Você  quer  ver esses erros o mais cedo possível para poder corrigi-los.

Na produção, por outro lado, você não quer mostrá-los na página da Web, mas ainda quer saber sobre eles.

Então o que você faz? Você os registra no log de erros.

Tudo isso é decidido na configuração do PHP.

Ainda não falamos sobre isso, mas há um arquivo na configuração do seu servidor que decide muitas coisas sobre como o PHP é executado.

É chamado de  php.ini.

O tamanho exato deste arquivo depende da sua configuração.

Para descobrir onde está o seu, a maneira mais fácil é adicionar isso a um arquivo PHP e executá-lo no seu navegador:

<?php
phpinfo();
?>

Você verá então em “Arquivo de configuração carregado”:

No meu caso é  /Applications/MAMP/bin/php/php8.1.0/conf/php.ini.

Observe que as informações geradas por  phpinfo() contêm muitas outras informações úteis. Lembre-se disso.

Usando o MAMP, você pode abrir a pasta do aplicativo MAMP e abrir  bin/php. Acesse a sua versão específica do PHP (8.1.0 no meu caso) e depois  conf. Lá você encontrará o  php.ini arquivo:

Abra esse arquivo em um editor.

Ele contém uma lista muito longa de configurações, com uma ótima documentação em linha para cada uma delas.

Estamos particularmente interessados em  display_errors:

Na produção, você quer que seu valor seja  Off, como diz a documentação acima.

Os erros não aparecerão mais no site, mas você os verá no  php_error.log arquivo na  logs pasta do MAMP neste caso:

Este arquivo estará em uma pasta diferente dependendo da sua configuração.

Você define isso em seu  php.ini:

O log de erros conterá todas as mensagens de erro geradas pelo seu aplicativo:

Você pode adicionar informações ao log de erros usando a  error_log() função:

error_log('test');

É comum usar um serviço de registro de erros, como  o Monolog .

Como lidar com exceções em PHP

Às vezes, erros são inevitáveis. Como quando algo completamente imprevisível acontece.

Mas, muitas vezes, podemos pensar no futuro e escrever um código que intercepte um erro e fazer algo sensato quando isso acontece, como mostrar uma mensagem de erro útil ao usuário ou tentar uma solução alternativa.

Fazemos isso usando  exceções .

Exceções são usadas para nos conscientizar, desenvolvedores, de um problema.

Envolvemos um código que pode potencialmente gerar uma exceção em um  try bloco, e temos um  catch bloco logo depois. Esse bloco catch será executado se houver uma exceção no bloco try:

try {
  //do something
} catch (Throwable $e) {
  //we can do something here if an exception happens
}

Observe que temos um  Exception objeto  $e sendo passado para o  catch bloco, e podemos inspecionar esse objeto para obter mais informações sobre a exceção, assim:

try {
  //do something
} catch (Throwable $e) {
  echo $e->getMessage();
}

Vejamos um exemplo.

Digamos que por engano eu divido um número por zero:

echo 1 / 0;

Isso acionará um erro fatal e o programa será interrompido nessa linha:

Envolvendo a operação em um bloco try e imprimindo a mensagem de erro no bloco catch, o programa termina com sucesso, me informando o problema:

try {
  echo 1 / 0;
} catch (Throwable $e) {
  echo $e->getMessage();
}

Claro que este é um exemplo simples, mas você pode ver o benefício: posso interceptar o problema.

Cada exceção tem uma classe diferente. Por exemplo, podemos capturar isso como  DivisionByZeroError e isso me permite filtrar os possíveis problemas e tratá-los de forma diferente.

Posso ter uma solução para qualquer erro que possa ser lançado no final, assim:

try {
  echo 1 / 0;
} catch (DivisionByZeroError $e) {
  echo 'Ooops I divided by zero!';
} catch (Throwable $e) {
  echo $e->getMessage();
}

E também posso acrescentar um  finally {} bloco no final desta estrutura try/catch para executar algum código depois que ele for executado com sucesso sem problemas, ou se houver um  catch :

try {
  echo 1 / 0;
} catch (DivisionByZeroError $e) {
  echo 'Ooops I divided by zero!';
} catch (Throwable $e) {
  echo $e->getMessage();
} finally {
  echo ' ...done!';
}

Você pode usar as  exceções integradas  fornecidas pelo PHP, mas também pode criar suas próprias exceções.

Como trabalhar com datas em PHP

Trabalhar com datas e horas é muito comum em programação. Vamos ver o que o PHP oferece.

Podemos obter o registro de data e hora atual (número de segundos desde 1º de janeiro de 1970 00:00:00 GMT) usando  time():

$timestamp = time();

Quando você tem um registro de data e hora, você pode formatá-lo como uma data usando  date(), no formato que preferir:

echo date('Y-m-d', $timestamp);

Y é a representação de 4 dígitos do ano,  m é o número do mês (com um zero à esquerda) e d  é o número do dia do mês, com um zero à esquerda.

Veja a  lista completa de caracteres que você pode usar para formatar a data aqui .

Podemos converter qualquer data em um registro de data e hora usando  strtotime(), que pega uma string com uma representação textual de uma data e a converte no número de segundos desde 1º de janeiro de 1970:

echo strtotime('now');
echo strtotime('4 May 2020');
echo strtotime('+1 day');
echo strtotime('+1 month');
echo strtotime('last Sunday');

...é bem flexível.

Para datas, é comum usar bibliotecas que oferecem muito mais funcionalidades do que a linguagem oferece. Uma boa opção é  o Carbon .

Como usar constantes e enumerações em PHP

Podemos definir constantes em PHP usando a  define() função interna:

define('TEST', 'some value');

E então podemos usar  TEST como se fosse uma variável, mas sem o  $ sinal:

define('TEST', 'some value');

echo TEST;

Usamos identificadores maiúsculos como uma convenção para constantes.

Curiosamente, dentro das classes podemos definir propriedades constantes usando a  const palavra-chave:

class Dog {
  const BREED = 'Siberian Husky';
}

Por padrão, eles são  public , mas podemos marcá-los como  private ou  protected:

class Dog {
  private const BREED = 'Siberian Husky';
}

Enumerações permitem agrupar constantes sob uma "raiz" comum. Por exemplo, você quer uma  Status enumeração com 3 estados: EATING SLEEPING RUNNING , os 3 estados do dia de um cachorro.

Então você tem:

enum Status {
  case EATING;
  case SLEEPING;
  case RUNNING;
}

Agora podemos referenciar essas constantes desta maneira:

class Dog {
  public Status $status;
}

$dog = new Dog();

$dog->status = Status::RUNNING;

if ($dog->status == Status::SLEEPING) {
  //...
}

Enums são objetos, eles podem ter métodos e muitos outros recursos dos quais podemos falar aqui nesta breve introdução.

Como usar PHP como uma plataforma de desenvolvimento de aplicativos da Web

PHP é uma linguagem do lado do servidor e normalmente é usada de duas maneiras.

Um está dentro de uma página HTML, então o PHP é usado para “adicionar” coisas ao HTML que são definidas manualmente no .php  arquivo. Esta é uma maneira perfeitamente adequada de usar PHP.

Outra abordagem considera o PHP mais como o mecanismo responsável por gerar uma "aplicação". Você não escreve o HTML em um  .php arquivo, mas usa uma linguagem de template para gerar o HTML, e tudo é gerenciado pelo que chamamos de  framework. .

Isso é o que acontece quando você usa um framework moderno como o Laravel.

Eu consideraria a primeira maneira um pouco "fora de moda" hoje em dia, e se você está apenas começando, deve conhecer esses dois estilos diferentes de uso do PHP.

Mas considere também usar um framework como o "modo fácil", pois frameworks oferecem ferramentas para lidar com roteamento, ferramentas para acessar dados de um banco de dados e facilitam a construção de um aplicativo mais seguro. E tornam tudo mais rápido de desenvolver.

Dito isso, não vamos falar sobre o uso de frameworks neste manual. Mas falarei sobre os blocos de construção básicos e fundamentais do PHP. Eles são essenciais que qualquer desenvolvedor PHP precisa conhecer.

Saiba apenas que “no mundo real” você pode usar a maneira de fazer as coisas do seu framework favorito em vez do  nível inferior  oferecidos pelo PHP.

É claro que isso não se aplica apenas ao PHP – é um “problema” que acontece com qualquer linguagem de programação.

Como lidar com solicitações HTTP em PHP

Vamos começar lidando com solicitações HTTP.

O PHP oferece roteamento baseado em arquivo por padrão. Você cria um  index.php arquivo e ele responde no /  caminho.

Vimos isso quando criamos o exemplo Hello World no começo.

Da mesma forma, você pode criar um  test.php arquivo e automaticamente esse será o arquivo que o Apache servirá no /test  rota.

 Como  usar  $_GETe $_POST$_REQUEST  em PHP

Os arquivos respondem a todas as solicitações HTTP, incluindo GET, POST e outros verbos.

Para qualquer solicitação, você pode acessar todos os dados da string de consulta usando o  $_GET objeto. É chamado de  superglobal  e está automaticamente disponível em todos os nossos arquivos PHP.

Isso é, obviamente, mais útil em solicitações GET, mas outras solicitações também podem enviar dados como uma string de consulta.

Para solicitações POST, PUT e DELETE, é mais provável que você precise dos dados postados como dados codificados em URL ou usando o objeto FormData, que o PHP disponibiliza para você usando $_POST .

Há também  $_REQUEST que contém todos  $_GET e $_POST  combinados em uma única variável.

Como usar o $_SERVER  objeto em PHP

Temos também a variável superglobal $_SERVER , que você usa para obter muitas informações úteis.

Você viu como usar phpinfo()  . Vamos usar novamente para ver o que $_SERVER nos oferece.

No seu  index.php arquivo na raiz do MAMP execute:

<?php
phpinfo();
?>

Em seguida, gere a página em  localhost:8888  e pesquise  $_SERVER. Você verá todas as configurações armazenadas e os valores atribuídos:

Os mais importantes que você pode usar são:

• $_SERVER['HTTP_HOST']
• $_SERVER['HTTP_USER_AGENT']
• $_SERVER['SERVER_NAME']
• $_SERVER['SERVER_ADDR']
• $_SERVER['SERVER_PORT']
• $_SERVER['DOCUMENT_ROOT']
• $_SERVER['REQUEST_URI']
• $_SERVER['SCRIPT_NAME']
• $_SERVER['REMOTE_ADDR']

Como usar formulários em PHP

Formulários são a maneira como a plataforma Web permite que os usuários interajam com uma página e enviem dados ao servidor.

Aqui está um formulário simples em HTML:

<form>
  <input type="text" name="name" />
  <input type="submit" />
</form>

Você pode colocar isso em seu  index.php arquivo como foi chamado index.html .

Um arquivo PHP pressupõe que você escreva HTML nele com alguns “acrescentos de PHP” usando <?php ?>  para que o servidor web possa enviar isso ao cliente. Às vezes, a parte PHP ocupa a página inteira, e é aí que você gera todo o HTML via PHP – é meio que o oposto da abordagem que estamos adotando aqui agora.

Então temos este  index.php arquivo que gera este formulário usando HTML simples:

Ao clicar no botão Enviar, será feita uma solicitação GET para a mesma URL, enviando os dados por meio de uma string de consulta. Observe que a URL mudou para  localhost:8888/?name=test .

Podemos adicionar algum código para verificar se esse parâmetro está definido usando a  isset() função:

<form>
  <input type="text" name="name" />
  <input type="submit" />
</form>

<?php
if (isset($_GET['name'])) {
  echo '<p>The name is ' . $_GET['name'];
}
?>

Viu? Podemos obter as informações da   string de consulta  da solicitação GET$_GET por meio de .

O que você normalmente faz com formulários é executar uma solicitação POST:

<form **method="POST"**>
  <input type="text" name="name" />
  <input type="submit" />
</form>

<?php
if (isset($_POST['name'])) {
  echo '<p>The name is ' . $_POST['name'];
}
?>

Veja, agora obtivemos as mesmas informações, mas a URL não mudou. As informações do formulário não foram anexadas à URL.

Isso ocorre porque estamos usando uma  solicitação POST , que envia os dados ao servidor de uma maneira diferente, por meio de dados codificados em URL.

Como mencionado acima, o PHP ainda servirá o  index.php arquivo, pois continuaremos enviando dados para a mesma URL em que o formulário está.

Estamos misturando um monte de código e poderíamos separar o manipulador de solicitação de formulário do código que gera o formulário.

Então podemos ter isso em  index.php:

<form **method="POST" action="/post.php"**>
  <input type="text" name="name" />
  <input type="submit" />
</form>

e podemos criar um novo  post.php arquivo com:

<?php
if (isset($_POST['name'])) {
  echo '<p>The name is ' . $_POST['name'];
}
?>

O PHP exibirá esse conteúdo agora depois que enviarmos o formulário, porque definimos o  action atributo HTML no formulário.

Este exemplo é muito simples, mas o  post.php arquivo é onde poderíamos, por exemplo, salvar os dados no banco de dados ou em um arquivo.

Como usar cabeçalhos HTTP em PHP

O PHP nos permite definir os cabeçalhos HTTP de uma resposta por meio da  header() função.

Cabeçalhos HTTP  são uma maneira de enviar informações de volta ao navegador.

Podemos dizer que a página gera um erro interno do servidor 500:

<?php
header('HTTP/1.1 500 Internal Server Error');
?>

Agora você deverá ver o status se acessar a página com as  Ferramentas do Desenvolvedor do Navegador  abertas:

Podemos definir o  content/type de uma resposta:

header('Content-Type: text/json');

Podemos forçar um redirecionamento 301:

header('HTTP/1.1 301 Moved Permanently');
header('Location: https://flaviocopes.com');

Podemos usar cabeçalhos para dizer ao navegador “armazenar esta página em cache”, “não armazenar esta página em cache” e muito mais.

Como usar cookies em PHP

Os cookies são um recurso do navegador.

Quando enviamos uma resposta ao navegador, podemos definir um cookie que será armazenado pelo navegador, no lado do cliente.

Então, cada solicitação feita pelo navegador incluirá o cookie de volta para nós.

Podemos fazer muitas coisas com cookies. Eles são usados principalmente para criar uma experiência personalizada sem que você precise fazer login em um serviço.

É importante observar que os cookies são específicos do domínio, portanto, só podemos ler os cookies que definimos no domínio atual do nosso aplicativo, não os cookies de outros aplicativos.

Mas JavaScript pode ler cookies (a menos que sejam  cookies HttpOnly  , mas estamos começando a entrar em detalhes), então os cookies não devem armazenar nenhuma informação sensível.

Podemos usar PHP para ler o valor de um cookie que faz referência ao  $_COOKIE superglobal:

if (isset($_COOKIE['name'])) {
  $name = $_COOKIE['name'];
}

A  setcookie() função permite que você defina um cookie:

setcookie('name', 'Flavio');

Podemos adicionar um terceiro parâmetro para indicar quando o cookie irá expirar. Se omitido, o cookie expirará ao final da sessão/quando o navegador for fechado.

Use este código para fazer o cookie expirar em 7 dias:

setcookie('name', 'Flavio', time() + 3600 * 24 * 7);

Só podemos armazenar uma quantidade limitada de dados em um cookie, e os usuários podem limpar os cookies do lado do cliente quando limpam os dados do navegador.

Além disso, eles são específicos para o navegador/dispositivo, então podemos definir um cookie no navegador do usuário, mas se ele mudar de navegador ou dispositivo, o cookie não estará disponível.

Vamos fazer um exemplo simples com o formulário que usamos antes. Vamos armazenar o nome inserido como um cookie:

<?php
if (isset($_POST['name'])) {
  setcookie('name', $_POST['name']);
}
if (isset($_POST['name'])) {
  echo '<p>Hello ' . $_POST['name'];
} else {
  if (isset($_COOKIE['name'])) {
    echo '<p>Hello ' . $_COOKIE['name'];
  }
}
?>

<form method="POST">
  <input type="text" name="name" />
  <input type="submit" />
</form>

Adicionei algumas condicionais para lidar com o caso em que o cookie já foi definido e para exibir o nome logo após o formulário ser enviado, quando o cookie ainda não foi definido (ele só será definido para a próxima solicitação HTTP).

Se você abrir as Ferramentas do desenvolvedor do navegador, deverá ver o cookie na aba Armazenamento.

A partir daí você pode inspecionar seu valor e excluí-lo se quiser.

Como usar sessões baseadas em cookies em PHP

Um caso de uso muito interessante para cookies são as sessões baseadas em cookies.

O PHP nos oferece uma maneira muito fácil de criar uma sessão baseada em cookies usando  session_start().

Tente adicionar isto:

<?php
session_start();
?>

em um arquivo PHP e carregue-o no navegador.

Você verá um novo cookie nomeado por padrão  PHPSESSID com um valor atribuído.

Este é o ID da sessão. Ele será enviado a cada nova solicitação e o PHP o usará para identificar a sessão.

Da mesma forma que usávamos cookies, agora podemos usá-los  $_SESSION para armazenar as informações enviadas pelo usuário, mas desta vez elas não são armazenadas no lado do cliente.

Somente o ID da sessão é.

Os dados são armazenados no lado do servidor pelo PHP.

<?php
session_start();

if (isset($_POST['name'])) {
  $_SESSION['name'] = $_POST['name'];
}
if (isset($_POST['name'])) {
  echo '<p>Hello ' . $_POST['name'];
} else {
  if (isset($_SESSION['name'])) {
    echo '<p>Hello ' . $_SESSION['name'];
  }
}
?>

<form method="POST">
  <input type="text" name="name" />
  <input type="submit" />
</form>

Isso funciona para casos de uso simples, mas é claro que para dados intensivos você precisará de um banco de dados.

Para limpar os dados da sessão, você pode chamar  session_unset().

Para limpar o cookie de sessão, use:

setcookie(session_name(), '');

Como trabalhar com arquivos e pastas em PHP

PHP é uma linguagem do lado do servidor e uma das coisas úteis que ela fornece é acesso ao sistema de arquivos.

Você pode verificar se um arquivo existe usando  file_exists():

file_exists('test.txt') //true

Obtenha o tamanho de um arquivo usando  filesize():

filesize('test.txt')

Você pode abrir um arquivo usando  fopen(). Aqui, abrimos o  test.txt arquivo em  modo somente leitura  e obtemos o que chamamos de  descritor de arquivo  em  $file:

$file = fopen('test.txt', 'r')

Podemos encerrar o acesso ao arquivo chamando  fclose($fd).

Leia o conteúdo de um arquivo em uma variável como esta:

$file = fopen('test.txt', 'r')

fread($file, filesize('test.txt'));

//or

while (!feof($file)) {
    $data .= fgets($file, 5000);
}

feof() verifica se não chegamos ao fim do arquivo, pois  fgets lê 5000 bytes por vez.

Você também pode ler um arquivo linha por linha usando  fgets():

$file = fopen('test.txt', 'r')

while(!feof($file)) {
  $line = fgets($file);
  //do something
}

Para gravar em um arquivo, você deve primeiro abri-lo no  modo de gravação e, em seguida, usar  fwrite():

$data = 'test';
$file = fopen('test.txt', 'w')
fwrite($file, $data);
fclose($file);

Podemos excluir um arquivo usando  unlink():

unlink('test.txt')

Essas são as noções básicas, mas é claro que há  mais funções para trabalhar com arquivos .

PHP e Bancos de Dados

O PHP oferece várias bibliotecas integradas para trabalhar com bancos de dados, por exemplo:

• PostgreSQL
• MySQL  / MariaDB
• MongoDB

Não abordarei isso no manual porque acho que é um tópico amplo e que também exigirá que você aprenda SQL.

Também me sinto tentado a dizer que, se você precisa de um banco de dados, deve usar um framework ou ORM que lhe pouparia problemas de segurança com injeção de SQL.  O Eloquent do Laravel  é um ótimo exemplo.

Como trabalhar com JSON em PHP

JSON  é um formato de dados portátil que usamos para representar dados e enviá-los do cliente para o servidor.

Aqui está um exemplo de uma representação JSON de um objeto que contém uma string e um número:

{
  "name": "Flavio",
  "age": 35
}

O PHP nos oferece duas funções utilitárias para trabalhar com JSON:

• json_encode() para codificar uma variável em JSON
• json_decode() para decodificar uma string JSON em um tipo de dado (objeto, array…)

Exemplo:

$test = ['a', 'b', 'c'];

$encoded = json_encode($test); // "["a","b","c"]" (a string)

$decoded = json_decode($encoded); // [ "a", "b", "c" ] (an array)

Como enviar e-mails com PHP

Uma das coisas que gosto no PHP são as conveniências, como enviar um e-mail.

Envie um e-mail usando  mail():

mail('test@test.com', 'this subject', 'the body');

Para enviar e-mails em larga escala, não podemos confiar nesta solução, pois esses e-mails tendem a cair na caixa de spam com mais frequência. Mas, para testes rápidos, isso é útil.

Bibliotecas como  https://github.com/PHPMailer/PHPMailer  serão muito úteis para necessidades mais sólidas, usando um servidor SMTP.

Como usar o Composer e o Packagist

O Composer  é o gerenciador de pacotes do PHP.

Ele permite que você instale pacotes facilmente em seus projetos.

Instale-o na sua máquina ( Linux/Mac  ou  Windows ) e quando terminar, você deverá ter um  composer comando disponível no seu terminal.

Agora, dentro do seu projeto, você pode executá-lo  composer require <lib> e instalá-lo localmente. Por exemplo, vamos instalar  a biblioteca Carbon  , que nos ajuda a trabalhar com datas em PHP.

composer require nesbot/carbon

Isso fará algum trabalho:

Uma vez feito isso, você encontrará algumas coisas novas na pasta  composer.json que lista a nova configuração para as dependências:

{
    "require": {
        "nesbot/carbon": "^2.58"
    }
}

composer.lock é usado para "bloquear" as versões do pacote no tempo, para que a mesma instalação que você tenha possa ser replicada em outro servidor. A  vendor pasta contém a biblioteca recém-instalada e suas dependências.

Agora no  index.php arquivo podemos adicionar este código no topo:

<?php
require 'vendor/autoload.php';

use CarbonCarbon;

e então podemos usar a biblioteca!

echo Carbon::now();

Viu? Não precisávamos baixar manualmente um pacote da internet e instalá-lo em algum lugar... era tudo rápido, ágil e bem organizado.

A  require 'vendor/autoload.php'; linha é o que permite  o carregamento automático . Lembra quando falamos sobre  require_once() e  include_once()? Isso resolve tudo – não precisamos procurar manualmente o arquivo a ser incluído, basta usar o use  palavra-chave para importar a biblioteca para o nosso código.

Como implantar um aplicativo PHP

Quando você tiver um aplicativo pronto, é hora de implantá-lo e torná-lo acessível a qualquer pessoa na Web.

PHP é a linguagem de programação com a melhor  história de implantação  na Web.

Acredite em mim, todas as outras linguagens de programação e ecossistemas gostariam de ser tão simples quanto o PHP.

O melhor do PHP é que ele  o acertou  e permitiu que ele tivesse o incrível sucesso que teve, é a implantação instantânea.

Você coloca um arquivo PHP em uma pasta servida por um servidor Web e  pronto  – simplesmente funciona.

Não é necessário reiniciar o servidor, executar uma repetição, nada.

Isso ainda é algo que muita gente faz. Você contrata uma hospedagem compartilhada por US$ 3/mês, envia seus arquivos via FTP e pronto.

Hoje em dia, porém, acredito que a implantação do Git é algo que deve ser incorporado a todos os projetos, e a hospedagem compartilhada deve ser coisa do passado.

Uma solução é sempre ter seu próprio VPS (Servidor Virtual Privado) privado, que você pode obter de serviços como DigitalOcean ou Linode.

Mas gerenciar seu próprio VPS não é brincadeira. Exige conhecimento sério, investimento de tempo e manutenção constante.

Você também pode usar a chamada PaaS (Plataforma como Serviço), que são plataformas que se concentram em cuidar de todas as coisas chatas (gerenciar servidores) e você apenas carrega seu aplicativo e ele roda.

Soluções como  plataforma de aplicativos DigitalOcean  (que é diferente de um VPS DigitalOcean), Heroku e muitas outras são ótimas para seus primeiros testes.

Esses serviços permitem que você conecte sua conta do GitHub e implante sempre que envie uma nova alteração ao seu repositório  Git .

Você pode aprender  como configurar o Git e o GitHub do zero aqui  .

Este é um fluxo de trabalho muito melhor comparado aos uploads via FTP.

Vamos fazer um exemplo básico.

Crie uma aplicação PHP simples com apenas um  index.phparquivo:

<?php
echo 'Hello!';
?>

Eu adiciono a pasta pai ao meu aplicativo GitHub Desktop, inicializo um repositório Git e o envio para o GitHub:

Agora acesse  digitalocean.com  .

Se você ainda não tem uma conta,  use meu código de indicação para se inscrever e ganhar US$ 100 em créditos gratuitos nos próximos 60 dias  , quando você puder trabalhar em seu aplicativo PHP de graça.

Eu me conectei à minha conta DigitalOcean e vou em Aplicativos → Criar aplicativo.

Conecte minha conta ao GitHub e selecione o repositório do meu aplicativo.

Certifique-se de que a opção “Implantar automaticamente” esteja marcada para que o aplicativo seja reimplantado automaticamente quando houver alterações:

Clique em “Avançar” e depois em Editar Plano:

Por padrão, o plano Pro foi selecionado.

Utilize o plano Básico e escolha o plano de US$ 5/mês.

Observe que você paga US$ 5 por mês, mas a cobrança é por hora, então você pode parar de usar o aplicativo quando quiser.

Em seguida, volte e clique em "Avançar" até que o botão "Criar Recursos" seja aplicado para criar o aplicativo. Você não precisa de nenhum banco de dados, caso contrário, seriam necessários mais US$ 7/mês.

Agora espere até que a implantação esteja pronta:

O aplicativo já está funcionando!

Conclusão

Você chegou ao final do Manual do PHP