# Como começar a usar o PHP - um tutorial para iniciantes
[PHP](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/o-que-e-php/) é uma das linguagens de programação mais comuns para **programação no lado do servidor**. Com o tempo, ele se tornou parte integrante dos sites contemporâneos e das tecnologias da Internet. No entanto, dominar o PHP pode ser difícil para os novatos. Neste tutorial de PHP, mostraremos os conceitos básicos da popular linguagem de programação e seus mais importantes [operadores](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/operadores-php/), loops e funções.
## O que você precisa ter antes de iniciar o tutorial de PHP
Nosso tutorial é voltado principalmente para iniciantes. No entanto, ter um conhecimento básico de desenvolvimento moderno da Web e HTML pode ser útil. Para acompanhar e reproduzir os exemplos em seu próprio computador, certifique-se de ter preparado o seguinte:
- Servidor da Web, incluindo **Interpretador PHP**
- PHP instalado
- Navegador da Web
- Editor de texto
Como servidor, recomendamos o [ambiente de teste local XAMPP](https://www.apachefriends.org/index.html "Página de download do Apache XAMPP"), que a Apache Friends fornece gratuitamente para os sistemas operacionais Windows, Linux e macOS. **O XAMPP é um servidor de teste puro.** Os desenvolvedores da Web podem usar o software para configurar ambientes de teste para scripts, páginas HTML e folhas de estilo com facilidade. Entretanto, a operação segura do servidor da Web na Internet não é garantida. Instruções detalhadas de instalação podem ser encontradas em nosso Tutorial do XAMPP.
## Qual é a sintaxe do PHP?
Depois de configurar seu servidor da Web local (, por exemplo, usando o XAMPP), é uma boa ideia testar se o PHP foi instalado corretamente e se está pronto para executar scripts. Um *script* é um programa que não é compilado em código binário. Em vez disso, eles são executados por um *interpretador*. Abra seu editor de texto preferido \*\*\*\* e aplique o seguinte script PHP:
```php
```
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/simple-php-code-in-notepad-plus-plus.png) Um editor de texto como o Notepad++ suporta programação com realce de sintaxe. Os scripts PHP seguem uma estrutura específica. A tag PHP de abertura `
```
A tag de abertura `` para encerrar o script. Observe o ponto e vírgula após a declaração. Qualquer texto pode ser usado no lugar de *Hello World!*.
Salve o script como *hello.php* dentro do diretório *htdocs* do seu servidor da Web. Em seguida, acesse o arquivo usando o URL `http://localhost/hello.php` no navegador da Web. Se o código tiver sido transferido com precisão, a janela do navegador deverá exibir a cadeia de caracteres que você usou:
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/hello-php-language-construct-echo.png) A construção de linguagem echo instrui o servidor da Web a emitir a string Hello World! Qualquer texto que você gere com *echo* pode incorporar **tags HTML**, conforme necessário. Essas tags serão interpretadas pelo navegador da Web de acordo com as especificações HTML. Faça experiências com esse conceito usando o seguinte script, por exemplo:
```php
Hello World!
This is my first PHP page.
';
?>
```
Quando chamado no navegador da Web, o **resultado da execução do script** é exibido da seguinte forma.
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/script-execution-result-html-tags-hello-world.png) Se o resultado da execução do script contiver tags HTML, elas serão automaticamente interpretadas pelo navegador da Web. O texto *Hello World!*, que está contido em `` tags, é interpretado pelo navegador da Web como um título principal. Isso é sucedido por uma quebra automática de linha e pelo parágrafo de texto entre as `
` tags.
Dependendo de suas necessidades, você pode usar *echo* com **aspas simples (*’*) ou aspas duplas (*“*)**. Se estiver produzindo apenas texto, a escolha das aspas não importa. Entretanto, essa distinção se torna significativa ao lidar com [variáveis PHP](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/variavel-php/).
### Variáveis
A construção de linguagem *echo* oferece mais do que apenas a exibição de texto. Embora a apresentação de texto já possa ser realizada com eficiência usando HTML. A verdadeira vantagem de usar a construção da linguagem PHP *echo* está em sua capacidade de produzir texto dinamicamente usando variáveis \*\*.
Os usuários de PHP frequentemente encontram variáveis no seguinte formato: `$example`
Cada variável consiste em um **sinal de dólar (*$*) seguido pelo nome da variável**. As variáveis são utilizadas nos scripts PHP para incorporar dados externos às páginas da Web. Elas podem abranger diversos tipos de valores, desde números básicos e cadeias de caracteres até textos completos ou estruturas de documentos HTML. O PHP faz distinção entre sete tipos diferentes de variáveis:
| Tipo de variável |
Description |
| String |
Uma string é uma sequência de caracteres. Ela pode representar uma palavra, uma frase, um trecho de texto ou até mesmo o código HTML inteiro de uma página da Web. |
| Integer |
Um número inteiro é um número inteiro sem casas decimais. Pode ser positivo ou negativo. |
| Float |
Um float é um número de ponto flutuante. Trata-se de um valor numérico com casas decimais. O PHP suporta até 14 dígitos após o ponto decimal. |
| Boolean |
Variáveis booleanas são o resultado de uma operação lógica e conhecem apenas dois valores: *TRUE* (true) and *FALSE* (false). Esse tipo de variável é usado ao trabalhar com condições. |
| Array |
Um array é uma variável que pode conter vários elementos. É um agrupamento de vários dados estruturados de forma semelhante que foram combinados em uma matriz. |
| Objeto |
O tipo de variável *objeto* permite que os programadores definam seus próprios tipos de dados. Ele é usado na programação orientada a objetos. Incluímos *object* variáveis neste tutorial de PHP. |
| NULL |
O valor NULL representa uma variável sem valor. Para variáveis desse tipo, NULL é o único valor possível. |
A centralização de conteúdo é normalmente gerenciada por meio de sistemas de banco de dados. No entanto, os valores das variáveis também podem ser atribuídos diretamente no script. Esse tipo de atribuição usa o seguinte padrão:
```php
$example = "value";
```
O cifrão é sucedido pelo nome da variável (nesse caso *exemplo*). Ele é vinculado pelo sinal de **igual (*=*)** com um valor entre aspas duplas. Os valores de variáveis dos tipos inteiro e float são escritos sem aspas (por exemplo, *$example = 24;*e*$example = 2.7;*).
O PHP oferece flexibilidade ao nomear variáveis. Entretanto, algumas restrições se aplicam:
- Cada variável começa com um cifrão.
- Um nome de variável é qualquer sequência de letras, números e sublinhados (Por exemplo, *$example\_1*).
- Um nome de variável válido sempre começa com uma letra ou um sublinhado (*$example1* ou *$\_example*), nunca com um dígito (wrong: *$1example*).
- O PHP é *sensível a maiúsculas e minúsculas*. A linguagem de script faz distinção entre maiúsculas e minúsculas (*$example ≠ $Example*).
- O nome da variável não deve conter espaços ou quebras de linha (wrong: *$example 1*).
- Strings reservadas pelo PHP para outros propósitos não podem ser usadas como variáveis definidas pelo usuário (por exemplo, *$this*)
Vamos ilustrar isso com um exemplo:
```php
Hello World!
This dynamic web page was created by $author.
";
?>
```
A tag PHP de abertura é seguida pela **definição da variável**. Nesse caso, *$author* recebe o valor *John Doe*. Após a execução do script, cada instância da variável *$author* dentro do script é substituída pelo valor *John Doe* no ambiente do script. Uma representação visual desse processo no navegador da Web é ilustrada no diagrama a seguir:
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/hello-world-html-tags-dynamic-text-creation-johndoe.png) Como resultado da execução do script, a variável $author recebeu o valor John Doe Se a página da Web deveria ser atribuída a Max Mustermann, colega alemão de John Doe, e não a John Doe, você pode corrigir isso alterando a variável *$author* .
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/dynamic-text-creation-hello-world-max-mustermann.png) Para a variável $author, o valor Max Mustermann é usado. Isso é particularmente eficiente se uma variável ocorrer várias vezes em um script. Nesse caso, uma correção só precisaria ser feita em um único ponto. Ou seja, onde o valor da variável é definido.
Isso ilustra a proeza do PHP: O conteúdo pode ser incorporado usando variáveis. Essa característica forma a base do desenvolvimento dinâmico da Web. Diferentemente das páginas estáticas da Web, que existem como páginas HTML pré-renderizadas, as páginas dinâmicas da Web são geradas somente quando a página é acessada. O interpretador PHP recupera elementos distintos da página da Web solicitada de vários bancos de dados por meio de variáveis e os compila em uma página HTML personalizada que se alinha à solicitação específica.
Os benefícios dessa abordagem são evidentes. Quando elementos do site (, por exemplo, na seção de rodapé) , são modificados, não são necessários ajustes manuais em cada subpágina individual. A atualização do registro correspondente **no banco de dados** é suficiente. Como resultado, as revisões são aplicadas automaticamente a todas as páginas da Web que apresentam os dados pertinentes como variáveis. Se uma **variável for definida várias vezes** em um script, a nova definição substituirá a anterior. Um *echo* subsequente sempre gera o valor atual de uma variável.
```php
Hello World!
This dynamic web page was created by $author.
";
$author = "Max Mustermann";
echo " Supported by $author.
";
?>
```
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/dynamic-text-creation-overwriting-variables-jd-mm.png) O valor John Doe é sobrescrito com o valor Max Mustermann No exemplo de código, a variável *$author* foi primeiro atribuída ao valor *John Doe* e depois substituído pelo valor *Max Mustermann*.
Agora vamos ao assunto dos **marcos de citação**. Ao contrário das cadeias de caracteres, as variáveis simples não precisam ser colocadas entre aspas:
```php
```
Exceto quando a variável precisa ser usada em uma cadeia de caracteres. Nesse caso, trabalhe com aspas duplas (*“*). Isso instrui o interpretador do PHP a procurar variáveis na cadeia de caracteres e substituí-las pelos valores correspondentes, conforme necessário. Strings entre aspas simples (*’*) são interpretadas e renderizadas como informações de texto simples, mesmo quando envolvem variáveis.
```php
Hello World!
This dynamic web page was created by $author.
';
?>
```
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/hello-world-dynamic-content-simple-quote-marks.png) Aspas simples resultam em saída de texto simples. As variáveis não são interpretadas. Agora você deve estar se perguntando o que acontece se omitir completamente as aspas. Nesse caso, o PHP aponta para um erro sintático.
### Mensagens de erro e mascaramento
Se **ocorrerem erros sintáticos** , não haverá código PHP válido e o interpretador do PHP emitirá uma mensagem de erro. Isso pode ser esperado, por exemplo, se você usar a instrução *echo* com uma string sem aspas:
```php
```
Na maioria dos casos, as mensagens de erro contêm informações sobre onde ocorreu um erro, fornecendo informações importantes sobre como eliminá-lo.
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-web-browser-parse-error.png) Uma mensagem de erro indica erros sintáticos no código do programa. No exemplo atual, suspeita-se de um erro na linha 2 do código do nosso programa. Foi exatamente nesse ponto que omitimos as aspas.
Os erros sintáticos também ocorrem quando você deseja gerar caracteres como texto que estão associados a uma tarefa específica no PHP. Um exemplo disso são as aspas (*’*). Caracteres como esse só podem ser exibidos como texto no PHP se você indicar ao interpretador que a função inerente do caractere foi neutralizada. No caso das aspas simples, há duas maneiras de fazer isso. Você pode colocar uma string de aspas simples entre aspas duplas ou pode mascarar as aspas com uma barra invertida anterior (*\\*):
```php
```
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-content-backslash-as-marking-symbol.png) Se os caracteres forem mascarados com uma barra invertida, eles serão destituídos de sua função na sintaxe do PHP. A combinação de aspas simples e duplas também é uma abordagem viável:
```php
```
No entanto, não esta ortografia:
```php
```
Os espaços entre as aspas foram inseridos nos exemplos para fins de legibilidade.
### Operadores de concatenação
Para gerar várias variáveis em um script PHP ao mesmo tempo, você pode usar o que aprendeu até agora e fazer o seguinte:
```php
Hello World!
This dynamic web page was created by $author1 and $author2.
";
?>
```
Basta escrever as duas variáveis na string entre aspas duplas junto com o restante do texto a ser gerado. O PHP reconhece automaticamente as variáveis pelo sinal de dólar (*$*) e insere os valores apropriados.
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/text-output-with-two-variables-php.png) As variáveis na string só são aceitas pelo PHP se o script não contiver funções. Entre os programadores, no entanto, esse procedimento é considerado impuro. Há uma regra de programação segundo a qual **variáveis não devem fazer parte da string**. Um motivo para isso é que muitas linguagens de programação exigem essa separação. Mais importante ainda, o PHP também exige que você separe string e variável ao trabalhar com chamadas de função ou variáveis mais complexas. Por isso, é melhor mantê-las separadas também na saída de texto simples, mesmo que isso não seja exatamente necessário nesse caso.
Ao trabalhar com variáveis, você sempre terá de lidar com vários elementos que precisam ser concatenados durante a saída. No PHP, o operador de concatenação \* \*\* \* (*.*) é usado para essa finalidade. Se programado de forma “limpa”, o código do exemplo acima deverá ter a seguinte aparência:
```php
Hello World!
This dynamic web page was created by ' . $author1 . ' and ' . $author2 . '.
';
?>
```
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-concatenation-of-strings-and-vars.png) Operadores de concatenação conectam strings e variáveis Aqui estamos lidando com três strings e duas variáveis que foram concatenadas em uma string.
| String1 |
|
Variable1 |
|
String2 |
|
Variable2 |
|
String3 |
| *’<h1>Hello World!</h1>
<p>Esta página da Web dinâmica foi criada por ’* |
. |
*$author1* |
. |
*’ e ’* |
. |
*$author2* |
. |
*’.</p>’* |
É importante mencionar que um operador de concatenação mescla cadeias de caracteres ou variáveis sem introduzir espaços. Se um espaço for pretendido, ele precisa ser explicitamente incluído entre aspas na cadeia de caracteres, conforme demonstrado no exemplo.
Os programadores empregam o operador de concatenação não apenas para combinar cadeias de caracteres e variáveis para saída textual, mas também para estender variáveis. O exemplo a seguir ilustra como isso é feito:
```php
```
Para estender o valor de uma variável, defina-a novamente, mas coloque o operador de concatenação *dot (.)* antes do sinal de igual. Essa é a notação comum de **shorthand** para *$example = $example . ‘world’*.
O PHP anexará o novo valor ao valor definido anteriormente. Se você quiser um espaço entre os dois valores, escreva-o no final da primeira cadeia de caracteres, como no exemplo.
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-extending-string-variable-via-operator.png) A string Hello foi estendida para Hello World. ### Incorporar PHP em HTML
Em princípio, o interpretador do PHP só se interessa pelo código que está entre uma tag PHP de abertura e uma de fechamento:
``
O interpretador ignora todas as seções restantes do documento e as encaminha para o servidor da Web sem alterá-las. Como resultado, o código PHP pode ser incorporado sem problemas **em documentos HTML** conforme necessário, por exemplo, ao criar modelos para sistemas de gerenciamento de conteúdo. É fundamental salvar os documentos HTML que contêm código PHP com a extensão de arquivo PHP. Caso contrário, o documento será apresentado diretamente ao navegador da Web sem passar pelo pré-processamento do interpretador PHP. Esse cenário faria com que o código ficasse visível como texto no site.
Você pode pensar no interpretador PHP como o colega preguiçoso do servidor da Web, que só trabalha quando é explicitamente solicitado a fazê-lo, por exemplo, por uma tag PHP de abertura.
Para combinar **HTML e PHP**, escreva sua página HTML na estrutura clássica de documentos e salve-a com a extensão de arquivo *.php*:
```html
My first PHP page
Hello World
What is the current time and date?
hash_6332162d018f3b0469533e7a8b85d3be2111e277
```
Agora, adicione um script PHP ao seu documento HTML. Certifique-se de que todo o código esteja dentro das tags PHP.
```html
My first PHP page
Hello World
What is the current time and date?
Your current time and date is:
.
hash_6332162d018f3b0469533e7a8b85d3be2111e277
```
Nesse caso, mesclamos a construção de linguagem *echo* com a [função PHP date()](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/php-date/) para gerar a data e a hora atuais como texto do lado do servidor. O parâmetro da função designa o formato preferencial, indicado como uma cadeia de caracteres:
*d.m.Y H:i:s = dia.mês.ano hora:minuto:segundo*.
Quando um navegador da Web solicita esse arquivo, o interpretador PHP executa inicialmente o script, incorporando **a hora atual como texto** no documento HTML. Em seguida, o servidor da Web transmite esse documento, que é exibido no navegador como uma página da Web.
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-integration-in-html-date-and-time.png) O documento HTML contém um script PHP integrado que exibe a data atual, incluindo a hora. ### Função de comentário PHP
Semelhante ao código HTML, você também pode deixar comentários em seu código PHP. **Os comentários no código-fonte são desconsiderados pelo interpretador do PHP, desde que obedeçam às regras de sintaxe.** O PHP oferece três métodos distintos para comentários.
Para designar uma linha inteira como um comentário e, assim, excluí-la da interpretação, você pode utilizar a **hashtag (*\#*)** ou duas barras consecutivas \*\* (*//*)\*\*. Ambas as opções são usadas no exemplo de código a seguir:
```php
Hello World!
This is my first PHP page.
';
//This is also a single-line comment!
?>
```
O editor de texto Notepad++ destaca os comentários em verde. Diferentemente dos comentários em HTML, as seções de texto rotuladas como comentários no ambiente de script não chegam ao navegador da Web. Essa distinção ocorre porque o interpretador PHP já as desconsidera durante a execução do script.
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-single-line-comment.png) As linhas marcadas como comentários não são visíveis na saída. Além disso, você pode inserir comentários que se estendem **por várias linhas**. Para fazer isso, marque o início de uma seção de comentários com uma barra seguida de um asterisco (*/\**) e o final com um asterisco seguido de uma barra (*\*/*).
```php
Hello World!
This is my first PHP page.
';
?>
```
Esses comentários não são analisados e não são exibidos no site.
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-multi-line-comment.png) O comentário de várias linhas não é visível na saída. Os programadores usam comentários para estruturar o código-fonte de seus scripts, deixar notas para edição posterior edição posterior ou adicionar informações internas à compilação, como o autor ou a data. Os comentários são opcionais e devem ser **utilizados com moderação** para garantir a boa legibilidade do código-fonte.
### Cálculo com variáveis
Em nosso tutorial de PHP, você já encontrou variáveis, que contêm principalmente valores de cadeia de caracteres. Agora, vamos nos aprofundar nas variáveis que representam **inteiros** ou **floats**. Quando as variáveis armazenam valores numéricos, o PHP permite a realização de cálculos com elas. Vamos começar com a adição de dois números inteiros:
```php
```
Primeiro, atribuímos os números inteiros 237 e 148 às variáveis $number1 e $number2 e, em seguida, definimos a variável *$result*. Isso é usado para armazenar a soma das variáveis $number1 e $number2. Para essa operação, usamos o operador aritmético ***+***(plus). Por fim, emitimos a soma como texto usando a construção de linguagem\* echo\* . Observe que não é necessário usar aspas ao atribuir valores numéricos a variáveis.
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-script-simple-integer-addition.png) O resultado da adição é exibido como texto no navegador da Web. O exemplo de código a seguir mostra uma **seleção de cálculos matemáticos** que podem ser executados no lado do servidor com o PHP. Os operadores PHP usados correspondem, em sua maior parte, a símbolos matemáticos padrão.
| Operador aritmético |
Operation |
Result |
| *$number1 + $number2* |
Addition |
Soma de $number1 e $number2 |
| *$number1 - $number2* |
Subtração |
Diferença de $número1 e $número2 |
| *$number1 \*$number2* |
Multiplicação |
Produto de $número1 e $número2 |
| *$number1 / $number2* |
Divisão |
Quociente de $número1 e $número2 |
| $número1 \*\*$número2 |
Power |
$number2-th power of $number1 |
```php
```
```php
";
echo "Result of subtraction: " . $subtraction . "
";
echo "Result of multiplication: " . $multiplication . "
";
echo "Result of division: " . $division . "
";
echo "10 to the 5th power (10^5): " . $power . "
";
echo "root of 81: " . sqrt(81) . "
";
?>
```
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-script-various-arithmetic-operations.png) Arithmetic operations at a glance Para cálculos complexos, várias operações aritméticas podem ser combinadas em um único script:
```php
```
O interpretador PHP determina os valores das variáveis e faz os cálculos:
`2 *10 + 5* 5 - 3 * √81 = 20 + 25 - 27 = 18`
A função *sqrt()* calcula a raiz quadrada do parâmetro entre colchetes. O clássico **ordem de classificação de operadores** da matemática se aplica: ponto antes do traço. A instrução *echo* produz o resultado como uma string para o navegador da Web.
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-script-complex-calculation-two-variables.png) O PHP segue a regra do ponto antes da barra. O PHP também avalia **termos entre colchetes** primeiro. Desta vez, trabalharemos com números de ponto flutuante:
```php
```
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-float-operation-with-brackets.png) Cálculo PHP com o resultado 94,5 Como todas as linguagens de programação comuns, o PHP permite operadores para **incrementar ou decrementar** valores numéricos pelo valor 1. É feita uma distinção entre o operador de pré-incremento, o operador de pré-decremento, o operador de pós-incremento e o operador de pós-decremento.
| Operation |
Operator |
Result |
| Pre-increment |
*++$number* |
O operador *++++* incrementa o valor da variável *$number*. O valor é incrementado em 1. O resultado é retornado como o novo valor de *$number*. |
| Pre-decrement |
*–$number* |
O operador *–* diminui o valor da variável *$number*. Isso diminui o valor em 1. O resultado é retornado como o novo valor de *$number*. |
| Post-increment |
*$number++* |
O valor atual de *$number* é primeiro retornado e, em seguida, incrementado em 1. |
| Post-decrement |
*$number–* |
O valor atual de *$number* é primeiro retornado e depois diminuído pelo valor 1. |
Primeiro, ilustraremos como executar operações aritméticas com operadores de incremento e decremento fornecendo um exemplo com pré-incremento. O script a seguir incrementa o valor da variável *$number* em 1, armazena o novo valor na variável *$result* e, em seguida, gera seu valor como uma cadeia de caracteres:
```php
```
Se você aumentar o valor 0 por 1, obterá o resultado 1.
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-operations-increment-plus-plus.png) O operador ++ incrementa 0 pelo valor 1. Para calcular o pré-decremento da variável *$number*, usamos os mesmos scripts, mas trocamos o operador de pré-incremento (*++*) por um operador de pré-decremento (*–*):
```php
```
Aqui, diminuímos o valor 0 da variável *$number* e obtemos o resultado -1.
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-operations-decrement-minus-minus.png) O operador -- decrementa o número 0 pelo valor 1 Um aumento antes e depois da saída (pre- vs. post-…) de um valor pode ser demonstrado com o seguinte script:
```php
result: ' . ++$x;
echo '
x has the value ' . $x;
echo 'result: ' . $x++;
echo '
x has the value ' . $x, '
';
?>
```
Em ambos os casos, obtemos o mesmo resultado. Com o pré-incremento, o valor de x é aumentado antes da saída na linha 3, enquanto que com o pós-incremento, ele é incrementado após a saída na linha 5.
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-script-pre-vs-post.png) Pre- and post-incrementations in comparison ## Como usar as superglobais $\_GET e $\_POST
Agora você está familiarizado com os fundamentos do PHP. Você pode trabalhar com variáveis, concatenar e realizar cálculos. A seguir, ilustraremos o papel fundamental das variáveis no scripting.
Uma função importante das linguagens de script é sua capacidade de avaliar a entrada do usuário e transferir os valores para outro script. O PHP depende das **superglobais $\_GET e $\_POST**-predefinidas**variáveis de sistema**disponíveis em todos os escopos-para a transferência de dados. Como arrays associativos (campos de dados),*$\_GET e $\_POST* armazenam um conjunto de variáveis na forma de strings em uma variável.
[As matrizes do PHP](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/php-array/) podem ser comparadas a um armário com várias gavetas. Cada uma dessas gavetas oferece um espaço para armazenar dados. Para manter a clareza sobre o conteúdo de cada gaveta, você as marca com um nome de variável. Dependendo do tipo de array, esse identificador pode ser um **índice ou uma chave**. Nas matrizes indexadas, você atribui um índice numérico a cada gaveta, enquanto nas matrizes associativas, você rotula as gavetas usando uma chave baseada em cadeia de caracteres.
As superglobais *$\_GET e $\_POST* abrangem uma coleção de variáveis representadas como chaves, permitindo o acesso aos valores correspondentes. Vamos nos aprofundar mais nesse assunto quando explorarmos as *$\_GET e $\_POST* superglobais em profundidade.
### Transferência de dados via $\_GET
A superglobal *$\_GET* representa uma matriz de variáveis que são passadas para um script PHP usando um URL.
Se você passa algum tempo em **blogs** ou em**lojas on-line**e**fóruns da Internet**, deve ter notado alguns URLs estranhos. Normalmente, eles são estruturados de acordo com o seguinte esquema:
`http://hostname/ordner/filename.php?variablenname=variablevalue`
Para um blog, o esquema pode ser parecido com este:
`http://www.example-blog.com/index.php?id=1`
A decomposição desse URL é relativamente simples. Em um servidor da Web que tenha o domínio *example-blog.com* , há um arquivo chamado *index.php*. Esse arquivo é usado para criar páginas dinâmicas da Web e normalmente contém código HTML e PHP, além de referências a arquivos de modelos externos e folhas de estilo - essencialmente, todos os componentes necessários para a exibição da página da Web.
A adição de *id=1* em um URL é uma maneira comum de saber se uma página da Web é dinâmica. Você o encontrará localizado após o ponto de interrogação (*?*) em um URL. Esse componente é conhecido como uma string de consulta HTTP e contém uma variável (*id*) e um valor (*1*), que são vinculados por um sinal de igual (*=*). **Parâmetros de URL** dessa natureza são empregados para gerar páginas da Web dinâmicas, recuperar o conteúdo do banco de dados e acionar modelos apropriados.
Os sites dinâmicos permitem a **separação do conteúdo e da apresentação**. Embora o *index.php* contenha as informações sobre a estrutura de um site, ele ainda precisa ser preenchido com conteúdo. Esses conteúdos geralmente são armazenados em um banco de dados e podem ser acessados usando parâmetros na string de consulta HTTP. No exemplo, a URL do *index.php* passa o parâmetro *id=1*. Isso especifica qual conteúdo deve ser lido do banco de dados e carregado em *index.php*. No contexto de um blog, pode ser o ID de um artigo; em um fórum, uma determinada postagem. Em uma loja on-line, pode ser um produto específico.
Se um URL contiver mais de um parâmetro, eles serão conectados com um **ampersand (&)**.
`www.example-blog.com/index.php?page=article&id=1`
A seguir, mostraremos como usar *$\_GET*. Para o exemplo, não é necessário usar um banco de dados. No script a seguir, usamos a superglobal *$\_GET* para ler os valores das variáveis *firstname*e*lastname* de uma string de consulta HTTP e gravá-los nas variáveis PHP $variable1 e $variable2:
```php
```
O script é chamado pelo seguinte URL:
*localhost/hello.php?firstname=John&lastname=Doe*.
Os parâmetros *firstname=John*e*lastname=Doe* foram passados. A saída dos valores é feita exatamente como antes, usando a construção de linguagem *echo*.
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-data-transmission-via-get.png) The URL parameters pass the variable value pairs firstname=John and lastname=Doe to the PHP script. Uma transferência de dados por meio de *$\_GET* inevitavelmente faz com que os **dados transferidos fiquem visíveis** na linha de endereço. Isso significa que os parâmetros que foram passados podem ser rastreados. A vantagem é que as variáveis podem ser armazenadas em hiperlinks. Além disso, os usuários têm a opção de salvar URLs incluindo a string de consulta HTTP como marcadores no navegador.
No entanto, o fato de os parâmetros GET serem listados em texto simples no URL torna esse método incompatível com a transferência de dados confidenciais, como os dados gerados por formulários on-line. Além disso, a quantidade de dados que pode ser passada usando *$\_GET* é limitada pelo comprimento máximo dos URLs.
Você pode contornar essas restrições com o método HTTP POST. Os dados que são passados com esse método podem ser encontrados na seção *$\_POST* superglobal.
### Transferência de dados via $\_POST
Enquanto no método GET os dados são passados como um parâmetro de URL, com *$\_POST*, a transferência de dados ocorre no corpo de uma solicitação HTTP. Isso possibilita até mesmo a passagem de grandes quantidades de dados de um script para outro.
Um campo de aplicação central do método HTTP POST é a **transferência de dados de formulários HTML**. Demonstraremos isso usando o exemplo de uma assinatura de boletim informativo.
Para fazer isso, crie um novo arquivo PHP com o nome *page1.php* e copie o seguinte bloco de código:
```php
```
O elemento HTML `
```
A estrutura corresponde a um formulário criado anteriormente. Desta vez, no entanto, um campo de entrada é suficiente: a consulta de senha. Como antes, a entrada do usuário é passada para o script *page2.php* .
Podemos adaptar isso usando o código a seguir para que a entrada de senha **seja comparada com uma senha armazenada**:
```php
```
O código pode ser explicado da seguinte forma: Inicialmente, atribuímos um valor à variável *$password* na linha 2, que recuperamos usando o método HTTP POST. Em seguida, definimos a seguinte estrutura de controle: O *if* construct na linha 3 deve verificar se o valor da variável *$password* corresponde à string *qwertz123*. Se esse for o caso, a cadeia de caracteres *A senha estava correta* é emitida. Se *if* retorna o resultado *FALSE*, *else* é usado na linha 7 e a string *The password was incorrect* é emitida.
Agora chamamos o script *page1.php* por meio do URL `http://localhost/page1.php`.
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-password-entry-page-html.png) O formulário HTML solicita que você digite uma senha. O navegador apresenta a visualização da Web do nosso formulário HTML de solicitação de senha. Digitamos a senha *quertz123* definida no script *page2.php* e, em seguida, clique no botão **Submit** .
[](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-password-entry-correct.png) O script confirma que a senha inserida está correta. O navegador da Web nos redireciona automaticamente para *page2.php* enquanto a estrutura de controle *if* compara nossa entrada com a senha armazenada. Ela chega ao resultado “*qwertz123 == qwertz123* is *TRUE*” e, em seguida, gera a string *The password was correct*.
Teste você mesmo para ver o que acontece quando você digita uma senha diferente no campo de entrada.
### Operadores lógicos
As condições que você define usando operadores de comparação na *expressão* do *se* construção pode ser combinada com outras condições na mesma *expressão* se necessário. O PHP conta com os operadores lógicos **AND**and**OR**.
| Close Bond |
Weak Bond |
Description |
| *&&* |
*AND* |
Ambas as condições associadas ao operador devem ser *TRUE*. |
| *||* |
*OR* |
Apenas uma das duas condições associadas ao operador deve ser *TRUE*. |
Para combinar condições, você pode usar **operadores lógicos de limite fechado e de limite fraco** no PHP. No uso prático, o emprego de qualquer uma das duas grafias isoladamente não produzirá nenhuma distinção perceptível. Se você combinar as duas grafias, verá que *OR* e *||* ligam-se mais estreitamente do que *AND* e OR. Além disso, *AND* and && se ligam mais fortemente do que *OR* and *||*. Isso é comparável à classificação de operadores conhecida dos operadores matemáticos (e.g., ponto antes do traço: *\**liga-se mais estreitamente do que*+*).
A **consulta de senha** oferece um exemplo prático. Normalmente, as credenciais de login incluem uma senha secreta e um nome de usuário. O login só será bem-sucedido se ambas as entradas corresponderem aos dados armazenados no sistema.
Agora, abriremos novamente nosso formulário de consulta de senha em *Page1.php* e adicionaremos um campo de entrada para o nome de usuário:
```php