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.

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

<?php
echo 'Hello World';
?>
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 <?php, que diz "aqui começa um código
em PHP".

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

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

Temos essa estrutura de abertura/fechamento porque podemos embutir PHP dentro

do HTML. O PHP é uma linguagem de script. Seu objetivo é poder "decorar" uma
página HTML com dados dinâmicos.

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

Hello
<?php
echo 'World';
?>
Para o usuário final, que só olha a tela do navegador e não tem ideia do código nos
bastidores, não há diferença alguma.

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

Fundamentos da linguagem PHP

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

mais detalhes.

Como as variáveis funcionam no PHP

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

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

$nome = 'Flavio';
$nome = "Flavio";
Ou números:
$idade = 20;
Ou qualquer outro tipo que o PHP permitir, como veremos mais para frente.

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

$nome = 3;

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

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

diferente de $Nome.

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

Como escrever comentários no PHP

Uma parte muito importante de qualquer linguagem de programação é como você

escreve comentários no meio do código.

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

// Comentários de linha única

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

/*
Isto é um comentário
*/
// Ou
/*
*
* Isto é um comentário
*
*/
// Ou para comentar uma parte do código dentro de uma linha:
$nome = /* Isto é um comentário */ 'Flavio';
O que são tipos em PHP?

Já mencionei as strings e os números.

O PHP possui os seguintes tipos:

 bool: valores booleanos (verdadeiro/falso)

 int: números inteiros (sem decimais)
 float: números de ponto flutuante (decimais)
 string: sequência de caracteres
 array: matriz
 object: objeto
 null: um valor que significa "nenhum valor atribuído" e alguns outros mais
avançados.

Como imprimir o valor de uma variável no PHP

Podemos usar a função interna var_dump() para obter o valor de uma variável:
$nome = 'Flavio';
var_dump($nome);

A instrução var_dump($nome) será impressa assim string(6) "Flavio" na página, o que

nos diz que a variável é uma string de 6 caracteres.
Se usarmos este código:

$idade = 20;

var_dump($idade); teríamos de volta int(20) dizendo que o valor é 20 e é um número

inteiro. var_dump() é uma das ferramentas essenciais em seu conjunto de
ferramentas para depurar o PHP.
Como os operadores funcionam no PHP

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

$largura = 20;
$altura = 10;

$area = $largura * $altura;

O * que eu usei para multiplicar $largura por $altura é o operador de multiplicação.
Temos alguns operadores – então, vamos fazer um rápido resumo dos principais.

Para começar, aqui estão os operadores

aritméticos: + (soma), - (subtração), * (multiplicação), / (divisão), % (resto)
e ** (exponencial).

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

variável.
Em seguida, temos os operadores de comparação, como <, >, <= e >=. Eles
funcionam da mesma forma que na matemática.
2 < 1; // false
1 <= 1; // true
1 <= 2; // true
== retorna true se os dois operandos forem iguais.
Já o operador === retorna true se os dois operandos forem idênticos.
Qual é a diferença? Um compara somente o valor, o segundo compara o tipo
também.

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

1 == '1'; // true
1 === '1'; // false
Também temos o operador != que detecta se os operandos não são iguais:
1 != 1; // false
1 != '1'; // false
1 != 2; // true
// Dica: <> funciona da mesma forma que !=, 1 <> 1
E o !== para detectar se os operandos não são idênticos:
1 !== 1; // false
1 !== '1'; // true
Os operadores lógicos trabalham com valores booleanos:

// Lógica E com && ou "and"

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

// Lógica OU com || ou "or"

true || true; // true

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

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

true xor true; // false

true xor false // true
false xor true // true
false xor false // false
Temos também o operador not:
$teste = true
!$teste // false

Eu usei os valores booleanos true e false aqui, mas, na prática, você usará
expressões que avaliam se é verdadeiro ou falso, como neste exemplo:
1 > 2 || 2 > 1; // true
1 !== 2 && 2 > 2; // false
Todos os operadores listados acima são binários, o que significa que envolvem 2
operandos.

O PHP também possui 2 operadores unários, são eles: ++ e --.

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

Como trabalhar com strings no PHP

Eu introduzi o uso de strings anteriormente quando falamos sobre variáveis e

definimos uma string usando esse exemplo:
$nome = 'Flavio'; // string definida com aspas simples
$nome = "Flavio"; // string definida com aspas duplas

A grande diferença entre usar aspas simples e duplas é que com aspas duplas
podemos expandir as variáveis desta forma:
$teste = 'um exemplo';

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

E com aspas duplas podemos usar caracteres de escape - como novas linhas \n ou
tabulações \t:
$exemplo = "Esta é uma linha\nEsta é uma linha";
/*
a saída será:
Esta é uma linha
Esta é uma linha
*/

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

Primeiro, podemos concatenar duas strings usando o operador .:

$primeiroNome = 'Flavio';
$sobrenome = 'Copes';
$nomeCompleto = $primeiroNome . ' ' . $sobrenome;
Podemos verificar o comprimento de uma string usando a função strlen():
$nome = 'Flavio';
strlen($nome); // 6
Essa é a primeira vez que usamos uma função.

Uma função é composta por um identificador (nesse caso é o strlen) seguido de

parênteses. Dentro desses parênteses, passamos um ou mais argumentos para a
função. Nesse exemplo, temos um argumento.

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

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

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

$nome = 'Flavio';
substr($nome, 3); // "vio" - comece na posição 3 e pegue todo o resto
substr($nome, 2, 2); // "av" - comece na posição 2 e pegue 2 caracteres
Podemos substituir uma parte de uma string usando str_replace():
$nome = 'Flavio';
str_replace('avio', 'or', $nome); // "Flor"
Claro que podemos também atribuir o resultado a uma nova variável:
$nome = 'Flavio';
$itemObservado = str_replace('avio', 'or', $nome); // "Flor"
Isso é só o começo. Há muito mais funções internas que você pode usar para
trabalhar com strings.

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

 trim(): remove o espaço em branco no início e no final de uma string

 strtoupper(): transforma uma string em maiúscula
 strtolower(): transforma uma string em minúscula
 ucfirst(): transforma o primeiro caractere maiúsculo
 strpos(): encontra a primeira ocorrência de uma substring na string
 explode(): divide uma string em um array
 implode(): junta os elementos de um array em uma string
Você pode encontrar a lista completa aqui.
Como usar funções internas para números no PHP

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

Agora vamos fazer uma lista de funções que usamos com números:
 round(): arredonda um número decimal, para cima/para baixo, dependendo de
o valor ser maior ou menor que 0,5
 ceil(): arredonda um número decimal para cima
 floor(): arredonda um número decimal para baixo
 rand(): gera um número inteiro aleatório
 min(): encontra o número mais baixo nos números passados como argumentos
 max(): encontra o número mais alto nos números passados como argumentos
 is_nan(): retorna true se o número não for um número

Há inúmeras funções diferentes para todos os tipos de operações matemáticas, como

seno, cosseno, tangentes, logaritmos e assim por diante.

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

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);
/*

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?