() translation by (you can also view the original English article)
En este artículo, vamos a discutir los fundamentos de los constructores en PHP. Aprenderás el propósito de los constructores de PHP y cómo usarlos.
¿Qué es un constructor?
Esta es la definición oficial:
Los constructores son métodos ordinarios que se llaman durante la instanciación de su correspondiente objeto. Como tales, pueden definir un número arbitrario de argumentos, que pueden ser necesarios, pueden tener un tipo y pueden tener un valor por defecto. Los argumentos del constructor se llaman colocando los argumentos entre paréntesis después del nombre de la clase. Manual de PHP: Constructores y Destructores
Cuando instancias un objeto de cualquier clase, y si esa clase ha definido el método constructor, este será llamado automáticamente. Si el método constructor ha definido algún argumento obligatorio, debes pasar esos argumentos también cuando instancias un objeto de esa clase.
Veamos rápidamente cómo es un método constructor en PHP.
1 |
<?php
|
2 |
class tutsplus { |
3 |
public function __construct() |
4 |
{
|
5 |
// you can initialize object properties here
|
6 |
echo 'Hey, you have just instantiated a new object!'; |
7 |
}
|
8 |
}
|
9 |
|
10 |
$objTutsplus = new tutsplus(); |
11 |
// output: Hey, you have just instantiated a new object!
|
12 |
?>
|
Así es como puedes definir un constructor en tu clase. Debes definir el método __construct en tu clase, y se convierte en el método constructor de tu clase. En el ejemplo anterior, cada vez que instancies el objeto tutsplus, el método __construct será llamado primero. Es importante notar que debes definir un método constructor como público, ¡o no podrás instanciar un objeto de tu clase!
Antes de PHP 5, para definir un constructor, se utilizaba una función con el mismo nombre que la clase en la que se definía, ¡y se trataba como un método constructor! Puede que estés familiarizado con esta forma de declarar constructores de otros lenguajes de programación como C++. En PHP, se llaman constructores estilo PHP4, y no se recomienda usar este estilo, ya que van a ser obsoletos tarde o temprano.
Revisemos el ejemplo anterior para ver cómo sería el constructor en una versión anterior de PHP:
1 |
<?php
|
2 |
class tutsplus { |
3 |
public function tutsplus() |
4 |
{
|
5 |
// you can initialize object properties here
|
6 |
echo 'Hey, you have just instantiated a new object!'; |
7 |
}
|
8 |
}
|
9 |
|
10 |
$objTutsplus = new tutsplus(); |
11 |
// output: Hey, you have just instantiated a new object!
|
12 |
?>
|
En el momento de escribir este artículo, este ejemplo seguía funcionando. ¡Pruébalo!
¿Para qué sirve un constructor?
Ahora ya sabes cómo declarar un método constructor en PHP, pero ¿cuál es el uso de un método constructor? Eso es lo que discutiremos en esta sección, con un par de ejemplos del mundo real.
Inicialización de las propiedades requeridas
El propósito principal de un método constructor es inicializar las propiedades de un objeto cuando se está creando. El beneficio de este enfoque es que no tienes que llamar a los métodos setter más tarde para inicializar las propiedades del objeto después de la creación de un objeto. Así que si crees que un objeto debe tener algunas propiedades establecidas, un método constructor es el camino a seguir.
Veamos rápidamente el siguiente ejemplo para entender cómo funciona.
1 |
<?php
|
2 |
class tutsplusAuthor |
3 |
{
|
4 |
private $author_name; |
5 |
private $author_email; |
6 |
|
7 |
public function __construct($name, $email) |
8 |
{
|
9 |
$this->author_name = $name; |
10 |
$this->author_email = $email; |
11 |
}
|
12 |
|
13 |
public function getAuthorName() |
14 |
{
|
15 |
return $this->author_name; |
16 |
}
|
17 |
|
18 |
public function getAuthorEmail() |
19 |
{
|
20 |
return $this->author_email; |
21 |
}
|
22 |
}
|
23 |
|
24 |
$objTutsplusAuthor = new tutsplusAuthor("John", "john@tutsplus.com"); |
25 |
echo $objTutsplusAuthor->getAuthorName(); |
26 |
echo $objTutsplusAuthor->getAuthorEmail(); |
27 |
?>
|
Como puedes ver, cuando el objeto tutsplusAuthor es instanciado, el método __construct es llamado. El método __construct espera dos argumentos, y hemos pasado esos dos argumentos cuando creamos el nuevo objeto: new tutsplusAuthor("John", "john@tutsplus.com"). Finalmente, hemos inicializado las propiedades author_name y author_email a los valores correspondientes que se pasan en el método __construct. Así que de esta manera, puedes inicializar las propiedades de los objetos con un método constructor.
Si intentaras instanciar el objeto tutsplusAuthor sin pasar ningún argumento, obtendrías un error fatal, como se muestra en el siguiente fragmento.
1 |
<?php
|
2 |
// try to instantiate tutsplusAuthor without arguments
|
3 |
$objTutsplusAuthor = new tutsplusAuthor(); |
4 |
// output
|
5 |
// PHP Fatal error: Uncaught ArgumentCountError: Too few arguments to function tutsplusAuthor::__construct(), 0 passed in /public_html/examples/constructor.php on line 24 and exactly 2 expected in /public_html/examples/constructor.php
|
6 |
?>
|
Por lo tanto, debes asegurarte de pasar los argumentos necesarios cuando instales el objeto tutsplusAuthor.
Comprobación de tipo de los argumentos del constructor
De hecho, también puedes hacer una comprobación de tipo si quieres asegurarte de que los argumentos son de tipos específicos.
1 |
<?php
|
2 |
class tutsplusAuthor |
3 |
{
|
4 |
...
|
5 |
...
|
6 |
public function __construct(string $name, string $email, array $hobbies) |
7 |
{
|
8 |
$this->author_name = $name; |
9 |
$this->author_email = $email; |
10 |
$this->hobbies = $hobbies; |
11 |
}
|
12 |
...
|
13 |
...
|
14 |
}
|
En el ejemplo anterior, debes pasar los dos primeros argumentos de tipo string, y el último argumento debe ser de tipo array. Si pasas un valor de cadena en el último argumento, obtendrás el siguiente error:
1 |
PHP Fatal error: Uncaught TypeError: Argument 3 passed to tutsplusAuthor::__construct() must be of the type array, string given |
Así es como se puede hacer una comprobación de tipos estricta con los argumentos del constructor.
Inicialización de la conexión a la base de datos
Otro uso de un constructor es hacer alguna I/O: por ejemplo, abrir un archivo y comenzar a leer su contenido, comenzar una solicitud de la API, o crear una conexión a una base de datos.
Veamos un ejemplo de un constructor que crea una conexión a la base de datos.
1 |
<?php
|
2 |
class Database |
3 |
{
|
4 |
private $host; |
5 |
private $user; |
6 |
private $password; |
7 |
private $dbname; |
8 |
private $connection; |
9 |
|
10 |
public function __construct($host, $user, $password, $dbname) |
11 |
{
|
12 |
$this->host=$host; |
13 |
$this->user=$user; |
14 |
$this->password=$password; |
15 |
$this->dbname=$dbname; |
16 |
|
17 |
$this->connection = mysqli_connect($this->host, $this->user, $this->password, $this->dbname); |
18 |
|
19 |
if (!$this->connection) { |
20 |
die("connection failed: " . mysqli_connect_error()); |
21 |
}
|
22 |
}
|
23 |
|
24 |
// other DBAL methods
|
25 |
}
|
26 |
?>
|
Cómo llamar a un constructor de la clase padre
En esta última sección, veremos cómo se puede llamar a los constructores de la clase padre. Si conoces el concepto de herencia, sabrás que una clase puede extender a otra para construir sobre sus funcionalidades.
Ahora bien, existe la posibilidad de que tanto la clase hija como la clase padre tengan sus propios constructores. Entonces, ¿cómo llamarías al constructor de la clase padre cuando se está instanciando un objeto de la clase hija?
Intentemos entenderlo con un ejemplo.
1 |
<?php
|
2 |
class Person |
3 |
{
|
4 |
private $name; |
5 |
|
6 |
public function __construct($name) |
7 |
{
|
8 |
$this->name=$name; |
9 |
}
|
10 |
}
|
11 |
|
12 |
class Employee extends Person |
13 |
{
|
14 |
private $employee_id; |
15 |
|
16 |
public function __construct($name, $employee_id) |
17 |
{
|
18 |
parent::__construct($name); |
19 |
$this->employee_id=$employee_id; |
20 |
}
|
21 |
}
|
22 |
$obj=new Employee('John', 'J123'); |
23 |
?>
|
Como puedes ver, la clase Employee extiende la clase Person. Ahora, cuando el objeto Employee es instanciado, se llama al método __construct() de la clase Employee. En este método, hemos utilizado la palabra clave especial parent para llamar al método __construct() de la clase parent. Y por lo tanto, terminaría llamando al método __construct() de la clase Person. Siempre es una buena práctica llamar al método __construct() de la clase padre si tu clase extiende alguna clase.
Conclusión
Hoy hemos hablado de los constructores en PHP, junto con un par de ejemplos del mundo real. Has visto cómo crear un constructor y algunos casos de uso de los constructores en las clases de PHP.
Consulta algunas de nuestras otras publicaciones sobre programación orientada a objetos en PHP.
