0Pricing
PHP Academy · Aula

Inclusão e exigência de arquivos

Divida páginas em partes reutilizáveis com include e require.

Inclusão e exigência de arquivos é uma aula grátis de PHP Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de PHP Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de PHP Academy inclui 4 aulas no total.

Reutilização de código com inclusão de arquivos

O PHP fornece quatro instruções para incluir código de outros arquivos:

  • include — incluir arquivo; aviso se estiver ausente
  • require — incluir arquivo; erro fatal se estiver ausente
  • include_once — incluir somente se ainda não tiver sido incluído
  • require_once — exigir somente se ainda não tiver sido incluído

include e require

A principal diferença: um arquivo require ausente causa um erro fatal; um include ausente apenas gera um aviso:

<?php
// Fatal error if missing — use for critical files
require 'config.php';
require 'database.php';

// Warning if missing, but execution continues
include 'optional_plugin.php';

// Use __DIR__ for reliable relative paths:
require __DIR__ . '/helpers/utils.php';

include_once e require_once

As variantes _once impedem que o mesmo arquivo seja incluído várias vezes:

<?php
// Without _once: including twice redefines functions
include 'functions.php';
include 'functions.php';  // Fatal: function redefined!

// With _once: second include is a no-op
require_once 'functions.php';
require_once 'functions.php';  // safe — skipped

// Rule: use require_once for class and function definition files

Escopo de variáveis em arquivos incluídos

Os arquivos incluídos compartilham o escopo do arquivo que os inclui — mas não o escopo de uma função:

<?php
// main.php
$title = 'My Site';
require 'header.php';  // header.php can use $title

// But in a function:
function loadTemplate(): void {
    require 'header.php';  // $title is NOT accessible here!
    // Must pass data explicitly
}

Retornando valores de arquivos incluídos

Os arquivos incluídos podem retornar valores usando a instrução return:

<?php
// config.php content:
// return ['debug' => true, 'db_host' => 'localhost'];

// main.php:
$config = require 'config.php';
echo $config['db_host'];  // localhost

// Common pattern for configuration files that return arrays

Criando um layout simples

Divida uma página em arquivos reutilizáveis de cabeçalho, conteúdo e rodapé:

<?php
// index.php
$pageTitle = 'Home Page';
$bodyClass = 'home';

require_once 'partials/header.php';
?>

<main class="container">
    <h1>Welcome!</h1>
    <p>Main content goes here.</p>
</main>

<?php require_once 'partials/footer.php'; ?>

Parciais de modelos

Crie arquivos parciais de visualização reutilizáveis para componentes repetidos:

<?php
// partials/card.php
// Expects: $card['title'], $card['body'], $card['url']
?>

<div class="card">
    <h3><a href="<?= htmlspecialchars($card['url']) ?>">
        <?= htmlspecialchars($card['title']) ?>
    </a></h3>
    <p><?= htmlspecialchars($card['body']) ?></p>
</div>

Passando variáveis para parciais

Passe dados para uma parcial atribuindo uma variável local antes da inclusão:

<?php
$articles = getArticles();

foreach ($articles as $article) {
    $card = [
        'title' => $article['title'],
        'body'  => substr($article['body'], 0, 100) . '...',
        'url'   => '/articles/' . $article['slug'],
    ];
    require 'partials/card.php';
}

include versus carregamento automático

No PHP moderno com Composer, os arquivos de classes são carregados automaticamente — não é necessário incluí-los manualmente:

<?php
// Old way (manual includes):
require 'classes/User.php';
require 'classes/Post.php';

// Modern way (Composer autoloading):
require __DIR__ . '/vendor/autoload.php';

// Classes are loaded automatically when first used
$user = new User();  // User.php loaded by autoloader
$post = new Post();  // Post.php loaded by autoloader

Segurança: evite a travessia de diretórios

Nunca inclua arquivos com base em uma entrada do usuário que não tenha sido validada:

<?php
// DANGEROUS:
$page = $_GET['page'];
include $page . '.php';  // allows ../../etc/passwd

// SAFE: whitelist allowed pages
$allowed = ['home', 'about', 'contact'];
$page = $_GET['page'] ?? 'home';

if (!in_array($page, $allowed)) {
    $page = 'home';
}

include __DIR__ . '/pages/' . $page . '.php';

Configuração de include_path

Configure o include_path do PHP para poder incluir arquivos sem caminhos completos:

<?php
// Current include_path:
echo get_include_path();

// Add your library directory:
set_include_path(
    get_include_path() . PATH_SEPARATOR . '/var/www/lib'
);

// Now you can include without full path:
include 'helpers.php';  // found in /var/www/lib/helpers.php

Verificação rápida

Qual é a diferença entre include e require quando o arquivo está ausente?

Recapitulação: inclusão de arquivos

Resumo:

  • require — erro fatal se estiver ausente; use para arquivos essenciais
  • include — aviso se estiver ausente; use para arquivos opcionais
  • As variantes _once impedem o carregamento duplicado
  • Os arquivos incluídos compartilham o escopo de variáveis do chamador
  • Os arquivos podem retornar valores com return
  • Nunca inclua caminhos provenientes da entrada do usuário — use somente uma lista de permissões

Perguntas Frequentes

A aula “Inclusão e exigência de arquivos” é grátis?

Sim — o texto completo de “Inclusão e exigência de arquivos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de PHP Academy, atualize para CoddyKit PRO. O curso de PHP Academy inclui 4 aulas no total.

O que vou aprender em “Inclusão e exigência de arquivos”?

Divida páginas em partes reutilizáveis com include e require. Você pratica PHP Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar PHP Academy?

Nenhuma experiência prévia é necessária. PHP Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Inclusão e exigência de arquivos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de PHP Academy?

Sim. Cada aula de PHP Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Tags do PHP e sintaxe de incorporação
  2. HTML dinâmico com loops do PHP
  3. Inclusão e exigência de arquivos
  4. Padrão de modelos: separando a lógica da visualização
← Voltar para PHP Academy