Newsgroup: it.comp.www.php
Titolo: commenti in php

Sapete se i commenti in php rallentano (anche minimamente)?
Ho scritto un codice commentato da cima a fondo, non vorrei che quei 3000
byte in piů rallentassero l'intero script, alla fine mi interessa piů la
performance che la pulizia del codice.
apollo

 apollo
Ciao

 performance che la pulizia del codice.
No, il parser quando incontra un commento passa avanti senza colpo ferire.
Potremmo discutere del fatto che più grande è il file più tempo impiega ad
essere aperto, se veramente qualche centesimo di secondo è importante
allora elimina i commenti, ma soltanto dopo aver sostituito tutte le
tabelle delle tue pagine con eleganti e certamente meno succhiabanda CSS e
aver ottimizzato ogni singolo Javascript, ciclo, uso della memoria :)
In poche parole lascia stare, i commenti sono bene, l'illeggibilità dei
sorgenti è male.
C'è un'interessante disquisizione in 'The Art of Unix Programming' che
trovi in rete sul sito personale di Eric Raymonds sull'ottimizzazione a
tutti i costi, interessante lettura.
Ciao,
	Nicholas

 Anche se rallentassero, credi che 3 Kb graverebbero pesantemente?!?
Dipende da quanti banner hai sulla pagina :-)
ciao
Marco
-- 
bernama -lumachina- libero -punto- it
Il pensiero e' come un paracadute: funziona bene
solo quando e' aperto.
M.B.
+- PHPRndSig 0.02 --------------------------------------------64/73-+

 sorgenti è male.
OKEY! :)
Sto lavorando ad un progetto che ciuccia banda a manetta, stiamo
ottimizzando i costi: ram e banda e ci stiamo riuscendo in maniera
eccezionale (visto le statistiche precedenti: giriamo con un decimo delle
risorse precedenti), solo che lavorando in coppia ci servono i commenti e mi
era venuto il dubbio che troppi commenti fossero dannnosi per la velocità di
esecuzione. In questo caso lavoravo alla ricerca dentro un forum, poichè
compaiono i millisecondi impiegati ero interessato che filasse liscio come
l'oro. Insomma non volevo che dopo tanto lavoro sottovalutassi qualche
particolare.
Cmq lascerò i commenti anche perchè così ci metto niente ad aggiornare e
modificare.
grazie per le risposte :)
apollo

scusate la dislessia!
apollo

 grazie per le risposte :)
Meglio cercare di ottimizzare il codice che cancellare commenti.
Se devi ottimizzare cose per migliorare prestazioni di un server devi
analizzare *bene* dove vengono spreccati le risorse. A volte il bottleneck e
la rete, altre volte un database malorganizzato, altre volte nella
elaborazione/algoritmi. Soprattutto linguaggi script possono essere
ottimizzati.
PHP ha qualche pecularieta' che potrebbe aiutarti a velocizzare il
processing, cmq. dipende molto da caso in caso. Conoscere e usare le
funzioni di php ti aiuta moltissimo, le funzioni sono scritte in 'C', se li
usi hai il massimo della elaborazione, se invece li emuli con php vedrai che
diventa lentissimo.
In questo esempio tre modi diversi per elaborare un array:
<?php
function getmicrotime(){
    list($usec, $sec) = explode(" ",microtime());
    return ((float)$usec + (float)$sec);
}
$ar=range(0,500000);
$start=getmicrotime();
$sum=0;
for ($i=0; $i < count($ar); $i++)
    $sum+=$ar[$i];
$t=getmicrotime()-$start;
echo "time = $t secs\n";
$start=getmicrotime();
$sum=0;
$l=count($ar);
for ($i=0; $i < $l; $i++)
    $sum+=$ar[$i];
$t=getmicrotime()-$start;
echo "time = $t secs\n";
$start=getmicrotime();
$sum=0;
foreach($ar as $v)
    $sum+=$v;
$t=getmicrotime()-$start;
echo "time = $t secs\n";
$start=getmicrotime();
$sum=0;
foreach($ar as $v)
{
    // commenti?
    $sum+=$v;
  /*
   * un
   * paio
   * di righe
   * per vedere
   * cosa succede
   */
}
$t=getmicrotime()-$start;
echo "time = $t secs\n";
?>
Hanno tempo di risposta molto diversi (occhio i tempi non sono costanti,
eseguire un paio di volte).
Su elaborazione stringhe e file le difference possono essere ancora piu'
pesanti.
Banda rete:
  un trim() su ogni riga html puo' causare miracoli. Uso di classi css.
Database:
  Controllare indici e ordine query

 echo "time = $t secs\n";
Ho provato il codice: i risultati che ottengo sono molto vicini tra di loro,
salvo che per la prima forma del ciclo che e' il 40% piu' lenta di quella
piu' efficiente (l'ultima).
Riguardo invece al calcolo dell'intervallo di tempo trascorso, nel sito
www.php.net
 alla funzione microtime() ci sono degli esempi SBAGLIATI per
il calcolo di precisione di questa differenza. Il problema sta nella
conversione del risultato fornito da microtime() in un float: e' vero
che l'algoritmo diventa cosi' molto semplice, ma si rischia di ottenere
risultati poco accurati perche' il tempo in secondi (10 cifre) unito al
tempo in microsecondi (6 cifre) da' oltre 16 cifre significative, mentre
il manuale PHP dice che i float tengono circa 14 cifre significative:
si perdono pertanto due o tre cifre significative nella conversione. In
pratica, il valore che salviamo e' accurato solo fino al millisecondo. Ok,
non e' un gran problema, pero'...
Ecco lo schema alternativo che suggerisco:
function diff($start)
{
	$end = microtime();
	list($start2, $start1) = explode(" ", $start);
	list($end2, $end1) = explode(" ", $end);
	$diff1 = $end1 - $start1;
	$diff2 = $end2 - $start2;
	if( $diff2 < 0 ){
		$diff1 -= 1;
		$diff2 += 1.0;
	}
	return $diff2 + $diff1;
}
$ar=range(0,1000);
$start=microtime();
...
$t=diff($start);
echo "time = $t secs\n";
Questo dovrebbe dare risultati accurati intorno al microsecondo. Chiaro
che se abbiamo un i386 a 33 MHz la cosa e' piuttosto irrilevante, ma
con un P4 a 2 GHz la differenza si vede.
Ciao,
 ___ 
/_|_\  Umberto Salsi
\/_\/  
www.icosaedro.it

   Controllare indici e ordine query
Ecco.... questo invece non l'ho fatto.... non ho ben chiaro come funzionano
gli indici e di come posso cambiare i tempi di esecuzione delle query
tramite essi.
apollo


Dato che floating point considera sempre il massimo dei bit disponibili non
bastava sforzare l'uso dei bit alla massima precisione con qualche
parentesi?
function diff($start)
{
    $end = microtime();
    list($start2, $start1) = explode(" ", $start);
    list($end2, $end1) = explode(" ", $end);
    return ($end1-$start1) + ($end2-$start2);
}
matematicamente un
(a + b) - (c + d) = (a - c) + (b - d)
o per visualizzare meglio:
(a + b/1000000) - (c + d/1000000) = (a - c) + (b/1000000 - d/1000000)
 = (a - c) + (b - d)/1000000;
avendo a e c con la stessa mantisse, e soprattutto portando la differenza di
a-c ad una mantisse molto vicina a quella di b - d con -1.0 < b - d < +1.0

 }
Ottimo, cosi' il codice e' piu' pulito e sintetico.
Un po' piu' difficile da controllare, perche' non e' subito evidente che la
prima differenza e' tra numeri interi, la seconda differenza e' tra numeri
float e la somma e' tra float, ma dovrebbe funzionare come previsto.
