Dubbio sulla definizione delle Classi

[Rubberick]

Salve a tutti difficilmente mi sono trovato a dover usare la programmazione ad oggetti in php...

Oggi pero' mi volevo scrivere una classettina di comodo per interagire col mysql in modo pulito e veloce...

Vado a leggermi il manuale di riferimento e trovo scritto:

<?php
class Cart {
/* questo non funziona in PHP 4. */
    var $todays_date = date("Y-m-d");
    var $name = $firstname;
    var $owner = 'Fred ' . 'Jones';
    /* E' permesso l'uso di matrici contenenti costanti */
    var $items = array("VCR", "TV");
}

/* Questo è corretto. */
class Cart {
    var $todays_date;
    var $name;
    var $owner;
    var $items;
    var $items = array("VCR", "TV");
    function Cart() {
        $this->todays_date = date("Y-m-d");
        $this->name = $GLOBALS['firstname'];
        /* etc ... */
    }
}
?>

In pratica, mi dice... non inizializzare le variabili dato all'interno della classe, fallo solo se si tratta di costanti, per inizializzarle usa il costruttore della classe...

Tuttavia ho fatto delle prove e ho visto script anche molto seri programmati fregandosene di questa regola e inizializzando i valori direttamente nella definizione addirittura senza l'utilizzo del costruttore...

Il manuale in questo senso riporta un qualcosa di obsoleto? non si usa + l'inizializzazione mediante costruttore da tempo? se non inzializzo mediante costruttore posso andare in grossi problemi di incompatibilita'?

Ok... poi se potete ricordatemi un'altra cosa... il distruttore va dichiarato e deve contenere tutti i vari unset delle variabili dato allocate oppure se non lo metto al momento della distruzione dell'oggetto tutta la memoria delle variabili dato viene pulita senza problemi?

Thank You

[Ratatuia]

in entrambi i casi non usi un array di costanti ma un array di stringhe, che in php non sono costanti...

[whisher]

Ciao.

/* Questo è corretto. */
class Cart {
    var $todays_date;
    var $name;
    var $owner;
    var $items;
    var $items;
    function Cart() {
        $this->todays_date = date("Y-m-d");
        $this->items = array("VCR", "TV");
        $this->name = $GLOBALS['firstname'];
        /* etc ... */
    }
} 

Questo è il metodo corretto e funziona
anche con php 4 (il manuale si riferisce
all'uso della parola chiave __construct).

PHP 5 introduces a destructor concept similar to that of other object-oriented languages, such as C++. The destructor method will be called as soon as all references to a particular object are removed or when the object is explicitly destroyed.

Il destructor vale solo per PHP5.

[Rubberick]

Forse non mi sono spiegato io... ho copiato il codice dalla pagina del manuale..

il mio dubbio e' che sia questo

class abc {

var $dato = 123;

}

$a = new abc; $a->dato = 567;

che questo

class abc {

var $dato;

function abc() {
$this->dato = 123;
}

}

$a = new abc; $a->dato = 567;

funzionano su php4... nello specifico sto con php su windows versione 4.4.2 modulo apache

percio' chiedevo se cio che e' scritto nella guida e' obsoleto o meno... in quanto con questa versione sia l'una che l'altra vanno... provato di persona... la guida dice che il primo metodo si puo' usare ma solo se il dato che viene creato e' una costante...

invece funziona... boh ^^

[whisher]

Ci mancherebbe altro !
Mi posti il link del manuale
xchè nonho mai letto una cosa simile.
Con PHP5 si sono aggiunti public, private, or protected

The visibility of a property or method can be defined by prefixing the declaration with the keywords: public, protected or private. Public declared items can be accessed everywhere. Protected limits access to inherited and parent classes (and to the class that defines the item). Private limits visibility only to the class that defines the item.

se provi ad utilizzare queste modalità su PHP4
ti dà errore.

[Rubberick]

Voce del manuale php: Capitolo 18. Classi e Oggetti (PHP 4)

In PHP 4, sono permesse inizializzazioni di variabili con valori costanti solamente grazie all'uso di var. Per inizializzare variabili con valori non-costanti, bisogna creare una funzione d'inizializzazione che è chiamata automaticamente all'istanziazione di un oggetto da una classe. Questo tipo di funzione si chiama costruttore (vedi sotto).

<?php
class Cart {
/* questo non funziona in PHP 4. */
    var $todays_date = date("Y-m-d");
    var $name = $firstname;
    var $owner = 'Fred ' . 'Jones';
    /* E' permesso l'uso di matrici contenenti costanti */
    var $items = array("VCR", "TV");
}

/* Questo è corretto. */
class Cart {
    var $todays_date;
    var $name;
    var $owner;
    var $items;
    var $items = array("VCR", "TV");
    function Cart() {
        $this->todays_date = date("Y-m-d");
        $this->name = $GLOBALS['firstname'];
        /* etc ... */
    }
}
?>

Minkia... o_O ho capito ^^'

Intende che non possono essere dati valori tipo funzioni in quanto quella e' solo una dichiarazione... non che dopo nn possano essere cambiati ^^'

Il manuale poteva esser scritto con un po' + di chiarezza ^^

[andr3a]

class Pluto {}

class Pippo {
	
	// vanno [sono costanti]
	var	$nulla = null,
		$intera = 1,
		$floattante = 1.2,
		$booleana = true,
		$stringa = "ciao",
		$array = array(null, 1, 1.2, true, "ciao");

	/** non vanno
	var	$pluto = new Pluto(),
		$anno = date("Y"),
                $array2 = array($this->stringa, "... altro"),
                $function = create_function('', 'return true;');
        // */
	
	//** ma puoi fare così
	var	$pluto,
		$anno,
                $array2,
                $function;
	
	// constructor
	function Pippo() {
		$this->pluto 	= new Pluto();
		$this->anno	= date("Y");
                $this->array2	= array($this->stringa, "... altro");
                $this->function = create_function('', 'return true;');
	}
	// */
	
	/** ... o per avere un costruttore PHP5 anche in PHP 4 ... 
	function __construct() {
		$this->pluto 	= new Pluto();
		$this->anno	= date("Y");
                $this->array2	= array($this->stringa, "... altro");
                $this->function = create_function('', 'return true;');
	}
	function Pippo() {
		$construct = array();
		for($i = 0, $j = func_num_args(); $i < $j; $i++)
			array_push($construct, '$_'.$i.'=func_get_arg('.$i.')');
		eval('$this->__construct('.implode(',', $construct).');');
	}
        // */
	
	function showYear() {
		echo 'Anno: '.$this->anno.'
';
	}
	
}

$pippo = new Pippo();
$pippo->showYear();


// questa inveve non va, non potendo impostare $anno
// Pippo::showYear(); 	// Anno:
			// Notice: Undefined variable: this in test.php on line 438

[Rubberick]

Sisi ho capito

Pensavo che il problema fosse + "fine"...

Ovvero l'impossibilita' di definire un valore a meno che questo non fosse sempre costante...

un po' come il const del c++

credevo che scrivendo una cosa del genere...


class Pippo() {

var abc = 123;

}
$x = new Pippo;

$x->abc = 543;

mi andasse in errore perche' non ho mantenuto costante abc al valore 123 per tutto il tempo

[andr3a]

costanti a livello di pseudo compilazione ... poi che siano tipi mutabili è un altro discorso.

L'esecuzione del costruttore, dei metodi o di qualunqe funzione è runtime, lo stato delle operazioni / importazioni è predefinito ma anche i valori devono essere predefiniti o assegnabili in modo statico (tanto il C dietro lavora con una sfilza di statiche ...)

quindi fare quello in classe è come fare questo in funzione

function anno($anno = date("Y")) {
	echo $anno;
}

non è possibile perchè il dato non puoi predefinirlo.

Anche le costanti vere e proprie hanno un comportamento analogo, solo che viene valutato il ritorno dell'assegnazione

define('ANNO', date("Y"));

ANNO viene definito come tipo immutabile con valore 2006

define('TEST', create_function('', 'return "test";'));

TEST viene definito come lambda N ... ma non sarà possibile fare
echo TEST();