Newsgroup: it.comp.www.php
Titolo: Esiste GOTO in PHP?

Salve!
Nei linguaggi standarddelle istruzioni GOTO per saltare a determinate 
posizioni del programma. Esiste qualche istruzione corrispondente in PHP?
Conosco l'istruzione BREAK, ma serve per terminare un ciclo.
Grazie
Ciao
Eugenio

 Conosco l'istruzione BREAK, ma serve per terminare un ciclo.
Perche` vorresti tale obbrobrio in PHP?
Goto e` utile solo a basso livello (in assembly e quando scrivi sistemi
operativi). Per il resto e` solo MALE.
Bye.


Sarà pure un obbrobrio, ma a volte rende il codice più leggibile che non 
molte if elseif ecc ecc. nidificate.
Per esempio devo verificare il valore di tre campi di una pagina: in questo 
momento ho risolto appunto con una serie di IF/ELSEIF/ELSE ecc. ecc. ,
ma se volessi lasciare i tre controlli distinti, controllare il primo e se è 
errato andare ad una certa posizione del programma, cosa posso fare?
Grazie
Ciao

Alessandro Pellizzari ha scritto:

E poi francamente, a che serve in un linguaggio strutturato?
-- 
Cordialmente.
Melus.
dal mio e-mail togli i simboli di Zorro.

 Ciao
se ti trovi con questi problemi.. forse dovresti rivalutare il design del
programma ed agire di conseguenza..
-- 
www.iuz-lab.info

 posso fare?
Detta cosi` e` troppo generica come domanda.
Ti posso dire che puoi farlo richiamando tre funzioni che verificano quei
dati, che puoi fare un oggetto che li prende come parametri, ecc. ecc.
Puoi anche fare qualcosa tipo
$errors = array();
if (!$valore1) {
	$errors["errore1"] = true;
}
if (!$valore2) {
	$errors["errore2"] = true;
}
if (!$valore3) {
	$errors["errore3"] = true;
}
if (count($errors) > 0) {
	pritn "C'e` stato un errore."
}
Ma senza avere qualcosa di specifico e` difficile risponderti.
Bye.


Questo è il sistema che uso normalmente con i linguaggi che qualcuno sembra 
definire indirettamente "non strutturati" (vedi altre risposte).
Vabbè non entro nella questione, perchè sono un tipo molto pratico e poco 
teorico (si vede? :-))))  ) e non m'interesso di "politica" informatica.
Uso quello che mi sembra più utile.
In questo esempio con un GOTO potresti decidere di non verificare $Valore2, 
$Valore3 se per $Valore1 hai già verificato l'errore.
Per farlo devi usare ELSE IF e ELSE.
Comunque grazie per l'assistenza. Se non c'è GOTO o simili, mi adeguo. :-)
Grazie a tutti
Ciao
 


Può essere, ma dubito sia un problema di design, quanto piuttosto di 
adeguarsi ad un linguaggio diverso.
Sono agli inizi con PHP e se lavori con altri linguaggi, fai per forza un 
confronto.
Grazie
:-) 

 Comunque grazie per l'assistenza. Se non c'è GOTO o simili, mi adeguo. :-)
Non è questione di adeguarsi, il punto è che GOTO anche in quei linguaggi 
dove è supportato viene altamente sconsigliato.
E non per antipatia, o masochismo ma perchè effettivamente rende il codice 
troppo complesso ed è come vedere un mostro in mezzo al codice moderno
Dunque se riesci ad evitarlo è tanto di guadagnato!

 farlo devi usare ELSE IF e ELSE.
Allora qualcosa tipo
if (!verifica($par1) || !verifica($par2) || !verifica($par3)) {
	print "errore";
}
Si ferma automaticamente appena una condizione si verifica (con tutti i
pro e i contro).
Ma appunto, senza specifiche si procede alla cieca.
Bye.

 posizioni del programma.
Scusa ma quali "linguaggi standard" usi ?
Gli unici che mi vengono in mente con GOTO sono il BASIC della mia 
infanzia e il C dove si usa in casi rarissimi.

 errato andare ad una certa posizione del programma, cosa posso fare?
Fai il controllo (che devi fare sia che tu abbia o meno GOTO a 
disposizione) e chiami una funzione.
E' proprio questo il punto per cui ti dicono che il design è sbagliato. 
Tu dici "non è vero" ma scomponi il programma in maniera funzionale, 
dopo "andare ad una certa posizione del programma" equivale a chiamare 
una certa funzione.


In molti casi "adeguarsi" non è significa  per forza un qualcosa di 
negativo. ;-)

 Bye.
Verifico questo suggerimento.
Grazie 

 Sono meno d'accordo, quando dici progettare mentre scrivi.
Non intendevo basi del linguaggio, ma base del progetto.
Io praticamente non scrivo mai diagrammi di flusso, struttura delle
tabelle del DB, schemi di funzionamento, ma un'idea del flusso del
programma ce l'ho in testa.
Bye.


switch e case?
http://it.php.net/switch

 una certa funzione.
Il mio pgm è strutturato sinteticamente così
RichiestaDati();
Controllo_Dati();
if (count($errors) != 0)
{ Emissione_Errori(); }
else
{PaginaRisultati(); }
In Controllo_Dati verifico i miei tre campi (o più).
Il GOTO mi sarebbe servito per evitare di controllare inutilmente tutti i 
dati, tanto l'operatore potrà correggere un dato per volta.
Certo potrei scrivere in piccolo l'errore in corrispondenza di ogni campo 
errato, ma il mio obiettivo è anche farmi uno standard e non sempre in una 
pagina è possibile scrivere tutto.
Comuque il mio obiettivo era sapere se esisteva una certa istruzione. Non 
c'è, va bene, opero diversamente.
Grazie
Ciao

Per farlo devi usare ELSE IF e ELSE.
Non necessariamente:
function is_string($valore)
{
	...
}
function is_cap($valore)
{
	return preg_match('/^[0-9][0-9][01][0-9][0-9]$/', $valore);
}
	$campi = array(
		'campo1'	=> 'is_string',
		'campo2'	=> 'is_telephone',
		'campo3'	=> 'is_cap');
	$ok	= true;
	foreach($campi as $campo => $verifier)
	{
		if (function_exists($verifier))
			if (!$verifier($_REQUEST[$campo]))
			{
				$ok = false;
				break;
			}
	}
	$ok || die("Si e' verificato un errore");
Questo fa una sola verifica, e ti consente parecchia flessibilita':
con poco sforzo puoi fare in modo da specificare, per ogni campo, o
una funzione, o una regexp, o un range di interi...
Leonardo
-- 
There is nothing makes a man suspect much, more than to know little,
and therefore men should remedy suspicion by procuring to know more,
and not keep their suspicions in smother.            (Francis Bacon)

c'è, va bene, opero diversamente.
C'e': e' per questo che ti dicono perche' e' bene sforzarsi di non usarla.
Se non ci fosse stata, per non fartela usare bastava dirti "Fai pure" :-)


 wrote:

Cobol, PL/1, Fortran  roba da mainframe
-- 
Virgilio

 Cobol, PL/1, Fortran  roba da mainframe
Il PL/1 non l'ho mai sentito neanche.
Cmq la domanda era indirizzata a Eugenio che aveva fatto l'affermazione, 
non volevo sapere in quali linguaggi c'è il GOTO ma quali di questi 
usasse lui.

 pagina è possibile scrivere tutto.
Puoi usare un ciclo all'interno del quale chiami la funzione di 
controllo e dentro la funzione usare un return quando un campo non è 
corretto.

 usasse lui.
Scusami ma non ho resistito
Ciao
-- 
Virgilio

 presenti una form con tre campi ne può correggere tre.
Magari ha senso in un contesto di generalizzazione, esempio:
$campi = array(dei, campi, da, valutare);
$input = array($_POST['c1'], c2 c3 c4);
if (controllo_dati($input, $campi)) {
 funziono($input);
} else {
 non_va($input);
}
function controllo_dati($dati, $controllo) {
 foreach ($controllo AS $campo) {
  if (! (c'è in input?   ha il valore che mi aspetto?   tutto ok?)) 
return false;
 }
 return true;
}
funziono() inserisce i dati nel db, manda la mail o quel che è e invece
non_va ripresenta il form con i campi compilati e l'indicazione che
qualcosa non va.
Non è il massimo ma è per rendere l'idea :-)
Piuttosto dagli esempi di Eugenio mi da' l'idea che lui venga dal
basic o dal fortran: attenzione allo scope delle variabili, cerca di
usare il meno possibile le variabili globali.
-- 
ValeRyo
  (...), se al 90% delle persone piace il pesce e al 70% il gelato
di lamponi, ti verra' fornito un pesce surgelato ai lamponi :-), e
qualche brillante marketroid sosterra' d'aver accontentato il 160%
del mercato.  -- Leonardo Serni 


Grazie a tutti per i molti consigli!
Alcuni in questo momento mi sembrano incomprensibili, ma cercherò di 
capirli.
:-)
Si è vero, provengo dall'ambiente prima IBM (Cobol e RPG) e poi Microsoft 
(VB/VBA e MSSQL).
Tutt'ora lavoro in ambiente Microsoft, qualsiasi cosa si possa dire, mi 
piace, invece per l'ambiente web ho preferito orientarmi su PHP e MySQL 
anche se ho avuto modo di fare piccole cose con ASP.
Grazie
Ciao

 infanzia e il C dove si usa in casi rarissimi.
Dai un occhio al codice sorgente del kernel o di samba...non è poi così 
raro!
	Francesco



Appunto, come dicevo io all'inizio, in assembly o per scrivere sistemi
operativi. E, come dice suppaman, in C.
In samba... mi fa perdere un po' di rispetto per quel progetto,
onestamente, ma ho paura che sia stato fatto per porcherie del protocollo
(quindi per necessita`) piu` che per mala programmazione.
Bye.

Alessandro Pellizzari ha scritto:

Mi viene un dubbio: e se fosse un flame?

 
già che hai fatto 30...
vai su it.arti.fotografia e, dovendo comprare una macchina fotografica, 
candido com un agnellino prova a chiedere: "meglio canon o nikon, voi 
cosa mi consigliate?"

Non volevo accedendere polemiche su l'opportunità del GOTO o meno.
Era solo una banale domanda, nulla più.
Non so quanti anni abbiate, ma vi immagino molto più giovani di me.
Io faccio il programmatore da molti anni (più di 25 anni), quindi non sono 
proprio giovanissimo.
Ho usato linguaggi differenti a seconda dell'ambiente in cui mi trovavo ad 
operare, prima IBM e poi Microsoft.
Io dico che se le istruzioni sono state fatte, ci sarà pure una valida 
ragione.
E' verissimo, le ho viste usare malissimo, da far schifo, soprattutto nei 
linguaggi del passato dove con il GOTO ti portavano ad istruzioni in altre 
parti del programma, al di fuori di subroutine o funzioni.
In questo caso è proprio mala programmazione, sono d'accordo con voi, però 
se usate con un certo criterio, non ci vedo nulla di male.
Signori, in fin dei conti è un'istruzione. Ve l'ho già detto, non sono un 
purista, sono molto pratico e il GOTO è un'istruzione pratica, un po' come 
le funzioni previste da un linguaggio che evitano ai programmatori la fatica 
di riscrivere tanto codice.
In PHP il GOTO non c'è?
Bene, mi ripeto, opero diversamente.
Dove sta il problema?
Quanto a eventuali flame o al disprezzo del mondo dei mainframe che 
rappresenta un pezzo di storia dell'informatica, beh, lasciamo perdere.
;-)
Grazie
Ciao
Eugenio

 mi consigliate?"
A parte il nick che usi che la dice lunga, ma non ho chiesto consiglio se è 
meglio un'istruzione o un'altra.
Ho solo chiesto se esiste un'istruzione. Cosa molto diversa, non credi?
Comunque non ci sarebbe nulla di male a chiedere consiglio del genere, qui 
ne ho ricevuti molti e ringrazio chi me li ha dati.
Loro hanno contribuito alla mia conoscenza di PHP, tu invece mi avresti 
allontanato.
Buona Pasqua!!!!
:-) 

 ;-)
In realta` il mondo dei mainframe sta pian piano tornando (e io
personalmente non l'ho mai disprezzato), visto che stiamo andando verso il
"sistema operativo nel browser" con una serie di thin client che si
collegano ad applicazioni web. Tra l'altro ne siamo in mezzo, con PHP.
Bye.

 :-) 
A te, mitticcoooooooooo

 Bye.
Sono corsi e ricorsi della storia. Nulla si crea, nulla si distrugge, tutto 
si ricicla.
Magari in una prossima versione di PHP si userà il GOTO.
:-)))))))))))))))))))))))
Va bene così.
Grazie
Ciao.
:-)

 :-)))))))))))))))))))))))
a dire la verità ci avevano provato, poi hanno optato per il break con le label
http://www.corephp.co.uk/archives/19-Prepare-for-PHP-6.html

 ha scritto nel messaggio 
news:ev3d2v$bgq$1...@tdi.cu.mi.it...

Ma dai, nel PHP 6!?!? Il GOTO in VB funziona allo stesso modo GOTO ---> 
LABEL.
Si in effetti avevo segnalato fin dal primo post l'istruzione Break. 
Chiamarla Goto o Break in effetti non fa differenza, la sostanza è la 
stessa, interrope un ciclo, ma nel susseguirsi degli interessanti consigli, 
la questione è passata in secondo piano.
Però a personaggi come "Gigiil..." sembrano cose diverse.
Comunque mi ha fatto veramente piacere capire come chi opera tutti i giorni 
con PHP risolve il problema.
Buona Pasqua a tutti. :-)


Francamente cosa tu faccia nella vita privata non m'interessa molto.
Il fatto è che in un NG che reputo serio ti presenti con un nick del genere 
e inizi una polemica. Questo intendevo.
Comunque vedo hk3project ti risponde meglio di quanto potessi farlo io.
;-)
GOTO (BREAK FOO)  è arrivato con PHP 6.
A casa mia si dice: WHY, PECCHE'?
:-)))))))
Ok, mi rispondo da solo: sono arrivati quelli da VB e bisogna aiutarli.
;-))))))))))))))))))
Ancora Buona Pasqua! 

 Però a personaggi come "Gigiil..." sembrano cose diverse.
E ha ragione. ;)
A me personalmente non piace nemmeno il concetto di label e di break con
label, porta allo stesso casino del goto, e speravo che non lo
introducessero in PHP 6. Gia` ce ne sono abbastanza di modi per scrivere
pessimo software in PHP... :(
Bye.

C'e'
Forse nell'universo in cui Spock ha la barba.
Leonardo alzheimer


 Bye.
Ciao 

 Non mi dire che bisogna sempre usare IF e ignorare la SWITCH!
Switch non e` un ciclo, e ne esci, come da specifiche, con break. Una
volta uscito dal case attuale salti automaticamente tutti gli altri case,
compreso "default:" e termini lo switch.
Con la modifica che vogliono fare a PHP 6, del break label, potresti
implementare un vero e proprio goto, e saltare dentro un altro case, o
parecchie istruzioni dopo la fine dello switch. Bruttobruttobrutto!
In Python, per esempio, non esiste switch, e si fa tutto con
if...elif...elif...else.
L'unico caso in cui un break con label (o meglio un break con un ergomento
numerico) e` utile e` quando hai n cicli nidificati e devi uscire da tutti
per un problema grave ai dati, ma spesso la cosa migliore e` sanitizzare i
dati prima di entrare nei cicli, a costo di appesantire un po' il software.
Io sto cercando di considerare quando un goto possa essere utile, ma
veramente non trovo casi in cui lo sia e non si possa riscrivere il codice
in modo piu` chiaro. :)
Bye.

 stesso nome in due oggetti.
[..]
per quanto non mi piacciano le eccezioni.. si possono usare al posto dei
goto in determinati casi..
non testato..
try {
        if ($n == 1) {
                throw new Exception('Errore', 1);
        }
        if ($n == 2) {
                throw new Exception('Errore', 2);
        }
        if ($n == 3) {
                throw new Exception('Errore', 3);
        }
} catch (Exception $e) {
        echo "{$e->getMessage()}: {$e->getCode()}\n";
}
cosi' si esce direttamente e si puo' anche capire dove il test e' fallito..
altrimenti.. sempre non testato..
try {
        if ($n == 1) {
                throw new Exception();
        }
        if ($n == 2) {
                throw new Exception();
        }
        if ($n == 3) {
                throw new Exception();
        }
} catch (Exception $e) {}
per saltare direttamente alla fine e proseguire senza 'indagare' sul test
fallito (in tutti e due i casi puoi sempre usare anche l'else if a tuo
piacere)..
comunque leggere la lettera di Dijkstra ed il documento di Knuth
sull'argomento puo' aiutare a capire meglio quando usare goto, quando no, e
quando intraprendere vie alternative come sopra..
-- 
www.iuz-lab.info

 Ancora Buona Pasqua!
rinnovo,
evvvvvvai, mitticooooooooo

"iuz" <us...@host.network> ha scritto nel messaggio 
news:ev6lc1$knr$1...@nnrp.linuxfan.it...

Interessanti i riferimenti accedemici, sono d'accordo, ma si estremizza 
sempre il discorso.
Insomma si pensa che il GOTO porti inevitabilmente ad un errore.
Non è così, ne porta tanti quando un uso esagerato di if nidificate.
Per dirla tutta, ho avuto più problemi ad intervenire in programmi che si 
perdevano negli if nidificati che non per un GOTO.
Sono d'accordo con quanto sostenuto da Alessandro che una subroutine non 
deve mai essere più troppo lunga, purtroppo non sempre è possibile.
Per esempio una sub che contiene solo la verifica dei controlli di una 
pagina, può essere lunga o corta a seconda del numero dei controlli da 
effettuare.
Quindi per me è sempre una pura questione di abuso.
Diverso è il discorso "estetico" con il quale concordo con voi.
Però resto sempre dell'idea che a volte ci sono necessità pratiche.
Per esempio mi piacerebbe capire, perchè secondo voi chi sviluppa PHP ha 
sentito la necessità d'introdurre tale istuzione nella versione 6?
Per quanto riguarda gli esempi riportati, scusami IUZ, ma non sono ancora 
esperto.
Mi sembra di capire che si imposta un'eccezione, quando si verifica la 
condizione e quindi si esce dalla if e da try.
E' così?
Se è così è esattamente l'uso che ammetto del GOTO. Cambia solo il nome 
dell'istruzione.
Se mi permettete faccio un esempio in VB linguaggio a me più familiare
(vabbè, turatevi il naso per una volta. ;-) )
Voglio che il mio programma interrompa i controlli al primo errore.
----------------------------
if ($n1 = "") then
    msgbox "Immetti $n1"
    goto BASTA
end if
if ($n2 = "") then
    msgbox "Immetti $n2"
    goto BASTA
end if
if ($n3 = "") then
    msgbox "Immetti $n3"
    goto BASTA
end if
BASTA:
------------------------------
In questo modo evito il controllo di $n2 e $n3.
Diversamente avrei dovuto fare
------------------------------
if ($n1 = "") then
    msgbox "Immetti $n1"
else
    if ($n2 = "") then
        msgbox "Immetti $n2"
   else
       if ($n3 = "") then
         msgbox "Immetti $n3"
      endif
  end if
end if
-----------------------------
Sono solo tre controlli e quindi poche righe. Immaginatevi 20 controlli.
Quale codice risulterebbe più leggibile?
Grazie.
Ciao.

 Grazie.
Prego
	Francesco

 BASTA:
Parrebbe il codice di validazione di una serie di dati che l'utente deve
immettere. Con questo codice se l'utente omette il primo dato (o, piu'
in generale, il dato immesso non supera il controllo della validazione)
l'utente riceve un msg di errore per quel dato e basta. Quindi l'utente
corregge il dato e riprova, ma ottiene la segnalazione di un altro errore
sul secondo dato che solo ora viene controllato. Poi le cose si ripetono
con il terzo dato, e cosi' via.
Secondo me e' meglio controllare TUTTI i dati e generare un messaggio
completo dell'errore. Ad esempio, basta accumulare i messaggi diagnostici
in una stringa secondo questo schema:
$err = "";
if( $n1 non va bene )
	$err .= "<li>n1 non va bene.";
if( $n2 non va bene )
	$err .= "<li>n2 non va bene.";
if( $n3 non va bene )
	$err .= "<li>n3 non va bene.";
#...
if( $err === "" ){
	elabora_dati($n1, $n2, $n3);
} else {
	echo "ERRORE: <ul>$err</ul>";
	ripresenta_il_form_con_questi_dati($n1, $n2, $n3);
}
In quanto al GOTO, spero proprio che non lo mettano: sono rarissimi i casi
in cui aiuta a snellire il codice, ma nel 99% dei casi viene usato solo
per pigrizia e cattiva analisi e rende il codice "write only". Ad esempio,
a volte un brano di codice molto complicato si snellisce con una funzione,
dalla quale si ritorna con il return senza bisogno di goto. E' il caso
dell'accesso a un file (un socket TCP, una pipe, ecc.) dove e' richiesta
una successione di operazioni, ciascuna delle quali puo' fallire:
# Obiettivo: leggere 100 byte da un certo file.
# Codice confuso a causa delle varie condizioni di errore, a rischio di
# tentazione GOTO:
$f = fopen(...);
if( $f === FALSE ){
    echo "Non riesco ad aprire il file.";
    mossa_alternativa();
} else {
    $s = fread($f, 100);
    fclose($f);
    if( $s === FALSE ){
        echo "Non riesco a leggere il file.";
    } else {
        elabora_stringa($s);
    }
}
# Codice ripulito introducendo una funzione:
function leggi_file()
# Ritorna 100 byte dal file oppure NULL su errore
{
    $f = fopen(...);
    if( $f === FALSE ){
        echo "Non riesco ad aprire il file.";
        return NULL;
    }
    $s = fread($f, 100);
    fclose($f);
    if( $f === FALSE ){
        echo "Non riesco a leggere il file.";
        return NULL;
    }
    return $s;
}
$s = leggi_file();
if( $s === NULL )
    mossa_alternativa();
else
    elabora_stringa($s);
 
"Snellire" il codice qualche volta comporta di introdurre qualche funzione,
qualche struttura dati, ecc. che, paradossalmente, sembra renderlo piu'
complicato. In realta' diventa piu' potente. Caso tipico e' la validazione
dei FORM. Il modello tipico adottato in questi casi e' una serie di
variabili semplici. Questo modello non scala bene se il solito percorso di
acquisizione/validazione/retroazione dell'errore/salvataggio dati si fa un
po' articolato.
In questo caso diventa utile introdurre un array o ancora meglio una classe
che contiene i campi del FORM e mantiene il suo stato. Si aprono molte
strade che rendono la vita piu' facile e permettono di andare piu' lontano.
Ad esempio, le funzioni coinvolte nella elaborazione si passano l'oggetto
come un semplice parametro; lo si puo' mettere nella sessione; lo si puo'
serializzare e mettere in un campo hidden; ecc.
Morale: lo sforzo di razionalizzazione previene il GOTO e porta a un
risultato migliore.
Ciao,
 ___ 
/_|_\  Umberto Salsi
\/_\/  
www.icosaedro.it

 Voglio che il mio programma interrompa i controlli al primo errore.
Questo ha senso in un software standalone, perche` puoi fare i controlli 
al volo mentre l'utente inserisce i dati, ma in ambito web, come dice 
Umberto, e` meglio controllare tutto, perche` non puoi dire niente 
all'utente finche` non hai finito l'esecuzione dello script sul server e 
mandi la pagina al client.
Bye.

 risultato migliore.
Sei riuscito a spiegare meglio di me quello che intendevo dire. :)
Bye.

 
Non sono d'accordo: se il dato seguente dipende dal dato precedente è 
ovvio che se il primo input contiene un errore devi fermarti e non 
validare i seguenti, altrimenti fornisci all'utente finale 
un'informazione sbagliata.
Poi tutto dipende dalle condizioni d'uso ma non si può dire a priori.
	Francesco

 Poi tutto dipende dalle condizioni d'uso ma non si può dire a priori.
Hai ragione. :)
Bye.

 pagina, ma conviene sempre fare un passo intermedio di verifica.
Condivido in pieno, ma talvolta ti trovi nella necessità di dover 
inserire qualche informazione collegata che non puoi suddividere su più 
pagine: nel precedente post ho estremizzato il concetto, ma puoi avere 
molti controlli su un unico (o due campi) pertanto il messaggio finale è 
uno solo, nonostante n controlli in cascata.
	Francesco

 in una stringa secondo questo schema:
E' un modo di concepire i controlli che va bene, ci mancherebbe, anche se 
personalmente ritengo che è quasi sempre meglio che l'operatore corregga un 
dato per volta, indipendentemente dal fatto che i dati che seguono siano 
dipendendano o no da quello in errore.
Certo dipende moltissimo dai casi e forse nelle applicazioni web è 
preferibile una stringa con tutti gli errori, ma è, appunto, un punto di 
vista.
La discussione si è fatta abbastanza accedemica, ma devo dire molto 
interessante per le varie soluzioni proposte.
Resto però dell'idea che non sia così scandaloso l'uso dei GOTO.
Grazie a tutti.
Ciao.

 controlli. Quale codice risulterebbe più leggibile?
Quello con uno switch, con una serie di elseif o con una funzione :-)
-- 
ValeRyo
  (...), se al 90% delle persone piace il pesce e al 70% il gelato
di lamponi, ti verra' fornito un pesce surgelato ai lamponi :-), e
qualche brillante marketroid sosterra' d'aver accontentato il 160%
del mercato.  -- Leonardo Serni