Newsgroup: it.comp.www.php
Titolo: fopen/fclose

) vedo esempi tipo
questo:
<?php
        $handle = fopen('somefile.txt', 'r');
        fclose($handle);
?>
In pratica suggerisce che la fclose() deve essere sempre eseguita, senza
controllare che la fopen sia andata o meno a buon fine. Mi pare
azzardato, ho ragione?
-- 
Stefano

 Mi pare azzardato, ho ragione?
Sì, l'esempio è approssimativo ed è solo indicativo dell'uso.
Ciao,
Tristan

 ?>
Giusto, ma in generale il codice si snellisce se elimini da subito la
condizione di errore evitando di inserire il codice nel blocco {...}:
$handle = fopen("$filename", 'r');
if( $handle === FALSE ){
    trigger_error() oppure die() o altro codice
    per recuperare la situazione
}
...qui il codice che legge il file,
...che puo' estendersi
...su molte righe
fclose($handle);
Gli esempi del manuale sono volutamente semplici, ma non li prenderei a
modello di buona programmazione. In generale omettono tutti i controlli
e non gestiscono le condizioni di errore proprio perche' il codice di
gestione degli errori oscura l'oggetto dell'esempio. Nelle applicazioni
reali la gestione degli errori tende a occupare buona parte del codice.
Ciao,
 ___ 
/_|_\  Umberto Salsi
\/_\/  
www.icosaedro.it

 condizione di errore evitando di inserire il codice nel blocco {...}:
Grazie per la dritta.
Sono abituato ad inserire il caso migliore dentro l'if e gli errori
nella parte bassa del codice. In questo modo mi rimane in alto
l'algoritmo principale e gli errori alla fine.
Solo una tecnica diversa o c'è qualche motivo più importante per mettere
la gestione degli errori in alto?
-- 
Stefano

 la gestione degli errori in alto?
Gli errori vanno individuati e risolti il piu' vicino possibile al
punto nel quale si verificano. Inoltre e' meglio evitare lunghi blocchi
di codice {...} perche' si fa fatica a visualizzarli sullo schermo e
vengono regolarmente tagliati nel salto pagina quando lo stampi, per
cui risulta difficile seguire le indentazioni multiple. La cosa peggiora
ulteriormente se metti diversi blocchi annidati { { ... } }.
Quindi se fopen() puo' produrre un errore, meglio affrontarlo subito
all'interno dello stesso blocco di righe di codice, in modo che dopo,
e allo stesso livello di indentazione, segue il codice che esegue
l'elaborazione regolare. Nel tuo stile (del tutto corretto dal punto
di vista logico) hai invece un enorme istruzione if() che distrae
l'attenzione del lettore del sorgente dalla struttura effettiva del
programma. Quindi secondo me lo schema
fopen()
if( errore ) {...}
fread()
if( errore ) {...}
fclose()
if( errore ) {...}
mette meglio in evidenza la struttura lineare del programma
(open/read/close) rispetto allo schema con if() annidati:
if( fopen ha successo ){
    if( fread ha successo ){ ...  }
    else { ...  }
    if( fclose ha successo ){ ...  }
    else { ...  }
}
else { ...  }
che oscura la linearita' dell'elaborazione e da' troppa enfasi alla
gestione degli errori.


 ulteriormente se metti diversi blocchi annidati { { ... } }.
<cut>
Finora ho scritto codice php solo per 'uso personale' quindi ho creduto
giusto mantenere lo stile a cui sono abituato da anni (programmo in c da
una quindicina abbondante). Non mi spaventano i codici lunghi e gli if
annidati e ho stampato il codice due volte in vita mia, un buon editor è
tutto quello che mi serve per continuare a capirci. Semmai, quando
diventa un po' troppo lungo è meglio cercare di scrivere delle funzioni
per semplificare la lettura. Tutto imho ovviamente.
Ciò che mi spingerebbe a cambiare tecnica è piuttosto qualche
convenzione usata nella comunità php. Se tu (e altri) che mi sembri
esperto usate questa tecnica farò di tutto per adottarla anch'io, anche
per essere preparato quando dovessi lavorare in un progetto open source.
Grazie ancora.
Ciao
-- 
Stefano

 gestione degli errori.
l'ideale sarebbe che fopen() e le altre funzioni throw-assero eccezioni.
si può comunque ovviare così:
try {
    $fn = 'I_dont_exist.sh';
    $fd = @fopen($fn, 'r');
    if ($fd === false)
        throw new Exception ("Impossibile aprire $fn!");
	// ...
} catch (Exception $e) {
	echo '[Errore] ' . $e->getmessage();
}
http://it.php.net/manual/it/language.exceptions.php
http://devzone.zend.com/node/view/id/666
in alternativa, si può sempre usare l'accoppiata trigger_error() &&
set_error_handler().
http://it.php.net/trigger_error
http://it.php.net/set_error_handler
Saluti,
Tristan

 si può comunque ovviare così:
<cut>
Ecco, questa è una tecnica a me sconosciuta e che studierò quanto prima.
In realtà l'ho già vista ma, sempre per il discorso che facevo
nell'altro messaggio riguardante le abitudini, ho sempre preferito usare
tecniche di programmazione più familiari.
-- 
Stefano

 tecniche di programmazione più familiari.
Be', uno non può non programmare object-oriented perché per abitudine
non l'ha mai fatto prima. ;-) Purtroppo o per fortuna, dobbiamo sempre
adattarci ai progressi.
Ciao,
Tristan

 adattarci ai progressi.
Propendo per "per fortuna" :-)
-- 
Stefano