Qual é a diferença entre include e require?

Question

Accepted Answer

Tanto `include` quanto `require` importam (e executam) o conteúdo de outro arquivo PHP no arquivo atual. A **única diferença é como tratam falhas**: `require` causa um erro fatal se o arquivo estiver faltando, enquanto `include` apenas emite um aviso e continua.

## A diferença chave: comportamento em caso de falha

```php
<?php
include "config.php";    // if missing → WARNING, script CONTINUES
require "database.php";  // if missing → FATAL ERROR, script STOPS
```

```text
include → file missing → emits a Warning, execution continues (file's code skipped)
require → file missing → throws a Fatal Error, execution HALTS
```

Use **`require`** para arquivos que a aplicação **não consegue executar sem** (classes centrais, configurações críticas, setup de banco de dados) — você quer que pare bruscamente se estiverem faltando. Use **`include`** para arquivos opcionais (ex: um template de sidebar) onde um arquivo faltando não deveria derrubar a página.

## As variantes _once (previnem inclusão dupla)

```php
require_once "functions.php";   // include the file ONLY if not already included
include_once "helper.php";
```

`require_once`/`include_once` importam o arquivo apenas se ele ainda não foi importado — **essencial** para evitar erros "cannot redeclare function/class" quando um arquivo pode ser incluído múltiplas vezes (ex: uma definição de classe usada por vários arquivos).

## O que a inclusão realmente faz

```php
// included files share the SAME scope and can define functions, classes, variables
// config.php:
$dbHost = "localhost";
// main.php:
require "config.php";
echo $dbHost;   // "localhost" — the variable is available
```

## PHP moderno: autoloading substitui includes manuais

```php
// ❌ old style — manually requiring every class file
require_once "User.php";
require_once "Order.php";

// ✅ modern — Composer AUTOLOADING loads classes on demand automatically
require "vendor/autoload.php";   // one line; classes load when used (PSR-4)
$user = new User();               // User.php loaded automatically
```

Em PHP moderno, você raramente usa `require` manual para classes — o **autoloader do Composer** carrega-as sob demanda. Você ainda usa `require "vendor/autoload.php"` uma vez para ativá-lo.

## Por que isso importa

Entender `include` vs `require` é conhecimento básico mas importante em PHP — é como arquivos PHP compartilham código, e a distinção importa para a correção.

O ponto-chave é o comportamento em caso de falha: **`require` para arquivos essenciais** (assim a app falha rápido e claramente se um arquivo crítico estiver faltando) e **`include` para os opcionais** (assim um arquivo não crítico faltando não derruba a página).

Saber as **variantes `_once`** é praticamente essencial para prevenir os comuns erros "cannot redeclare" de acidentalmente incluir uma definição de classe ou função duas vezes.

Igualmente importante é entender o contexto moderno: embora esses construtos sejam fundamentais, **PHP moderno depende do autoloading do Composer** (carregar classes sob demanda) em vez de require manual de cada arquivo, então em código atual você principalmente faz `require "vendor/autoload.php"` uma vez e deixa o autoloading lidar com o resto.

Saber tanto a mecânica de include/require (e quando cada modo de falha é apropriado) quanto como o autoloading moderno substitui includes manuais é conhecimento do dia a dia para trabalhar com bases de código PHP antigas e novas.