Newsgroup: it.comp.www.php
Titolo: Moduli

Eccomi qui, un primo aiuto per vedere se ho capito come articolare il
mio progetto (ovviamente, no!)
config.php
------------
<?php
$config['dir'] = "/home/mirko/public_html/test";
$config['www'] = "
http://localhost/test
";
?>
------------
functions/general.php
------------
<?php
function my_include($filename)
{
	global $config;
	if(file_exists($config['dir'].'/'.$filename))
		include_once($config['dir'].'/'.$filename);
	else
	{
		header('Location: '.$config['www'].'/index.php?mod=error');
		exit;
	}
}
function isNotEmpty($string)
{
	if(strlen(strip_tags(trim($string)))>0)
		return(TRUE);
	else
		return(FALSE);
}
?>
-------------
index.php
<?php
require_once('config.php');
require_once('functions/general.php');
class index
{
	private $mod;
	function __construct()
	{
		if(isset($_GET['mod']) AND isNotEmpty($_GET['mod']))
			$this->mod = $_GET['mod'];
		else
			$this->mod = "default";
	}
	function insert_module()
	{
		my_include('modules/'.$this->mod.'.php');
	}
}
$index = new index;
$index->insert_module();
?>
-----------------------
Ha un minimo di senso quello che ho scritto? :-)
Funzionare, funziona...

 Funzionare, funziona...
Alcune migliorie: non usare global (passa la variabile come parametro 
della funzione my_include(), poi nelle classi tratta sempre variabili 
d'istanza e non variabili globali o superglobal: il valore $_GET['mod'] 
passalo come parametro al costruttore. Uno dei vantaggi della 
programmazione OOP è riciclare l codice, ma se lo leghi troppo alla 
struttura del progetto diventa soltato un raccoglitore di funzioni, poco 
mantenibile e difficilmente debuggabile.
Un'altra cosa, è terribile nel metodo insert_module la chiamata ad una 
funzione esterna. Male male, se non puoi fare altrimenti, trasforma la 
funzione my_include come metodo statico della classe index, oppure di 
una classe gerarchicamente superiore (potresti pensare ad una classe 
formata solo da metodi statici, come classe di servizio, praticamente 
una libreria di funzioni)
My two cents,
	Francesco

 una libreria di funzioni)
Volevo fare appunto di index una sorta di libreria di funzioni. Quindi
tu mi consigli di inglobare tutto lì dentro, considerando che sarà
gerarchicamente sempre la prima classe?
Il problema nasce da questo fatto:
supponiamo che l'utente chiami index.php?mod=post
A questo punto verrà incluso il modulo "post" per inserire qualcosa
nel database.
Il fatto è che post.php altro non è che la classe post che estende
index... ma ho inizializzato la classe index... non è sbagliato tutto
ciò?

 comunque?
Tranne per questo punto, ho modificato come mi hai consigliato.
Come faccio a passare un $_GET? Dovrei prima accertarmi che esista, ma
a questo punto non avrebbe senso utilizzare la programmazione a
oggetti, no?
Ora lo script è così:
config.php
-----------------------
<?php
define("root", "/home/mirko/public_html/test");			#Percorso della
directory di root
define("www", "
http://localhost/test
");					#Indirizzo della directory
di root
?>
----------------------
index.php
----------------------
<?php
require_once('config.php');				#Include le variabili di configurazione
class index
{
	private $mod;
	function __construct()
	{
		if(isset($_GET['mod']) AND $this->stringNotEmpty($_GET['mod']))
			$this->mod = $_GET['mod'];
		else
			$this->mod = "default";
	}
	function include_file($filename)
	{
		if(file_exists(root.'/'.$filename))
			include_once(root.'/'.$filename);
		else
		{
			header('Location: '.www.'/index.php?mod=error');
			exit;
		}
	}
	#Carica il modulo richiesto
	function insert_module()
	{
		$this->include_file('modules/'.$this->mod.'.php');
	}
	function stringNotEmpty($string)
	{
		if($string==TRUE AND strlen(strip_tags(trim($string)))>0)
			return(TRUE);
		else
			return(FALSE);
	}
}
$index = new index;
$index->insert_module();	#Carica il modulo richiesto dall'utente o
quello di default
?>
----------------------
Resta comunque il problema di prima... dopo dovrò instanziare una
classe che è figlia di index... ha senso?

 classe che č figlia di index... ha senso?
Mi sono perso un pň nel tuo ragionamento...praticamente vuoi passare un 
parametro a index.php e in base a quest'ultimo istanziare la relativa 
classe, giusto?
Allora potresti fare:
index.php
$get_value = isset($_GET['mod'] ? $_GET['mod'] : null);
switch($get_value) {
   case 'post':
      $obj = new post();
      break;
   case 'form':
      $obj = new forum();
      break;
   default:
      $obj = new index();
      bfreak;
}
Per l'include delle classi, usa on metodo __autoload()
	Francesco

         Francesco
Sì, ok, fin qui c'ero :-)
Ma se queste classi che devo instanziare solo figlie di una classe già
istanziata?
Esempio:
istanzio index, grazie a index includo post.php, che contiene la
classe post figlia di index... ha senso questo?
E per quanto riguarda il problema del get?

Mumble... ora che ci penso, non è meglio se la classe la istanzio nel
file che includo e che appunto la contiene?
Perché comunque anche lì dovrei fare un controllo sul GET per sapere
cosa c'è da fare (mostrare un form, inserire dei dati, mostrare un
errore...).
Oppure il controllo lo posso inserire nel costruttore?

 E per quanto riguarda il problema del get?
Non ti seguo...nell'esempio che ti avevo postato, il file index.php non 
è una classe, ma istanzia l'oggetto che hai richiesto: prima controlla 
un eventuale parametro get, gestendo l'errore (opzione default del case) 
e poi, istanzia la classe richiesta. Non capisco la tua perplessità 
sulla classe index.
	Francesco


Ah... quindi tu mi consigli di rimuovere la classe index, ho capito
bene?

Ah no, scusa, forse ora ho capito quello che mi stai consigliando:
la classe index la lascio lì ma non la istanzio, istanzio la classe
figlia (quella che mi serve) dopo averla inclusa nel modo da te
suggerito. Ho capito bene?

 suggerito. Ho capito bene?
Si č quello che avevo tentato (male) di scriverti.
Sicuramente avrai una situazione in cui istanzierai la classe index (per 
esempio l'home page). Un conto č la classe index, un conto č il file 
index.php che fa da "router".
	Francesco

         Francesco
Ti sarei molto grato se guardassi come ho modificato il tutto...
config.php
---------------------------
<?php
define("root", "/home/mirko/public_html/test");			#Percorso della
directory di root
define("www", "
http://localhost/test
");					#Indirizzo della directory
di root
define("module_default", "default");					#Modulo di default (deve
essere inserito anche nella lista dei moduli supportati!)
define("module_error", "default");						#Modulo di errore (deve essere
inserito anche nella lista dei moduli supportati!)
/* ------------------------ */
/* Elenco moduli supportati */
/* ------------------------ */
$modules[]= "default";
$modules[]= "error";
?>
-------------------------------------------
index.php
-------------------------------------------
<?php
require_once('config.php');				#Include le variabili di configurazione
class index
{
	static function error($error_text = "non ancora definito")
	{
		index::redirect('/index.php?mod='.module_error);
	}
	static function include_file($filename)
	{
		if(file_exists(root.'/'.$filename))
			include_once(root.'/'.$filename);
		else
			index::error("Si sta cercando di includere un file non esistente");
	}
	static function is_module($module_name)
	{
		global $modules;
		if(index::stringNotEmpty($module_name) AND in_array($module_name,
$modules))
			return(TRUE);
		else
			return(FALSE);
	}
	static function redirect($url)
	{
		header('Location: '.www.$url);
		exit;
	}
	static function stringNotEmpty($string)
	{
		if(strlen(strip_tags(trim($string))))
			return(TRUE);
		else
			return(FALSE);
	}
}
if(isset($_GET['mod']))
{
	if(index::is_module($_GET['mod']))
		$mod = $_GET['mod'];
	else
		index::error("Il modulo richiesto non è esistente");
}
else
	$mod = module_default;
index::include_file("modules/".$mod.".php");
?>
------------------------------------------
Che ne dici?