PHP

Variáveis, Tipos de Dados e Operadores

Nathan Geeksman 3 visualizações

Artigo 04 — Variáveis, Tipos de Dados e Operadores

Módulo 1 · Semana 4 · Nível: Iniciante

Introdução

Todo programa de computador, em sua essência, faz três coisas: recebe dados, processa dados e produz resultados. Para isso, precisa de um lugar para guardar informações temporariamente durante a execução — e esse lugar são as variáveis. Neste artigo vamos entender como o PHP lida com variáveis, quais tipos de dados existem, como convertê-los e como operar sobre eles com os operadores da linguagem.

Este é um dos artigos mais densos do Módulo 1, mas também um dos mais importantes. Tudo que vem depois — estruturas de controle, funções, orientação a objetos — depende de você dominar bem este conteúdo.

Variáveis

No PHP, toda variável começa com o símbolo $ seguido do nome. O nome deve começar com uma letra ou underscore, e pode conter letras, números e underscores. O PHP é case-sensitive: $nome e $Nome são variáveis diferentes.

<?php

// Declaração e atribuição são feitas ao mesmo tempo
// Não existe "declarar sem valor" em PHP como em outras linguagens
$nome     = "Ricardo";
$idade    = 35;
$altura   = 1.78;
$ativo    = true;
$endereco = null; // null significa ausência intencional de valor

// Variáveis podem ser reatribuídas a qualquer momento
// e até mudar de tipo — PHP permite isso (tipagem dinâmica)
$valor = 10;      // int
$valor = "dez";   // agora é string — PHP aceita, mas evite isso
$valor = 10.5;    // agora é float

// Exibindo valores
echo $nome;   // Ricardo
echo "\n";
echo $idade;  // 35

A convenção de nomenclatura mais usada no PHP é o camelCase para variáveis e funções: $nomeDoUsuario, $totalDeItens, $dataDeNascimento. Para constantes, usa-se UPPER_SNAKE_CASE. Siga essas convenções — elas tornam o código previsível e legível.

Tipos de dados

O PHP possui oito tipos primitivos divididos em três grupos:

Escalares — armazenam um único valor:

  • string — texto
  • int — número inteiro
  • float — número decimal
  • bool — verdadeiro ou falso

Compostos — armazenam múltiplos valores:

  • array — lista ou mapa de valores
  • object — instância de uma classe

Especiais:

  • null — ausência de valor
  • resource — referência a recursos externos (arquivos, conexões de banco)
<?php

// STRING — sequência de caracteres
// Aspas duplas: interpola variáveis
// Aspas simples: tudo literal, mais performático para strings sem variáveis
$simples  = 'Olá, mundo!';             // aspas simples
$duplas   = "Olá, $simples";           // interpola — resultado: "Olá, Olá, mundo!"
$heredoc  = <<<EOT
    Texto com múltiplas linhas.
    Suporta interpolação de $simples.
    EOT;                               // heredoc — para textos longos

// INT — inteiro, positivo ou negativo, sem limite fixo (depende do sistema)
$positivo  =  42;
$negativo  = -17;
$hexadec   = 0x1A;  // hexadecimal — equivale a 26
$binario   = 0b101; // binário — equivale a 5
$octal     = 0777;  // octal — equivale a 511
$separador = 1_000_000; // PHP 7.4+: underscore como separador visual

// FLOAT — número com ponto decimal ou notação científica
$preco     = 19.99;
$cientifico = 1.5e3;  // 1500.0
$negativo_f = -0.001;

// BOOL — true ou false (case-insensitive: TRUE, True, true são iguais)
$ativo    = true;
$inativo  = false;

// NULL — ausência de valor
$vazio = null;

// Verificando tipos com gettype() e funções is_*
echo gettype($positivo);  // integer
echo gettype($preco);     // double (nome interno do float)
echo gettype($simples);   // string
echo gettype($ativo);     // boolean
echo gettype($vazio);     // NULL

var_dump(is_int($positivo));    // bool(true)
var_dump(is_string($simples));  // bool(true)
var_dump(is_null($vazio));      // bool(true)

Strings em detalhes

Strings merecem atenção especial pois são o tipo mais usado no desenvolvimento web.

<?php

$nome  = "Ana";
$sobrenome = "Silva";

// Concatenação com ponto (.)
$nomeCompleto = $nome . " " . $sobrenome;
echo $nomeCompleto; // Ana Silva

// Interpolação dentro de aspas duplas
echo "Olá, $nome!";          // Olá, Ana!
echo "Olá, {$nome}!";        // Olá, Ana! — chaves deixam o limite da variável claro

// Funções essenciais de string
echo strlen($nome);           // 3 — comprimento
echo strtoupper($nome);       // ANA — maiúsculas
echo strtolower($nome);       // ana — minúsculas
echo str_replace("Ana", "Maria", $nomeCompleto); // Maria Silva
echo substr($nomeCompleto, 0, 3); // Ana — extrai parte da string
echo strpos($nomeCompleto, "Silva"); // 4 — posição da substring
echo trim("  espaços  ");     // "espaços" — remove espaços nas bordas
echo str_pad("5", 3, "0", STR_PAD_LEFT); // "005" — preenchimento

// Verificando conteúdo
var_dump(str_contains($nomeCompleto, "Silva")); // bool(true) — PHP 8+
var_dump(str_starts_with($nomeCompleto, "Ana")); // bool(true) — PHP 8+
var_dump(str_ends_with($nomeCompleto, "Silva")); // bool(true) — PHP 8+

Conversão de tipos (Type Casting)

O PHP converte tipos automaticamente em muitos contextos — isso se chama coerção de tipos. Mas você também pode fazer conversões explícitas, o que é sempre mais seguro e legível.

<?php

// Conversão implícita (automática) — PHP decide o tipo
$resultado = "5" + 3;     // PHP converte "5" para int — resultado: 8
$resultado = "5 anos" + 3; // PHP pega o número do início — resultado: 8
$resultado = "anos" + 3;   // string sem número vira 0 — resultado: 3

// Conversão explícita (casting) — você decide — sempre prefira isso
$texto   = "42";
$inteiro = (int) $texto;    // 42 como int
$decimal = (float) $texto;  // 42.0 como float
$bool    = (bool) $texto;   // true (string não-vazia = true)

// Regras importantes do casting para bool:
// São considerados FALSE: 0, 0.0, "", "0", [], null
// Todo o resto é TRUE
var_dump((bool) 0);      // bool(false)
var_dump((bool) "");     // bool(false)
var_dump((bool) "0");    // bool(false) — armadilha!
var_dump((bool) []);     // bool(false)
var_dump((bool) "false"); // bool(true) — a string "false" não é false!

// Funções de conversão — mais explícitas que casting
$numero = intval("42abc");   // 42 — para inteiro
$decimal = floatval("3.14"); // 3.14 — para float
$texto = strval(100);        // "100" — para string

A linha (bool) "false" retornando true é uma das maiores armadilhas para iniciantes. Lembre-se: o PHP avalia se a string está vazia ou é "0" — não avalia o conteúdo semântico.

Constantes

Constantes são como variáveis, mas seu valor não pode ser alterado após a definição. São definidas com define() ou com a palavra-chave const:

<?php

// define() — pode ser usado em qualquer ponto do código
define('VERSAO_APP', '2.1.0');
define('MAX_TENTATIVAS', 3);
define('PI', 3.14159);

// const — deve ser usada no escopo global ou dentro de classes
const NOME_EMPRESA = 'Minha Empresa Ltda';

echo VERSAO_APP;    // 2.1.0 — sem o $
echo MAX_TENTATIVAS; // 3

// Constantes predefinidas pelo PHP
echo PHP_VERSION;   // versão do PHP instalado
echo PHP_INT_MAX;   // maior inteiro suportado
echo PHP_EOL;       // quebra de linha do sistema operacional
echo PHP_MAJOR_VERSION; // número da versão maior (8, no PHP 8.x)
echo __FILE__;      // caminho completo do arquivo atual
echo __LINE__;      // número da linha atual — útil para debug

Use constantes para valores que não devem mudar ao longo da execução: versões, limites, nomes de configuração, caminhos base. Isso torna o código mais seguro e mais fácil de manter.

Operadores

Operadores são símbolos que realizam operações sobre um ou mais valores. O PHP tem um conjunto rico de operadores.

Operadores aritméticos

<?php

$a = 10;
$b = 3;

echo $a + $b;   // 13 — adição
echo $a - $b;   // 7  — subtração
echo $a * $b;   // 30 — multiplicação
echo $a / $b;   // 3.333... — divisão (resultado sempre float se não divisível)
echo $a % $b;   // 1  — módulo (resto da divisão)
echo $a ** $b;  // 1000 — exponenciação (PHP 5.6+)

// Operadores de incremento e decremento
$contador = 0;
$contador++;    // pós-incremento: usa o valor DEPOIS incrementa
++$contador;    // pré-incremento: incrementa ANTES de usar o valor
$contador--;    // pós-decremento
--$contador;    // pré-decremento

// Operadores de atribuição combinados — atalhos
$total = 100;
$total += 50;   // equivale a $total = $total + 50  → 150
$total -= 30;   // equivale a $total = $total - 30  → 120
$total *= 2;    // equivale a $total = $total * 2   → 240
$total /= 4;    // equivale a $total = $total / 4   → 60
$total %= 7;    // equivale a $total = $total % 7   → 4
$texto  = "Olá";
$texto .= ", mundo!"; // concatenação combinada → "Olá, mundo!"

Operadores de comparação

<?php

$a = 10;
$b = "10";

// == comparação frouxa (loose) — compara valor, ignora tipo
var_dump($a == $b);   // bool(true) — 10 == "10" após coerção

// === comparação estrita — compara valor E tipo
var_dump($a === $b);  // bool(false) — int !== string

// != diferente (frouxa)
var_dump($a != 5);    // bool(true)

// !== diferente estrita
var_dump($a !== $b);  // bool(true) — tipos diferentes

// Comparações numéricas
var_dump($a > 5);     // bool(true)
var_dump($a < 5);     // bool(false)
var_dump($a >= 10);   // bool(true)
var_dump($a <= 10);   // bool(true)

// Spaceship operator <=> — PHP 7+
// Retorna -1, 0 ou 1 dependendo da comparação
// Muito usado em funções de ordenação
echo (1 <=> 2);   // -1 (esquerda menor)
echo (2 <=> 2);   //  0 (iguais)
echo (3 <=> 2);   //  1 (esquerda maior)

Sempre prefira === ao ==. A comparação frouxa tem regras de coerção complexas que causam bugs sutis e difíceis de encontrar.

Operadores lógicos

<?php

$idade    = 25;
$cadastro = true;

// && e || são os operadores lógicos modernos (preferidos)
var_dump($idade >= 18 && $cadastro);  // bool(true) — E lógico
var_dump($idade < 18 || $cadastro);   // bool(true) — OU lógico
var_dump(!$cadastro);                  // bool(false) — NÃO lógico

// and, or, not existem mas têm precedência MENOR que &&, ||
// Isso causa comportamento inesperado em expressões complexas
// Prefira sempre && e || para evitar surpresas
$x = true && false;  // $x = (true && false) = false — correto
$x = true and false; // $x = true, depois "and false" é ignorado — armadilha!

Operadores específicos do PHP

<?php

// Null coalescing (??) — PHP 7+
// Retorna o operando esquerdo se não for null, senão retorna o direito
$nome = null;
$exibir = $nome ?? "Visitante"; // "Visitante"

// Encadeamento: pega o primeiro valor não-null
$a = null;
$b = null;
$c = "Ricardo";
echo $a ?? $b ?? $c; // "Ricardo"

// Null coalescing de atribuição (??=) — PHP 7.4+
$config = [];
$config['tema'] ??= 'claro'; // só atribui se for null
echo $config['tema']; // "claro"

// Operador ternário
$idade = 20;
$status = ($idade >= 18) ? "maior" : "menor";
echo $status; // "maior"

// Ternário curto (Elvis operator) — retorna o próprio valor se truthy
$entrada = "" ;
$valor = $entrada ?: "padrão"; // como $entrada é falsy, usa "padrão"
echo $valor; // "padrão"

// Nullsafe operator (?->) — PHP 8+
// Evita erros ao chamar métodos em objetos possivelmente null
// $resultado = $usuario?->getPerfil()?->getAvatar();
// Se qualquer parte for null, retorna null em vez de erro

Resumo

Tópico Ponto principal
Variáveis Sempre com $, camelCase, tipagem dinâmica
Tipos escalares string, int, float, bool
Tipos especiais null, array, object, resource
Strings Aspas simples (literal) vs duplas (interpola variáveis)
Casting Prefira casting explícito (int), (string) etc.
(bool) "false" Retorna true — armadilha clássica
Constantes define() ou const, sem $, UPPER_SNAKE_CASE
Comparação Sempre === em vez de ==
Null coalescing ?? para valores padrão quando null
Nullsafe ?-> para encadeamento seguro em PHP 8

Referências e leituras para aprofundar