Te comento lo siguiente > Los objetos que tengan que ser creados dentro de tu desarrollo no solo en PHP sino en cualquier lenguaje deben ser analizados a profundidad puesto que

Si por ejemplo tengo esta clase

<?php

class DB
{
	public $server;
	public $user;
	public $pass;
	public $data;
	
	public function __construct($server, $user, $pass, $data)
	{
		$this->server = $server;
		$this->user = $user;
		$this->pass = $pass;
		$this->data = $data;
	}
	
	public function conectando()
	{
		return "Ahora estoy conectado";
	}
}

Y ahora por ejemplo creamos un objeto instanciado de la clase anterior

$obj = new DB("localhost", "root", "secret", "demo");
var_dump($obj);

Y ahora nuestra app la ejecutan 3000 usuarios concurrentes, pues imagina el impacto que eso tiene en el rendimiento considerando que por cada petición del usuario, se va a crear un objeto instanciado de la clase anterior.

Lo anterior afecta por que es espacio de memoria ocupado considerando que se crea una copia de la clase DB ahora contenida en el objeto $obj

Por lo tanto se hace necesario que dentro de cada clase que tiene un método constructor, se declare al mismo tiempo un método destructor que elimine de memoria la presencia de los elementos de dicha clase, quedando de este modo

<?php

class DB
{
	public $server;
	public $user;
	public $pass;
	public $data;
	
	public function __construct($server, $user, $pass, $data)
	{
		$this->server = $server;
		$this->user = $user;
		$this->pass = $pass;
		$this->data = $data;
	}
	
	public function conectando()
	{
		return "Ahora estoy conectado";
	}
	
	public function __destruct()
	{
		echo "Conexión destruida";
	}
}

$obj = new DB("localhost", "root", "secret", "demo");
var_dump($obj);

Lo cual nos da como resultado lo siguiente

object(DB)#1 (4) { ["server"]=> string(9) "localhost" ["user"]=> string(4) "root" ["pass"]=> string(6) "secret" ["data"]=> string(4) "demo" } Conexión destruida

Entonces como puedes observar ayuda a que cada clase no mantenga en memoria la instancia de si misma si no que una vez que es procesada sea inmediatamente destruida para que de este modo cumpla con su cometido pero no siga existiendo después de ello.

¿Pero cuántos objetos debo crear en mi App?

Considera lo siguiente partimos de que una Class debe tener métodos y propiedades que le sean afines a su propia existencia en si misma

Pero te puedes apoyar para por ejemplo reducir la cantidad de clases el uso de traits o de las interfaces para tener métodos que esperas utilizar en muchas clases, con lo que estas pueden ser menos.

Por otro lado si a lo anterior le sumamos el uso de __construct() para destruir lo que ya no se ocupa después de su onvocación ayudarás a aligerar a tu App

EJEMPLO 1

---

Si por ejemplo tenemos varias clases dentro de un CRUD para hacer op, a los datos almacenados podemos declararlos dentro de interfaces así:

interface CRUD{
	public function getAll();
	public function deleteOne();
	public function updateOne();
}

Con lo anterior puedes implementar dichos métodos en múltiples clases que hagan uso de ellos y evitar involucrar a otra clase para ello

EJEMPLO 2

---

O bien también lo puedes hacer con los traits, la única diferencia notable es que estos exigen que los métodos tengan cuerpo, es decir que indiques su funcionalidad interna

trait CRUD
{
	public function getAll()
	{
		return "Todos los registros";
	}
	
	public function deleteOne()
	{
		return "Eliminando un registro";
	}
}

CONCLUSIONES

• Aunque la App sea grande no implica necesariamente la misma cantidad de clases o métodos
• Depende de la destreza para proponer la arquitectura de la App lo que derive en mas o menos líneas de código
• Siempre que un lenguaje permita el uso del recolector de basura como PHP con el método __construct() se debería utilizar

Espero la explicación te sirva...

Muchas gracias por tu respuesta Alberto! Me ha sido de mucha ayuda!

Saludos!

Te comento lo siguiente > Los objetos que tengan que ser creados dentro de tu desarrollo no solo en PHP sino en cualquier lenguaje deben ser analizados a profundidad puesto que

Si por ejemplo tengo esta clase

<?php

class DB
{
	public $server;
	public $user;
	public $pass;
	public $data;
	
	public function __construct($server, $user, $pass, $data)
	{
		$this->server = $server;
		$this->user = $user;
		$this->pass = $pass;
		$this->data = $data;
	}
	
	public function conectando()
	{
		return "Ahora estoy conectado";
	}
}

Y ahora por ejemplo creamos un objeto instanciado de la clase anterior

$obj = new DB("localhost", "root", "secret", "demo");
var_dump($obj);

Y ahora nuestra app la ejecutan 3000 usuarios concurrentes, pues imagina el impacto que eso tiene en el rendimiento considerando que por cada petición del usuario, se va a crear un objeto instanciado de la clase anterior.

Lo anterior afecta por que es espacio de memoria ocupado considerando que se crea una copia de la clase DB ahora contenida en el objeto $obj

Por lo tanto se hace necesario que dentro de cada clase que tiene un método constructor, se declare al mismo tiempo un método destructor que elimine de memoria la presencia de los elementos de dicha clase, quedando de este modo

<?php

class DB
{
	public $server;
	public $user;
	public $pass;
	public $data;
	
	public function __construct($server, $user, $pass, $data)
	{
		$this->server = $server;
		$this->user = $user;
		$this->pass = $pass;
		$this->data = $data;
	}
	
	public function conectando()
	{
		return "Ahora estoy conectado";
	}
	
	public function __destruct()
	{
		echo "Conexión destruida";
	}
}

$obj = new DB("localhost", "root", "secret", "demo");
var_dump($obj);

Lo cual nos da como resultado lo siguiente

object(DB)#1 (4) { ["server"]=> string(9) "localhost" ["user"]=> string(4) "root" ["pass"]=> string(6) "secret" ["data"]=> string(4) "demo" } Conexión destruida

Entonces como puedes observar ayuda a que cada clase no mantenga en memoria la instancia de si misma si no que una vez que es procesada sea inmediatamente destruida para que de este modo cumpla con su cometido pero no siga existiendo después de ello.

¿Pero cuántos objetos debo crear en mi App?

Considera lo siguiente partimos de que una Class debe tener métodos y propiedades que le sean afines a su propia existencia en si misma

Pero te puedes apoyar para por ejemplo reducir la cantidad de clases el uso de traits o de las interfaces para tener métodos que esperas utilizar en muchas clases, con lo que estas pueden ser menos.

Por otro lado si a lo anterior le sumamos el uso de __construct() para destruir lo que ya no se ocupa después de su onvocación ayudarás a aligerar a tu App

EJEMPLO 1

---

Si por ejemplo tenemos varias clases dentro de un CRUD para hacer op, a los datos almacenados podemos declararlos dentro de interfaces así:

interface CRUD{
	public function getAll();
	public function deleteOne();
	public function updateOne();
}

Con lo anterior puedes implementar dichos métodos en múltiples clases que hagan uso de ellos y evitar involucrar a otra clase para ello

EJEMPLO 2

---

O bien también lo puedes hacer con los traits, la única diferencia notable es que estos exigen que los métodos tengan cuerpo, es decir que indiques su funcionalidad interna

trait CRUD
{
	public function getAll()
	{
		return "Todos los registros";
	}
	
	public function deleteOne()
	{
		return "Eliminando un registro";
	}
}

CONCLUSIONES

• Aunque la App sea grande no implica necesariamente la misma cantidad de clases o métodos
• Depende de la destreza para proponer la arquitectura de la App lo que derive en mas o menos líneas de código
• Siempre que un lenguaje permita el uso del recolector de basura como PHP con el método __construct() se debería utilizar

Espero la explicación te sirva...

Muchas gracias por tu respuesta Alberto! Me ha sido de mucha ayuda!

Saludos!

Te comento lo siguiente > Los objetos que tengan que ser creados dentro de tu desarrollo no solo en PHP sino en cualquier lenguaje deben ser analizados a profundidad puesto que

Si por ejemplo tengo esta clase

<?php

class DB
{
	public $server;
	public $user;
	public $pass;
	public $data;
	
	public function __construct($server, $user, $pass, $data)
	{
		$this->server = $server;
		$this->user = $user;
		$this->pass = $pass;
		$this->data = $data;
	}
	
	public function conectando()
	{
		return "Ahora estoy conectado";
	}
}

Y ahora por ejemplo creamos un objeto instanciado de la clase anterior

$obj = new DB("localhost", "root", "secret", "demo");
var_dump($obj);

Y ahora nuestra app la ejecutan 3000 usuarios concurrentes, pues imagina el impacto que eso tiene en el rendimiento considerando que por cada petición del usuario, se va a crear un objeto instanciado de la clase anterior.

Lo anterior afecta por que es espacio de memoria ocupado considerando que se crea una copia de la clase DB ahora contenida en el objeto $obj

Por lo tanto se hace necesario que dentro de cada clase que tiene un método constructor, se declare al mismo tiempo un método destructor que elimine de memoria la presencia de los elementos de dicha clase, quedando de este modo

<?php

class DB
{
	public $server;
	public $user;
	public $pass;
	public $data;
	
	public function __construct($server, $user, $pass, $data)
	{
		$this->server = $server;
		$this->user = $user;
		$this->pass = $pass;
		$this->data = $data;
	}
	
	public function conectando()
	{
		return "Ahora estoy conectado";
	}
	
	public function __destruct()
	{
		echo "Conexión destruida";
	}
}

$obj = new DB("localhost", "root", "secret", "demo");
var_dump($obj);

Lo cual nos da como resultado lo siguiente

object(DB)#1 (4) { ["server"]=> string(9) "localhost" ["user"]=> string(4) "root" ["pass"]=> string(6) "secret" ["data"]=> string(4) "demo" } Conexión destruida

Entonces como puedes observar ayuda a que cada clase no mantenga en memoria la instancia de si misma si no que una vez que es procesada sea inmediatamente destruida para que de este modo cumpla con su cometido pero no siga existiendo después de ello.

¿Pero cuántos objetos debo crear en mi App?

Considera lo siguiente partimos de que una Class debe tener métodos y propiedades que le sean afines a su propia existencia en si misma

Pero te puedes apoyar para por ejemplo reducir la cantidad de clases el uso de traits o de las interfaces para tener métodos que esperas utilizar en muchas clases, con lo que estas pueden ser menos.

Por otro lado si a lo anterior le sumamos el uso de __construct() para destruir lo que ya no se ocupa después de su onvocación ayudarás a aligerar a tu App

EJEMPLO 1

---

Si por ejemplo tenemos varias clases dentro de un CRUD para hacer op, a los datos almacenados podemos declararlos dentro de interfaces así:

interface CRUD{
	public function getAll();
	public function deleteOne();
	public function updateOne();
}

Con lo anterior puedes implementar dichos métodos en múltiples clases que hagan uso de ellos y evitar involucrar a otra clase para ello

EJEMPLO 2

---

O bien también lo puedes hacer con los traits, la única diferencia notable es que estos exigen que los métodos tengan cuerpo, es decir que indiques su funcionalidad interna

trait CRUD
{
	public function getAll()
	{
		return "Todos los registros";
	}
	
	public function deleteOne()
	{
		return "Eliminando un registro";
	}
}

CONCLUSIONES

• Aunque la App sea grande no implica necesariamente la misma cantidad de clases o métodos
• Depende de la destreza para proponer la arquitectura de la App lo que derive en mas o menos líneas de código
• Siempre que un lenguaje permita el uso del recolector de basura como PHP con el método __construct() se debería utilizar

Espero la explicación te sirva...

Muchas gracias por tu respuesta Alberto! Me ha sido de mucha ayuda!

Saludos!