static

La palabra clave static en PHP

La palabra clave static en PHP tiene dos usos distintos, y conviene distinguirlos desde el principio:

1. Miembros de clase — static marca una propiedad o método como perteneciente a la clase en sí misma en lugar de a cualquier objeto individual. Se accede a él sin crear una instancia, y todas las instancias comparten el mismo valor.
2. Variables locales estáticas — dentro de una función, static hace que una variable local conserve su valor entre llamadas en lugar de reiniciarse cada vez.

Este capítulo cubre ambos usos, junto con las palabras clave relacionadas self, static:: y parent:: que casi siempre aparecen junto a los miembros estáticos. Si las clases y los objetos son nuevos para ti, lee primero Clases y Objetos.

Miembros de clase estáticos

Una propiedad normal existe en cada objeto. Una propiedad estática existe en la clase — hay exactamente una copia, compartida por todas las instancias y accesible incluso cuando no existe ninguna instancia.

Sintaxis básica

<?php

class MyClass {
  public static $myProperty = "Hello, world!";

  public static function myMethod() {
    return self::$myProperty;
  }
}

Para acceder a un miembro estático se usa el operador de resolución de ámbito ::, no el operador de objeto ->:

<?php

echo MyClass::$myProperty;   // Hello, world!
echo MyClass::myMethod();    // Hello, world!

Dentro de la clase, accede a tus propios miembros estáticos con self:: (o static::, explicado más adelante) — nunca con $this, ya que un método estático puede ejecutarse sin ningún objeto.

Para una cobertura más detallada, consulta Propiedades Estáticas y Métodos Estáticos.

Variables locales estáticas

La misma palabra clave hace algo completamente diferente dentro de una función: hace que una variable persista entre llamadas. Sin static, una variable local se reinicializa en cada llamada; con ella, el valor inicial se establece una sola vez y la variable conserva el valor que tenía la última vez.

<?php

function counter() {
  static $count = 0;   // initialised only on the first call
  $count++;
  return $count;
}

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

Esto resulta útil para almacenar en caché un resultado costoso o contar cuántas veces se ejecutó una función, sin exponer una variable global.

Ejemplos

Veamos algunos ejemplos prácticos de miembros de clase estáticos:

Ejemplos de la palabra clave static en PHP

<?php

// Example 1
class Counter
{
  public static $count = 0;

  public static function increment()
  {
    self::$count++;
  }
}

Counter::increment();
Counter::increment();
echo Counter::$count . PHP_EOL;

// Example 2
class User
{
  public static $name;

  public static function setName($name)
  {
    self::$name = $name;
  }
}

User::setName("John Doe");
echo User::$name;

En Counter, la propiedad estática $count es compartida, por lo que dos llamadas a increment() acumulan 2. En User, setName() almacena datos en la clase misma en lugar de en algún objeto.

self vs static (enlace estático tardío)

Cuando haces referencia a un miembro estático desde dentro de un método, tienes dos opciones, y la diferencia importa en la herencia:

• self:: se resuelve en tiempo de compilación — siempre apunta a la clase donde está escrito el código.
• static:: usa el enlace estático tardío — se resuelve en tiempo de ejecución a la clase que fue llamada realmente.

<?php

class Base {
  public static function create() {
    return new static();   // runtime class
  }
  public static function createSelf() {
    return new self();     // always Base
  }
}

class Child extends Base {}

echo get_class(Child::create());     // Child
echo "\n";
echo get_class(Child::createSelf()); // Base

Usa static:: cuando una subclase deba poder sobreescribir un comportamiento o ser la que se instancia — el patrón anterior es la base de los métodos de fábrica. Usa self:: cuando te refieras específicamente a esta clase. Para llamar al método estático de un padre, usa parent::. Consulta Herencia para una visión más amplia.

Casos de uso comunes

• Contadores y estado compartido — un único valor rastreado en todas las instancias, como el Counter anterior.
• Métodos de utilidad/ayuda — funciones sin estado agrupadas bajo una clase, p. ej. Math::clamp(), llamadas sin un objeto.
• Métodos de fábrica — User::fromArray($data) devuelve una instancia configurada; new static() lo mantiene compatible con subclases.
• Singletons y cachés simples — una propiedad estática almacena la instancia única o un resultado memoizado.

Para valores compartidos con nombre e inmutables, prefiere una constante de clase sobre una propiedad estática.

Errores comunes

• No hay $this en los métodos estáticos. Un método estático puede ser llamado sin un objeto, por lo que $this no está definido. Acceder al estado de instancia desde un método estático es un indicio de mal diseño.
• Las propiedades estáticas son estado compartido de tipo global. Como todas las instancias comparten la misma copia, mutarla desde cualquier lugar afecta a todos — fácil de introducir acoplamiento oculto y de romper el aislamiento en las pruebas. Úsala de forma deliberada.
• :: para estático, -> para instancia. MyClass::$prop (estático) frente a $obj->prop (instancia). Nota que $ permanece en el nombre de la propiedad en la forma estática: Counter::$count, no Counter::count.
• Las variables locales estáticas son por función, no por llamada. Dos llamadas recursivas comparten la misma variable static, lo que ocasionalmente puede sorprender.

Conclusión

La palabra clave static cumple dos funciones: define propiedades y métodos a nivel de clase compartidos entre todas las instancias y accesibles sin un objeto, y hace que la variable local de una función sobreviva entre llamadas. Combínala con self::, static:: y parent:: para controlar exactamente a qué clase se resuelven tus llamadas estáticas. Usa miembros estáticos para estado genuinamente compartido y funciones de ayuda sin estado — pero trata los datos estáticos mutables compartidos con la misma precaución que usarías con una variable global.

Práctica