new

La palabra clave new en PHP

Una clase es un plano; un objeto (o instancia) es algo concreto construido a partir de ese plano. La palabra clave new es lo que lo construye: asigna un nuevo objeto, ejecuta el constructor de la clase y te devuelve una referencia al resultado. Casi siempre que trabajas con objetos en PHP, new es el punto de partida.

Esta página cubre la sintaxis de new, lo que ocurre cuando la llamas, cómo funcionan los argumentos del constructor y las variaciones modernas que encontrarás en código real (nombres de clases dinámicos, new self/new static, clases anónimas y la forma sin paréntesis añadida en PHP 8.4).

Sintaxis

$object = new ClassName(arguments);

• new desencadena la instanciación.
• ClassName es la clase a instanciar.
• arguments se pasan al método __construct() de la clase. Si la clase no tiene constructor, o su constructor no toma parámetros, puedes usar paréntesis vacíos new ClassName().

El resultado es un identificador de objeto asignado a $object. Llamar a new de nuevo sobre la misma clase produce un objeto separado e independiente.

Un primer ejemplo

<?php

class Greeter
{
  public function sayHello(): void
  {
    echo "Hello!";
  }
}

$object = new Greeter();
$object->sayHello();
// Output: Hello!

Una vez que el objeto existe, usas el operador -> para llamar a sus métodos y leer sus propiedades.

Pasar argumentos al constructor

Si la clase define un método __construct(), los argumentos que colocas en los paréntesis después de new se envían a él. Así es como cada objeto recibe su propio estado inicial:

<?php

class User
{
  public function __construct(public string $name) {}
}

$alice = new User("Alice");
$bob   = new User("Bob");

echo $alice->name; // Alice
echo "\n";
echo $bob->name;   // Bob

$alice y $bob son dos objetos distintos de la misma clase, cada uno con su propio $name. Aprende más en Constructor de PHP.

Crear un objeto a partir de un nombre de clase variable

La clase a instanciar no tiene que estar fija en el código: puede provenir de una variable. Esta es la base de las fábricas, los sistemas de plugins y los contenedores de dependencias:

<?php

class PdfReport {}
class CsvReport {}

$type = "Csv";
$className = $type . "Report"; // "CsvReport"

$report = new $className();
echo get_class($report);
// Output: CsvReport

new self, new static y new parent

Dentro de una clase, a menudo necesitas crear otra instancia de la misma clase. Dos palabras clave hacen esto, y la diferencia importa cuando hay herencia:

• new self — siempre instancia la clase donde está escrita la línea.
• new static — instancia la clase real en tiempo de ejecución (enlace estático tardío), por lo que las subclases obtienen su propio tipo.

<?php

class Animal
{
  public static function create(): static
  {
    return new static();
  }
}

class Dog extends Animal {}

echo get_class(Animal::create()); // Animal
echo "\n";
echo get_class(Dog::create());    // Dog (thanks to `new static`)

Si create() hubiera usado new self(), ambas llamadas devolverían Animal. Consulta Palabra clave Static para más información sobre el enlace estático tardío.

Clases anónimas

Cuando necesitas un objeto de un solo uso y no quieres darle nombre a una clase, new class crea e instancia una clase anónima en una sola expresión:

<?php

$logger = new class {
  public function log(string $message): void
  {
    echo "LOG: $message";
  }
};

$logger->log("started");
// Output: LOG: started

Las clases anónimas pueden recibir argumentos del constructor, implementar interfaces y extender otras clases; son útiles para mocks rápidos y callbacks ligeros.

Llamar a un método directamente sobre new (PHP 8.4+)

Históricamente había que envolver una expresión new entre paréntesis para llamar a un método sobre el objeto recién creado. Desde PHP 8.4 los paréntesis son opcionales:

// PHP 8.4 and later:
$name = new User("Alice")->name;

// Before PHP 8.4 you had to write:
$name = (new User("Alice"))->name;

Usa la forma con paréntesis si necesitas compatibilidad con PHP 8.3 o versiones anteriores.

Errores comunes

• new devuelve un objeto, nunca una copia. Asignar el objeto a otra variable copia el identificador, no el objeto. Para obtener un duplicado independiente, usa clone.
• Los argumentos faltantes lanzan un error. Si el constructor declara parámetros obligatorios y los omites, PHP lanza un ArgumentCountError.
• Olvidar los paréntesis en una instanciación simple. new MyClass (sin paréntesis) solo es válido cuando no se requieren argumentos en el constructor; prefiere new MyClass() para mayor claridad fuera del caso de encadenamiento de métodos de la versión 8.4.

Temas relacionados

• Clases y Objetos de PHP — la base sobre la que construye new.
• Constructor de PHP — cómo se reciben los argumentos de new.
• clone — duplicar un objeto ya creado.
• Palabra clave Static — new static y el enlace estático tardío.

Práctica