Newsgroup: it.comp.www.php
Titolo: che estensione bisogna dare alla pagina? HTML o PHP?

Ciao a tutti.
Ormai sapete che sono alle primissime armi con PHP e quindi ho tanti
dubbi che solo voi potete dipanare.
Oggi vorrei chiedervi questo:
ho realizzato una pagina HTML con all'interno solo due singoli codici
PHP del tipo:
[...] <a href="area.php?url=<?print($url)?>">nome</a>
mi chiedo, anzi VI chiedo, quale estensione devo dare al nome del file
che contiene così poco codice PHP?
 .HTML oppure .PHP ?
In qualsiasi caso mi sapreste dire in base a quale regola (se esiste)
si stabilisce se il file deve avere estensione .PHP oppure .HTML?
Già che ci sono vi pongo anche un'altra domanda. Che differenza c'è
tra echo e print? Ho letto sul manuale di PHP 4 ma non mi ha chiarito
per niente le idee. Mi sembra che alla fine svolgano esattamente la
stessa funzione. Mi potete spiegare?
Grazie mille di tutto!

se la pagina contiene sintassi e/o funzioni scritte in PHP...l'estensione
deve essere PHP oppure PHP3 o PHTML(si usa poco..)!
Buon Lavoro!
Klaudio
ICQ 140843737
http://cosmovr.too.it
http://arkivio.too.it
<La...@nessunindirizzo.nulla> wrote in message
3c18af72...@news.noicom.net...


 e quindi ho tanti dubbi che solo voi potete dipanare.
Non esageriamo... nulla che il manuale di PHP generosamente distribuito
gratis da 
php.net
 non possa chiarire a chiunque!

 come print() e printf() richiedono l'uso delle parentesi".
guarda che con print non servono le parentesi...

per quel che riguarda Echo, il manuale lo dice espressamente:
"Echo() is not actually a function (it is a language construct) so you are
not required to use parantheses with it."
Invece non dice nulla sull'omissione delle parentesi con print; però ho
provato ed è vero: anche con print puoi non usare le parentesi. Anzi grazie,
non l'avrei mai saputo.
Si potrebbe discutere se sia più opportuno usarle o meno; a mio avviso è
meglio non andare in cerca di guai, e scrivere codice php (e anche html!)
formalmente il più corretto possibile, anche se costa un po' di fatica.
E' vero che <? richiede ben tre caratteri in meno di <?PHP e che scrivere
gli attributi dei tag html senza le virgolette evita di dover inserire
escape e farsi casino, ma ho due buone ragioni dalla mia:
1. come in tutte le cose, soprattutto all'inizio, è meglio essere rigorosi:
si impara di più e meglio; quando ci si prendono delle "libertà" nella
scrittura del codice, bisogna farlo in maniera consapevole, altrimenti si
rischia di sbattere un bel giorno la testa contro dei bug mai visti senza
riuscire a capire da dove vengano.
2. è risaputo che un codice steso in maniera rigorosa fa poi recuperare
tutto il tempo perso nella sua stesura.

 wrote in
news:9vceri$ij2$
1...@newsfeed.cineca.it
: 

... pensa che io non sapevo che funzionasse con le parentesi!!!
:-)
per fortuna che su metà dei miei script uso classi che mi mascherano la 
print, così se un giorno dovessi cambiare sarà + facile!!
ciao

<?="Ciao" ?>
Funziona anche così, ma questo è un tipico esempio che va bene anche per il
Perl e l'Asp.
Ciao, Luca


Beh, insomma, il manualene per spiegare spiega ma sul chiarire le
cose, specialmente a un novellino, ho qualche riserva!
I chiarimenti offerti da una persona con esperienza sono, al
contrario, risolutori, per ciň te ne sono grato.


Ringraziandoti del chiarimento te ne chiedo un altro che "nasce
spontaneo" dalla tua risposta:
se io usassi questa riga di codice:
<a href="link.php?url=
www.fermat.f2s.com
">FERMAT</a>
sarebbe considerata codice PHP (e quindi dovrei dare estensione .php
al file) oppure non lo sarebbe (e quindi dovrei dare estensione .html
al file)?
Ovviamente la citazione al tuo sito è un omaggio per la tua
disponibilità!
Grazie in anticipo per la risposta

Il post è interessante e mette in luce varie tecniche di parserizzazione dei
documenti.
Io personalmente ragiono in questo modo:
1) Metto estensione .php se ho un file puro,solo codice
2) Metto estensione .inc (anche come mime type per il server) per i file con
variabili statiche
3) Metto estensione .html per tutti i file contenenti elementi grafici,
anche se con tag php.
Questo mio modo di lavorare parte infatti dal mio presupposto secondo il
quale un file html viene sempre incluso in un file .php da cui prende le
informazioni.
Ovvero:
pagina.php
-----------
    include("parametri.inc"); -> Parametri statici, (tipico le info per la
connessione mysql)
codice per lavorare con la connessione aperta
    include("pagina.html"); -> Include per l'output
Questo perchè la maggior parte delle volte ho pagine HTML quasi pure e le
uso solo per buttare fuori i risultati. Mi permette di separare bene il
codice di generazione(input) dati e quello di espulsione (output) dati.
Il mio limite "complesso" è che per seguire la mia logica fino in fondo, se
ho una pagina HTML con un solo tag php semplice, faccio un link simbolico
(ln -s pagina.html pagina.php) in modo che sia sempre evidente che sia una
pagina html
oppure
pagina.php
-----------
include("pagina.html");
per farla leggere al parser. Difficilmente chiamo .php una pagina con dentro
tag html
J

| se io usassi questa riga di codice:
| <a href="link.php?url=
www.fermat.f2s.com
">FERMAT</a>
| sarebbe considerata codice PHP (e quindi dovrei dare estensione .php
| al file) oppure non lo sarebbe (e quindi dovrei dare estensione .html
| al file)?
Questa riga di codice è html puro e semplice: non è altro che un link con il
quale passi anche un parametro nell'url. Questo sistema di passare valori è
comune e non è proprio solo a php. È quello utilizzato anche quando hai un
form con method="get".
Per risolvere i tuoi dubbi, puoi sempre chiederti: "php deve fare qualcosa a
QUESTA pagina?".

Molto interessante.

 dentro tag html
mmm... se uno sul browser immette parametri.inc "VEDE" il sorgente del tuo 
file include.
meglio parametri.inc.php, cosě riceve una pagina bianca!!
(stessa cosa per gli html, te li include, sě; ma uno immettendo nel browser 
pagina.html, per assurdo, si vede il codice delle tue funzioni incluse!!)
a meno che tu non dica al php di parsificare forzatamente anche tutti i 
.html e .inc che ti trovi sul sito!!!
occhio, dunque!
ciao

 tag html
Ci complichiamo la vita, eh? ;-)
E' più pesante un include() che una pagina .php del tipo:
<html>
 <body>
   .... codice HTML per 600 linee
   <?=$var?>
   .... codice HTML per 600 linee
 </body>
</html>
quindi IMO conviene utilizzare .php anche se c'è solo una riga di codice
php ... In fin dei conti, il parser non tocca il file finchè non vede <?
Se poi tu ti trovi meglio a lavorare come hai detto nel post, per
carità, nulla da dire!
Ciao
--ev

 anche se con tag php.
Tutto ok, ma se un progetto con questa infrastruttura deve essere spostato
su un altro server potresti creare un paio di problemi. Dal punto di vista
della manutenzione non e' una soluzione felice. Se vendi un pacchetto cosi
ad un cliente, e quel cliente prende una altra persona per mantenere il
sito, e deve fare dei cambiamenti crei dei problemi al povero che prende in
mano il progetto ed e' abituato a lavorare in un modo piu' mainstream.
Immmagina solo di spostare link simbolici da un UNIX ad un windows (povero
windows)...
Alla fine cmq. puoi fare come ti pare...  :-)

I file .inc li faccio parserizzare (vedi post precedente). I .html stanno
normalmente in una dir esterna alla root delle pagine.
A meno che uno non sia bravo ed indovini la dir in cui metto i file HTML ed
il loro nome difficile che li veda non parsizzati. Inoltre anche se fosse,
cazzi sua :) Mica glieli ho messi io a disposizione.
Per i .INC aggiungo sempre il mime al server, anche perchè avendo la
possibilità di personalizzare le impostazioni di ogni dominio, agisco un po'
come voglio e non mi limito ai .php solo perchè nel manuale c'è scritto
così'.
J

Facciamo un test :-)
Normalmente quante include metti in un sorgente php ? 1, 2 forse 3
Domanda, ci mette di più codice puro ad essere eseguito o codice "sporco" in
cui elaborare solo il codice php inserito tra html ?
Ecco la prova:
Primo test: 0.0004270076751709  (in millisecondi)
Secondo test: 0.00037193298339844 (in millisecondi)
Questo forse ti fa capire che un documento solo codice è più rapido, di
circa il 23%...
Ora... magari i miei conti non sono molto attendibili... però vedi tu :-)
Ecco il codice con il quale ho eseguito il test:
Non ci sono commenti nella parte in cui viene eseguito il ciclo.
test.php
--------
<?php
/* Funzione di conteggio dei microsecondi, secondo quanto documentato:
http://www.php.net/manual/en/function.microtime.php
 */
function getmicrotime(){
    list($usec, $sec) = explode(" ",microtime());
    return ((float)$usec + (float)$sec);
    }
// Primo test: la parola "ciao" viene ripetuta 10.000 volte come se fosse
HTML, senza echo.
$tempo1=microtime();
for ($i=0;$i<10000;$i++) {
        ?>
        ciao
        <?php
}
$tempo2=microtime();
?>
<?php
// Stampa la differenza tra il tempo iniziale e quello finale
echo(getmicrotime($tempo1)-getmicrotime($tempo2)."<BR>");
/* Inizia il secondo test: la parola "ciao" viene stampata da una echo
(addirittura abbiamo qui ancora un elemento di complessità maggiore) sempre
nello stesso */
/* frammento di codice */
$tempo1=microtime();
for ($i=0;$i<10000;$i++) {
        echo(ciao);
}
$tempo2=microtime();
// Stessa stampa di prima
echo(getmicrotime($tempo1)-getmicrotime($tempo2)."<BR>");
?>
(ma tu pensa se devo star qui a fare pure il codice per avvallare le mie
tesi :-)) eheheh
J

Link simbolici ? :-)
eheheh questo è un problema "fittizzio". Infatti quando fai ftp, i link
simbolici vengono convertiti in files.
Non solo, tar quando comprime, ad esempio, può lavorare coi link in modo
diverso, o come "hard link" o come "simbolici".
Inoltre, lavorando io solitamente da un server di prova, ed andando in
produzione con sitecopy via ftp, non ho mai trovato problemi.
Non c'è dubbio che la cosa possa tornare scomoda ad un altro che non segua
la mia stessa logica,
però una domanda... le classi non funzionano allo stesso modo ? :) Separano
il codice dai documenti che ne fanno uso...
Il concetto è il medesimo.
Codice da una parte e le echo da un'altra.
Non solo, ma è molto facile risalire alla struttura avendo il codice
sottomano.
Certo che se uno cerca di capire come funziona un sito guardandolo da un
browser, certo non sta iniziando dalla parte giusta :-)
J

         echo(ciao);
[...]
Aaaaaaaaaaaaaaallllllttttttttt,   Stooooooppppppp,  ehiiiiiiiiii.....
Se vuoi fare un test di precisione devi essere preciso, ma molto, molto
preciso:
Sono due output completamente diverse, e quindi assolutamente non
paragonabili (per ora).
Il primo manda al output:
 [qualche tab oppure spazio, nel tuo caso forse 8 spazi]
"ciao" ed un newline
[altri spazi fino al <?php]
in tutto 21 byte, e non 4 come forse pensavi...
la seconda vorrebbe scrivere la costante ciao (che non esiste e quindi viene
interpretato come 'ciao' e su un php con error_reporting=E_ALL ti crea un
casino)...
Se poi aggiungi qualche '<!--'; '-->'; vedi anche meglio il
risultato nel browser ;-)
E poi, calcola anche la differenza fra un
    echo 'ciao'; ed un
    echo "ciao";
(altro :P)
Ma attenzione, il testo e circa 99% NON attendibile come valore assoluto
(fai un reload della pagina e vedrai che differenze ti crea; meglio usare i
tick per fare un test di questo genere:
http://www.php.net/manual/en/control-structures.declare.php
).
rifai il test :^P
Alla fine poi: chi si ne frega di 1 microsecondo, se basta cambiare la CPU?
Penso che sia piu' importante creare codice corretto, leggibile, chiaro e
facile da mantenere...
J.

 J.
Please, potete utilizzare due firme differenti??? Non capisco più a chi
sto rispondendo! :-)))
Oppure vi chiamiamo J1 e J2, con 1 e 2 risultanti da un veloce test sul
php per vedere chi sia più bravo dei due ! ;-))
Ciao
--ev
 
[1] Cosa sulla quale mi devo ricredere: ho fatto un testino al volo ed i
risultati sono pressochè identici: con questi 2 script:
------------- SCRIPT 1 ---------------------
<html>
 <body>
  <table width=10 cellspacing=0 cellpadding=0 border=0>
   <th>TEST</td>
<?
   for($i= 0; $i<1000; $i++) {
        echo "<tr><td>$i</td></tr>\n";
   }
?>
  </table>
<?
        for($j=0;$j<100;$j++) {
         echo "TEST";
    }
?>
 </body>
</html>
------------------------------------------
----------- SCRIPT 2 ---------------------
<?
include("header.html");
for($i= 0; $i<1000; $i++) {
 echo "<tr><td>$i</td></tr>\n";
}
for($j=0;$j<100;$j++) {
 echo "TEST";
}
include("footer.html");
?>
dove header.html:
<html>
 <body>
  <table width=10 cellspacing=0 cellpadding=0 border=0>
   <th>TEST</td>
e footer.html:
  </table>
 </body>
</html>
---------------------------------------
-----------------------------------------
i risultati sono:
$ time php test1.php 2&>/dev/null
real    0m0.192s
user    0m0.150s
sys     0m0.030s
$ time php test2.php 2&>/dev/null
real    0m0.190s
user    0m0.150s
sys     0m0.030s
Certo che non mi sono sprecato più di tanto con il codice!
Avrei dovuto provare ad includere per una decina di volte un file con
una tabella con una migliaio di celle, e a fare la stessa cosa da dentro
la stessa pagina .php ... Amen, al momento 
$tempo_a_disposizione = 0; // :-)
if($qualcuno_ha_tempo) {
	prego_lo_faccia();
} else {
	teniamoci_le_supposizioni();
}

 così'.
Ho sempre sognato di avere un server tutto mio con relativo sito annesso
nel quale poter editare httpd.conf e scrivere:
AddType application/x-httpd-php .edo
Poi vorrei anche il TLD .edo, ma quello è possibile solo in LAN! :-((
http://www.edo.edo/edo.edo
:-))))))
Ok, mi tolgo la maschera da Megaloman! :-)
Ciao
--ev

 E quindi? Tutto in una pagina o con gli include? ;-)
voto per include per la chiarezza del codice... :)

Non condivido nulla :-)
In una condizione realistica, non stai a contare gli enter, conta il
risultato.
Non sono stato a badare alla teoria, agli apici etc etc. Ho usato il codice
come normalmente lo scrivo :-) In effetti essendo tutto nato da come io
metto le mie estensioni (ognuno libero di fare come vuole) questo dimostra a
me stesso che nel mio modus operandi lavoro in modo corretto.
Il risultato è che la gente scrive l'html misto ai tag (tant'è che non ho
tenuto conto per esempio del tempo "funzione stampa" a complessità 1
rispetto al fatto che php non esegue alcun comando/funzione per l'html
"ciao".
Per quanto riguarda ' e " siamo ancora in alto mare. Questa è tutta da
provare.
Per quanto mi riguarda non è plausibile la teoria della diversità tra i due.
Vero è che coi millisecondi poco conta, ma c'è comunque una diversità sempre
alta (più del 20%) anche se fai reload 10.000 volte. Questo vuol dire che se
ho 1000 chiamate già diventano secondi :-)
E allora il 20% si sente :-)
Aspetto però il tuo test :-) Non si controbatte con parole, ma con codice
:-))
Ma poi voglio dire... ancora a dire che il codice nelle pagine html è più
leggibile di uno puro ? :)
Allora qui sbagliano tutti :-)
Anzi, dovevamo usare le server-side-include altro che php :-))
J

Dai a parte gli scherzi, non mi piace proprio farmi dare del "fake-test".
Puoi usare tick quanto vuoi, ma rimane che la funzione di calcolo del tempo
è la stessa, quindi le unità sono commensurabili.
Infatti nessuna delle due prevede stranezze ma situazioni realistiche di
scrittura del codice.
Ripeto quanto detto. Se vuoi controbattere proponi un test, codificato per
intero e vediamo.
Altrimenti fai il bravo, e prima di usare la parola "fake" controllati negli
slip grrrrrrrrr
Se poi così come dici è, ti darò ragione pienamente (e ti offro pure un
caffè) altrimenti ciccia :-)
J(u) [sennò ci confondiamo]
I miei test  li trovi su:
http://magic.thecloud.org/test.php
e il codice completo, per provarlo su:
http://magic.thecloud.org/test.phps

Giusta osservazione, le include.
Una pagina con le include è strutturata così (o quasi)
codice.php
    codice_puro
    variabili_statiche.inc
    header.html (parte sopra della pagina html)
    ciclo
        parte_in_ripetizione.html (pagina html che si ripete con dentro
codice misto)
        fine_ciclo
    footer.html (parte sotto della pagina html)
Sarà anche un caso,ma mi sembra che molti (vedi varie applicazioni quali
shopping cart etc etc)
usino una struttura simile, ops anche 
http://www.php.net
 usa questo
sistema... o mamma...
addirittura loro nelle variabili_statiche dichiarano anche tutte le funzioni
e all'interno delle stesse il codice html... per dinci bacco :-)
Ora, magari farò i "fake-test" però non sono l'unico :-)
J
PS: Ev, fai le include :-) Hai codice più leggibile, riutilizzabile e rapido
:-)

 richiedono l'uso delle parentesi".
e qui casca l'asino...
eh ma scusa, l'hai detto tu stesso: "prima de parlar, tase!"
Alex

 eh ma scusa, l'hai detto tu stesso: "prima de parlar, tase!"
Chi di email ferisce... ;)
Saluti
Matteo

 :-))
Allora, prima c'e' un errore nel tuo codice scrivendo [echo ciao]. Questo
gia' imperdonabile (sui miei server configurato con il massimo del
error_reporting genera un errore, niente da dire, e' sbagliato, punto).
Poi dicevo che non si possono paragonare l'output di 21*10000=210000 byte
con un output di 4*10000=40000 byte. un differenza di ben 1:5.25 ed una
situazione tale tu lo chiami 'reale'.
La differenza tra " e ' c'e', basta analizzare il codice 'C' del PHP. Ed e'
gia ampiamente discusso in altri contesti in questo newsgroup.
A me un test fatto cosi non sta bene e con il tuo codice errato,
superficiale e non vicino ad una realta' informatica crei solo confusione. E
non posso far passare tale lacune per il rispetto per chi legge quello che
viene scritto qui e lo prende come l'unica verita'.
A questo punto tolgo il 'fake' e lo chiamo 'superficiale'. Ti sta meglio?
E temo di non essere assolutamente l'unico in it.comp.www.php che la pensa
cosi...
Jurgen
P.S.: Per sottolineare la superficialita' ricordo anche al tuo posting del
thread: "Ridete pure 
http://www.html.it/test/php.htm
" in cui avevi ammesso
di aver risolto 50% delle domande sul php e nello stesso fiato dici di non
commettere errori. 90% si potevano fare senza troppi problemi se non
commetti veramente mai errori.

 :-))
Dopo tante parole il (tuo) test (visto che non vuoi toccare il tuo codice)
in una versione revised:
Tra altro c'era ancora un errore [molto, molto piu' grave di tutto il resto]
in getmicrotime()). Nella tua versione ti dava solo la differenza tra due
microtime, xke' il risultato del tuo getmicrotime non usava il parametro che
passavi (in somma, hai misurato il tempo trascorso tra  le due chiamate a
microtime).
Ora sintassi e semantica vanno (AFAIK) bene, e ti attende forse una
sorpresa...
Ho anche aumentato nel loop l'output per ridurre l'influsso della gestione
del loop sul tempo totale. Per poter raggionare fai vari run di questo
codice con un server a 0 load.
<?php
define ("MAX",200000);
set_time_limit(1000);
function getmicrotime($t){
    list($usec, $sec) = explode(" ",$t);
    return ((float)$usec + (float)$sec);
}
echo "<!--\n";
$tempo1=microtime();
for ($i=0;$i<MAX;$i++) {
?>1234567890<?php
?>1234567890<?php
?>1234567890<?php
?>1234567890<?php
?>1234567890<?php
}
$tempo2=microtime();
echo "-->\n";
$time1= getmicrotime($tempo2)-getmicrotime($tempo1);
printf("Run 1: %2.4f<BR>", $time1);
echo "<!--\n";
$tempo1=microtime();
for ($i=0;$i<MAX;$i++) {
        echo('1234567890');
        echo('1234567890');
        echo('1234567890');
        echo('1234567890');
        echo('1234567890');
}
$tempo2=microtime();
echo "-->\n";
$time2=getmicrotime($tempo2)-getmicrotime($tempo1);
printf("Run 2: %2.4f &nbsp; %3.2f%%<BR>", $time2, ($time2/$time1)*100);
echo "<!--\n";
$tempo1=microtime();
for ($i=0;$i<MAX;$i++) {
        echo("1234567890");
        echo("1234567890");
        echo("1234567890");
        echo("1234567890");
        echo("1234567890");
}
$tempo2=microtime();
echo "-->\n";
$time3=getmicrotime($tempo2)-getmicrotime($tempo1);
printf("Run 3: %2.4f &nbsp; %3.2f%%<BR>", $time3, ($time3/$time1)*100);
?>

Occavolo, sul manuale hanno sbagliato la funzione getmicrotime!!! :-grin
ahuahauhauh

A parte che finalmente iniziamo a discutere con codice e non con parole,
non vorrai mica prendere in considerazione un test che parla di
"compilazione del codice php" vero ?
Se hai fatto 90% aiuto :-)
Ovviamente essendo il tempo di una echo maggiore del tempo di una "non
funzione" (cosa che avevo sottolineano nel mio codice) il tempi cambiano
così:
Run 1: 8.3933
Run 2: 8.2392   98.16%
Run 3: 8.5338   101.67%
Ma poi ... non dicevi che per avere affidabilità bisognasse usare i tick ?
:-)
J

 :-)
Ohibò, chi ha mai detto che non le faccio? :-)
Mica in ogni pagina ho
mysql_connect()
mysql_select_db()
mysql_*()
print <<< BORDATE_DI_HTML
Certo che se ho due righette in croce di php da inserire in una pagina
HTML mica includo, a meno che le pagina in oggetto siano 200!
Solo che _credevo_ (erroneamente, a quanto sembra!) che le include
appesantissero gli script più del necessario!
Ciao J!
--ev

 Non e' stato J che postava il codice con il fake-test sui tempi?
Visto che anche tu, caro J, ti incasini quando ci sono troppe J di
mezzo? :-)))
--ev 


Ringraziandoti del chiarimento te ne chiedo un altro che "nasce
spontaneo" dalla tua risposta:
se io usassi questa riga di codice:
<a href="link.php?url=
www.fermat.f2s.com
">FERMAT</a>
sarebbe considerata codice PHP (e quindi dovrei dare estensione .php
al file) oppure non lo sarebbe (e quindi dovrei dare estensione .html
al file)?
Ovviamente la citazione al tuo sito è un omaggio per la tua


| se io usassi questa riga di codice:
| <a href="link.php?url=
www.fermat.f2s.com
">FERMAT</a>
| sarebbe considerata codice PHP (e quindi dovrei dare estensione .php
| al file) oppure non lo sarebbe (e quindi dovrei dare estensione .html
| al file)?
Questo è semplice html. Il fatto che nell'url passi un parametro (e che poi,
nella pagina link.php userai php per gestire questo parametro) non deve
disorientarti. Difatti, come vedi, non è stato necessario mettere il codice
all'interno dei tag <?php ?>.



Grazie!