' Rapid-Q by William Yu (c)1999-2000                                             .
' ================================================================================
' Upload_il_tuo_script_su_Rapidq.it

' Come_si_controlla_il_flusso_dei_programmi_

Numeri di LineaNei primi giorni del BASIC, gli interpreti richiedevano che ciascuna
linea di codice fosse identificata mediante un numero di linea. L'interprete poi
seguendo l'ordine dei numeri di linea, eseguiva le istruzioni che trovava. Rapid-
Q permette ancora l'uso dei numeri di linea per identificare le linee di codice
sorgente, ma è solo per riferirsi dettagliatamente ad una linea di codice, non per
indicare l'ordine di esecuzione del programma. Ad esempio guardate il codice
sorgente con numeri di linea qui sotto in BASIC:
10 CLS
20 PRINT "What is your name?";
30 INPUT N$
40 PRINT "Hello, ";
50 PRINT N$
Tale codice suesposto mostra la domanda What is your name? ed attende che l'utente
immetta qualcosa. L'inpu dell'utente viene immagazzinato nella variabile STRING N$.
Poi il programma mostra la scritta Hello, [dati in N$]. Se l'utente ha immeno il
nome Steven, l'output sarà Hello, Steven
Rapid-Q accetta il codice suesposto come se fose scritto e lo esegue, ma lo stesso
codice sorgente pò essere ri-scritto in Rapid-Q in questo modo:
10 CLS
50 PRINT "What is your name?";
60 INPUT N$
20 PRINT "Hello, ";
15 PRINT N$
Il programma continua a pulire lo schermo, chiedere il nome, mostrare il messaggio
Hello . Questo perchè Rapid-Q, come la maggior parte dei compilatori moderni, segue
il flusso del codice dall'alto al basso e i numeri di linea sono considerati come
fossere etichette.
Labels Invece dei numeri di linea delle vecchie versioni del BASIC, i programmatori
possono usare le etichette per indicare un punto di riferimento nel codice sorgente
del loro programma. Una etichetta può essere descrittiva quanto vuoi e contenere
qualsiasi carattere eccetto lo spazio. Una etichetta deve essere messa nella prima
colonna della linea a cui si riferisce ed essere seguita subito dopo dai due punti
(:). Esempi:
startOfProgram:
skip2here:
123SesameStreet:
Although Sebbene le etichette non devono essere sulla stessa linea da sole, è pi
facile trovarle mentre si osserva il codice sorgente se non sono seguite da altre
istruzioni.
GOTO GOTO potrebbe essere indicata come la istruzione antenata delle istruzioni
atte a controllare il flusso del programma nel BASIC. GOTO determina un immediato e
incondizionato salto in una altra sezione del codice sorgente. La sintassi per GOTO
è:
GOTO marcatore
Il marcatore può essere un numero di linea o una etichetta, in etnrambi i casi la
successiva istruzione viene eseguita ed il programma continua da lì.
Esempi :
PRINT "I am first"
PRINT "I am second"
GOTO skip
PRINT "Am I next?"    '<--- Questo non sarà mai stampato
skip:
PRINT "I am third"
PRINT "I am fourth"
L'uso di GOTO è aborrito da molti programmatori moderni. Essi lo considerano un
segno di scarsa programmazione e perdono la possibilità di uscire da loop troppo
complessi ed incapsulati mediante un semplice salto con una istruzione GOTO.
La ragione per cui viene evitata l'istruzione GOTO deriva dai giorni in cui era
frequente la programmazione del codice a spaghetti ("spaghetti code"). Il nome
"spaghetti" viene dato ad un particolare tipo di codice con una ampia disposizione
di codice non lineare, spezzato e con ritorni poco chiari creato mediante un
intenso uso di GOTO. Tali codici sorgente sono molto difficili da leggere e capire
per la loro astrusa e continua alternanza tra diversi blocchi di codice dovuta a
continui salti incondizionati. La condizione attuale è una fusione tra i salti
incondizionati dei primi programmatori e il flusso del programma controllato con
diversi metodi tipico dei linguaggi moderni.
Il miglior consiglio è: cerca di usare le forme di controllo di flusso più moderne,
strutturate ma se GOTO risultasse essere il miglior modo di gestire un problema
allora non esitare ad usarlo.
GOSUB...RETURN GOSUB è il primo modo con cui il vecchio BASIC ha offerto un mezzo
per strutturare meglio i programmi. GOSUB è un lieve potenziamento della istruzione
GOTO che salta ritornando alla istruzione successiva a quella del salto effettuato
con GOSUB quando viene incontrata la istruzione RETURN . La struttura
GOSUB...RETURN è la seguente :
GOSUB marcatore
( questa linea di codice è dove ritorna il flusso di programma con RETURN)
marcatore
( codice "tipo subroutine" )
RETURN

The marcatore nella istruzione GOSUB può essere qualsiasi numero di linea o
etichetta.
Un esempio dell'uso di GOSUB...RETURN:
GOSUB dividerline
PRINT "LINE 1"
GOSUB dividerline
PRINT "LINE 2"
GOSUB dividerline
END
dividerline:
PRINT "*******"
RETURN
L'output sarà :
*******
LINE 1
*******
LINE 2
*******
La struttura GOSUB...RETURN è un miglioramento rispetto all'istruzione GOTO poichè
permette di definire un blocco di codice paragonabile ad una "subroutine" nel
programma da poter chiamare da qualsiasi punto del programma senza la necesità di
porre un marcatore per il salto di ritorno, come invece bisognava fare con GOTO.
IF...THEN La istruzione condizionale IF viene usata per valutare se una altra
istruzione o blocco di codice deve essere eseguito. Testa se il la condizione è
vera (TRUE) in tal caso viene eseguito il codice indicato da THEN:
IF condizione THEN codice da eseguire
Esempio:
IF Counter > 10 THEN PRINT "Over the limit!"
Il blocco IF può essere usato per valutare se eseguire uno o più istruzioni
mediante il formato IF...THEN...END IF :
IF condizione THEN
codice da eseguire
END IF
Esempio:
IF Counter > 10 THEN
    PRINT "Over the limit!"
END IF
Se è necessario introdurre una sezione di codice da eseguire nel caso non si
verifichi la condizione testata (FALSE), allora usare il blocco
IF...THEN...ELSE...END IF.
IF condizione THEN
codice da eseguire se la condizione è vera
ELSE
codice da eseguire se la condizione è falsa (non vera)
END IF
Esempio:
IF Counter > 10 THEN
    PRINT "Over the limit!"
ELSE
    PRINT "You can try again."
END IF
Se sono necessari più di un solo testo per eseguire diverse sezioni di codice
sorgente allora usare il blocco multiplo IF...THEN...ELSEIF...ELSE...END IF:
IF prima condizioneTHEN
codice da eseguire se la prima condizione è vera
ELSEIF seconda condizione
THEN codice da eseguire se la seconda condizione è vera
ELSEIF terza condizione
THEN codice da eseguire se la terza condizione è vera
ELSE codice da eseguire se nessuna condizione precedente è vera
END IF
Esempio:
IF Counter > 10 THEN
    PRINT "Over the limit!"
ELSEIF Counter = 10 THEN
    PRINT "This is your last try!"
ELSE
    PRINT "You can try again."
END IF
SELECT CASE La istruzione blocco SELECT CASE è un modo più facile di gestire test
multipli per verificare condizioni multiple rispetto ad una lunga serie di test con
ELSEIF.
SELECT CASE esegue uno dei diversi blocchi di istruzioni in base al valore di una
espressione.
La sintassi è la seguente:
SELECT CASE condizione
CASE valore
codice da eseguire
CASE valore1, valore2, valore3
codice da eseguire
CASE valore minimoTO valore massimo
codice da eseguire
CASE IS [ < | <=| >= | > ] valore
codice da eseguire
CASE ELSE
codice da eseguire se nessuna altra precedente condizione risulti vera
END SELECT
Esempio:
SELECT CASE Counter
    CASE 0
        PRINT "Let's get started"
    CASE 1 TO 4
        PRINT "Too, bad. Try it again."
    CASE 8, 9
        PRINT "You're running out of tries!"
    CASE IS > 9
        PRINT "This is your last attempt!"
    CASE ELSE
        PRINT "Try harder!"
END SELECT
FOR...NEXT Il loop FOR...NEXT viene usato quando si deve ripetere una operazione o
gruppo di operazioni per un numero di volte.
La sintassi è:
FOR contatore = inizioTO fine[ STEP incremento ]
codice da ripetere ad ogni ciclo
NEXT contatore

Esempio:
FOR Number = 1 to 10
    PRINT Number
NEXT Number
Usa l'istruzione EXIT FOR per interrompere prematuramente il ciclo FOR-NEXT.
WHILE...WEND Se devi ripeter un processo un certo numero di volte, ma la quantità 
di ripetizioni varia in base alla situazione contingente, hai bisogno di usare un
loop condizionale.
Il loop WHILE...WEND effettua un test condizionale prima di entrare nel loop. Usa
un loop WHILE se potrebbe anche non essere necessario eseguire almeno una volta il
codice presente nel loop.
La sintassi è:
WHILE condizione
codice da ripetere ad ogni ciclo
WEND
Esempio:
WHILE Counter < 11
    PRINT Counter
    Counter = Counter + 1
WEND
Se per una qualche necessità devi interrompere il ciclo WHILE prima che si verifica
la condizione testata, allora impiega la istruzione EXIT WHILE all'interno del
ciclo loop.
DO...LOOP Se devi ripetere un processo per un certo numero di volte, ma la quantità 
varia in base alle circostanze, devi usare un loop condizionale.
Il loop DO...LOOP effettua il test condizionale alla fine dell'esecuzione del
codice presente nel loop, quindi può essere usato quando il codice deve essere
eseguito almeno una volta indipendentemente dal risultato del test condizionale.
La sintassi è:
DO
codice da ripetere
LOOP [ UNTIL condizione ]
Esempio:
DO
    PRINT Counter
    Counter = Counter + 1
LOOP UNTIL Counter = 10
La parte condizionale del loop è opzionale in DO...LOOP . Se la condizione viene
omessa il loop diviene perenne/eterno. Ossia diventa un loop infinito. Usa la
istruzione EXIT DO per uscire da un loop infinito o dal loop prima che si verifichi
la condizione testata.



' ===============================================================================
'                      2003 Holyguard.net - 2007_Abruzzoweb