Os operadores em PHP indicam o que o interpretador deve fazer com o valor informado. Pode ser uma soma, uma comparação, um incremento e assim por diante. É muito importante que você entenda este conceito do PHP, já que isso vai ajudar no seu desenvolvimento.

Operadores bit-a-bit em PHP (também conhecidos como operadores bitwise ou binários) trabalham em um nível de abstração bem mais baixo, diretamente com a representação binária do valor em questão. Eles podem ser utilizados para realizar comparações binárias, inversões de bits do operando, deslocar bits para a direita ou esquerda, e assim por diante.

A tabela abaixo mostra os operadores bit-a-bit disponíveis no PHP:

Exemplo Nome Resultado
$a & $b E Os bits que estão ativos tanto em $a quanto em $b são ativados.
$a | $b OU Os bits que estão ativos em $a ou em $b são ativados.
$a ^ $b XOR Os bits que estão ativos em $a ou em $b, mas não em ambos, são ativados.
~ $a NÃO Os bits que estão ativos em $a não são ativados, e vice-versa.
$a << $b Deslocamento à esquerda Desloca os bits de $a $b passos para a esquerda (cada passo significa "multiplica por dois")
$a >> $b Deslocamento à direita Desloca os bits de $a $b passos para a direita (cada passo significa "divide por dois")

Esta tabela pode ser encontrada no próprio manual do PHP.

Vamos ver alguns exemplos abaixo.

Operador Bit-a-Bit & (AND – E)

O operador bit-a-bit & (and ou e) compara dois valores utilizando sua representação binária e retorna um novo valor. Nesse caso, o interpretador do PHP vai comparar cada bit; quando os bits forem iguais a 1, 1 é retornado; quando ambos os valores forem 0, 0 é retornado; se os valores forem diferentes, 0 é também retornado.

Veja o exemplo abaixo:

<?php
// 00001010
$a = 10;
// 01101001
$b = 105;

$c = $a & $b;
#   01101001
# & 00001010
# = 00001000

// Exibe 8 Na tela
// 00001000
echo $c;
?>

Operador Bit-a-Bit | (OR – OU)

O operador bit-a-bit | (or / ou) comparara cada um dos bits do valor e retorna um novo valor. A comparação é feita da seguinte maneira:

  • Se qualquer um dos bits for igual a 1, 1 é retornado;
  • Se ambos os bits forem 0, 0 é retornado.

Veja o exemplo:

<?php
// 00001010
$a = 10;
// 01101001
$b = 105;

$c = $a | $b;
#   01101001
# & 00001010
# = 01101011

// Exibe 107 Na tela
// 01101011
echo $c;
?>

Operador Bit-a-Bit ^ (XOR)

O operador bit-a-bit ^ (xor) comparara cada um dos bits do valor e retorna um novo valor. A comparação é feita da seguinte maneira:

  • Se os bits forem diferentes, 1 é retornado;
  • Se os bits forem iguais, 0 é retornado.

Veja o exemplo:

<?php
// 00001010
$a = 10;
// 01101001
$b = 105;

$c = $a ^ $b;
#   01101001
# & 00001010
# = 01100011

// Exibe 99 Na tela
// 01100011
echo $c;
?>

Operador Bit-a-Bit ~ (Not ou Não)

O operador ~ (não) inverte a posição dos bits ativos para não ativo em um único valor. Veja um exemplo:

<?php
// 00000000000000000000000000001010
$a = 10;

// 11111111111111111111111111110101
$a = ~$a;

// Exibe -11 na tela
echo $a;
?>

Perceba no trecho de código acima que onde tínhamos 0, agora temos 1, e onde tínhamos 1, agora temos 0.

Operador Bit-a-Bit >> (right shift)

O operador bit-a-bit >> (right shift) desloca bits para a direita. Cada deslocamento para a direita, é o mesmo que dividir o valor por 2.

Veja no exemplo abaixo:

<?php
// 1010
$a = 10;

// Desloca 1 bit para a direita
$a = $a >> 1; // 101

// Exibe 5 na tela
echo $a;
?>

Operador Bit-a-Bit >> (left shift)

O operador bit-a-bit << (left shift) desloca bits para a esquerda. Cada deslocamento para a esquerda, é o mesmo que multiplicar o valor por 2.

Veja no exemplo abaixo:

<?php
// 1010
$a = 10;

// Desloca 1 bit para a esquerda
$a = $a << 1; // 10100

// Exibe 20 na tela
echo $a;
?>

Concluindo

Como você pode perceber, estou mostrando os valores binários para que você entenda o que realmente acontecer por baixo dos panos, porém, se você utilizar o recurso indicado nos trechos de código acima, não verá nenhum valor binário, mas sim, números decimais comuns.

Para que você possa ver a representação binária de um valor numérico em PHP utilize a função decbin.

Exemplo:

<?php
$a = 10;

// Exibe 1010 na tela
echo decbin($a);
?>

Aulas anteriores

Veja todas as aulas, e mais, na categoria Curso de PHP do Tutsup.

Em PHP você pode utilizar o acento grave (`) como operador de execução de comandos do servidor, ou seja, o interpretador do PHP irá tentar executar qualquer coisa que estiver entre ` e ` para retornar o output do comando para a variável que você estiver configurando.

Por exemplo:

<?php
// Windows
$output = `ipconfig`;

// Abre a tag HTML pre
echo '<pre>';

// Mostra o resultado na tela
echo $output;

// Fecha a tag HTML pre
echo '</pre>';
?>

Se você estiver no Windows, verá algo como:

Configuração de IP do Windows

Adaptador Ethernet CABO:

   Sufixo DNS específico de conexão. . . . . . : domínio
   Endereço IPv6 de link local . . . . . . . . : O Endereço IPv6 aqui
   Endereço IPv4. . . . . . . .  . . . . . . . : O Endereço IP aqui
   Máscara de Sub-rede . . . . . . . . . . . . : 255.255.255.0
   Gateway Padrão. . . . . . . . . . . . . . . : O gateway aqui

Adaptador de túnel domínio:

   Estado da mídia. . . . . . . . . . . . . .  : mídia desconectada
   Sufixo DNS específico de conexão. . . . . . : domínio

Adaptador de túnel Teredo Tunneling Pseudo-Interface:

   Sufixo DNS específico de conexão. . . . . . : 
   Endereço IPv6 . . . . . . . . . . . . . . . : O Endereço aqui
   Endereço IPv6 de link local . . . . . . . . : O Endereço aqui
   Gateway Padrão. . . . . . . . . . . . . . . : ::

Isso é o que o comando retornaria para o prompt de comando quando executado.

Se você estiver no Linux, poderá executar o seguinte:

<?php
// Linux
$output = `ls -al`;

// Abre a tag HTML pre
echo '<pre>';

// Mostra o resultado na tela
echo $output;

// Fecha a tag HTML pre
echo '</pre>';
?>

E terá um output de listagem de pastas do sistema.

Basicamente, basta colocar o comando que você deseja entre dois acentos graves:

$comando = `ipconfig /all`;

Isto seria o mesmo que a função shell_exec() do PHP retornaria.

Aulas anteriores

Caso queira acessar os links para aulas anteriores:

Veja todas as aulas, e mais, na categoria Curso de PHP do Tutsup.

Os operadores de incremento em PHP servem para somar ou subtrair em um (+1 ou -1) qualquer valor do tipo numérico ou string.

Por exemplo:

<?php
// $a valor 20
$a = 20;
// Agora $a vale 21
$a++;

// Mostra 21 na tela
echo $a;
?>

O PHP suporta operadores de pré e pós-incremento e decremento, isso indica que seu interpretador poderá incrementar ou decrementar o valor e depois executar uma ação, ou executar uma ação e só depois incrementar ou decrementar o valor. Para fazer essa inversão, basta colocar dois sinais de mais (++) ou de menos (–) para incrementar ou decrementar o valor, antes ou depois da variável. Veja exemplos de pré e pós-incremento.

Pós-incremento

<?php
// Pós-incremento
$a = 20;

echo $a++; // Exibe 20
echo $a; // Exibe 21
?>

Pré-incremento

<?php
// Pré-incremento
$a = 20;

echo ++$a; // Exibe 21
echo $a; // Exibe 21
?>

Pós-decremento

<?php
// Pós-decremento
$a = 20;

echo $a--; // Exibe 20
echo $a; // Exibe 19
?>

Pré-decremento

<?php
// Pós-decremento
$a = 20;

echo --$a; // Exibe 19
echo $a; // Exibe 19
?>

Você também pode incrementar letras de A a Z, veja:

<?php
$a = "a";
echo $a++; // a
echo $a++; // b
echo $a++; // c
echo $a++; // d
?>

Isso pode ser bem útil em alguns casos.

Por exemplo, você pode utilizar um laço for (ainda vamos falar sobre isso ao longo desse curso) para incrementar os valores de A a Z. Veja o exemplo:

<?php
$a = 'a';

// Resultado abcdefghijklmnopqrstuvwxyz
for ( $i = 0; $i < 26; $i++ ) {
	echo $a++;
}
?>

No trecho acima, utilizei o comando for para incrementar a variável $a (valor 'a') 26 vezes, isso irá retornar valores de A a Z e exibir na tela.

Tabela de operadores de Incremento e Decremento em PHP

A tabela abaixo está disponível no site do PHP:

Operadores de Incremento/Decremento
Exemplo Nome Efeito
++$a Pré-incremento Incrementa $a em um, e então retorna $a.
$a++ Pós-incremento Retorna $a, e então incrementa $a em um.
–$a Pré-decremento Decrementa $a em um, e então retorna $a.
$a– Pós-decremento Retorna $a, e então decrementa $a em um.

Que, basicamente, é o que eu expliquei anteriormente.

Aulas anteriores

Caso queira acessar os links para aulas anteriores:

Veja todas as aulas, e mais, na categoria Curso de PHP do Tutsup.

Operadores lógicos em PHP servem para comparar expressões que podem, ou não, retornar valores verdadeiros (true) ou falsos (false). Normalmente você precisa de duas expressões (ou mais) para ter uma comparação lógica.

Um exemplo disso seria uma comparação na vida real, veja a frase:

Se o Brasil ganhar e fizer sol hoje, vou nadar.

Neste caso temos duas comparações na frase acima, "Se o Brasil ganhar" e "Se fizer sol". Neste caso, uma comparação lógica com o operador "E" (&& ou and) indicaria ao PHP que, se as duas expressões retornarem um valor verdadeiro (o Brasil ganhou e faz sol), a ação indicada deverá ser executada.

Nota: Você sempre vai utilizar estruturas de controle para verificar expressões.

Veja o exemplo acima no código PHP:

<?php
if ( $brasil == 'ganhar' && $sol === true ) {
	echo 'Vou nadar.';
}
?>

Perceba acima que estou utilizando duas comparações (lembre-se dos operadores de comparação):

  • Se (if) $brasil é igual (==) a ganhar;
  • e (&&) – Este é um operador lógico;
  • Se (if) $sol é idêntico (===) a verdadeiro (true);

Ambas estão ligadas pelo operador lógico && (significa o mesmo que "e" em português), isso indica que as duas expressões devem retornar true (verdadeiro) para aparecer "Vou nadar" na tela do usuário.

Existem vários operadores lógicos em PHP, veja na tabela a seguir.

Tabela de operadores lógicos em PHP

Esta tabela está disponível no próprio site do PHP.

Operadores Lógicos
Exemplo Nome Resultado
$a and $b E (and) Verdadeiro (TRUE) se tanto $a quanto $b são verdadeiros.
$a or $b OU (or) Verdadeiro se $a ou $b são verdadeiros.
$a xor $b XOR (xor) Verdadeiro se $a ou $b são verdadeiros, mas não ambos.
! $a NÃO (!) Verdadeiro se $a não é verdadeiro.
$a && $b E (&&) Verdadeiro se tanto $a quanto $b são verdadeiros.
$a || $b OU (||) Verdadeiro se $a ou $b são verdadeiros.

Na tabela acima você pode ver que existem dois "E" e "OU", são eles:

  • E = and ou &&
  • Ou = or ou ||

Eles fazem a mesma coisa, porém, && e || têm maior precedência sobre and e or.

Você também pode perceber que existe um operador de negação – o exclamação – que funciona um pouco diferente dos outros operadores. Este operador não precisa de duas (ou mais expressões), você pode verificar uma expressão de negação com apenas uma expressão.

Por exemplo: Suponhamos que eu queira verificar se uma variável não existe.

<?php
if ( ! isset( $variavel ) ) {
	echo 'Variável não existe.';
}
?>

Perceba que no trecho acima, o exclamação (!) muda a expressão para "Não", ou seja, "Se a variável NÃO está setada, mostra isto na tela".

Nota: Para verificar se uma variável existe, você pode utilizar a função isset do PHP.

Exemplos de operadores lógicos em PHP

Veja abaixo alguns exemplos que podem lhe ajudar a entender melhor:

<?php
// Verifica se $a e (&&) $b são iguais a 1
if ( $a == 1 && $b == 1 ) {
	echo 'OK';
}

// Verifica se $a OU (||) $b são iguais a 1
if ( $a == 1 || $b == 1 ) {
	echo 'OK';
}
?>

Nos dois casos acima estamos avaliando a mesma expressão; $a e $b iguais a 1. No primeiro caso, as duas expressões devem retornar true (verdadeiro), ou seja, $a E $b devem ser iguais a 1 para executar a ação. No segundo, $a OU $b precisam ter o valor igual a 1, se qualquer um dos dois tiver este valor, a ação será executada.

Aulas anteriores

Caso queira acessar os links para aulas anteriores:

Veja todas as aulas, e mais, na categoria Curso de PHP do Tutsup.

Em PHP você pode utilizar o arroba (@) como operador de controle de erros, basta adicioná-lo antes de qualquer expressão que o erro não será exibido.

Para testar, crie um arquivo PHP e tente exibir o comando abaixo:

<?php
echo $variavel_qualquer;
?>

Provavelmente você deverá visualizar um erro parecido com o trecho abaixo:

Notice: Undefined variable: variavel_qualquer in D:HD AntigoProgramasEasyPHP-DevServer-14.1VC9datalocalwebCursosphpaula_10index.php on line 2

O que é um erro indicando o arquivo (index.php) e a linha de código onde ele ocorreu (line 2).

Se você não quiser que esse erro apareça, basta adicionar um arroba (@) antes do nome da variável (ou de qualquer expressão):

<?php
echo @$variavel_qualquer;
?>

Agora, nada será exibido na tela, nem erro e nem o valor da variável, porque ela não existe (era isso que o erro estava descrevendo).

Se o recurso track_errors estiver habilitado no arquivo php.ini (o arquivo de configuração do PHP):

track_errors = On

Ou no trecho de código no início do arquivo PHP:

ini_set('track_errors', 1);

Qualquer mensagem de erro gerada pela expressão será gravada na variável global $php_errormsg.

Por exemplo:

<?php
// Variável que não existe
echo @$variavel_qualquer;

// Exibir o erro se existir
if ( isset( $php_errormsg ) && !empty( $php_errormsg ) ) {
	echo $php_errormsg;
}
?>

No trecho de código acima, utilizei uma estrutura de controle if para verificar se a variável $php_errormsg está setada (isset) e (&&) se ela não está vazia (!empty).

Esta variável ($php_errormsg) será sobrescrita a cada erro gerado, por isso, verifique-a constantemente no seu script se quiser usá-la.

Por que não utilizar este recurso?

Nunca utilize este recurso se não for estritamente necessário pelo seguinte:

  • Se seu código tem erros, ele foi mal escrito;
  • Você não vai conseguir saber onde está o erro, caso precise.

Portanto, evite o @ ao máximo.

Aulas anteriores

Caso queira acessar os links para aulas anteriores:

Veja todas as aulas, e mais, na categoria Curso de PHP do Tutsup.

Operadores de comparação em PHP, como o próprio nome já diz, servem para comparar valores e realizar determinadas ações de acordo com a resposta. Você pode comparar se um valor é maior ou menor que o outro, se são iguais, se são iguais e do mesmo tipo, e assim por diante.

Eles são muito úteis no seu código, já que podem determinar se alguma ação deverá ser tomada ou não. Um bom exemplo disso seria um sistema de login, onde você deve saber se o usuário está (ou não) logado quando ele tentar acessar sua página de atualização de perfil, porém, as possibilidades de cenários aqui são infinitas.

Operadores de comparação em PHP

A tabela abaixo mostra os operadores de comparação suportados pelo PHP (está presente no próprio site do PHP).

ExemploNomeResultado
$a == $bIgual (==)Verdadeiro (TRUE) se $a é igual a $b.
$a === $bIdêntico (===)Verdadeiro (TRUE) se $a é igual a $b, e eles são do mesmo tipo.
$a != $bDiferente (!=)Verdadeiro se $a não é igual a $b.
$a <> $bDiferente (<>)Verdadeiro se $a não é igual a $b.
$a !== $bNão idêntico (!==)Verdadeiro de $a não é igual a $b, ou eles não são do mesmo tipo.
$a < $bMenor que (<)Verdadeiro se $a é menor que $b.
$a > $bMaior que (>)Verdadeiro se $a é maior que $b.
$a <= $bMenor ou igual (<=)Verdadeiro se $a é menor ou igual a $b.
$a >= $bMaior ou igual (>=)Verdadeiro se $a é maior ou igual a $b.

Quando precisamos comparar valores em PHP, utilizamos as estruturas de controle (que ainda vamos falar no decorrer deste curso). Elas servem para que possamos executar ações se alguma comparação for verdadeira ou falsa.

Veja um exemplo:

<?php
// Verifica se $a é maior que $b
if ( $a > $b ) {
	echo '$a é maior que $b.';
} else {
	echo '$a é menor que $b';
}
?>

Os tipos de dados também interferem na sua comparação. A tabela abaixo mostra o que acontece quando você tenta comparar valores de tipos diferentes.

Tipo do 1º operandoTipo do 2º operandoResultado
null ou stringstringConverte NULL para “”, numérico ou comparação léxica
bool or nullqualquerConverte para bool, FALSE < TRUE
objectobjectClasses nativas podem definir como são comparadas, classes diferentes são incomparáveis, mesma classe – compara propriedades igual faz arrays (PHP 4), PHP 5 tem sua explicação
string, resource ou numberstring, resource ou numberTransforma strings e resources para números
arrayarrayArray com menos membros é menor, se a chave do operando 1 não é encontrada no operando 2, então os arrays são incomparáveis, caso contrário – compara valor por valor (veja o seguinte exemplo)
arrayqualquerarray é sempre maior
objectqualquerobject é sempre maior

Também é possível utilizar o operador ternário (?:) para comparar valores. Veja um exemplo:

<?php
echo isset( $a ) && $a > $b ? '$a existe e é maior que $b' : '$a não existe';
?>

Neste caso a comparação é feita da seguinte maneira:

(comparação) ? (ação verdadeira) : (ação falsa)

Veja outro exemplo mais simples:

<?php
echo 1 > 2 ? 'É maior' : 'É menor';
?>

No trecho acima, a expressão de comparação é “1 > 2” (Se um é maior que dois); isso irá retornar um valor falso, já que 1 é menor que dois. A ação para imprimir “É maior” não será executada, restando apenas a ação “É menor”. Essa expressão irá mostrar “É menor” na tela do usuário.

Concluindo

Os operadores de comparação dependem muito das estruturas condicionais, portanto, vamos voltar a falar deles quando falarmos sobre elas.

Vídeo aula

O vídeo abaixo descreve a aula acima:

Link do vídeo: https://youtu.be/FjAuSfAc0x0

Todas as aulas: https://www.todoespacoonline.com/w/2015/09/venha-aprender-php-de-graca/

Playlist do Curso de PHP: https://youtu.be/BMxAWNL-9pU?list=PLbIBj8vQhvm0Dq-kaGS4uXR_FdKdA_7nm

Até a próxima!

Operadores de atribuição são os que você mais vai utilizar no PHP, de fato, você já está utilizando um operador de atribuição desde a segunda aula, o sinal de igual (=).

A atribuição mais básica que você pode fazer no PHP é configurar o valor da direita para o operando da esquerda, separados por um sinal de igual.

<?php
// Configura um valor por atribuição
$variavel = 'Valor';
$array[]  = 'Valor';
?>

Você já viu ambos os exemplos acima nas aulas sobre variáveis e arrays. Isso significa que estamos atribuindo um valor para determinado elemento, seja ele qual for.

Posteriormente, você vai perceber que existem outros operadores – os de comparação – que também utilizam o sinal de igual para realizar sua função, veja na tabela abaixo:

OperadorFunção
=Atribui um valor para o operando da esquerda.
==Compara se um valor é igual ao outro.
===Compara se um valor é igual e do mesmo tipo que o outro.

Se você, em alguma parte do código, se confundir e trocar dois ou três sinais de igual por um, seu código vai atribuir um valor para a variável e retornar um resultado positivo para sua comparação. Só para resumir, vai dar problemas graves.

Atribuição e aritmética

Lembra dos operadores aritméticos?  Eles podem ser combinados com o sinal de igual e se transformarem em operadores de atribuição com super poderes.

Veja um exemplo abaixo:

<?php
// Configura uma variável 
// (Valor inicial 20)
$valor = 20;

// Soma 10 na variável
// (Valor até aqui 20)
$valor += 10;
// (Valor atual 30)

// Exibe 30
echo $valor;

// (Valor até aqui 30)
// Multiplica por 2
$valor *= 2;
// (Valor atual 60)

// Exibe 60
echo $valor;

// (Valor até aqui 60)
// Divide por 10
$valor /= 10;
// (Valor atual 6)

// Exibe 6
echo $valor;
?>

Perceba que é possível utilizar um operador aritmético qualquer, mais o sinal de igual (=), para que o cálculo seja realizado e o resultado atribuído à variável.

Quando você faz dessa maneira, a conta é realizada entre o valor atual da variável e o valor que você está tentando atribuir. Ou seja, isso:

<?php
$valor = 20;
$valor += 20; // 40
?>

É igual a isso:

<?php
$valor = 20;
$valor = $valor + 20; // 40
?>

O valor atual da variável é copiado e a conta é realizada.

Concatenação

Outro operador que também pode ser combinado com o sinal de igual, é o ponto (.), que serve para concatenar (juntar) o valor de duas ou mais variáveis (ou simplesmente incluir um valor a mais em uma variável).

<?php
$frase = 'Oi';

// Junta mais partes na frase;
$frase .= ', Eu sou ';
$frase .= 'o Luiz Otávio';
$frase .= '.';

// Exibe: Oi, Eu sou o Luiz Otávio.
echo $frase;
?>

Suponhamos que você crie uma variável que pode receber vários valores, e esses valores vão sendo emendados (juntados) na mesma linha.

Por exemplo, você tem que preencher o perfil do Joãozinho formando um texto sobre ele, porém, você não sabe se ele preencheu todas as perguntas do perfil. Então você pode criar uma variável vazia inicial, fazer suas comparações e preencher o valor da variável quando as comparações forem verdadeiras.

Veja o exemplo:

<?php
$perfil = NULL;
$perfil .= 'Olá, ';
$perfil .= 'meu nome é ' . $nome . '.';
$perfil .= ' Tenho ' . $idade . ' anos e adoro ';
$perfil .= $hobbie;
?>

Você só precisa criar a variável normalmente, depois, a cada linha nova, adicionar um ponto e um sinal de igual ( .= valor a ser adicionado ).

Vídeo aula

O vídeo abaixo descreve a aula acima:

Link do vídeo: https://youtu.be/iu99dyaJwrc

Todas as aulas: https://www.todoespacoonline.com/w/2015/09/venha-aprender-php-de-graca/

Playlist do Curso de PHP: https://youtu.be/BMxAWNL-9pU?list=PLbIBj8vQhvm0Dq-kaGS4uXR_FdKdA_7nm

Até a próxima!

Hoje vamos falar sobre os operadores aritméticos em PHP, que não tem nada de diferente sobre o que você já aprendeu na escola. Somar, subtrair, multiplicar e dividir valores numéricos é exatamente o que você vai fazer, porém, agora você utilizando variáveis e o comando echo do PHP para isso.

Operadores aritméticos em PHP

Operadores aritméticos fazem contas, confira na tabela abaixo:

OperadorAção
+ (Sinal de mais)Soma
– (Sinal de menos)Subtração
* (Asterisco)Multiplicação
/ (Barra)Divisão
% (Sinal de porcentagem)Resto da divisão
– (Sinal de menos antes do número)Converte em negativo

Agora vamos ver um pouco de código para praticar.

Na prática

Soma

Para somar valores, simplesmente crie variáveis com valores numéricos e utilize o sinal de mais (+) entre elas.

<?php
// Soma 1 + 1
$a = 1;
$b = 1;

// Exibe 2 na tela (A soma das variáveis $a e $b)
echo $a + $b;
?>

Ou você pode até incluir o valor da soma em uma terceira variável para uso posterior:

<?php
// Soma 1 + 1
$a = 1;
$b = 1;
$c = $a + $b;

// Exibe 2 na tela (A soma das variáveis $a e $b)
// O valor de $c é 2
echo $c;
?>

Também é possível somar quantos valores você quiser:

<?php
// Exibe 10 na tela
echo 1 + 5 + 3 + 1;
?>

Na verdade, todos os operadores são praticamente iguais, a única diferença acontece quando eles são misturados, pois, alguns têm precedência sobre outros (Veja uma tabela).

Mais exemplos de contas:

Multiplicação

<?php
$a = 22.5;
$b = 1.2546;

// Exibe 28.2285 na tela
// Resultado da multiplicação entre 22.5 e 1.2546
echo $a * $b;
?>

Divisão

<?php
$a = 22.5;
$b = 1.2546;
$c = 2;

// Exibe 8.9670014347202 na tela
// Resultado da divisão entre 22.5 e 1.2546 e 2
echo $a / $b / $c;
?>

Subtração

<?php
$a = 22.5;

// Exibe 22 na tela
// Resultado da subtração entre 22.5 e 0.5
echo $a - 0.5;
?>

Resto da divisão (%)

Como nem todas as contas de divisão resultam em valores exatos, este operador retorna somente o resto da divisão de contas que não são exatas.

<?php
$a = 11;

// Exibe 0 na tela
// Resultado do resto da divisão entre 11 e 1
// Uma conta exata
echo $a % 1;
?>

Conversão para negativo

Para converter um número para negativo, apenas coloque um sinal de menos no seu início:

<?php
$a = 11; // 11 Positivo
$b = -$a; // 11 Negativo

// $b tem o valor de $a negativo
// Portanto, $a é maior que $b
if ( $a > $b ) {
	echo 'OK';
}
?>

Nota: O trecho de código acima tem uma estrutura de controle condicional if, não se preocupe que ainda vamos falar sobre isso posteriormente nesse curso.

Várias contas ao mesmo tempo

É possível fazer várias contas ao mesmo tempo na mesma linha, porém, evite confiar na precedência dos operadores, utilize parênteses.

Assim como estudamos na escola, podemos colocar as contas que serão executadas primeiro entre parênteses, veja:

<?php
// Exibe 8.06 na tela
echo (1 + 2.1) * ( 5.2 / 2 );
?>

No trecho acima, as contas entre parênteses serão realizadas primeiro, em seguida o valor do resultado de ambos será multiplicado (conforme indicado pelo asterisco).

Se eu remover os parênteses:

<?php
// Exibe 6.46 na tela
echo 1 + 2.1 * 5.2 / 2;
?>

O resultado não será o mesmo, pois, o valor da precedência dos operadores fará a conta ser realizada de um modo diferente.

Você pode incluir quantos parênteses desejar, até mesmo uns dentro dos outros, veja:

<?php
// Exibe 2 na tela
echo ( ( 1 + 2 ) * ( 2 / 3 ) ) % ( ( 8 * 5 ) * 5 );
?>

E possível até criar novas variáveis dentro de parênteses e fazer contas com elas ao mesmo tempo, veja:

<?php
$a = 2;

// Exibe 4 na tela
echo $a * ( $b = 2 );

// Exibe 2 na tela
echo $b;
?>

Agora tenho duas variáveis, $a e $b, sendo que $b foi criada dentro da conta.

Concluindo

Como eu disse anteriormente, os operadores aritméticos em PHP são os mesmos que você aprendeu na escola, o que facilita um pouco seu entendimento.

Tente fazer alguns testes em seu computador para ver se encontra alguma dúvida; caso ela apareça, basta comentar aí abaixo.

Estamos ansiosos para ajudar.

Em vídeo

O vídeo abaixo explica o que foi descrito no texto acima:


Link do vídeo: https://www.youtube.com/watch?v=glML3YjtMPc

Aulas anteriores

Caso queira acessar os links para aulas anteriores:

Veja todas as aulas, e mais, na categoria Curso de PHP do Tutsup.