PHP - freeCodeCamp.org

O manual do PHP – Guia para iniciantes em PHP

Thiago Costa Barbosa — Sun, 31 Jul 2022 23:45:54 +0000

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:

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:

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:

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.

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).

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:

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

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 , 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

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 . '
';
}

`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:

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

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:

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:

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:

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

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

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

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:

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();
}

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();
}

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!';
}

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:

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:

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:

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 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:

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.

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


  
  


The name is ' . $_GET['name'];
}
?>

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:


  
  


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.

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:

Podemos criar um arquivo chamado post.php com:

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:

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

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:

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

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.

`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:

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.

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.

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

É 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.

Agora, dentro do seu projeto, você pode rodar composer require 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:

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:

Já podemos usar nossa biblioteca!

echo Carbon::now();

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:

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

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:

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

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.

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.

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

A aplicação já está funcionando!

`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.



 Os melhores exemplos do PHP 
Thiago Costa Barbosa — Sun, 31 Jul 2022 01:18:52 +0000
 
        Artigo original: The Best PHP Examples
      
O PHP é uma linguagem de script para back-end (em que o código que é executado pelo servidor, e não pelo dispositivo do usuário) criada em 1995 por Rasmus Lerdorf.
O PHP é uma linguagem de script de uso geral, com código aberto, e é amplamente utilizada no mercado, sendo mais apropriada para o desenvolvimento para a web, podendo ser incorporada ao HTML.
Uma linguagem de programação de script (ou scripting) é uma linguagem em que uma rotina (script) ou programa é executado em tempo de execução, ou seja, não precisa ser transformado em código de máquina (compilada) para só depois ser executado.
Para que serve o PHP?
Em outubro de 2018, ele era usado em 80% dos sites cuja linguagem do lado do servidor é conhecida (em inglês). Normalmente, ele é usado em sites para gerar de forma dinâmica o conteúdo da página, podendo ser usado em:
Sites e aplicativos da web (o código do back-end)
Script de linha de comando
Aplicativos de área de trabalho (GUI)
Em geral, ele é usado principalmente para gerar de modo dinâmico o conteúdo das páginas. Por exemplo, se você tiver um blog, podes escrever algum script em PHP para recuperar suas publicações a partir de um banco de dados e exibi-las no seu blog. Outras maneiras de usar scripts PHP incluem:
Processar e salvar os dados inseridos pelos usuários em um formulário
Configurar e manipular os cookies do site
Restringir o acesso a determinadas páginas do seu site
A maior plataforma de rede social, o Facebook, foi inicialmente escrita usando PHP.
Como funciona o PHP?
Todo o código em PHP é executado apenas no servidor, e não no dispositivo local do usuário. Por exemplo, se você preencher um formulário em um site e enviá-lo, ou se clicar em um link de uma página escrita em PHP, nenhum código PHP será executado no seu computador. Em vez disso, os dados do formulário ou a requisição da página serão enviados a um servidor para serem processados pelos scripts em PHP. Depois de processados, o servidor enviará o HTML resultante para você (que é de onde vem o termo "Hypertext Preprocessor" - ou pré-processador de hipertexto) e o navegador o exibe na tela. Por essa razão, você não consegue ver o código PHP de um site, apenas o HTML resultante produzido pelos scripts em PHP do site.
Ilustrarei isso abaixo:
O PHP é uma linguagem interpretada. Isso quer dizer que, quando você faz alterações no código-fonte, pode testar imediatamente essas alterações, sem precisar compilar (transformar) o código-fonte em formato binário. Ignorar a etapa de compilação torna o processo de desenvolvimento muito mais rápido.
O código em PHP precisa sempre ser colocado entre as tags  e ?> e também pode ser incorporado dentro de um código HTML.
Instalação
O PHP pode ser instalado com ou sem um servidor web.
GNU/Linux
Em distribuições GNU/Linux baseadas em Debian, você pode instalá-lo pelo terminal com o comando:
sudo apt install php
No Centos 6 ou 7, você pode instalar com o comando:
sudo yum install php
Depois de instalado, você pode executar qualquer arquivo em PHP simplesmente escrevendo no terminal:
php nome_do_arquivo.php
Ou, se preferir, pode instalar um servidor da web para poder executar seus sites em PHP no seu próprio computador (http://localhost).
Só para esclarecer, o domínio http://localhost é um domínio padrão do sistema , e quando fazemos uma requisição para ele. Ele, então, direciona essa requisição para o IP do próprio computador (por padrão aponta o endereço 127.0.0.1), agora não mais enviando, mas recebendo uma requisição de recurso.
O que um servidor localhost faz é gerenciar as rotas de endereços e executar o seu site no domínio que você quiser (podendo ser diferente do domínio http://localhost também).
O servidor mais usado no mundo é o Apache. Para instalá-lo em distribuições Linux, digite o seguinte comando no seu terminal:
sudo apt install apache2 libapache2-mod-php
Ou, se preferir, pode instalar o PHP, o MySQL e o servidor web, instalando o XAMPP (é um pacote de soluções para servidor web multiplataforma, gratuito e de código aberto) ou pacotes semelhantes como WAMP e MAMP.
Frameworks do PHP
Como escrever todo o código de um site não é algo prático/viável para a maioria dos projetos, a maioria dos desenvolvedores tende a usar frameworks para o desenvolvimento para a web. As vantagens de se usar um framework são:
Você não precisa reinventar a roda toda vez que cria um projeto, muitas nuances já estão prontas para você
Geralmente, eles são bem estruturados para ajudar você na separação das responsabilidades
A maioria dos frameworks tende a seguir as melhores práticas da linguagem
Muitos deles seguem o padrão MVC (Model-View-Controller) para separar as camadas de apresentação da lógica
Frameworks populares de PHP
CodeIgniter
Laravel
Symfony
Zend
CakePHP
FuelPHP
Slim
Yii 2
Sintaxe básica
Os scripts de PHP podem ser colocados em qualquer lugar dentro de um documento, e sempre começam com a tag  e terminam com a tag ?>. Além disso, cada instrução PHP deve terminar com um ponto e vírgula ;.
Aqui está um script simples que usa a função nativa echo para enviar o texto "Os melhores exemplos de PHP" para a página:




Notícias do desenvolvedor




 
A saída disso seria:
Notícias do desenvolvedor

Os melhores exemplos de PHP
Comentários
O PHP suporta as seguintes maneiras de se comentar o código:
Comentários de linha única, ou single-line:
Comentários de várias linhas, ou multi-line:
Sensibilidade a maiúsculas e minúsculas
Todas as palavras-chave (keywords), classes e funções NÃO diferenciam maiúsculas de minúsculas.
No exemplo abaixo, todas as três declarações de echo são válidas:
";
echo "Notícias do desenvolvedor
";
EcHo "Aproveite todos os artigos
";
?>
No entanto, todos os nomes de variáveis diferenciam maiúsculas de minúsculas. No exemplo abaixo, apenas a primeira instrução é válida e exibirá o valor da variável $name, as variáveis $NAME e $NaMe serão tratadas como variáveis diferentes:
";
//Olá! Meu nome é Quincy!

echo "Olá! Meu nome é " . $NAME . "
";
//Erro de sintaxe: sintaxe inválida

echo "Olá! Meu nome é " . $NaMe . "
";
//Erro de sintaxe: sintaxe inválida
?>
Variáveis
Variáveis são a principal maneira de se armazenar informações em um programa em PHP.
Todas as variáveis no PHP começam com um cifrão, como em $nome_da_variavel. Para atribuir uma variável, use o operador =, com o nome da variável à esquerda e a expressão a ser avaliada à direita.
Sintaxe:
Regras para variáveis em PHP
Declarações de variáveis começam com $, seguido pelo nome da variável
Os nomes de variáveis só podem começar com uma letra maiúscula ou minúscula ou um sublinhado ( _)
Os nomes de variáveis podem conter apenas letras, números ou sublinhado (Az, 0-9 e _). Outros caracteres especiais, como + - % ( ) . &, são inválidos
Os nomes das variáveis diferenciam maiúsculas de minúsculas
Alguns exemplos de nomes de variáveis permitidos:
$minha_variavel
$outraVariavel
$variavelNro2
Variáveis predefinidas
O PHP tem várias palavras-chave especiais que, embora sejam nomes de variáveis "válidas", não podem ser usadas para suas variáveis. A razão disso é que a própria linguagem já definiu essas variáveis e elas são usadas para propósitos especiais. Vários exemplos estão listados abaixo, mas se quiser ver a lista completa, essa é a documentação do PHP.
$this
$_GET
$_POST
$_SERVER
$_FILES
Tipos de dados em PHP
As variáveis podem armazenar dados de diferentes tipos, como:
String ("Olá")
Inteiro (5)
Float (também chamado de double) (1.0)
Booleano (1 ou 0)
Array (array("Eu", "sou", "um", "array"))
Objeto
NULL
Recurso
Strings
Uma string é uma sequência de caracteres. Ela pode ser qualquer texto entre aspas (simples ou duplas):
$x = "Olá!";
$y = 'Olá!';
Inteiros
Um tipo de dados inteiro é um número não decimal entre -2.147.483.648 e 2.147.483.647.
Regras para números inteiros:
Os números inteiros devem ter pelo menos um dígito
Os inteiros não devem ter o ponto decimal
Os inteiros podem ser positivos ou negativos até o número 2.147.483.647
$x = 5;
Flutuantes (float)
Um número flutuante, ou de ponto flutuante, é um número com um ponto decimal, ou um número na forma exponencial(por exemplo, 5.046E-7), podendo ter, uma precisão de até 14 dígitos, dependendo do sistema.
$x = 5.01;
Booleanos
Um booleano representa dois estados possíveis: TRUE (Verdadeiro) ou FALSE (Falso). Booleanos são frequentemente usados em testes condicionais.
$x = true;
$y = false;
Arrays
Um array armazena mais de um valor em uma única variável.
$cores = array("Magenta", "Amarelo", "Ciano");
NULL
Null é um tipo de dado especial que só pode ter o valor null. As variáveis podem ser declaradas sem valor ou esvaziadas definindo o seu valor como null. Além disso, se uma variável for criada sem receber um valor, ela é atribuída com o valor null automaticamente.
Classes e objetos
Uma classe é uma estrutura de dados útil para modelar coisas do mundo real, podendo conter propriedades e métodos. Os objetos são instâncias de uma classe e são uma maneira prática de agrupar valores e funções específicas de uma classe.
model = "Tesla";
    }
}

// Cria um objeto
$Lightning = new Car();

// Mostra as propriedades do objeto
echo $Lightning->model;
?>
Recurso em PHP
Um recurso, ou, como é mais conhecido, resource, é uma variável especial, mantendo uma referência a um recurso externo. Os resources são criados e usados por funções especiais. Um exemplo é a função getresourcetype(), que você pode usar para ver o tipo de recurso que uma variável oferece.
doc) . "\n";
Strings
Uma string é uma série de caracteres. Elas podem ser usadas para armazenar qualquer informação textual em seu aplicativo.
Existem diversas maneiras diferentes de se criar strings em PHP.
Aspas simples
Strings simples podem ser criadas usando aspas simples.
$nome = 'Joe';
Para incluir aspas simples dentro de uma string de aspas simples, use a barra invertida como escape (que altera o significado do próximo caractere).
$sobrenome = 'O\'Brian';
Aspas duplas
Você também pode criar strings usando aspas duplas.
$name = "Joe";
Para incluir aspas duplas dentro de uma string de aspas duplas, use a barra invertida também.
$citacao = "Mary disse: \"Eu quero algumas torradas\" e depois fugiu.";
Strings com aspas duplas também permitem sequências de escape. Esses são códigos especiais que colocam caracteres em sua string e representam caracteres normalmente invisíveis. Os exemplos mais comuns são novas linhas \n, tabulações \t e a barra invertida \\.
Você também pode incorporar variáveis em PHP em strings com aspas duplas para que seus valores sejam adicionados à string normalmente.
$nome = 'Joe';
$saudacao = "Olá $nome"; // agora contém a string "Olá Joe"
Funções de String
Encontrar o tamanho de uma string
A função strlen() retorna o tamanho de uma string.
Encontrar o número de palavras em uma string
A função strwordcount() retorna o número de palavras em uma string:
Inverter uma string
A função strrev() inverte uma string:
Pesquisar um texto em uma string
A função strpos() procura um texto em string e retorna a posição em que ele aparece:
Substituir texto dentro de uma string
A função str_replace() substitui o texto em uma string:
Constantes
Constantes são um tipo de variável em PHP. A função define() é usada para definir uma constante, e recebe três argumentos - o nome da chave, o valor da chave e um booleano (verdadeiro ou falso) que determina se o nome da chave não diferencia maiúsculas de minúsculas (falso por padrão). O valor de uma constante não pode ser alterado depois que é definido. É usado para valores que raramente mudam (por exemplo, uma senha de banco de dados OU chave de API).
Escopo
É importante você saber também que, diferente das variáveis, as constantes SEMPRE possuem o escopo global, e podem ser acessadas de qualquer função no script.
?

// exibe: Aprenda a programar e ajudar organizações sem fins lucrativos
Além disso, quando você está criando classes, você pode declarar suas próprias constantes.
lass Humano {
  const TYPE_MACHO = 'm';
  const TYPE_FEMEA = 'f';
  const TYPE_UNKNOWN = 'u'; // Quando o usuário não selecionar o gênero
}
Observação: se você quiser usar essas constantes dentro da classe Humano, você pode referenciá-las como self::NOME_DA_CONSTANTE. Se você quiser usá-las fora da classe, você precisa referenciar elas como HumanO::NOME_DA_CONSTANTE.
Operadores
O PHP contém todos os operadores normais que se espera encontrar em uma linguagem de programação.
Um único "=" é usado como operador de atribuição e um duplo "==" ou o triplo "===" é usado para comparação.
Os usuais "<" e ">" também podem ser usados para comparação e "+=" pode ser usado para somar um valor à variável e atribuir o resultado à si mesma ao mesmo tempo.
O mais notável é o uso do "." para concatenar strings e ".=" para adicionar uma string ao final de outra.
Uma novidade do PHP 7.0.X é o operador Spaceship "<=>". Esse operador retorna -1, 0 ou 1 quando $a é menor, igual ou maior que $b.
 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1
Instruções if/else/elseif
If/else (se/senão) é uma instrução condicional onde, dependendo de uma condição ser verdadeira ou não, diferentes ações serão executadas.
Observação: os colchetes {} são necessários apenas se a condição tiver mais de uma ação; no entanto, é uma boa prática incluí-los, independentemente da quantidade de ações.
Instrução if
Observação: é possível aninhar quantas instruções em um bloco "if" você quiser; você não está limitado à quantidade dos exemplos.
Instrução if/else
Observação: a instrução else é opcional.
Instrução if/elseif/else
Observação: elseif deve ser escrito sempre como uma palavra só.
Instruções if/else aninhadas
Múltiplas condições
Várias condições podem ser usadas de uma só vez com os operadores lógicos "ou" (||), "xor" e "e" (&&).
Por exemplo:
Observação: é uma boa prática envolver condições individuais entre parênteses quando você tiver mais de um (pois pode melhorar a legibilidade).
Sintaxe alternativa de if/else
Há também uma sintaxe alternativa para estruturas de controle:
if (condicao1):
  instrucao1;
else:
  instrucao2;
endif;
Operador ternário
Outra opção é o operador ternário, que é basicamente uma instrução if/else de uma única linha.
Vamos supor que você precise exibir "Olá (nome do usuário)" se um usuário estiver logado e "Olá visitante" se ele não estiver logado.
Instrução if/else:
if($usuario == !NULL {
  $mensagem = 'Olá '. $usuario;
} else {
  $mensagem = 'Olá visitante';
}
Operador ternário:
$mensagem = 'Olá '.($usuario == !NULL ? $usuario : 'Guest');
Switch
Em PHP, a instrução Switch é muito semelhante à instrução Switch do JavaScript (consulte essa Introdução ao Switch em JavaScript para comparar as duas - texto em inglês). Ele permite testes rápidos de caso com muitas condições diferentes possíveis, de forma mais legível.
Break
A instrução break; sai do switch e continua a execução do código depois dele. Se você não usar a instrução break;, poderá acabar executando vários casos e instruções, sendo que, somente quando isso for desejado, você deve não incluir a instrução break;.
Um exemplo desse comportamento pode ser visto abaixo:
Se $i = 1, o valor de $j seria:
1
Se $i = 2, o valor de $j seria:
2
Embora a quebra possa ser omitida sem causar falhas, em alguns casos (como o exemplo abaixo), geralmente é uma boa prática inclui-la para se ter legibilidade e segurança:
Exemplo‌
Resultado
Se case for 1
> O dado caiu no número Um.
Se case for 2
> O dado caiu no número Dois.
Se case for 3
> O dado caiu no número Três ou Quatro.
Se case for 4
> O dado caiu no número Três ou Quatro
Se case for 5
> CincoSeisO dado caiu no número Seis
Se case for 6
> SeisO dado caiu no número Seis.
Se não for nenhuma das anteriores
> O dado caiu no número desconhecido.
Laços
Quando você precisa repetir uma tarefa várias vezes, pode usar um laço (ou loop) em vez de adicionar o mesmo código várias vezes.
Usar um break dentro do laço permite que você interrompa a execução.
Laço for
Para fazer um laço em um bloco de código um número específico de vezes, utilize o laço for.

/* Exibirá:
Contador do laço atual em 0.
Contador do laço atual em 1.
Contador do laço atual em 2.
Contador do laço atual em 3.
Contador do laço atual em 4.
*/
Laço while
A instrução while executa um laço em um bloco de código enquanto uma condição for verdadeira.
= 0) {
    echo "O índice é ".$indice.".\n";
    $indice--;
  }
?>
/*
Exibirá:
O índice é 5.
O índice é 4.
O índice é 3.
O índice é 2.
O índice é 1.
O índice é 0.
*/
Laço do...while
Com essa instrução, você consegue fazer um laço em um bloco de código uma vez e só repeti-lo se a condição for verdadeira.
 0)
?>
/* Exibirá:
Índice: 3.
Índice: 2.
Índice: 1.
*/
Laço foreach
O laço foreach repete o bloco de código para cada valor de um array, atribuindo esse valor a uma variável criada internamente e redefinida a cada repetição.

/*
Exibirá:
Índice: 1.
Índice: 2.
Índice: 3.
Índice: 4.
*/
Funções
Uma função é um bloco de instruções que pode ser executado sempre que for chamado em um programa.
Função simples + chamada
function diga_ola() {
  return "Olá!";
}

echo diga_ola()
Função simples + parâmetro + chamada‌ 
function diga_ola($amigo) {
  return "Olá " . $amigo . "!";
}

echo diga_ola('Tommy');
Função strtoupper()
A função strtoupper retorna a string que foi enviada para ela como parâmetro na sua versão em MAIÚSCULAS!
function fazerIssoGRANDE($um_monte_de_nomes) { 
  foreach($um_monte_de_nomes as $os_simpsons) {
    $GRANDE[] = strtoupper($os_simpsons);
  }
  return $GRANDE;
}
$lista_com_nomes = ['Homer', 'Marge', 'Bart', 'Maggy', 'Lisa'];
var_dump(fazerIssoGRANDE($lista_com_nomes));
Arrays
Arrays são como variáveis normais, só que contêm vários valores em uma lista ordenada. Isso é útil se você tiver vários valores relacionados entre si, como uma lista de nomes de alunos ou uma lista de capitais.
Tipos de arrays
No PHP, existem dois tipos de arrays: arrays indexados e arrays associativos. Cada um deles tem seu próprio uso e veremos aqui como criar esses arrays.
Array indexado
Um array indexado é uma lista de valores ordenados. Cada um desses valores no array recebe um número de índice. Os índices em arrays sempre começam no 0 para o primeiro valor e depois crescem de um em um a partir daí.
$lista_de_mercado[0] retornaria "ovos", $lista_de_mercado[1] retornaria "leite", e $lista_de_mercado[2] retornaria "queijo".
Array associativo
Um array associativo é uma lista de valores que são acessados por meio de uma chave ao invés de índices numéricos. Uma chave pode ter qualquer valor e ser de qualquer tipo, contanto que seu nome seja único no array.
 83, "Frank" => "93", "Benji" => "90");
?>
$pontuacao_dos_estudantes['Joe'] retornaria 83, $pontuacao_dos_estudantes['Frank'] retornaria 93, $pontuacao_dos_estudantes['Benji'] retornaria 90.
Array multidimensional
Um array multidimensional é um array que contém outros arrays. Isso permite criar estruturas de dados complexas que podem modelar um grupo de dados muito complexo.
 "Joe", "pontuacao" => 83, "ultimo_nome" => "Smith"),
      array("primeiro_nome" => "Frank", "pontuacao" => 92, "ultimo_nome" => "Barbson"),
      array("primeiro_nome" => "Benji", "pontuacao" => 90, "ultimo_nome" => "Warner")
    );
?>
Agora você pode obter o primeiro estudante pelo primeiro_nome dele com:
$estudantes[0]['primeiro_nome']
Obter o comprimento de um array - a função count()
A função count() é usada para retornar o comprimento (o número de elementos) de um array:
Ordenando arrays
O PHP oferece várias funções para ordenar arrays. Esta página descreve as diferentes funções e inclui exemplos.
sort()
A função sort() ordena os valores de um array em ordem alfabética/numérica ascendente (por exemplo, A, B, C, D, E... 1, 2, 3, 4, 5...).
Resultado:
Array
(
    [0] => camp
    [1] => code
    [2] => free
)
rsort()
As funções rsort() ordenam os valores de um array em ordem alfabética/numérica decrescente (por exemplo, Z, Y, X, W, V... 5, 4, 3, 2, 1...).
Resultado:
Array
(
    [0] => free
    [1] => code
    [2] => camp
)
asort()
A função asort() ordena um array associativo, por seus valores, em ordem alfabética/numérica ascendente (por exemplo, A, B, C, D, E... 1, 2, 3, 4, 5...).
"free", "one"=>"code", "two"=>"camp");
  asort($freecodecamp);
  print_r($freecodecamp);
?>
Resultado:
Array
(
    [two] => camp
    [one] => code
    [zero] => free
)
ksort()
A função ksort() ordena um array associativo, por suas chaves, em ordem alfabética/numérica ascendente (Ex. A, B, C, D, E... 1, 2, 3, 4, 5...)
"free", "one"=>"code", "two"=>"camp");
ksort($freecodecamp);
print_r($freecodecamp);
?>
Resultado:
Array
(
    [one] => code
    [two] => camp
    [zero] => free
)
arsort()
A função arsort() ordena um array associativo, por seus valores, em ordem alfabética/numérica decrescente (por exemplo, Z, Y, X, W, V... 5, 4, 3, 2, 1...)
"free", "one"=>"code", "two"=>"camp");
arsort($freecodecamp);
print_r($freecodecamp);
?>
Resultado:
Array
(
    [zero] => free
    [one] => code
    [two] => camp
)
krsort()
A função krsort() ordena um array associativo, por suas chaves em ordem alfabética/numérica decrescente (Ex: Z, Y, X, W, V... 5, 4, 3, 2, 1...)
"free", "one"=>"code", "two"=>"camp");
krsort($freecodecamp);
print_r($freecodecamp);
?>
Resultado:
Array
(
    [zero] => free
    [two] => camp
    [one] => code
)
Formulários
Os formulários são uma maneira de os usuários inserirem dados ou selecionarem dados da página. Os formulários servem para podermos armazenar os dados inseridos, bem como para permitir que informações sejam recuperadas para serem usadas.
Para fazer um formulário funcionar em linguagens como o PHP, você precisa de alguns atributos básicos em html. Na maioria dos casos, o PHP usa variáveis super globais 'post' e 'get' para obter os dados do formulário.


  
      

      

  

O atributo 'method' aqui informa ao formulário como enviar os dados do formulário. Em seguida, o atributo 'action' informa para onde enviar os dados do formulário para serem processados. Já o atributo 'name' é extremamente importante e deve ser o único na página com um valor, porque no PHP o valor do nome funciona como a identidade desse campo de entrada.
Verificando os campos obrigatórios do formulário
O PHP possui algumas funções para verificar se os campos de entrada obrigatórios foram atendidos. Essas funções são isset, empty, e is_numeric.
Verificando o formulário para ter certeza de que está preenchido
As verificações isset servem para ver se o campo foi preenchido e não é nulo. Exemplo:
$primeiroNome = $_GET['primeiroNome'];

if(isset($primeiroNome)){
  echo "o campo primeiroNome foi preenchido". "
";
} else {
  echo "O campo não está preenchido."."
";
}
Manipulando as entradas do formulário
Pode-se obter os valores de entrada dos campos de um formulário com as variáveis globais $POST e $GET.
$_POST["primeiroNome"] or $_GET['ultimoNome']

PHP - freeCodeCamp.org

O manual do PHP – Guia para iniciantes em PHP

Por que aprender PHP?

Introdução ao PHP

Mas que tipo de linguagem é o PHP?

Como configurar o PHP

Como escrever seu primeiro programa PHP

Fundamentos da linguagem PHP

Como as variáveis ​​funcionam no PHP

Como escrever comentários no PHP

O que são tipos em PHP?

Como imprimir o valor de uma variável no PHP

Como os operadores funcionam no PHP

Como trabalhar com strings no PHP

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

Como os arrays funcionam no PHP

Funções úteis para arrays no PHP

Como usar arrays associativos no PHP

Como funcionam as condicionais no PHP

Como os laços funcionam no PHP

Como usar um laço while no PHP

Como usar um laço do while no PHP

Como usar um laço foreach no PHP

Como usar um laço for no PHP

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

Como agem as funções no PHP

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

Programação Orientada a Objetos no PHP

Como usar classes e objetos no PHP

Como usar propriedades no PHP

Como usar métodos no PHP

Como usar o método construtor no PHP

O que é herança no PHP?

Propriedades e métodos protected no PHP

Como substituir métodos no PHP

Propriedades e métodos estáticos no PHP

Como comparar objetos no PHP

Como iterar sobre propriedades de objeto no PHP

Como clonar objetos no PHP

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

Como incluir outros arquivos PHP

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

Como lidar com erros no PHP

Como lidar com exceções no PHP

Como trabalhar com datas no PHP

Como usar constantes e enums no PHP

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

Como lidar com requisições HTTP no PHP

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

Como usar o objeto $_SERVER no PHP

Como usar formulários no PHP

Como usar cabeçalhos HTTP no PHP

Como usar cookies no PHP

Como usar sessões baseadas em cookies no PHP

Como trabalhar com arquivos e pastas no PHP

PHP e bancos de dados

Como trabalhar com JSON no PHP

Como enviar e-mails com o PHP

Como usar o Composer e o Packagist

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

Conclusão

Os melhores exemplos do PHP

Para que serve o PHP?

Como funciona o PHP?

Instalação

GNU/Linux

Frameworks do PHP

Frameworks populares de PHP

Sintaxe básica

Notícias do desenvolvedor

Comentários

Sensibilidade a maiúsculas e minúsculas

Variáveis

Regras para variáveis em ​​PHP

Variáveis ​​predefinidas

Tipos de dados em PHP

Strings

Inteiros

Flutuantes (float)

Booleanos

`Fundamentos da linguagem PHP`

`Como as variáveis funcionam no PHP`

`Como escrever comentários no PHP`

`O que são tipos em PHP?`

`Como imprimir o valor de uma variável no PHP`

`Como os operadores funcionam no PHP`

`Como trabalhar com strings no PHP`

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

`Como os arrays funcionam no PHP`

`Funções úteis para arrays no PHP`

`Como usar arrays associativos no PHP`

`Como funcionam as condicionais no PHP`

`Como os laços funcionam no PHP`

`Como usar um laço while no PHP`

`Como usar um laço do while no PHP`

`Como usar um laço foreach no PHP`

`Como usar um laço for no PHP`

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

`Como agem as funções no PHP`

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

`Programação Orientada a Objetos no PHP`

`Como usar classes e objetos no PHP`

`Como usar propriedades no PHP`

`Como usar métodos no PHP`

`Como usar o método construtor no PHP`

`O que é herança no PHP?`

`Propriedades e métodos protected no PHP`

`Como substituir métodos no PHP`

`Propriedades e métodos estáticos no PHP`

`Como comparar objetos no PHP`

`Como iterar sobre propriedades de objeto no PHP`

`Como clonar objetos no PHP`

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

`Como incluir outros arquivos PHP`

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

`Como lidar com erros no PHP`

`Como lidar com exceções no PHP`

`Como trabalhar com datas no PHP`

`Como usar constantes e enums no PHP`

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

`Como lidar com requisições HTTP no PHP`

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

`Como usar o objeto $_SERVER no PHP`

`Como usar formulários no PHP`

`Como usar cabeçalhos HTTP no PHP`

`Como usar cookies no PHP`

`Como usar sessões baseadas em cookies no PHP`

`Como trabalhar com arquivos e pastas no PHP`

`PHP e bancos de dados`

`Como trabalhar com JSON no PHP`

`Como enviar e-mails com o PHP`

`Como usar o Composer e o Packagist`

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

`Conclusão`

`Instalação`

`GNU/Linux`

`Frameworks do PHP`

`Frameworks populares de PHP`

`Sintaxe básica`

`Comentários`

`Sensibilidade a maiúsculas e minúsculas`

`Variáveis`

`Regras para variáveis em PHP`

`Variáveis predefinidas`

`Tipos de dados em PHP`

`Strings`

`Inteiros`

`Flutuantes (float)`

`Booleanos`

`Arrays`

`NULL`

`Classes e objetos`

`Recurso em PHP`

`Strings`

`Aspas simples`

`Aspas duplas`

`Funções de String`

`Encontrar o tamanho de uma string`

`Encontrar o número de palavras em uma string`

`Inverter uma string`