PHP Academy · Aula

Escopo de variáveis: local e global

Entenda como o PHP isola o escopo das funções e como usar a palavra-chave global.

Escopo de variáveis: local e global é 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.

Escopo de variáveis no PHP

No PHP, toda variável tem um escopo — a região do código onde ela pode ser acessada.

Variáveis criadas fora de funções estão no escopo global
Variáveis criadas dentro de funções estão no escopo local
O PHP NOT possui escopo de bloco (ao contrário de C ou JavaScript)

Escopo local

As variáveis dentro de uma função são locais — elas desaparecem quando a função retorna:

<?php
function compute(): void {
    $result = 42;  // local variable
    echo $result;  // 42
}

compute();
echo $result ?? 'undefined';  // undefined — $result is gone

Variáveis globais não ficam visíveis automaticamente

Ao contrário de muitas linguagens, as funções do PHP não conseguem ver variáveis globais por padrão — você precisa importá-las explicitamente:

<?php
$message = 'Hello';

function printMessage(): void {
    echo $message ?? 'not visible';  // 'not visible'
    // $message from global scope is not accessible here
}

A palavra-chave global

Use global $varName dentro de uma função para acessar uma variável global:

<?php
$counter = 0;

function increment(): void {
    global $counter;
    $counter++;
}

increment();
increment();
echo $counter;  // 2

Superglobal $GLOBALS

$GLOBALS é um array que contém todas as variáveis globais — acessível em qualquer lugar sem a palavra-chave global:

<?php
$total = 100;

function addTax(): void {
    $GLOBALS['total'] *= 1.18;  // 18% tax
}

addTax();
echo $total;  // 118

Por que evitar global

O uso excessivo de global cria dependências ocultas — as funções ficam difíceis de testar e depurar. Prefira passar valores como argumentos:

<?php
// Bad
$db = new PDO(/* ... */);
function getUsers(): array {
    global $db;
    return $db->query('SELECT * FROM users')->fetchAll();
}

// Good
function getUsers(PDO $db): array {
    return $db->query('SELECT * FROM users')->fetchAll();
}

Variáveis estáticas

Uma variável static mantém seu valor entre chamadas da função, mas continua sendo local à função:

<?php
function callCount(): int {
    static $count = 0;
    return ++$count;
}

echo callCount();  // 1
echo callCount();  // 2
echo callCount();  // 3

Fechamentos e captura de variáveis

Fechamentos (funções anônimas) podem capturar variáveis externas com use:

<?php
$prefix = 'Mr';

$greet = function(string $name) use ($prefix): string {
    return "$prefix. $name";
};

echo $greet('Smith');  // Mr. Smith

Captura por referência

Capture por referência com use (&$var) para que o fechamento possa modificar a variável externa:

<?php
$total = 0;

$add = function(int $n) use (&$total): void {
    $total += $n;
};

$add(10);
$add(5);
echo $total;  // 15

Funções de seta

As funções de seta do PHP 7.4 (fn =>) capturam automaticamente o escopo externo por valor — não é necessário usar use:

<?php
$multiplier = 3;
$nums = [1, 2, 3, 4];

$result = array_map(fn($n) => $n * $multiplier, $nums);

print_r($result);  // [3, 6, 9, 12]

Funções aninhadas

O PHP permite definir uma função dentro de outra, mas a função interna se torna acessível globalmente depois que a externa é chamada:

<?php
function outer(): void {
    function inner(): void {
        echo 'inner called';
    }
}

// inner(); // Fatal: undefined before outer() is called
outer();
inner(); // works now

Verificação rápida

O que uma variável static dentro de uma função do PHP faz?

Recapitulação: escopo de variáveis

Principais regras de escopo no PHP:

As funções têm seu próprio escopo local
As variáveis globais devem ser importadas com global
Use $GLOBALS['name'] como alternativa
As variáveis static persistem entre chamadas dentro de uma função
Os fechamentos capturam variáveis externas com use
As funções de seta capturam automaticamente por valor

Perguntas Frequentes

A aula “Escopo de variáveis: local e global” é grátis?

Sim — o texto completo de “Escopo de variáveis: local e global” é 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 “Escopo de variáveis: local e global”?

Entenda como o PHP isola o escopo das funções e como usar a palavra-chave global. 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 “Escopo de variáveis: local e global”?

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

← Voltar para PHP Academy