Artigo original: https://www.freecodecamp.org/news/the-php-handbook/

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

As estatísticas dizem que ele é usado por 80% de todos os sites da web. E é a linguagem por trás do WordPress, o sistema de gerenciamento de conteúdo mais utilizado para sites.

Ele também é a base de muitos frameworks diferentes que facilitam o desenvolvimento para a web, como o Laravel. Falando em Laravel, ele pode ser uma das razões mais convincentes para se aprender PHP nos dias de hoje.

Por que aprender PHP?

PHP é uma linguagem muito polarizadora. Algumas pessoas a adoram, enquanto outras a odeiam. Se, porém, deixarmos as emoções de lado e olharmos para a linguagem como uma ferramenta, o PHP tem muito a oferecer.

Claro que ele não é perfeito, mas saiba que nenhuma linguagem é.

Neste manual, vou ajudar você a aprender PHP.

Este manual é uma introdução perfeita se você é novo na linguagem. Ele também é ótimo se você já "mexeu um pouco" com o PHP no passado e quer voltar a ele.

Explicarei aqui o PHP moderno, na sua versão 8+.

Ele evoluiu muito nos últimos anos. Então, se a última vez que você trabalhou nele foi com o PHP 5 ou mesmo com o PHP 4, ficará surpreso com todas as novidades que o PHP oferece agora.

Vamos lá!

Aqui está o que abordaremos neste manual:

  1. Introdução ao PHP
  2. Mas que tipo de linguagem é o PHP?
  3. Como configurar o PHP
  4. Como escrever seu primeiro programa PHP
  5. Fundamentos da linguagem PHP
  6. Como trabalhar com strings no PHP
  7. Como usar funções internas para números no PHP
  8. Como os arrays funcionam no PHP
  9. Como funcionam as condicionais no PHP
  10. Como os laços funcionam no PHP
  11. Como agem as funções no PHP
  12. Como fazer um laço através de arrays com map(), filter()e reduce() no PHP
  13. Programação Orientada a Objetos no PHP
  14. Como incluir outros arquivos PHP
  15. Constantes, funções e variáveis ​​úteis para sistema de arquivos no PHP
  16. Como lidar com erros no PHP
  17. Como lidar com exceções no PHP
  18. Como trabalhar com datas no PHP
  19. Como usar constantes e enums no PHP
  20. Como usar o PHP como uma plataforma de desenvolvimento de aplicativos da web
  21. Como usar o Composer e o Packagist
  22. Como fazer o deploy (implantação) de um aplicativo PHP
  23. Conclusão

Você também pode ter uma versão desse manual, em inglês, em PDF, ePub ou Mobi, para uma fácil referência ou para ler no seu Kindle ou tablet.

Introdução ao PHP

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

Como linguagem, ele teve um começo humilde. Foi criado em 1994, por Rasmus Lerdorf, para construir seu site pessoal. Ele não sabia na época que se tornaria uma das linguagens de programação mais populares do mundo. Ele se tornou popular em 1997/8, mas explodiu mesmo foi nos anos 2000, quando o PHP 4 chegou.

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

Também se pode usá-lo como o mecanismo de uma aplicação para a web, que cria páginas HTML dinamicamente e as envia para o navegador.

Ele pode ser escalado para milhões de visualizações de página.

Você sabia que o Facebook foi desenvolvido em PHP? Já ouviu falar da Wikipédia, do Slack ou do Etsy?

Mas que tipo de linguagem é o PHP?

Vamos usar um pouco de jargão técnico agora.

As linguagens de programação são divididas em grupos, dependendo de suas características. Por exemplo: se ela é interpretada ou compilada, fraca ou fortemente tipada, de tipagem dinâmica ou estática.

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

Essas linguagens que citei são linguagens compiladas. O compilador de cada uma delas gera um programa executável que, só então, você consegue executar. É um processo de 2 etapas.

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

PHP é também uma linguagem de tipagem dinâmica. Isso quer dizer que o tipo das variáveis ​​é verificado em tempo de execução, e não antes de o código ser executado, como acontece com as linguagens de tipagem estática (que também são compiladas – essas duas características geralmente andam de mãos dadas).

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

Ser interpretado e tipado de forma dinâmica torna os bugs mais difíceis de serem encontrados antes que aconteçam, em tempo de execução.

Em linguagens compiladas, você pode, em muitos casos, detectar os erros na hora que estiver compilando a aplicação, algo que não acontece em linguagens interpretadas.

Por outro lado, uma linguagem interpretada tem maior flexibilidade.

Um fato engraçado é que o PHP é escrito internamente em C, uma linguagem compilada e estaticamente tipada.

Em sua natureza, o PHP é similar ao JavaScript, outra linguagem de tipagem dinâmica, fracamente tipada e interpretada.

O PHP suporta programação estrutural, orientada a objetos e até funcional. Você pode usá-lo como quiser.

Como configurar o PHP

Existem muitas formas de instalar o PHP em sua máquina local.

A maneira mais conveniente que encontrei para instalar o PHP localmente é usando o MAMP.

MAMP é uma ferramenta que está disponível gratuitamente para todos os sistemas operacionais – Mac, Windows e Linux. É um pacote que fornece todas as ferramentas de que você precisa para começar a trabalhar.

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

Os servidores mais utilizados são o Apache ou o NGINX.

Para fazermos qualquer coisa que não seja trivial, também precisaremos 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 fácil de iniciar/parar tudo de uma vez.

Claro, você pode configurar cada uma dessas partes por conta própria, se quiser, e muitos tutoriais explicam como fazer isso. Eu, no entanto, gosto de ferramentas simples e práticas, e o MAMP certamente é uma delas.

Saiba, contudo, que você é livre para seguir os passos desse manual com qualquer tipo de método de instalação do PHP, não apenas com o MAMP.

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

O processo dependerá do seu sistema operacional. Porém, assim que a instalação terminar, você terá o aplicativo "MAMP" instalado.

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

Screen_Shot_2022-06-24_at_15.14.05

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

No momento em que escrevo, o MAMP permite que você escolha a versão 8.0.8.

Observação: percebi que o MAMP tem uma versão um pouco atrasada, mas não é a mais recente. Você pode instalar a versão mais recente do PHP ativando a demonstração do MAMP PRO e, logo depois, instalando a versão mais recente das configurações do MAMP PRO (no meu caso, foi a 8.1.0). Em seguida, feche-o e reabra o MAMP (versão não profissional). O MAMP PRO tem mais recursos e você pode querer usá-lo, mas ele não é necessário para seguir este manual.

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

Vá para o URL http://localhost:8888 e você verá uma página similar a esta:

Screen_Shot_2022-06-24_at_15.19.05

Agora estamos prontos para escrever um pouco de PHP!

Abra a pasta listada como "Document root". Você consegue abri-la diretamente ou configurar o caminho dela em Preferences > Server (Preferências > Servidor). Se estiver usando o MAMP em um Mac, por padrão, a pasta é /Applications/MAMP/htdocs.

No Windows, ela é C:\MAMP\htdocs.

No seu computador, ela pode ser diferente, dependendo da configuração. No MAMP, você pode encontrá-la na interface de usuário do aplicativo.

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

Ele é o responsável por mostrar a página mostrada acima.

Screen_Shot_2022-06-24_at_15.17.58

Como escrever seu primeiro programa PHP

Ao aprender uma nova linguagem de programação, temos a tradição de criar uma aplicação "Hello, World!", que é algo que simplesmente mostrará essa string.

Certifique-se de que o MAMP esteja em execução e abra a pasta htdocs como expliquei antes.

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

Eu recomendo usar o VS Code, por ser um editor de código simples e poderoso. Você pode ver uma introdução a ele em https://flaviocopes.com/vscode/ (em inglês).

Screen_Shot_2022-06-24_at_15.37.36

Esse é o código que mostra a página de boas-vindas do MAMP, que você viu no navegador.

Apague tudo e substitua o conteúdo por:

<?php
echo 'Hello World';
?>

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

Screen_Shot_2022-06-24_at_15.39.00

Excelente! Você criou seu primeiro programa em PHP.

Vamos explicar o que está acontecendo aqui.

Temos o servidor Apache HTTP escutando na porta 8888 do localhost, que é o seu computador.

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

O Apache, por padrão, está configurado para mostrar esse caminho com o arquivo index.html incluído na pasta htdocs. Esse arquivo não existe, mas, como configuramos o Apache para trabalhar com PHP, ele procurará um arquivo index.php.

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

No arquivo PHP, temos uma tag de abertura <?php, que diz "aqui começa um código em PHP".

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

Só lembrando, que o ponto e vírgula é necessário ao final de cada instrução.

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

Observe que, com o PHP moderno, geralmente evitamos misturar PHP no HTML. Em vez disso, usamos PHP como um "framework para gerar o HTML" – por exemplo, usando ferramentas como o Laravel. No entanto, como vamos discutir o PHP simples nesse manual, faz sentido começarmos do básico.

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

Hello
<?php
echo 'World';
?>

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

A página é tecnicamente uma página com extensão HTML, embora não tenha tags HTML, apenas uma string Hello World. O navegador é quem faz o trabalho de descobrir como exibir isso na janela.

Fundamentos da linguagem PHP

Após o primeiro "Hello World", é hora de mergulhar nos recursos da linguagem em mais detalhes.

Como as variáveis ​​funcionam no PHP

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

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

$nome = 'Flavio';

$nome = "Flavio";

Ou números:

$idade = 20;

Ou qualquer outro tipo que o PHP permitir, como veremos mais para frente.

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

$nome = 3;

O PHP não vai reclamar que agora o tipo é diferente (lembre-se que ele é uma linguagem fracamente tipada).

Os nomes de variáveis ​​diferenciam maiúsculas de minúsculas. Então, $nome é diferente de $Nome.

Não é uma regra fixa, mas geralmente os nomes das variáveis ​​são escritos no formato camelCase, assim: $marcaDoCarro ou $idadeDoCachorro. Mantemos a primeira letra minúscula e as letras que iniciam as palavras seguintes em maiúsculas.

Como escrever comentários no PHP

Uma parte muito importante de qualquer linguagem de programação é como você escreve comentários no meio do código.

Comentários de linha única são escritos em PHP desta forma:

// Comentários de linha única

Já comentários de várias linhas são feitos desta forma:

/*

Isto é um comentário

*/

// Ou

/*
 *
 * Isto é um comentário
 *
 */

// Ou para comentar uma parte do código dentro de uma linha:

$nome = /* Isto é um comentário */ 'Flavio';

O que são tipos em PHP?

Já mencionei as strings e os 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: sequência de caracteres
  • array: matriz
  • object: objeto
  • null: um valor que significa "nenhum valor atribuído"

e alguns outros mais avançados.

Como imprimir o valor de uma variável no PHP

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

$nome = 'Flavio';

var_dump($nome);

A instrução var_dump($nome) será impressa assim string(6) "Flavio" na página, o que nos diz que a variável é uma string de 6 caracteres.

Se usarmos este código:

$idade = 20;

var_dump($idade);

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

var_dump() é uma das ferramentas essenciais em seu conjunto de ferramentas para depurar o PHP.

Como os operadores funcionam no PHP

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

$largura = 20;
$altura = 10;

$area = $largura * $altura;

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

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

Para começar, aqui estão os operadores aritméticos: + (soma), - (subtração), * (multiplicação), / (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 os operadores de comparação, como <, >, <= e >=. Eles funcionam da mesma forma que na matemática.

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

== retorna true se os dois operandos forem iguais.

Já o operador === retorna true se os dois operandos forem idênticos.

Qual é a diferença? Um compara somente o valor, o segundo compara o tipo também.

Com a experiência ficará bem claro isso, mas, por exemplo:

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

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

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

// Dica: <> funciona da mesma forma que !=, 1 <> 1

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

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

Os operadores lógicos trabalham com valores booleanos:

// Lógica E com && ou "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

// Lógica OU com || ou "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

// Lógica XOR (um dos dois é verdade, mas não ambos)

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

Temos também o operador not:

$teste = true

!$teste // false

Eu usei os valores booleanos true e false aqui, mas, na prática, você usará expressões que avaliam se é verdadeiro ou falso, como neste 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 possui 2 operadores unários, são eles: ++ e --.

$idade = 20;
$idade++;
// a idade agora é 21

$idade--;
// a idade agora é 20

Como trabalhar com strings no PHP

Eu introduzi o uso de strings anteriormente quando falamos sobre variáveis ​​e definimos uma string usando esse exemplo:

$nome = 'Flavio'; // string definida com aspas simples

$nome = "Flavio"; // string definida com aspas duplas

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

$teste = 'um exemplo';

$exemplo = "Este é $teste"; // Este é um exemplo

E com aspas duplas podemos usar caracteres de escape - como novas linhas \n ou tabulações \t:

$exemplo = "Esta é uma linha\nEsta é uma linha";

/*
a saída será:

Esta é uma linha
Esta é uma linha
*/

O PHP oferece uma lista de funções bem abrangentes em sua biblioteca padrão (a biblioteca de funcionalidades que a linguagem oferece por padrão).

Primeiro, podemos concatenar duas strings usando o operador .:

$primeiroNome = 'Flavio';
$sobrenome = 'Copes';

$nomeCompleto = $primeiroNome . ' ' . $sobrenome;

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

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

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

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

Uma função é responsável por fazer algo e, quando terminar, pode ou não retornar um valor. Nesse caso, ela retorna o número 6. Se não há retorno de nenhum valor, a função retorna null.

Veremos mais para frente como escrever nossas próprias funções.

Podemos obter uma parte de uma string usando a função substr():

$nome = 'Flavio';
substr($nome, 3); // "vio" - comece na posição 3 e pegue todo o resto
substr($nome, 2, 2); // "av" - comece na posição 2 e pegue 2 caracteres

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

$nome = 'Flavio';
str_replace('avio', 'or', $nome); // "Flor"

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

$nome = 'Flavio';
$itemObservado = str_replace('avio', 'or', $nome); // "Flor"

Isso é só o começo. Há muito mais funções internas que você pode usar para trabalhar com strings.

Esta é uma  pequena lista (não abrangente) para mostrar algumas possibilidades:

  • trim(): remove o espaço em branco no início e no final de uma string
  • strtoupper(): transforma uma string em maiúscula
  • strtolower(): transforma uma string em minúscula
  • ucfirst(): transforma o primeiro caractere maiúsculo
  • strpos(): encontra a primeira ocorrência de uma substring na string
  • explode(): divide uma string em um array
  • implode(): junta os elementos de um array em uma string

Você pode encontrar a lista completa aqui.

Como usar funções internas para números no PHP

Eu listei algumas funções que normalmente usamos para strings.

Agora vamos fazer uma lista de funções que usamos com números:

  • round(): arredonda um número decimal, para cima/para baixo, dependendo de o valor ser maior ou menor que 0,5
  • ceil(): arredonda um número decimal para cima
  • floor(): arredonda um número decimal para baixo
  • rand(): gera um número inteiro aleatório
  • min(): encontra o número mais baixo nos números passados ​​como argumentos
  • max(): encontra o número mais alto nos números passados ​​como argumentos
  • is_nan(): retorna true se o número não for um número

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

Como os arrays funcionam no PHP

O array é uma lista de valores agrupados sob um nome comum.

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

$lista = [];

$lista = array();

Um array pode ser inicializado com valores também:

$lista = [1, 2];

$lista = array(1, 2);

Arrays podem conter valores de qualquer tipo:

$lista = [1, 'test'];

E também outros arrays:

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

Você pode acessar os elementos de um array desta forma:

$lista = ['a', 'b'];
$lista[0]; // 'a' - o índice começa em 0
$lista[1]; // 'b'

Depois que um array é criado, você pode anexar valores a ele, assim:

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

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

Ou, se quiser usar a função array_unshift() para adicionar o item no início do array:

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

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

Para contar quantos itens um array tem, você pode usar a função interna count():

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

count($lista); // 2

Ou verificar se um array contém um valor específico, usando a função in_array():

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

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

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

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

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

Funções úteis para arrays no PHP

Assim como com strings e números, o PHP fornece muitas funções muito úteis para arrays. Já vimos count(), in_array(), array_search(). Vejamos mais funções abaixo:

  • is_array(): verifica se uma variável é um array
  • array_unique(): remove valores duplicados de um array
  • array_search(): pesquisa um valor no array e retornar a chave
  • array_reverse(): inverte um array
  • array_reduce(): reduz um array à um único valor usando uma função callback
  • array_map(): aplica uma função de callback a cada item no array. Normalmente usado para criar um novo array modificando os valores de um array existente, sem alterá-lo.
  • array_filter(): para filtrar um array para um único valor usando uma função callback
  • max(): obtém o valor máximo contido no array
  • min(): obtém o valor mínimo contido no array
  • array_rand(): obtém um item aleatório do array
  • array_count_values(): conta todos os valores no array
  • implode(): transforma um array em uma string
  • array_pop(): remove 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(): ordena um array
  • rsort(): classifica um array na ordem inversa
  • array_walk(): da mesma forma que array_map(), faz algo para cada item no array, mas, além disso, pode alterar valores no array existente

Como usar arrays associativos no PHP

Até agora só usamos arrays com índice numérico incremental: 0, 1, 2…

Você também pode, no entanto, usar arrays com índices nomeados (chaves), aos quais chamamos de arrays associativos:

$lista = ['primeiro' => 'a', 'segundo' => 'b'];

$lista['primeiro'] // 'a'
$lista['segundo'] // 'b'

Temos algumas funções que são muito úteis para arrays associativos:

  • array_key_exists(): verifica se existe uma chave no array
  • array_keys(): obtém todas as chaves do array
  • array_values(): obtém todos os valores do array
  • asort(): classifica um array associativo por valor
  • arsort(): classifica um array associativo em ordem decrescente por valor
  • ksort(): classifica um array associativo por chave
  • krsort(): classifica um array associativo em ordem decrescente por chave

Você pode ver todas as funções relacionadas a arrays aqui.

Como funcionam as condicionais no PHP

Anteriormente, mostrei os operadores de comparação: <, >, <=, >=, ==, ===, !=, !==...

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

Condicional é a primeira estrutura de controle que se vê.

Com ela podemos decidir fazer uma coisa ou fazer outra, com base em uma comparação.

Por exemplo:

$idade = 17;

if ($idade > 18) {
  echo 'Você pode entrar no pub';
}

O código dentro dos colchetes só será executado se a condição for avaliada como true.

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

$idade = 17;

if ($idade > 18) {
  echo 'You can enter the pub'; // Você pode entrar no pub
} else {
  echo 'You cannot enter the pub'; // Você não pode entrar no pub
}

Observação: eu usei cannot em vez de can't porque a aspa simples terminaria minha string antes do final da frase. Nesse caso, você pode "escapar" o ' desta forma: echo 'You can\'t enter the pub';

Você pode ter o encadeamento de várias instruções if usando elseif:

$idade = 17;

if ($idade > 20) {
  echo 'Você tem 20+';
} elseif ($idade > 18) {
  echo 'Você tem 18+';
} else {
  echo 'Você tem <18';
}

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

Nós a usamos quando temos uma variável que pode ter alguns valores diferentes e não precisamos ter um bloco if/elseif longo:

$idade = 17

switch($idade) {
  case 15:
	echo 'Você tem 15';
    break;
  case 16:
	echo 'Você tem 16';
    break;
  case 17:
	echo 'Você tem 17';
    break;
  case 18:
	echo 'Você tem 18';
    break;
  default:
    echo "Você tem $idade";
}

Eu sei que o exemplo não tem lógica, mas acho que ele pode ajudá-lo a entender como funciona o switch.

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

Você tem 17
Você tem 18
Você tem 17

Ao invés de apenas isto:

Você tem 17

Que é o que você esperaria.

Como os laços funcionam no PHP

Os laços, ou loops (como são mais conhecidos), são outra estrutura de controle superútil.

Temos alguns tipos diferentes de laços no PHP: while, do while, for e foreach.

Vamos ver todos eles!

Como usar um laço while no PHP

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

while (true) {
  echo 'repetindo';
}

O exemplo acima geraria um laço infinito, e é por isso que usamos variáveis ​​e comparações:

$contador = 0;

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

Como usar um laço do while no PHP

do while é similar, mas difere um pouco em como a primeira iteração é executada:

$contador = 0;

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

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

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

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

Você escolherá um tipo de laço ou outro, dependendo de seu caso de uso.

Como usar um laço foreach no PHP

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

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

foreach ($lista as $valor) {
  echo $valor;
}

Também é possível obter o valor do índice (ou chave, em um array associativo), desta forma:

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

foreach ($lista as $chave => $valor) {
  echo $chave;
}

Como usar um laço for no PHP

O laço for é semelhante ao while, mas, ao invés de definir a variável usada na condicional antes da repetição e de incrementar a variável do índice manualmente, tudo é feito na primeira linha:

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

// result: 0123456789

Você pode usar o laço for para iterar sobre um array desta forma:

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

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

// resultado : abc

Como usar as instruções break e continue no PHP

Em muitos casos, você vai querer ser capaz de interromper um laço sob demanda.

Por exemplo, se desejar interromper um laço for quando o valor da variável no array for 'b':

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

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

// resultado: a

Isso faz com que o laço pare completamente nesse ponto e a execução do programa continue na próxima instrução após o laço.

Já se quiser apenas pular a iteração do laço atual e continuar procurando, use o continue:

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

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

// resultado: ac

Como agem as funções no PHP

As funções são um dos conceitos mais importantes na programação.

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

Por exemplo, se fizermos uma função que envia um e-mail. N[os a chamaremos de enviarEmail e vamos defini-la assim:

function enviarEmail() {
  // código para enviar o e-mail
}

Agora podemos chamá-la em qualquer outro lugar usando esta sintaxe:

enviarEmail();

Também podemos passar argumentos para uma função. Por exemplo, quando enviarmos um e-mail e desejarmos enviá-lo para alguém específico. Adicionamos o e-mail individual como o primeiro argumento:

enviarEmail('test@test.com');

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

function enviarEmail($to) {
  echo "enviar e-mail para $to";
}

É possível enviar vários argumentos separando-os com vírgulas:

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

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

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

Podemos, opcionalmente, definir o tipo dos parâmetros, assim:

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

Além de os parâmetros poderem ter um valor padrão. Nesse caso, mesmo se forem omitidos quando chamados, eles ainda terão um valor:

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

enviarEmail('test@test.com')

Uma função pode retornar um valor. Apenas um valor pode ser retornado a partir de uma função, não mais de um. Você faz isso usando a palavra-chave return. Se ela for omitida, a função retorna null.

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

function enviarEmail($to) {
	return true;
}

$successo = enviarEmail('test@test.com');

if ($successo) {
  echo 'e-mail enviado com sucesso';
} else {
  echo 'erro ao enviar e-mail';
}

Opcionalmente, podemos definir o tipo de retorno de uma função usando esta sintaxe:

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

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

function enviarEmail($to) {
	$teste = 'a';
}

var_dump($teste); // Erro no PHP: variável indefinida $test

E variáveis ​​definidas fora da função não são acessíveis dentro da função.

Isso impõe uma boa prática de programação, pois podemos ter certeza de que a função não modifica variáveis ​​externas e não acaba causando "efeitos colaterais".

Em vez disso, você retorna um valor da função e o código externo que chama a função assumirá a responsabilidade de atualizar a variável externa, assim:

$caractere = 'a';

function teste() {
  return 'b';
}

$caractere = teste();

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

$caractere = 'a';

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

teste($caractere);

Porém, você não poderá modificar esse valor de dentro da função.

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

Isso é possível, no entanto usando a sintaxe a seguir (observe que usei & na definição do parâmetro):

$caractere = 'a';

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

teste($caractere);

echo $caractere; // 'b'

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

Elas têm um nome.

No entanto, também temos as funções anônimas, que são úteis em muitos casos.

Elas não têm um nome por si mesmas, mas são atribuídas a uma variável. Para chamá-las, você invoca a variável com parênteses no final:

$minhafuncao = function() {
  // faz alguma coisa aqui
};

$minhafuncao()

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

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

$teste = 'teste';

$minhafuncao = function() use ($teste) {
  echo $teste;
  return 'ok';
};

$minhafuncao()

Outro tipo de função bem conhecida é a arrow function (ou função de seta, em português).

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

Você a define assim:

fn (argumentos) => expressão;

Este é um exemplo:

$imprimirTeste = fn() => 'teste';

$imprimirTeste(); // 'teste'

Você pode passar parâmetros para ela normalmente:

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

$multiplicar(2, 4) // 8

Observe que, como mostrará o próximo exemplo, as arrow functions têm acesso automático às variáveis ​​do escopo delimitador externo, sem a necessidade de use().

$a = 2;
$b = 4;

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

$multiplicar()

As arrow functions são superúteis quando você precisa passar uma função de callback. Veremos como usá-las para realizar algumas operações de array mais tarde.

Portanto, temos ao todo 3 tipos de funções: funções nomeadas, funções anônimas e arrow functions.

Cada uma deles tem sua utilidade. Você aprenderá a usá-las corretamente ao longo do tempo e com a prática.

Como fazer um laço através de arrays com map(), filter() e reduce() no PHP

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

Essas 3 funções incorporadas ao PHP pegam um array e uma função de callback que, em cada iteração, pegam um item do array por vez.

array_map() retorna um novo array que contém o resultado da execução da função de callback em cada item do array:

$numeros = [1, 2, 3, 4];
$duplos = array_map(fn($valor) => $valor * 2, $numeros);

// $duplos agora é [2, 4, 6, 8]

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

$numeros = [1, 2, 3, 4];
$mesmo = array_filter($numeros, fn($valor) => $valor % 2 === 0)

// $mesmo é agora [2, 4]

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

Por exemplo, podemos usá-la para multiplicar todos os itens em um array:

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

$resultado = array_reduce($numeros, fn($somatorio, $valor) => $somatorio * $valor, 1)

Observe o último parâmetro – ele é 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 (pois qualquer número multiplicado por zero é zero).

Perceba que a ordem dos argumentos na função array_map() é invertida. Primeiro, você tem a função de callback e depois o array. Isso ocorre porque podemos passar vários arrays usando vírgulas (array_map(fn($valor) => $valor * 2, $numeros, $outrosNumeros, $outroArray);). O ideal seria ter mais consistência, mas é isso que temos.

Programação Orientada a Objetos no PHP

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

A programação orientada a objetos permite criar abstrações úteis e tornar seu código mais simples de entender e gerenciar.

Como usar classes e objetos no PHP

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

Uma classe é um blueprint (modelo), ou tipo, de objeto.

Por exemplo, temos a classe Cachorro, definida desta forma:

class Cachorro {

}

Lembre-se de que as classes devem sempre começar com letra maiúscula.

Agora, você pode criar objetos desta classe – cães individuais e específicos.

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

$roger = new Cachorro();

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

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

Como usar propriedades no PHP

Esses objetos, os cães do exemplo acima, compartilharão as mesmas características definidas pela classe. Uma vez instanciados, contudo, eles terão vida própria.

Por exemplo, um cão tem um nome, uma idade e uma cor de pele.

Assim, podemos definir essas características como propriedades dentro da classe:

class Cachorro {
  public $nome;
  public $idade;
  public $cor;
}

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

Você pode atribuir valores a essas propriedades assim:

class Cachorro {
  public $nome;
  public $idade;
  public $cor;
}

$roger = new Cachorro();

$roger->nome = 'Roger';
$roger->idade = 10;
$roger->cor = 'cinza';

var_dump($roger);

/*
object(Cachorro)#1 (3) {
  ["nome"]=> string(5) "Roger"
	["idade"]=> int(10)
	["cor"]=> string(4) "cinza"
}
*/

Observe que a propriedade foi definida como public.

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

Veremos mais sobre protect quando falarmos sobre herança.

Como usar métodos no PHP

Eu disse método? Mas o que é um método?

Um método é uma função definida dentro da própria classe e é definida desta forma:

class Cachorro {
  public function latir() {
    echo 'au au!';
  }
}

Os métodos são muito úteis para anexar um comportamento a um objeto. Neste exemplo, podemos fazer um cachorro latir.

Observe que também usei a palavra-chave public. Isso quer dizer que será possível invocar esse método de fora da classe. E assim como para propriedades, você pode marcar métodos como private, ou protected, para restringir o acesso à eles.

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

class Cachorro {
  public function latir() {
    echo 'au au!';
  }
}

$roger = new Cachorro();

$roger->latir();

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

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 Cachorro {
  public $nome;

  public function latir() {
    echo $this->nome . ' latiu!';
  }
}

$roger = new Cachorro();
$roger->nome = 'Roger';
$roger->latir();

Observe que eu usei $this->nome para definir e acessar a propriedade $nome, e não $this->$nome(a diferença está no $).

Como usar o método construtor no PHP

Existe um tipo especial de método, que é o __construct(). Ele é chamado de construtor. Você o declara assim:

class Cachorro {
	public function __construct() {

  }
}

Esse método serve para inicializar as propriedades de um objeto ao criá-lo, pois ele é chamado automaticamente quando chamamos new Nomedaclasse().

class Cachorro {
  public $nome;

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

  public function latir() {
    echo $this->nome . ' latiu!';
  }
}

$roger = new Cachorro('Roger');
$roger->latir();

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

class Cachorro {
  public $nome;

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

  //...

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

class Cachorro {
	public function __construct(public $nome) {
  }

  public function latir() {
    echo $this->nome . ' latiu!';
  }
}

$roger = new Cachorro('Roger');
$roger->nome; // 'Roger'
$roger->latir(); // 'Roger latiu!'

Se preferir, as propriedades podem ser tipadas.

Você pode exigir, por exemplo, que a propriedade nome seja uma string usando public string $nome:

class Cachorro {
  public string $nome;

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

  public function latir() {
    echo $this->nome . ' latiu!';
  }
}

$roger = new Cachorro('Roger');
$roger->nome; // 'Roger'
$roger->latir(); // 'Roger latiu!'

Nesse exemplo acima, tudo funciona corretamente, mas tente alterar o tipo da propriedade para public int $nome para exigir que seja um número inteiro.

O PHP vai gerar um erro se você inicializar $nome com uma string:

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

Interessante, certo?

Podemos impor às propriedades que tenham um tipo específico entre int, float, string, object, array, bool e outros (página ainda não traduzida na documentação).

O que é herança no PHP?

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

Suponhamos que você tenha uma classe Animal:

class Animal {

}

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

class Animal {
  public $idade;

  public function comer() {
    echo 'o animal está comendo';
  }
}

Um cachorro é um animal, tem uma idade e pode comer também, então a classe Cachorro – ao invés de reimplementar as mesmas coisas que temos na classe Animal– pode estender a outra classe:

class Cachorro extends Animal {

}

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

$roger = new Cachorro();
$roger->comer();

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

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

Vale a pena notar que, embora possamos acessar as propriedades e métodos do pai a partir do filho, não podemos fazer o contrário.

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

Propriedades e métodos protected no PHP

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

Propriedades e métodos private só podem ser acessados ​​dentro da classe.

Propriedades e métodos protected podem ser acessados somente ​​dentro da própria classe e das classes filhas.

Como substituir métodos no PHP

O que acontece se tivermos um método comer() em Animal e quisermos personalizá-lo em Cachorro? Podemos substituir esse método.

class Animal {
  public $idade;

  public function comer() {
    echo 'o animal está comendo';
  }
}

class Cachorro extends Animal {
  public function comer() {
    echo 'o cachorro está comendo';
  }
}

Agora, qualquer instância de Cachorro usará a implementação do método comer() da classe Cachorro.

Propriedades e métodos estáticos no PHP

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

Por vezes, será útil atribuí-los à própria classe.

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

Vamos começar com propriedades estáticas. Nós os definimos com a palavra-chave static:

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

Nós fazemos referência a elas dentro da classe usando a palavra-chave self, que aponta para a classe:

self::$versao;

Fora da classe, nós a referenciamos desta forma:


Utils::versao

Para os métodos estáticos, é assim:

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

Do lado de fora da classe, podemos chamá-los desta forma:

Utils::versao();

Dentro da classe, podemos referenciá-los usando a palavra-chave self, que se refere à própria classe:

self::versao();

Como comparar objetos no PHP

Quando falamos dos operadores que mencionei, lá no início, temos o operador == para verificar se dois valores são iguais e === para verificar se são idênticos.

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

Quando usamos o operador == para comparar objetos, verificamos se os dois objetos possuem a mesma classe e possuem os mesmos valores atribuídos a eles.

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

Por exemplo:

class Cachorro {
  public $nome = 'Cachorro bom';
}

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

echo $roger == $syd; // true

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

Como iterar sobre propriedades de objeto no PHP

Você pode iterar sobre todas as propriedades públicas em um objeto usando um laço foreach, assim:

class Cachorro {
  public $nome = 'Cachorro bom';
  public $idade = 10;
  public $cor = 'cinza';
}

$cachorro = new Cachorro();

foreach ($cachorro as $chave => $valor) {
  echo $chave . ': ' . $valor . '<br>';
}

Como clonar objetos no PHP

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

class Cachorro {
  public $nome;
}

$roger = new Cachorro();
$roger->nome = 'Roger';

$syd = clone $roger;

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

Porém, para fazer um clone profundo, você terá um pouco mais de trabalho.

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

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

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

Já vimos o __construct() antes.

Esse é um método mágico.

Há outros, no entanto. Por exemplo, se tivermos uma propriedade booleana chamada "clonado", quando o objeto for clonado, se quisermos definir ela como true, podemos fazer o seguinte:

class Cachorro {
  public $nome;

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

$roger = new Cachorro();
$roger->nome = 'Roger';

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

Outros métodos mágicos que temos são: __call(), __get(), __set(), __isset(), __toString(), entre outros.

Você pode ver a lista completa deles aqui.

Como incluir outros arquivos PHP

Agora que terminamos de falar sobre os recursos orientados a objetos do PHP, vamos explorar alguns outros assuntos interessantes!

Dentro de um arquivo PHP, você pode incluir outros arquivos PHP. Temos os seguintes métodos, todos usados ​​nesse exemplo, mas que são muito diferentes entre si: include, include_once, require e require_once.

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

O require faz o mesmo, mas, se houver algum erro ao carregá-lo, o programa para. O include, por sua vez, apenas gera um aviso.

Você pode decidir usar um ou outro dependendo do que precisar. Se você quiser que seu programa interrompa o processo se não conseguir importar o arquivo, use require.

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

Isso é útil, por exemplo, se você tiver vários arquivos carregando o mesmo arquivo e desejar evitar carregá-lo mais de uma vez.

Particularmente, minha regra geral é nunca usar o include ou o require, porque podemos carregar o mesmo arquivo duas vezes. E o include_once e require_once nos ajudam a evitar esse problema.

Use o 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');

// agora temos acesso às funções, classes
// e variáveis definidas no arquivo `test.php`

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

Você pode usar caminhos relativos também:

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

Incluir um arquivo da pasta pai ou ir para uma subpasta:

require_once('test/test.php');

Ou usar caminhos absolutos:

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

Nas bases de código moderno do PHP que usam frameworks, 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 no PHP

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

Pode-se obter o caminho completo do arquivo atual usando:

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

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

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

Como lidar com erros no PHP

Todo programador comete erros. Somos humanos, afinal de contas.

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

No PHP, temos:

  • Warnings (avisos)
  • Notices (observações)
  • Errors (erros)

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

Já os Errors encerram a execução do programa e imprimem 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 que "o PHP imprime uma mensagem", mas... onde?

Vai depender da sua configuração.

No modo de desenvolvimento, é comum registrar erros de PHP diretamente na página da web, ou em um log de erros.

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

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

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

Isso tudo é decidido na configuração do PHP.

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

Ele é chamado php.ini.

A localização exata deste arquivo depende de sua configuração.

Para descobrir onde ele está, a maneira mais fácil é adicioná-lo no código de um arquivo PHP, como no exemplo abaixo, e executar esse arquivo no navegador:

<?php
phpinfo();
?>

Você verá o local em "Loaded Configuration File" (Arquivo de configuração carregado):

Screen_Shot_2022-06-27_at_13.42.41

Neste caso, ele está em /Applications/MAMP/bin/php/php8.1.0/conf/php.ini.

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

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

Screen_Shot_2022-06-27_at_12.11.28

Abra esse arquivo em um editor.

Ele terá uma lista realmente longa de configurações, com uma ótima documentação embutida para cada item.

Estamos particularmente interessados ​​em display_errors:

Screen_Shot_2022-06-27_at_12.13.16

Em produção, você vai querer que seu valor seja Off, diferente do que vemos no documento acima (onde ele está On).

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

Screen_Shot_2022-06-27_at_12.16.01

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

Você é quem define o local no seu arquivo php.ini:

Screen_Shot_2022-06-27_at_12.17.12

O log de erros conterá todas as mensagens de erro que seu aplicativo gera:

Screen_Shot_2022-06-27_at_12.17.55

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

error_log('teste');

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

Como lidar com exceções no PHP

Às vezes, os erros são inevitáveis, como se algo completamente imprevisível acontecesse.

Muitas vezes, porém, podemos pensar no futuro e escrever um código que possa interceptar um erro e fazer algo sensato quando isso acontecer, como mostrar uma mensagem de erro útil para o usuário ou tentar uma solução alternativa.

Fazemos isso usando exceções.

Exceções são usadas para que nós, desenvolvedores, estejamos cientes de um problema.

Envolvemos um código, potencialmente gerador de uma exceção, em um bloco try e escrevemos um bloco catch logo após. Esse bloco catch será executado se houver uma exceção no bloco try:

try {
  // fazer alguma coisa
} catch (Throwable $e) {
  // podemos fazer algo aqui se ocorrer uma exceção
}

Observe que um objeto Exception $e está sendo passado para o bloco catch. Podemos inspecioná-lo para obter mais informações sobre a exceção, assim:

try {
  // fazer alguma coisa
} catch (Throwable $e) {
  echo $e->getMessage();
}

Vamos ver isso na prática.

Digamos que, por engano, eu divida um número por zero:

echo 1 / 0;

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

Screen_Shot_2022-06-26_at_20.12.59

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

try {
  echo 1 / 0;
} catch (Throwable $e) {
  echo $e->getMessage();
}
Screen_Shot_2022-06-26_at_20.13.36

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

Cada exceção tem uma classe diferente. Por exemplo, podemos pegá-la como DivisionByZeroError, nos permitindo filtrar os possíveis problemas e tratá-los de maneiras diferente.

Eu posso ter também um catch-all para qualquer tipo de erro no final, assim:

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

Também podemos anexar um bloco finally {} no final do try/catch para executar alguma coisa após o código ser executado com sucesso, sem problemas ou houver um problema:

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

Você pode usar as exceções internas fornecidas pelo PHP, ou se preferir, pode criar suas próprias exceções.

Como trabalhar com datas no PHP

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

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

$timestamp = time();

Quando temos um registro de data/hora, podemos formatá-lo no formato de data que preferirmos, usando o date():

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

Y é a representação de 4 dígitos do ano, m é o número do mês (com duas casas) e d é o número do dia do mês(com duas casas também).

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

Podemos converter qualquer data em um timestamp 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, também é comum usar bibliotecas, que oferecem muito mais funcionalidades do que a linguagem sozinha pode oferecer. Uma boa opção é a Carbon.

Como usar constantes e enums no PHP

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

define('TESTE', 'algum valor');

Depois, usamos TESTE como se fosse uma variável, mas sem o sinal $:

define('TESTE', 'algum valor');

echo TESTE;

Usamos identificadores maiúsculos como uma convenção para constantes, mas não é obrigatório.

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

class Cachorro {
  const BREED = 'Husky Siberiano';
}

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

class Cachorro {
  private const BREED = 'Husky Siberiano';
}

Já os Enums nos permitem agrupar constantes sob uma "raiz" comum. Por exemplo, se quiser ter um enum Status que tenha 3 estados: COMENDO, DORMINDO e CORRENDO, os 3 estados do dia de um cachorro. :)

Então, você tem:

enum Status {
  case COMENDO;
  case DORMINDO;
  case CORRENDO;
}

Agora, podemos referenciar essas constantes desta forma:

class Cachorro {
  public Status $status;
}

$cachorro = new Cachorro();

$cachorro->status = Status::CORRENDO;

if ($cachorro->status == Status::DORMINDO) {
  //...
}

Enums são objetos, que podem ter métodos e muito mais recursos do que podemos abordar aqui nesta breve introdução.

Como usar o PHP como uma plataforma de desenvolvimento de aplicativos da web

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

Uma delas é dentro de uma página HTML, então o PHP é usado para "adicionar" coisas ao HTML que é definido manualmente no arquivo .php. Esta é uma maneira perfeitamente boa de usar o PHP.

A outra maneira considera o PHP mais como o motor responsável por gerar uma "aplicação". Você não escreve o HTML em um arquivo .php, mas usa uma linguagem de modelagem 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. Se você está apenas começando, no entanto, deve conhecer esses dois estilos diferentes de se utilizar o PHP.

Pense em um framework, no entanto, como um "modo fácil" de fazer as coisas, pois fornecem ferramentas para lidar com roteamento, acessar dados de um banco de dados e facilitam a criação de um aplicativo mais seguro. E eles tornam tudo mais rápido para desenvolver.

Não falaremos sobre o uso de frameworks neste manual, apenas sobre os blocos de construção básicos e fundamentais do PHP. Eles são essenciais, e todo desenvolvedor PHP deve conhecê-los.

Apenas saiba que, "no mundo real", você pode preferir a maneira que usa o framework, em vez de fazer as coisas com os recursos de nível inferior oferecidos pelo PHP.

Isso não se aplica apenas ao PHP, é claro – é um "problema" que acontece com qualquer linguagem de programação.

Como lidar com requisições HTTP no PHP

Vamos começar com o tratamento de requisições HTTP.

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

Vimos isso quando fizemos o "Hello World" de exemplo no começo.

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

Como usar $_GET, $_POST e $_REQUEST no PHP

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

Em qualquer requisição, você pode acessar os dados da string de consulta usando o objeto $_GET. Esses objetos são conhecidos como superglobal e estão disponíveis automaticamente em todos os nossos arquivos PHP.

Obviamente, eles são mais úteis em requisições GET, porém existem outras requisições que podem enviar dados como uma string de consulta.

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

Há, também, o objeto $_REQUEST, que contém tanto o $_GET quanto o $_POST combinados em uma única variável.

Como usar o objeto $_SERVER no PHP

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

Você viu como usar phpinfo() antes. Vamos usá-lo novamente para ver o que $_SERVER nos oferece.

No seu index.php, no diretório raiz do MAMP, execute:

<?php
phpinfo();
?>

Em seguida, abra a página em localhost:8888 e pesquise por $_SERVER. Você verá toda a configuração armazenada e todos valores atribuídos:

Screen_Shot_2022-06-27_at_13.46.50

Os valores mais importantes que você pode querer 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 no PHP

Os formulários são a forma como a plataforma web permite que os usuários interajam com uma página e enviem dados para o servidor.

Aqui está um formulário simples em HTML:

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

Você pode colocá-lo no seu arquivo index.php da mesma forma como foi inserido no index.html.

Um arquivo PHP assume por padrão que você está escrevendo HTML nele, com alguns "extras de PHP" usando <?php ?> para que o servidor web possa enviá-lo no client. Às vezes, a parte do PHP ocupa a página toda, e é aí que você gera todo o HTML via PHP – é o oposto da abordagem que estamos adotando aqui agora.

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

Screen_Shot_2022-06-27_at_13.53.47

Pressionando o botão Submit (Enviar), ele fará uma requisição GET para o mesmo URL enviando os dados via string de consulta. Note que o URL agora mudou para localhost:8888/?name=test.

Screen_Shot_2022-06-27_at_13.56.46

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

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

<?php
if (isset($_GET['name'])) {
  echo '<p>The name is ' . $_GET['name'];
}
?>
Screen_Shot_2022-06-27_at_13.56.35

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

O que você costuma fazer com formulários, porém, é executar uma requisiçã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'];
}
?>

Agora, veja que, desse modo, temos as mesmas informações, mas o URL não mudou. As informações do formulário não foram anexadas ao URL.

Screen_Shot_2022-06-27_at_13.59.54

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

Como mencionado acima, o PHP ainda enviará o index.php, pois ainda estamos enviando dados para o mesmo URL em que o formulário está.

Esse código está todo misturado, mas podemos separar o manipulador de requisição (do formulário) e o código que gera o formulário.

Então, teremos em index.php:

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

Podemos criar um arquivo chamado post.php com:

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

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

Embora esse exemplo seja bem simples, poderíamos ter no post.php, por exemplo, um código para salvar os dados no banco de dados ou em um arquivo.

Como usar cabeçalhos HTTP no PHP

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

Os cabeçalhos HTTP (texto em inglês) são uma maneira de retornar informações ao navegador.

Podemos dizer que a página gera um 500 Internal Server Error:

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

Agora, você verá esse status ao acessar a página com as Ferramentas do desenvolvedor do navegador aberta (texto em inglês):

Screen_Shot_2022-06-27_at_14.10.29

Podemos definir também o content/type de uma response:

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 para "armazenar a página em cache" ou "não armazenar a página em cache" e muito mais.

Como usar cookies no PHP

Os cookies são um recurso do navegador.

Quando enviamos uma response ao navegador, podemos definir um cookie que será armazenado pelo navegador, do lado do client.

Então, cada requisição que o navegador fizer 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 outra aplicação.

Mas o JavaScript pode ler cookies (a menos que sejam cookies HttpOnly, mas aí estaríamos começando a entrar em um assunto interminável) e, por isso, os cookies não devem armazenar informações sensíveis.

Podemos usar o PHP para ler o valor de um cookie referenciando a variável superglobal $_COOKIE:

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

A função setcookie() permite definir um cookie:

setcookie('name', 'Flavio');

Podemos adicionar também um terceiro parâmetro para dizer quando o cookie vai expirar. Se omitido, o cookie expira no final da sessão/quando o navegador é fechado.

O código abaixo configura o cookie para expirar em 7 dias:

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

Podemos armazenar apenas uma quantidade limitada de dados em um cookie. Os usuários podem limpá-los no lado do client quando limpam os dados do navegador.

Além disso, eles são específicos para aquele navegador/dispositivo. Portanto, 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 tratar os casos em que o cookie já está definido, para mostrar o nome logo após o envio do formulário, ou quando o cookie ainda não estiver definido (ele será definido apenas para a próxima requisição HTTP).

Se você abrir as Ferramentas do desenvolvedor do navegador, deverá ver o cookie na guia Armazenamento (ou Storage).

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

Screen_Shot_2022-06-27_at_14.46.09

Como usar sessões baseadas em cookies no 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().

Em um arquivo PHP, adicione:

<?php
session_start();
?>

Agora abra-o no navegador.

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

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

Screen_Shot_2022-06-27_at_14.51.53

Da mesma forma que usamos cookies, agora podemos usar $_SESSION para armazenar as informações enviadas pelo usuário – que, desta vez, não são armazenadas no lado do client.

Apenas 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>
Screen_Shot_2022-06-27_at_14.53.24

É claro, contudo, que isso funciona para casos de uso simples. Porém, quando há a transmissão de dados intensivamente, 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 no PHP

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

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

file_exists('test.txt') // true

Ou obter o tamanho de um arquivo usando filesize():

filesize('test.txt')

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

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

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

É possível, também, ler o conteúdo de um arquivo e passar ele para uma variável assim:

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

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

// OU

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

A função feof() verifica se não chegamos ao final do arquivo, pois fgets lê 5.000 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);
  // faça alguma coisa
}

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

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

Podemos excluir um arquivo usando unlink():

unlink('test.txt')

Esses são os básicos, mas é claro que existem 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 (página ainda não traduzida na documentação)
  • MongoDB (página ainda não traduzida na documentação)

Não abordarei essa questão nesse manual, porque acho que esse é outro tópico gigante e que também exigiria que você aprendesse SQL.

Além disso, se você precisa de um banco de dados, deve usar um framework ou ORM que economize problemas de segurança, como injeção de SQL. O Eloquent do Laravel é um ótimo exemplo disso.

Como trabalhar com JSON no PHP

JSON (texto em inglês) é um formato de dados portátil que usamos para representar e enviar dados do cliente para o servidor.

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

{
  "nome": "Flavio",
  "idade": 35
}

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

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

Exemplo:

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

$encodificado = json_encode($teste); // "["a","b","c"]" (a string)

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

Como enviar e-mails com o PHP

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

Envie um e-mail usando mail():

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

Para enviar e-mails em escala, não podemos usar essa solução, pois esses e-mails tendem a ir para a pasta de spam com mais frequência. Porém, para testes rápidos, isso é útil.

Bibliotecas como https://github.com/PHPMailer/PHPMailer serão superúteis para necessidades mais robustas usando um servidor SMTP.

Como usar o Composer e o Packagist

Composer é o gerenciador de pacotes do PHP.

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

Instale ele em sua máquina (Linux/Mac ou Windows - textos em inglês) e, assim que terminar, você deverá ter o comando composer disponível no terminal.

Screen_Shot_2022-06-27_at_16.25.43

Agora, dentro do seu projeto, você pode rodar composer require <lib> e ele será instalado localmente. Por exemplo, vamos instalar a biblioteca Carbon, que ajuda na manipulação de datas em PHP.

composer require nesbot/carbon

Ele vai fazer o download e a instalação do pacote:

Screen_Shot_2022-06-27_at_16.27.11

Feito isso, você encontrará algumas coisas novas na pasta composer.json que listará a nova configuração para as dependências do projeto:

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

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

No arquivo index.php, podemos simplesmente adicionar este código no topo:

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

use Carbon\Carbon;

Já podemos usar nossa biblioteca!

echo Carbon::now();
Screen_Shot_2022-06-27_at_16.34.47

Viu? Não foi preciso baixar manualmente os pacotes da internet e instalá-los em algum lugar... foi tudo feito de forma simples, rápida e bem organizada.

A linha require 'vendor/autoload.php'; é o que permite o carregamento automático das dependências. Você se lembra de quando falamos sobre require_once() e include_once()? Isso resolve todo aquele problema – não precisamos procurar manualmente o arquivo a ser incluído, basta apenas usarmos a palavra-chave use para importar a biblioteca para nosso código.

Como fazer o deploy (implantação) de um aplicativo PHP

Depois que você tiver um aplicativo pronto para uso, chega finalmente a hora de fazer o deploy (implantação) dele e de torná-lo acessível para qualquer pessoa na Web.

Nesse quesito, PHP é a linguagem de programação com o melhor histórico de deploy na web.

Confie em mim, todas as outras linguagens de programação e ecossistemas gostariam muito de ser tão fáceis quanto o PHP.

A maior coisa do PHP, em que ele acertou em cheio e permitiu que tivesse o sucesso incrível que teve, foi o deploy instantâneo.

Você coloca um arquivo PHP em uma pasta veiculada por um servidor web e era isso – simplesmente funciona.

Não há necessidade de reiniciar o servidor, iniciar um executável, nada.

Isso é algo que muitas pessoas ainda fazem nos dias de hoje. Você consegue uma hospedagem compartilhada por U$3/mês, carrega seus arquivos via FTP e pronto.

Hoje em dia, porém, acho que o deploy por Git é algo que deve ser incorporado a todos os projetos, independentemente do tamanho, e hospedagem compartilhada deve ser uma coisa do passado.

Uma solução é sempre ter seu próprio VPS (Virtual Private Server) privado, que você pode obter de serviços como DigitalOcean ou Linode. No entanto, gerenciar seu próprio VPS não é brincadeira. Requer conhecimento sério e investimento de tempo e manutenção constante.

Você também pode usar o chamado PaaS (Platform as a Service), que são plataformas que se encarregam de cuidar de todas as coisas chatas (gerenciar servidores) e você apenas carrega nela seu aplicativo e ela roda.

Soluções como DigitalOcean App Platform (que é diferente do VPS da DigitalOcean), Heroku e muitas outras são ótimas para seus primeiros testes.

Esses serviços permitem que você conecte sua conta do GitHub e faça o deploy sempre que enviar uma nova alteração para seu repositório Git.

Você pode aprender como configurar o Git e o GitHub do zero aqui (texto em inglês).

Esse é um fluxo de trabalho muito melhor em comparação com uploads de FTP.

Vamos fazer um exemplo básico.

Eu criei uma aplicação PHP simples com apenas o arquivo index.php:

<?php
echo 'Hello!';
?>

Adicionamos a pasta pai ao meu aplicativo GitHub Desktop, inicializo um repositório do Git e faço o push para o GitHub:

Screen_Shot_2022-06-27_at_17.26.24

Agora, vá para digitalocean.com.

Se você ainda não tem uma conta, use meu código de referência para se inscrever, e receber U$ 100 em créditos grátis nos próximos 60 dias e você poderá trabalhar na sua aplicação PHP de forma gratuita.

Entramos na conta e vamos para Apps → Create App.

Conectamos à conta do GitHub e selecionamos o repositório da aplicação.

Quando for criar a aplicação, certifique-se de que a opção "Autodeploy" esteja marcada, para que ela seja reimplantada automaticamente quando fizer alterações nela:

Screen_Shot_2022-06-27_at_17.31.54

Clique em Next (Avançar) e depois em Edit Plan (Editar plano):

Screen_Shot_2022-06-27_at_17.32.24

Por padrão, o plano Pro é selecionado.

Use o Basic e escolha o plano de U$5/mês.

Note que você paga U$5 por mês, mas o faturamento é por hora - para que você possa interromper a aplicação a qualquer momento.

Screen_Shot_2022-06-27_at_17.32.28
Screen_Shot_2022-06-27_at_17.33.15

Em seguida, volte para a página de criação e pressione Next até que o botão Create Resources (Criar recursos) apareça para criar a aplicação. Você não vai precisar de nenhum banco de dados. Caso contrário, seriam mais U$ 7/mês em cima do valor anterior.

Screen_Shot_2022-06-27_at_17.33.46

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

Screen_Shot_2022-06-27_at_17.35.00

A aplicação já está funcionando!

Screen_Shot_2022-06-27_at_17.35.31

Conclusão

Você chegou ao final do Manual do PHP! Parabéns!

Obrigado por ler esta introdução ao maravilhoso mundo do desenvolvimento em PHP. Espero que esse conhecimento o ajude a conseguir trabalho na área de desenvolvimento web, se tornar melhor nela ou capacitar você a trabalhar na próxima grande ideia de sua vida.

Observação: Você também pode ter uma versão desse manual, em inglês, em PDF, ePub ou Mobi, para uma fácil referência ou para ler no seu Kindle ou tablet.