Rocketseat
O guia completo para aprender PHP
Rocketseat

Rocketseat

11 min de leitura
php

Navegação Rápida:

E aí, dev! Já imaginou criar sistemas web dinâmicos, robustos e escaláveis, daqueles que rodam em uma fatia gigantesca da internet – cerca de 75%, incluindo gigantes como WordPress e Magento? Se a resposta é sim, ou se você está buscando uma linguagem poderosa e com demanda no mercado para impulsionar sua carreira, então você chegou ao lugar certo. Bem-vindo ao universo do PHP!
Gráfico mostrando a posição de mercado do PHP em comparação com outras linguagens de programação como JavaScript, ASP.NET, Java e Ruby, indicando sua ampla utilização por muitos sites segundo o W3Techs.
Gráfico mostrando a posição de mercado do PHP em comparação com outras linguagens de programação como JavaScript, ASP.NET, Java e Ruby, indicando sua ampla utilização por muitos sites segundo o W3Techs.
Talvez você já tenha ouvido algum "meme" ou visto discussões sobre o PHP. Mas deixe a gente te contar um segredo: o PHP evoluiu muito. Esqueça as ideias antigas! Com as versões recentes (estamos falando de PHP 8 e além!), a linguagem ganhou uma performance incrível, recursos modernos e continua sendo uma excelente opção para desenvolvimento web. Se você quer aprender PHP, saiba que está investindo em uma habilidade com:
  • Alta demanda no mercado: muitas empresas, de startups a gigantes, usam PHP.
  • Curva de aprendizado acessível: é uma ótima porta de entrada para o backend, mesmo que você esteja começando.
  • Excelente integração com bancos de dados: trabalhar com MySQL, PostgreSQL e outros é muito direto.
  • Comunidade vibrante e ativa: recursos, bibliotecas e ajuda não faltam.
Este artigo é o seu guia, o mapa da mina para você navegar desde os fundamentos até conceitos mais avançados e começar a construir suas próprias aplicações web. Aqui na Rocketseat, nosso compromisso é transformar vidas através da educação em tecnologia, e queremos te guiar nessa jornada com a mesma paixão e foco prático que já impulsionou milhares de devs.
📽️
Ainda está com dúvidas sobre PHP? Assista ao vídeo, embora o vídeo tenha saído em 2024, ele traz insights valiosos que podem te ajudar a entender melhor essa linguagem:
Video preview

Uma breve viagem no tempo: a história e evolução do PHP

Para entender o poder do PHP hoje, vale a pena conhecer um pouco da sua trajetória. Tudo começou lá em 1994, quando Rasmus Lerdorf criou um conjunto de scripts para gerenciar sua página pessoal – daí o nome original "Personal Home Page Tools". Mal sabia ele que estava plantando a semente de uma das linguagens mais influentes da web!
O PHP passou por marcos importantes:
  • PHP 3 (1998): trouxe uma sintaxe mais parecida com a que conhecemos hoje e começou a ganhar popularidade.
  • PHP 5 (2004): uma revolução! Introduziu um modelo de Orientação a Objetos (OOP) robusto, o PDO (PHP Data Objects) para acesso a bancos de dados e muitas outras melhorias. Foi um salto de maturidade.
  • PHP 7 (2015): outro divisor de águas! O foco foi em performance, com a Zend Engine 3, entregando melhorias drásticas de velocidade (até 2x mais rápido que o PHP 5.6) e menor consumo de memória. Trouxe também tipagem escalar e de retorno.
  • PHP 8+ (2020 em diante): a modernização continua a todo vapor! O PHP 8 trouxe o compilador JIT (Just-In-Time), Attributes, Named Arguments, a expressão match, Union Types e muito mais, tornando a linguagem ainda mais expressiva, rápida e segura. O PHP 8.4, a versão mais recente até o momento (abril de 2025), continua refinando a linguagem.
Empresas gigantes como o Facebook (Meta) construíram partes cruciais de suas plataformas com PHP, inicialmente usando uma versão otimizada própria (o HHVM) e posteriormente retornando ao PHP oficial devido às evoluções significativas da linguagem. O WordPress, que domina amplamente o mercado de sistemas de gerenciamento de conteúdo (CMS) com aproximadamente 61,3% de participação segundo o relatório mais recente da W3Techs (abril de 2025), é inteiramente construído em PHP. Isso evidencia não apenas a resiliência e popularidade contínua da linguagem, mas também sua capacidade constante de se modernizar e atender às necessidades de projetos robustos e escaláveis. O PHP atual é rápido, moderno e, quando bem implementado, extremamente seguro.
Gráfico mostrando o domínio do WordPress com 61,3% entre os sistemas CMS, segundo relatório W3Techs 2025.
Gráfico mostrando o domínio do WordPress com 61,3% entre os sistemas CMS, segundo relatório W3Techs 2025.

Preparando o terreno: configurando seu ambiente de desenvolvimento PHP

Antes de escrever nossa primeira linha de código PHP, precisamos preparar nosso ambiente de desenvolvimento local. Basicamente, você precisará de três componentes principais:
  1. O Interpretador PHP: o "cérebro" que executa seu código.
  1. Um servidor web: como Apache ou Nginx, para processar as requisições HTTP e entregar suas páginas.
  1. Um banco de dados: geralmente MySQL ou PostgreSQL, para armazenar os dados da sua aplicação.
Parece complicado? Relaxa, existem ferramentas que facilitam muito esse processo!

Opção 1: pacotes "tudo-em-um" (ideal para iniciantes)

Ferramentas como XAMPP (multiplataforma), MAMP (macOS) ou Laragon (Windows) instalam e configuram automaticamente o Apache, PHP e MySQL (ou MariaDB) para você. É a forma mais rápida de começar.
  • Como verificar: após instalar um desses pacotes e iniciar os serviços (Apache e MySQL), crie um arquivo chamado info.php na pasta raiz do seu servidor web (geralmente htdocs no XAMPP ou www no Laragon/MAMP) com o seguinte conteúdo:PHP
      • <?php
phpinfo();
?>
      Abra seu navegador e acesse http://localhost/info.php. Se você vir uma página cheia de informações sobre a sua instalação do PHP, parabéns, está tudo pronto!

Opção 2: Docker (abordagem moderna)

Se você já tem alguma familiaridade com desenvolvimento ou quer seguir uma abordagem mais profissional e isolada, o Docker é fantástico. Ele permite criar contêineres com ambientes específicos para cada projeto, garantindo consistência entre desenvolvimento e produção. A configuração inicial pode ser um pouco mais complexa, mas os benefícios a longo prazo são enormes.

Opção 3: servidor embutido do PHP (para testes rápidos)

Para scripts simples ou testes rápidos, o próprio PHP oferece um servidor web embutido. Navegue até a pasta do seu projeto pelo terminal e execute:
php -S localhost:8000
Isso iniciará um servidor na porta 8000, servindo os arquivos da pasta atual. Simples e direto!

Editor de código:

Para escrever seu código PHP, recomendamos o Visual Studio Code (VSCode). Ele é gratuito, poderoso e tem uma comunidade imensa criando extensões úteis. Algumas indispensáveis para PHP:
  • PHP Intelephense: autocomplete inteligente, análise de código e muito mais.
  • PHP Debug: permite depurar seu código passo a passo diretamente no editor.
  • Prettier - Code formatter: para manter seu código formatado e padronizado (funciona bem com plugins PHP).
📄
Com o ambiente configurado, estamos prontos para colocar a mão na massa! Se algo deu errado, fique tranquilo(a), no universo da programação, se deparar com erros é completamente normal, se algo aconteceu, recomendo que visite esse artigo: Como configurar ambiente PHP.
E agora? Bora decolar com PHP?
notion image

Os alicerces: fundamentos essenciais da linguagem PHP

Vamos começar construindo a base. Assim como em qualquer linguagem, o PHP tem sua própria sintaxe e conceitos fundamentais que você precisa dominar.

1. Sintaxe básica e tags PHP

O código PHP é geralmente embutido em arquivos HTML. Para indicar ao servidor que um trecho de código deve ser interpretado como PHP, usamos as tags <?php e ?>.
<!DOCTYPE html>
<html>
<head>
    <title>Aprendendo PHP na Rocketseat</title>
</head>
<body>
    <h1>
        <?php
        // Isso é um comentário de linha única
        /* Isso é um
           comentário de múltiplas linhas */
        echo "Decole com PHP!"; // 'echo' exibe texto na página
        ?>
    </h1>
    <p>Meu primeiro script PHP.</p>
    <?php
        print "<p>Print também funciona!</p>"; // 'print' é similar a 'echo'
    ?>
</body>
</html>

2. Variáveis

Variáveis em PHP armazenam dados que podem ser usados e modificados ao longo do script. Elas sempre começam com um cifrão ($) seguido pelo nome.
  • Nomes de variáveis são case-sensitive ($nome é diferente de $Nome).
  • Devem começar com letra ou underscore (_), seguido por letras, números ou underscores.
<?php
$saudacao = "Olá, Dev!"; // String
$ano = 2025;             // Integer
$versaoPHP = 8.3;        // Float (ou Double)
$aprendendo = true;      // Boolean
$modulos = null;         // NULL (sem valor)

echo $saudacao;          // Exibe "Olá, Dev!"
echo "<br>";             // Quebra de linha HTML
echo "Estamos no ano de $ano"; // Interpolação com aspas duplas
echo 'Estamos no ano de ' . $ano; // Concatenação com ponto
?>

3. Tipos de dados

PHP é uma linguagem de tipagem dinâmica (embora suporte tipagem estrita desde o PHP 7), o que significa que você não precisa declarar o tipo de uma variável explicitamente. Os principais tipos são:
  • string: sequência de caracteres ("Olá", 'Rocketseat'). Aspas duplas interpretam variáveis internas ("$saudacao"), aspas simples não.
  • integer: números inteiros (10, 5, 2025).
  • float (ou double): números com ponto flutuante (3.14, 8.3).
  • boolean: representa valores verdadeiro (true) ou falso (false).
  • array: coleção ordenada de valores. Pode conter diferentes tipos de dados.
  • object: instância de uma classe (veremos mais sobre OOP).
  • NULL: representa uma variável sem valor.
Para investigar o tipo e o valor de uma variável, a função var_dump() é sua melhor amiga:
<?php
$nome = "Laís";
$idade = 28;
$hobbies = ["Programar", "Ler", "Café"];
$empresa = null;

var_dump($nome);    // string(4) "Laís"
echo "<br>";
var_dump($idade);   // int(28)
echo "<br>";
var_dump($hobbies); // array(3) { [0]=> string(9) "Programar" [1]=> string(3) "Ler" [2]=> string(5) "Café" }
echo "<br>";
var_dump($empresa); // NULL
?>

4. Constantes

São valores que não mudam durante a execução do script. Definidas com define() (tradicional) ou const (a partir do PHP 5.3, geralmente dentro de classes ou namespaces).
<?php
define("EMPRESA", "Rocketseat");
const VERSAO_ATUAL = 1.0;

echo EMPRESA;      // Rocketseat
echo "<br>";
echo VERSAO_ATUAL; // 1.0
?>

5. Operadores

Permitem realizar operações com variáveis:
  • Aritméticos: + (soma), -(subtração), *(multiplicação), / (divisão), % (módulo - resto da divisão).
  • Atribuição: = (atribui valor), += (soma e atribui), -= (subtrai e atribui), *= (multiplica e atribui), /= (divide e atribui), .= (concatena e atribui).
  • Comparação: == (igual), === (identico - valor e tipo), != ou <> (diferente), !== (não idêntico), >, <, >=, <=.
  • Lógicos: && ou and (E), || ou or (OU), ! (NÃO).
  • Incremento/Decremento: ++$var, $var++, -$var, $var--.
<?php
$num1 = 10;
$num2 = 5;
$soma = $num1 + $num2; // 15

$idade = 18;
$podeDirigir = ($idade >= 18); // true

$temLogin = true;
$temPermissao = false;
$podeAcessar = $temLogin && $temPermissao; // false
?>
📄
Dominar operadores e como eles interagem com variáveis e tipos de dados é a chave para construir lógicas mais complexas. Quer ver como aplicar isso na prática? Confira nosso artigo sobre como resolver Problemas Clássicos de Lógica com PHP.
Com esses fundamentos, você já pode começar a escrever scripts simples! O próximo passo é aprender a controlar o fluxo do seu código e a reutilizar tarefas com estruturas de controle e funções.

Controlando o fluxo e reutilizando código: estruturas de controle e funções

Agora que conhecemos os blocos básicos, vamos aprender a controlar como nosso código executa (tomar decisões e repetir tarefas) e como evitar repetições, organizando nossa lógica em blocos reutilizáveis.

1. Estruturas condicionais

Permitem que seu programa tome decisões com base em condições. Essenciais para criar lógicas flexíveis.
  • if, elseif, else: a estrutura mais comum. Executa blocos de código diferentes dependendo se uma condição é verdadeira ou falsa.
<?php
$nota = 7.5;
$nomeAluno = "Diego";

if ($nota >= 7.0) {
    echo "$nomeAluno, você foi aprovado!";
} elseif ($nota >= 5.0) {
    echo "$nomeAluno, você está de recuperação.";
} else {
    echo "$nomeAluno, você foi reprovado.";
}
?>
switch: útil quando você precisa comparar uma variável com múltiplos valores específicos. Muitas vezes mais legível que vários elseif encadeados para o mesmo tipo de comparação.
<?php
$statusPedido = "processando";

switch ($statusPedido) {
    case "pendente":
        echo "Seu pedido está aguardando pagamento.";
        break; // Importante! Sai do switch
    case "processando":
        echo "Seu pedido está sendo preparado para envio.";
        break;
    case "enviado":
        echo "Seu pedido foi enviado!";
        break;
    default:
        echo "Status do pedido desconhecido.";
}
?>
Operador ternário: uma forma concisa de escrever um if/else simples, ótimo para atribuições condicionais. (condição) ? valor_se_verdadeiro : valor_se_falso;
<?php
$idade = 20;
$mensagem = ($idade >= 18) ? "Maior de idade" : "Menor de idade";
echo $mensagem; // Maior de idade
?>
📄
Quer mergulhar fundo em como tomar decisões no seu código PHP? Temos um guia completo esperando por você: Estruturas Condicionais em PHP: Guia para Iniciantes.

2. Estruturas de repetição (loops)

Usadas para executar um bloco de código várias vezes, seja um número definido de vezes ou enquanto uma condição for atendida. Indispensáveis para processar listas de dados, por exemplo.
  • for: ideal quando você sabe exatamente quantas vezes quer repetir o bloco. Controla a inicialização, condição e incremento/decremento em uma única linha.
<?php
// Exibe os números de 1 a 5
for ($i = 1; $i <= 5; $i++) {
    echo "Número: " . $i . "<br>";
}
?>
while: repete um bloco de código enquanto uma condição especificada for verdadeira. A condição é verificada antes de cada iteração.
<?php
$contador = 0;
while ($contador < 3) {
    echo "Contador while: " . $contador . "<br>";
    $contador++;
}
?>
do-while: similar ao while, mas com uma diferença crucial: garante que o bloco de código execute pelo menos uma vez, pois a condição é verificada depois da iteração.
<?php
$tentativa = 0;
$conectou = false; // Simula que não conectou ainda
do {
    echo "Tentando conexão... (tentativa " . ++$tentativa . ")<br>";
    // Lógica de conexão aqui...
    if ($tentativa == 2) { // Simula sucesso na 2ª tentativa
        $conectou = true;
        echo "Conectado!<br>";
    }
} while (!$conectou && $tentativa < 3);

if (!$conectou) {
    echo "Falha ao conectar após $tentativa tentativas.<br>";
}
?>
foreach: a forma mais elegante e prática de iterar sobre os elementos de um array (ou propriedades de um objeto iterável). Abstrai o controle de índices ou ponteiros.
<?php
$cursos = ["PHP", "Laravel", "React", "Node.js"];

echo "Cursos da Rocketseat:<br>";
foreach ($cursos as $curso) { // Itera sobre os valores
    echo "- " . htmlspecialchars($curso) . "<br>"; // Boa prática escapar output
}

$instrutores = ["PHP" => "Mayk", "React" => "Diego", "Node.js" => "Rodrigo"];
echo "<br>Instrutores:<br>";
foreach ($instrutores as $tecnologia => $nome) { // Itera sobre chave e valor
    echo "- " . htmlspecialchars($tecnologia) . ": " . htmlspecialchars($nome) . "<br>";
}
?>
📄
Os loops são ferramentas poderosas para automatizar tarefas repetitivas. Para entender cada tipo em detalhes e ver mais exemplos, confira nosso artigo: Loops em PHP Explicados de Forma Simples.

3. Funções

Funções são blocos de código nomeados que realizam uma tarefa específica. Elas são a base da reutilização e organização em PHP (e em muitas outras linguagens). Ao invés de repetir o mesmo trecho de código várias vezes, você o encapsula em uma função e a chama sempre que precisar. Isso segue o princípio DRY (Don't Repeat Yourself - Não se Repita).
  • Definindo e chamando funções: a sintaxe é simples, usando a palavra-chave function.
<?php
// Define a função 'saudacao' que aceita um parâmetro $nome
// $nome tem um valor padrão "Dev", usado se nenhum argumento for passado
function saudacao($nome = "Dev") {
    // Retorna a string formatada
    return "Bem-vindo(a) à Rocketseat, " . htmlspecialchars($nome) . "!";
}

// Chama a função passando um argumento
$mensagemFernanda = saudacao("Fernanda");
echo $mensagemFernanda; // Exibe: Bem-vindo(a) à Rocketseat, Fernanda!

echo "<br>";

// Chama a função sem passar argumento, usando o valor padrão
$mensagemPadrao = saudacao();
echo $mensagemPadrao; // Exibe: Bem-vindo(a) à Rocketseat, Dev!
?>
  • Parâmetros e retorno: funções podem receber múltiplos dados como entrada (parâmetros/argumentos) e podem retornar um valor usando a instrução return. Se uma função não tiver um return explícito, ela retorna NULL por padrão.
  • Escopo de variáveis: é crucial entender o escopo. Variáveis definidas dentro de uma função (parâmetros ou criadas localmente) só existem dentro dela. Variáveis definidas fora não são automaticamente acessíveis dentro da função (a menos que passadas como argumento ou usando a palavra-chave global, que geralmente deve ser evitada por dificultar o rastreamento do fluxo de dados).
  • Funções nativas: PHP vem com um arsenal gigantesco de funções prontas para usar, cobrindo manipulação de strings, arrays, datas, matemática, arquivos, redes e muito mais! Algumas muito úteis que você usará frequentemente:
    • strlen($string): retorna o comprimento (número de bytes/caracteres) de uma string.
    • str_replace($busca, $substitui, $string): substitui todas as ocorrências de $busca por $substitui em $string.
    • count($array): conta o número de elementos em um array (ou propriedades de um objeto).
    • date($formato, $timestamp = null): formata uma data/hora local. Se $timestamp não for fornecido, usa a hora atual.
    • implode($separador, $array): junta os elementos de um array em uma única string, usando $separador entre eles.
    • explode($delimitador, $string): divide uma string em um array, usando $delimitador como ponto de quebra.
    • isset($variavel): verifica se uma variável foi definida e seu valor não é NULL. Essencial antes de acessar índices de array ou propriedades de objeto que podem não existir.
    • empty($variavel): verifica se uma variável é considerada "vazia" (p.ex., '', 0, '0', null, false, []). Útil para verificar se um formulário foi preenchido, por exemplo.
📄
As funções são a espinha dorsal da organização do seu código PHP. Para um guia detalhado sobre como criar e usar suas próprias funções, além de explorar mais exemplos, veja nosso post: PHP: Como Criar e Utilizar Funções.
Explore a documentação oficial para descobrir o vasto arsenal de funções nativas disponíveis! Dominar as estruturas de controle e as funções é o que vai permitir que você comece a construir lógicas realmente interessantes e úteis com PHP.

Organização e escalabilidade: PHP orientado a objetos (OOP)

À medida que suas aplicações crescem, organizar o código apenas com funções pode se tornar complicado. É aí que entra a Orientação a Objetos (OOP), um paradigma de programação que nos ajuda a modelar o mundo real (ou o problema que estamos resolvendo) usando objetos. É fundamental para o desenvolvimento moderno em PHP, especialmente ao usar frameworks.
Por que OOP?
  • Abstração: focar no essencial, escondendo detalhes complexos.
  • Encapsulamento: proteger os dados internos de um objeto, expondo apenas o necessário através de interfaces controladas (métodos).
  • Reutilização: herança permite criar novas classes baseadas em existentes, reaproveitando código.
  • Manutenção: código mais organizado é mais fácil de entender, modificar e depurar.
Conceitos fundamentais:
  • Classe: a planta, o molde para criar objetos. Define as propriedades (características) e métodos (ações) que os objetos desse tipo terão.
<?php
class Curso {
    // Propriedades (Atributos)
    public $nome; // Acessível de qualquer lugar
    private $cargaHoraria; // Acessível apenas dentro desta classe
    protected $instrutor; // Acessível aqui e em classes filhas

    // Construtor: Método especial chamado ao criar um objeto (new)
    public function __construct($nome, $cargaHoraria, $instrutor = "A definir") {
        $this->nome = $nome; // '$this' se refere ao objeto atual
        $this->setCargaHoraria($cargaHoraria);
        $this->instrutor = $instrutor;
        echo "Curso '{$this->nome}' criado!<br>";
    }

    // Métodos (Ações)
    public function getNome() {
        return $this->nome;
    }

    public function setCargaHoraria($horas) {
        if ($horas > 0) {
            $this->cargaHoraria = $horas;
        } else {
            $this->cargaHoraria = 10; // Valor padrão mínimo
        }
    }

    public function getCargaHoraria() {
        return $this->cargaHoraria;
    }

    // Destrutor: Chamado quando o objeto é destruído
    public function __destruct() {
        // echo "Curso '{$this->nome}' destruído.<br>"; // Útil para liberar recursos
    }
}
?>
Objeto: uma instância de uma classe. É a "coisa" real criada a partir do molde.
<?php
// Inclua a definição da classe Curso aqui...

// Criando objetos (instanciando a classe)
$cursoPHP = new Curso("Formação PHP Completa", 80, "Isabela");
$cursoJS = new Curso("JavaScript Moderno", 60);

// Acessando propriedades e métodos públicos
echo "Nome do curso: " . $cursoPHP->getNome() . "<br>"; // Formação PHP Completa
echo "Carga horária: " . $cursoPHP->getCargaHoraria() . " horas<br>"; // 80 horas

// $cursoPHP->cargaHoraria = -10; // Erro! 'cargaHoraria' é private
$cursoPHP->setCargaHoraria(-10); // Usa o método para validar
echo "Nova carga horária: " . $cursoPHP->getCargaHoraria() . " horas<br>"; // 10 horas (valor mínimo)

var_dump($cursoJS);
?>
Encapsulamento: controlar o acesso às propriedades e métodos usando public, private e protected. Isso protege o estado interno do objeto. Getters (como getNome()) e Setters (como setCargaHoraria()) são métodos usados para acessar e modificar propriedades privadas/protegidas de forma controlada.
Herança (extends): permite que uma classe (filha) herde propriedades e métodos de outra classe (pai), promovendo a reutilização.
<?php
// ... (classe Curso definida acima) ...

class CursoOnline extends Curso { // Herda de Curso
    public $plataforma = "Rocketseat Platform";

    public function exibirDetalhes() {
        // Acessa método público da classe pai
        echo "Curso: " . $this->getNome() . "<br>";
        // Acessa propriedade protegida da classe pai
        echo "Instrutor: " . $this->instrutor . "<br>";
        // Acessa propriedade da própria classe
        echo "Plataforma: " . $this->plataforma . "<br>";
    }
}

$cursoLaravel = new CursoOnline("Laravel Avançado", 50, "Mayk");
$cursoLaravel->exibirDetalhes();
?>
Conceitos adicionais (importantes para frameworks):
  • Interfaces: contratos que definem quais métodos uma classe deve implementar.
  • Classes abstratas: classes que não podem ser instanciadas diretamente, servindo como base para outras classes.
  • Traits: permitem reutilizar métodos em classes não relacionadas (uma forma de "herança horizontal").
  • Namespaces: evitam conflitos de nomes entre classes de diferentes bibliotecas ou partes do seu projeto.
  • Autoloading (PSR-4): padrão para carregar arquivos de classe automaticamente quando são necessários, geralmente gerenciado pelo Composer.
Dominar OOP é um passo crucial para se tornar um desenvolvedor PHP profissional e trabalhar com frameworks modernos como Laravel e Symfony.
Mesa com notebook, café e óculos, destacando tags PHP, simbolizando ambiente ideal para desenvolvimento em PHP.
Mesa com notebook, café e óculos, destacando tags PHP, simbolizando ambiente ideal para desenvolvimento em PHP.
🚀
Quer dominar OOP e aplicá-lo em projetos reais com a ajuda de quem entende do assunto? A Formação em PHP da Rocketseat te guia passo a passo, desde os fundamentos até a construção de aplicações completas usando as melhores práticas de OOP. Conte com projetos práticos e suporte personalizado via IA e nossa equipe de Sucesso do Aluno para destravar seu potencial. Clique aqui e conheça a Formação em PHP.

Interagindo com o mundo exterior: manipulação de arquivos e banco de dados

Aplicações web raramente vivem isoladas. Elas precisam ler configurações, escrever logs, e, o mais importante, armazenar e recuperar dados persistentes. O PHP brilha nessas tarefas!

1. Manipulação de arquivos

O PHP oferece funções simples para interagir com o sistema de arquivos:
  • Ler um arquivo inteiro: file_get_contents('arquivo.txt')
  • Escrever em um arquivo (sobrescrevendo): file_put_contents('log.txt', 'Nova entrada de log\n')
  • Adicionar a um arquivo: file_put_contents('log.txt', 'Outra entrada\n', FILE_APPEND)
  • Controle fino (abrir, ler/escrever, fechar): fopen(), fread(), fwrite(), fgets() (ler linha), fclose(). Mais complexo, mas oferece mais controle.
Exemplo: Escrevendo um log simples
<?php
$logMessage = date('[Y-m-d H:i:s]') . " Usuário 'Rodrigo' acessou o dashboard.\n";
file_put_contents('activity.log', $logMessage, FILE_APPEND);
echo "Log registrado com sucesso!";
?>
Cuidado: Ao trabalhar com arquivos, sempre considere as permissões do sistema operacional.

2. Interação com banco de dados: o poder do PDO

Esta é uma das maiores forças do PHP. A extensão PDO (PHP Data Objects) é a forma recomendada e moderna para se conectar e interagir com diversos sistemas de banco de dados (MySQL, PostgreSQL, SQLite, SQL Server, etc.) usando uma interface consistente.
Principais vantagens do PDO:
  • Abstração: seu código PHP para interagir com o banco muda pouco ou nada se você trocar MySQL por PostgreSQL, por exemplo.
  • Segurança: oferece suporte nativo a Prepared Statements, a principal defesa contra ataques de SQL Injection.
Passos essenciais com PDO:
  1. Conectar ao banco:
      2. <?php
$host = 'localhost'; // ou IP do servidor DB
$db   = 'rocketseat_cursos'; // Nome do banco de dados
$user = 'root'; // Usuário do banco
$pass = 'exemplo_senha'; // Senha do banco
$charset = 'utf8mb4';

// DSN (Data Source Name) - string de conexão
$dsn = "mysql:host=$host;dbname=$db;charset=$charset";

$options = [
    PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION, // Lança exceções em caso de erro
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,       // Retorna arrays associativos por padrão
    PDO::ATTR_EMULATE_PREPARES   => false,                  // Usa prepared statements nativos
];

try {
     $pdo = new PDO($dsn, $user, $pass, $options);
     // echo "Conectado ao banco '$db' com sucesso!";
} catch (\PDOException $e) {
     // Em produção: logar o erro, não exibir detalhes sensíveis
     throw new \PDOException($e->getMessage(), (int)$e->getCode());
     // die("Erro ao conectar ao banco de dados: " . $e->getMessage());
}
?>
      Use try...catch para lidar com possíveis erros de conexão.
  1. Executar queries (COM PREPARED STATEMENTS!)
      2. Sempre evite inserir variáveis diretamente na sua string SQL! Isso abre uma brecha enorme para SQL Injection. Use Prepared Statements:
      <?php
// --- Supondo que a conexão $pdo já existe ---

// INSERT (Inserir dados)
$nomeCurso = "Formação PHP Completa";
$cargaHoraria = 80;
$sql_insert = "INSERT INTO cursos (nome, carga_horaria) VALUES (?, ?)";
$stmt_insert = $pdo->prepare($sql_insert);
// $stmt_insert->execute([$nomeCurso, $cargaHoraria]); // Passa os valores em um array

// Ou usando placeholders nomeados:
$sql_insert_named = "INSERT INTO cursos (nome, carga_horaria) VALUES (:nome, :carga)";
$stmt_insert_named = $pdo->prepare($sql_insert_named);
// $stmt_insert_named->execute(['nome' => $nomeCurso, 'carga' => $cargaHoraria]);
// $idInserido = $pdo->lastInsertId(); // Pega o ID do último registro inserido

// SELECT (Buscar dados)
$busca = "PHP";
$sql_select = "SELECT * FROM cursos WHERE nome LIKE ?"; // Busca cursos com 'PHP' no nome
$stmt_select = $pdo->prepare($sql_select);
$stmt_select->execute(["%$busca%"]); // % é um curinga SQL
$cursosEncontrados = $stmt_select->fetchAll(); // Pega todos os resultados como array associativo

echo "<h2>Cursos encontrados com '$busca':</h2>";
if ($cursosEncontrados) {
    echo "<ul>";
    foreach ($cursosEncontrados as $curso) {
        echo "<li>" . htmlspecialchars($curso['nome']) . " (" . $curso['carga_horaria'] . "h)</li>";
    }
    echo "</ul>";
} else {
    echo "Nenhum curso encontrado.";
}

// UPDATE (Atualizar dados)
$idCursoAtualizar = 1; // Supondo que o curso com ID 1 existe
$novaCarga = 90;
$sql_update = "UPDATE cursos SET carga_horaria = :carga WHERE id = :id";
$stmt_update = $pdo->prepare($sql_update);
// $stmt_update->execute(['carga' => $novaCarga, 'id' => $idCursoAtualizar]);
// echo "Curso atualizado: " . $stmt_update->rowCount(); // Número de linhas afetadas

// DELETE (Remover dados)
$idCursoDeletar = 2;
$sql_delete = "DELETE FROM cursos WHERE id = ?";
$stmt_delete = $pdo->prepare($sql_delete);
// $stmt_delete->execute([$idCursoDeletar]);
// echo "Curso deletado: " . $stmt_delete->rowCount(); // Número de linhas afetadas
?>
      Note o uso de htmlspecialchars() ao exibir dados vindos do banco para prevenir XSS (veremos mais sobre segurança).
Dominar a interação com bancos de dados é essencial para qualquer aplicação backend, e o PDO torna isso seguro e eficiente em PHP.

Acelerando o desenvolvimento: frameworks populares de PHP

Embora seja possível construir aplicações complexas com PHP puro (como vimos até aqui), usar um framework pode acelerar drasticamente seu desenvolvimento, além de promover boas práticas e organização.
Balão de diálogo com exemplo de sintaxe básica de código PHP escrito em giz.
Balão de diálogo com exemplo de sintaxe básica de código PHP escrito em giz.

O que é um framework e por que usar?

Pense em um framework como uma caixa de ferramentas e uma planta baixa para construir sua casa (aplicação). Ele oferece:
  • Estrutura: uma organização de pastas e arquivos padronizada (geralmente seguindo o padrão MVC - Model-View-Controller).
  • Componentes reutilizáveis: ferramentas prontas para tarefas comuns como roteamento (URLs amigáveis), ORM (mapeamento objeto-relacional para banco de dados), sistemas de template (separar HTML do PHP), autenticação, validação de formulários, envio de emails, e muito mais.
  • Segurança: frameworks populares já vêm com proteções embutidas contra ataques comuns (como CSRF e, indiretamente, facilitam a prevenção de XSS e SQL Injection).
  • Boas práticas: incentivam o uso de padrões de projeto, OOP e código mais limpo.
  • Comunidade e ecossistema: suporte, documentação extensa, pacotes adicionais.

Os gigantes do PHP: Laravel e Symfony

  • Laravel: atualmente, é o framework PHP mais popular do mundo. Conhecido por sua sintaxe elegante, foco na "felicidade do desenvolvedor" (developer happiness), ecossistema rico (Forge, Vapor, Nova, Octane) e uma comunidade imensa. É extremamente produtivo para construir desde APIs RESTful até aplicações web completas, de pequeno a grande porte. Ideal para quem busca rapidez e um conjunto completo de ferramentas "out-of-the-box".
  • Symfony: um framework robusto e altamente flexível, composto por um conjunto de componentes PHP desacoplados e reutilizáveis (muitos dos quais são usados pelo próprio Laravel!). É uma escolha sólida para aplicações complexas, de larga escala e de longa duração, onde a flexibilidade e a arquitetura bem definida são cruciais. Empresas e projetos grandes frequentemente optam por Symfony.
Outros Frameworks:
  • CodeIgniter: conhecido por sua simplicidade, leveza e excelente documentação. Ótima opção para iniciantes em frameworks ou projetos menores.
  • CakePHP: outro framework veterano com foco em convenção sobre configuração e desenvolvimento rápido.
A escolha do framework depende do projeto, da equipe e da preferência pessoal. No entanto, Laravel e Symfony são, sem dúvida, os líderes atuais e excelentes opções para se aprofundar. Lembre-se: dominar os fundamentos do PHP e OOP é essencial para tirar o máximo proveito de qualquer framework!
🚀
Frameworks são o passaporte para o desenvolvimento PHP profissional e produtivo! Quer mergulhar fundo no framework mais popular do mercado? A Formação em PHP da Rocketseat tem um módulo completo dedicado a Laravel, onde você aprende do zero a construir aplicações robustas, com suporte dedicado e mentoria de carreira para te levar ao próximo nível. Descubra como dominar Laravel com a Rocketseat!

Código seguro e profissional: segurança e boas práticas em PHP

Escrever código que funciona é só o começo. Escrever código seguro e profissional é o que diferencia um amador de um dev de verdade. Segurança não é opcional!

Principais vulnerabilidades e como prevenir:

  1. SQL Injection:
      • Risco: permite que um atacante manipule suas queries SQL, podendo roubar, modificar ou deletar dados.
      • Prevenção: use Prepared Statements (com PDO ou o ORM do seu framework). Nunca concatene input do usuário diretamente na query.
  1. Cross-Site Scripting (XSS):
      • Risco: injeta scripts maliciosos (geralmente JavaScript) nas páginas vistas por outros usuários, podendo roubar sessões, cookies ou redirecionar para sites falsos.
      • Prevenção: escape dados de saída que vieram de fontes não confiáveis (usuários, banco de dados) antes de exibi-los no HTML. Use htmlspecialchars($variavel, ENT_QUOTES, 'UTF-8'). Frameworks geralmente têm helpers para isso nos templates. PHP
          • <?php
// $_POST['comentario'] veio de um formulário
$comentarioUsuario = $_POST['comentario'] ?? '';
// Exibição SEGURA:
echo '<p>' . htmlspecialchars($comentarioUsuario, ENT_QUOTES, 'UTF-8') . '</p>';
?>
  1. Cross-Site Request Forgery (CSRF):
      • Risco: engana um usuário autenticado para executar ações indesejadas na aplicação sem o seu conhecimento (ex: transferir fundos, deletar conta).
      • Prevenção: use tokens anti-CSRF em todos os formulários que realizam ações de escrita (POST, PUT, DELETE). Frameworks como Laravel e Symfony geralmente lidam com isso automaticamente.
  1. Gerenciamento de Senhas:
      • Risco: armazenar senhas em texto plano ou com hash inseguro (MD5, SHA1) facilita o roubo em caso de vazamento de dados.
      • Prevenção: use as funções password_hash() (para criar o hash ao salvar/atualizar senha) e password_verify() (para verificar a senha no login). Elas usam algoritmos fortes (como bcrypt) e incluem "salts" automaticamente.
  1. Inclusão de Arquivos e Uploads:
      • Risco: incluir arquivos com base em input do usuário (include $_GET['pagina']) ou permitir uploads sem validação pode levar à execução de código remoto ou sobrecarga do servidor.
      • Prevenção: valide rigorosamente qualquer caminho de arquivo vindo do usuário. Para uploads, valide tipo MIME, extensão, tamanho máximo e armazene os arquivos fora da raiz pública do site, se possível, ou com nomes aleatórios e permissões restritas.

Boas práticas essenciais:

  • Composer: use o Composer para gerenciar as dependências (bibliotecas externas) do seu projeto. Mantenha as dependências atualizadas (composer update).
  • PSRs (PHP Standards Recommendations): siga os padrões da comunidade, especialmente:
    • PSR-12 (Extended Coding Style): padroniza a formatação do código (espaços, indentação, etc.). Use ferramentas como PHP-CS-Fixer ou Pint (Laravel) para automatizar.
    • PSR-4 (Autoloader): padrão para carregamento automático de classes.
  • Tratamento de erros: configure error_reporting e display_errors adequadamente: mostre todos os erros em ambiente de desenvolvimento, mas em produção, desabilite a exibição e registre os erros em logs. Use blocos try...catch para lidar com exceções de forma graciosa.
  • Código limpo: escreva código legível. Use nomes claros para variáveis e funções. Mantenha funções e métodos curtos e focados em uma única tarefa. Evite código duplicado (princípio DRY).
  • Versionamento (Git): use Git (e plataformas como GitHub, GitLab, Bitbucket) para controlar as versões do seu código, facilitar o trabalho em equipe e ter um histórico seguro.
Adotar essas práticas desde o início fará de você um desenvolvedor PHP muito mais confiável e profissional.

Mãos à obra: ideias de projetos práticos para exercitar

A teoria é importante, mas é construindo que a mágica acontece! Colocar o conhecimento em prática é a melhor forma de solidificar o aprendizado e ganhar confiança.
Aqui estão algumas ideias de projetos, com dificuldade crescente, alinhadas ao universo que respiramos na Rocketseat:
  1. Calculadora de mensalidade: um formulário simples onde o usuário seleciona um curso (com valor base) e talvez um cupom de desconto, e o PHP calcula o valor final.
  1. Formulário de inscrição em evento: coleta nome, email e talvez a área de interesse do dev. Valida os dados no backend e salva em um arquivo de log ou (melhor ainda) em uma tabela simples no banco de dados usando PDO.
  1. Sistema de login básico: uma página de login que verifica usuário e senha (armazenada com password_hash()) no banco. Se válido, cria uma sessão ($_SESSION) para manter o usuário logado e redireciona para uma página de "dashboard" simples. Inclui uma página de logout.
  1. CRUD de conteúdos educacionais: um sistema para Criar, Ler, Atualizar e Deletar (CRUD) pequenos artigos ou dicas de programação. Use PHP puro com PDO e organize o código minimamente (talvez separando HTML e PHP).
  1. Blog educacional simples: crie posts com título e conteúdo, exiba uma lista de posts na home, e permita visualizar cada post individualmente. Bônus: Adicione categorias ou comentários simples.
Dicas:
  • Comece simples: não tente construir um clone do Facebook logo de cara! Escolha um projeto pequeno e adicione funcionalidades aos poucos.
  • Use Git: desde o primeiro echo "Hello World!" do seu projeto, inicialize um repositório Git. Faça commits frequentes.
  • Não tenha medo de errar: erros fazem parte do processo. Use var_dump(), logs e ferramentas de debug para entender o que está acontecendo.
  • Consulte a documentação: tenha a documentação do PHP sempre aberta.
Cada projeto concluído é uma vitória e um passo enorme na sua jornada para aprender PHP de verdade!

Indo além: recursos essenciais para aprofundamento

A jornada do aprendizado nunca termina! Felizmente, a comunidade PHP é vasta e existem muitos recursos excelentes para continuar evoluindo:
  1. Documentação oficial do PHP : Sua fonte número 1! É completa, bem organizada e tem exemplos para quase todas as funções e conceitos. Aprenda a navegar e pesquisar nela.
  1. Documentação dos Frameworks: Se você decidir usar Laravel, Symfony ou outro, a documentação oficial deles é o melhor lugar para aprender suas particularidades.
  1. Blog da Rocketseat: Continue explorando nossos conteúdos! Temos diversos artigos e tutoriais que se aprofundam em tópicos específicos.
  1. Comunidades Online:
      • Stack Overflow: Para tirar dúvidas específicas (pesquise antes de perguntar!).
      • GitHub: Explore projetos open-source em PHP para ver como outros devs estruturam seu código.
Seja curioso, continue estudando e, principalmente, continue codando!

Conclusão: decole sua carreira com PHP!

Ufa! Percorremos uma jornada e tanto neste guia, não é mesmo? Desde os fundamentos da sintaxe, passando pelo poder da Orientação a Objetos, a interação com bancos de dados, a eficiência dos frameworks como Laravel e Symfony, até a importância crucial da segurança e das boas práticas. Você agora tem um mapa claro para navegar no vasto e poderoso oceano do PHP.
Vimos que o PHP não só continua extremamente relevante, impulsionando uma parcela massiva da web, como também evoluiu para uma linguagem moderna, rápida e robusta. Aprender PHP abre portas para inúmeras oportunidades no mercado de trabalho, desde desenvolvimento de sites e e-commerces até APIs complexas e sistemas empresariais.
Mas sabemos que ter o mapa é diferente de ter um guia experiente ao seu lado durante a viagem. A teoria te leva longe, mas a prática acompanhada acelera sua evolução exponencialmente.
Está pronto para transformar esse conhecimento em uma carreira de sucesso? A Formação em PHP da Rocketseat é o seu foguete para o próximo nível! Não é apenas um curso, é uma experiência completa de aprendizado projetada para te levar do zero à preparação para o mercado.
Imagine ter:
  • ✅ Projetos práticos e completos que simulam desafios reais do mercado.
  • ✅ Suporte personalizado via IA da Rocketseat e nossa equipe de Sucesso do Aluno para nunca te deixar travar.
  • ✅ Tutorias individuais e em grupo para discutir seus estudos e carreira.
  • ✅ Mentoria de Carreira em 5 encontros focada em autoconhecimento, comunicação, LinkedIn, portfólio e mais!
  • ✅ Eventos ao vivo como o "Café com os Instrutores".
  • ✅ Talent Space: Eventos exclusivos com empresas parceiras para impulsionar sua carreira.
Não espere mais para investir no seu futuro! A Formação em PHP da Rocketseat é o caminho mais rápido e eficaz para você dominar a linguagem, construir um portfólio incrível e conquistar seu espaço no mercado de tecnologia.
👉
Clique aqui, conheça todos os detalhes da Formação em PHP e comece a construir seu futuro hoje mesmo.
O universo PHP te espera. Bora codar.
Artigos_

Explore conteúdos relacionados

Descubra mais artigos que complementam seu aprendizado e expandem seu conhecimento.

Aprenda programação do zero e DE GRAÇA

No Discover você vai descomplicar a programação, aprender a criar seu primeiro site com a mão na massa e iniciar sua transição de carreira.

COMECE A ESTUDAR AGORA