• Ámbito local
• Ámbito global
• Ámbito estático
• Parámetros
• Punto de vista profesional

Ámbito de variables, es una frase que hace referencia a la parte del programa donde una variable es accesible. También se conoce como scope y se traduce precisamente como ámbito o alcance, de manera directa, el ámbito puede ser global o local pero ya veremos que hay más matices.

# Ámbito local

function testLocal(): string {
    $text = 'My local text';
    
    return $text;
}

echo testLocal(); // Imprime "My local text"

echo $text; // Warning: Undefined variable $text 

En este ejemplo, la variable $text se define dentro de la función testLocal(), por eso su ámbito es local, es decir, solo vive o es accesible dentro de esa función. Cuando intentamos acceder a $text fuera de la función, obtenemos un error porque no está definida en ese contexto.

Es sencillo deducir que específicamente la variable $text funcionará dentro de las llaves {} de la función testLocal(). Eso es todo.

De hecho, este simple concepto confirma que las funciones son bloques independientes.

function testLocal(): string {
    $text = 'My local text';
    
    return $text;
}

$text = 'My global text';

echo testLocal(); // Imprime "My local text"

echo $text; // Imprime "My global text"

Aquí vemos que la variable $text se define dos veces, una dentro de la función y otra fuera. Pero cada una tiene su propio ámbito y por eso no hay conflicto, es decir, no interfieren ni chocan entre sí.

# Ámbito global

Ya vimos que si defines una variable fuera de una función, su ámbito es global y es accesible desde cualquier parte del código, excepto desde dentro de las funciones. Mira que interesante:

$textGlobal = 'My global text';

function testLocal(): string {
    $text = $textGlobal ?? 'My local text';
    
    return $text;
}

echo testLocal(); // Imprime "My local text"

Este operador ?? se lllama null coalescing operator (en español es operador de fusión nula), y lo usé para trabajar con un condicional sencillo, si $textGlobal no está definido (o es null), entonces se asigna el valor 'My local text' a $text.

Y eso fue lo que sucedió, que dentro de la función testLocal(), la variable $textGlobal no está definida porque su ámbito es global, por ello vemos que se asigna el valor por defecto 'My local text'.

Conclusión rápida, "las funciones no pueden acceder a las variables globales directamente".

Pero veamos una excepción a esta regla.

$textGlobal = 'My global text';

function testLocal(): string {
    global $textGlobal;
    
    $text = $textGlobal ?? 'My local text';
    
    return $text;
}

echo testLocal(); // Imprime "My global text"

Aquí trabajamos con la palabra global, que en realidad habla por sí misma, es decir, le dice a la función que queremos usar la variable global $textGlobal dentro de su ámbito local.

También podemos usar el array superglobal $GLOBALS, que es un array asociativo que contiene todas las variables globales del script. Veamos cómo funciona:

$textGlobal = 'My global text';

function testLocal(): string {
    $text = $GLOBALS['textGlobal'] ?? 'My local text';

    return $text;
}

echo testLocal(); // Imprime "My global text"

# Ámbito estático

Esto es interesante, porque lo normal es que cuando una función termina, todas las variables locales se destruyen. Pero si las declaramos como static, su valor se conserva entre llamadas a la función. Es decir, la particularidad del ámbito estático es que las variables locales conservan su valor entre llamadas a la función.

function appName() {
    static $name = null;

    if ($name === null) {
        $name = 'Estudia PHP';
    }
    
    return $name;
}

echo appName(); // Imprime "Estudia PHP"

Aunque también podemos apoyarnos en el ejercicio clásico del contador para entender mejor el ámbito estático:

function counter(): int {
    static $count = 0;
    
    $count++;
    
    return $count;
}

echo counter(); // Imprime 1
echo counter(); // Imprime 2
echo counter(); // Imprime 3

Si quitas la palabra static, cada vez que llames a la función counter(), la variable $count se reiniciará a 0, y siempre devolverá el valor 1.

# Parámetros

Cómo puedes imaginar, los parámetros de una función tienen ámbito local, es decir, solo son accesibles dentro de la función. Veamos un ejemplo:

function testParam($param) {
    return $param;
}

echo testParam('Esto es un test'); // Imprime "Esto es un test"

Aquí, $param es un parámetro de la función testParam(), y solo existe dentro de esa función.

Me gustaría que revises el artículo sobre Funciones en PHP explicadas de forma simple para entender mejor cómo funcionan los parámetros y las funciones en general.

Y para complementar, te dejo lo siguiente:

• Local: Existe solo dentro de la función.
• Global: Existe en todo el código, excepto dentro de las funciones.
• Estático: Existe dentro de la función y conserva su valor, es decir, no destruye nada al terminar o salir de la función.
• Parámetros: Son variables locales que se pasan desde fuera de la función.

# Punto de vista profesional

Desde un punto de vista profesional, es crucial entender este tema. En un examen técnico, de certificación o en una entrevista de trabajo, es común que te pregunten al respecto porque brinda contexto sobre tu nivel de conocimiento en programación y del lenguaje PHP.

Pero te hago una fuerte advertencia: basar nuestras soluciones en el ámbito global es una mala práctica, de hecho, es un error de diseño común entre principiantes.

¿Por qué?

1. Mantenimiento: Un proyecto que dependa de $GLOBALS, global o elementos globales en general, es difícil de mantener. Esto causa verdaderas molestias a la hora de depurar errores o añadir nuevas funcionalidades.
2. Acoplamiento: El objetivo es siempre alta cohesión y bajo acoplamiento. Esto forma parte de los principios SOLID y es fundamental para escribir código limpio y sostenible. El objetivo es que las funciones y cualquier pieza de código sean lo más independientes posible.
3. Legibilidad: Un código así es difícil de leer, de seguir y de entender. Si una función depende de variables globales, es complicado saber qué datos está utilizando sin revisar todo o varias partes del código.
4. Pruebas: El objetivo es que los tests sean aislados y confiables. Siempre debes poder ejecutar una función o método sin depender de nada externo.

Si esto es tan malo, ¿por qué existe y por qué lo explico?

Hay varias respuestas:

1. Es algo que existe en PHP, te servirá para entender código de terceros.
2. En muchas ocasiones, puede ser útil para cualquier código simple o pequeño.
3. Si quieres entender las buenas prácticas, primero debes conocer las malas para poder evitarlas.
4. Si deseas certificarte o presentarte a un examen técnico, es probable que te pregunten sobre este tema.

Recuerda que PHP existe desde 1995, y en esa época se trabajaba con PHP y HTML mezclados, sin patrones de diseño, sin buenas prácticas y sin orientación a objetos. Era muy común ver como los documentos iniciaban con variables globales y luego funciones que las usaban.

Entiendo que en ese momento $GLOBALS y global eran útiles, pero hoy en día, con las buenas prácticas y la programación orientada a objetos, es mejor evitarlas.

Mala práctica:

$GLOBALS['cart'] = [];

function addItem(string $item): void {
    $GLOBALS['cart'][] = $item;
}

function getItems(): array {
    return $GLOBALS['cart'];
}

addItem('Laptop');
addItem('Mouse Pad');
addItem('Keyboard');

print_r(getItems());

/* Imprime
Array
(
    [0] => Laptop
    [1] => Mouse Pad
    [2] => Keyboard
)
*/

Buena práctica:

class Cart 
{
    private array $items = [];

    public function addItem(string $item): void 
    {
        $this->items[] = $item;
    }

    public function getItems(): array 
    {
        return $this->items;
    }
}

$cart = new Cart();

$cart->addItem('Laptop');
$cart->addItem('Mouse Pad');
$cart->addItem('Keyboard');

print_r($cart->getItems());

/* Imprime
Array
(
    [0] => Laptop
    [1] => Mouse Pad
    [2] => Keyboard
)
*/

En ambos casos, el resultado es el mismo, pero la segunda opción es mucho más limpia, fácil de mantener y mucho más profesional.

En términos generales, debemos siempre encapsular, evitar variables globales y diseñar nuestro código para que sea lo más independiente posible. Como puedes ver, tiene sentido explicarlo.

Las variables viven en diferentes mundos (scopes). Tu tarea como programador profesional es saber cuáles existen, cuál usar, y cuándo dejar atrás las viejas prácticas y malas costumbres.