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

' Come_sono_i_tipi_di_dati_

Tipi di dati Quando lo osservi, il PC è solo una macchina che è buona a gestire
milioni di piccoli bit di informazione. A livello più basso, ogni cosa viene
rappresentata in un computer come uno stato OFF (0 - zero) o ON (1 - uno). I
programmi che vengono eseguiti su un computer raggruppano questi bit di informazioni
insieme per generare forme più complesse di dati. In base a quale compilatore viene
usato, il programmatore ha a disposizione una varietà di tipi di dati tra cui
scegliere. I tipi di dati disponigili in Rapid-Q possono essere suddivisi in due
gruppi principali in base al tipo di dati che rappresentano - caratteri o numeri.
Un tipo di dato carattere viene definito in Rapid-Q come stringa. Le Stringhe sono
presenti solo di due tipi: a lunghezza variabile e a lunghezza fissa. Le stringhe a
lunghezza variabile sono create mediante l'uso dell'identificatore STRING e
modificano il loro contenuto e la loro grandezza in base al valore che viene loro
asseganto. La stringa a lunghezza variabile può anche essere dichiarata mediante il
suffisso/token $.
Le stringhe a lunghezza fissa sono create mediante l'identificatore STRING * e
restano sempre della stessa lunghezza durante tutta la durata del programma. Una
stringa di un solo carattere (STRING * 1) usa 8 bits (o 1 byte) di memoria del
computer.
I dati di tipo numerico possono essere ulteriormente divisi mediante il range di
numeri che possono contenere, che è limitato dal numero di bit raggruppati insieme
per formare il tipo di dato numerico. Rapid-Q permette al programmatore l'uso dei
seguenti identificatori per definire i dati numerici nei suoi programmi:
Identificatore   Token   Bits(Bytes)            Range
----------   -----   -----------   ------------------------
BYTE                     ?         8  (   1 )             0..255
WORD                  ??        16  (   2 )             0..65535
SHORT                 %        16  (   2 )        -32768..32767
LONG (INTEGER)  &        32  (   4 )   -2147483648..2147483647
SINGLE                 !          32  (   4 )   -1.5 x 1045..3.4 x 1038
DOUBLE                #        64  (   8 )  -5.0 x 10324..1.7 x 10308
L'identificatore INTEGER è esattamente lo stesso di LONG ed entrambi sono
intercambiabili tra di loro. C'è anche un altro tipo di dati, DWORD che è
implementato sotto Unix/Linux ma non è valido per Windows.
BYTE, WORD, SHORT, LONG, e INTEGER rappresentano tutti i numeri matematici interi
(senza decimali); mentre SINGLE e DOUBLE rappresentano i numeri con virgola mobile.
Il punto ni numeri a virgola mobile si riferisce alla posizione decimale all'interno
del numero e come esso si sposta nel numero variando il numero di cifre decimali da
presentare (float) .
Variabili Le variabili sono nomi simbolici a cui possono essere assegnati dei
valori. Il nome variabile viene usato perchè il valore assegnato e conservato dalla
variabile può essere modificato in qualsiasi momento durante l'esecuzione del
programma. Rapid-Q permette al programmatore di assegnare dei nomi descrittivi alle
variabili in modo che il programmatore possa renderle auto_descrittive. Dopo tutto,
leggere il codice sorgente di un programma è più semplice con nomi di variabili
quali tasso_di_Imposta e Membri_del_Gruppo.
Le variabili possono essere create in due modi differenti in Rapid-Q. Il primo modo
è considerato come lo stile 'perdente' della maggior parte dei linguaggi BASIC.
Questo viene fatto mettendo come ultimo carattere del nome della variabile, al
momento di assegnargli un valore, con il 'token' che indica al compilatore che tipo
di dato contiene e quindi che tipo di variabile è, ecco un esempio:
Nome$ = 'Steven'
Bilancio_Banca! = -12.58
Il secondo modo di creare le variabili è un approcio più strutturato. Viene fatto
usando l'istruzione DIM . DIM è il modo di specificare il tipo di dati per una
variabile che non sia array.
La sintassi è la seguente:

DIM nome_variabile[token_tipo_dato | AS tipo_di_variabile ]

Il che equivale a dire che le variabili possono essere create in tale modo:

DIM Nome$
DIM Bilancio_Banca!

usando i tokens per specificare il tipo di dato, oppure in questo altro modo:

DIM Nome AS STRING
DIM Bilancio_Banca AS SINGLE

usando gli identificatori del tipo di variabile. L'assegnazione del valore alle
variabili viene eseguito in secondo tempo nel programma.
VARIANT Esiste uno speciale tipo di dati chiamato VARIANT. Esso come una normale
variabile di un certo tipo di dati può cambiare i valori durante l'esecuzione della
applicazione, una variabile VARIANT può anche cambiare il tipo di dati che contiene.

Per creare una variabile di tipo VARIANT, usare il comando DIM:

DIM MyVariant AS VARIANT

Ora MyVariant cambierà in base alle assegnazioni e alle situazioni.
Ecco degli esempi:

MyVariant = 100
MyString$ = 'A century is ' + MyVariant + ' years.'
MyInteger% = 200 + MyVariant

MyVariant è un numero con il valore di 100. Quando usata nella linea MyString$,
MyVariant passa un tipo stringa in modo che l'assegnazione ha come risultato 'A
century is 100 years.' Quando usata nella linea MyInteger%, MyVariant passa un tipo
intero short in modo che l'assegnazione finale sia 300.
Siccome il tipo VARIANT ha la abilità di cambiare comportamento e tipo di dati è
bene essere cauti nel suo impiego, e devi essere sicuro di ottenere il giusto tipo
di dato che ti serve.
Ecco degli esempi:

Variant1 = '100'
Variant2 = 33.3

Variant2 + Variant1 darà come risultato il numero 133.3 perchè la stringa '100'
viene convertita nel valore numerico corrispondente al tipo di variant2, prima di
essere aggiunta a 33.3 .
Variant1 + Variant2 darà come risultato la stringa '10033.3' perchè il valore
numerico 33.3 è convertito nel valore stringa prima di essere aggiunto a '100' .
Arrays Un array è una sequenza di variabili dello stesso tipo distinte da un indice
e aventi lo stesso nome. Un array viene dichiarato con il comando DIM . La sintassi
è la seguente:
DIM nomevariabile( numero_elementi) AS tipo di variabile
numero_elementi definisce quanti elementi sono presenti nell'array.
Ad esempio:

DIM Day(7) AS STRING
Day( 1) = 'Domenica'
Day(2) = 'Lunedì'
Day(3) = 'Martedì'
Day(4) = 'Mercoledì'
Day(5) = 'Giovedì'
Day(6) = 'Venerdì'
Day(7) = 'Sabato'

Questo esempio crea un array di variabili stringa con il nome Day che contiene sette
elementi stringa. In ciascuno di essi viene caricato il nome di un giorno della
settimana. Ora possiamo accedere a ciascun nome direttamente mediante l'indice
dell'array. Un riferimento al Day(6) ritorna la stringa Venerdì.
Gli Arrays possono anche avere più di un gruppo di elementi (dimensioni). Per creare
un array multidimensionale, definire la variabile in questo modo:

DIM Day(7, 2) AS STRING
Day(1,1) = 'Domenica'
Day(1,2) = 'DOM'
Day(2,1) = 'Lunedì'
Day(2,2) = 'LUN'
Day(3,1) = 'Martedì'
Day(3,2) = 'MAR'
Day(4,1) = 'Mercoledì'
Day(4,2) = 'MER'
Day(5,1) = 'Giovedì'
Day(5,2) = 'GIO'
Day(6,1) = 'Venerdì'
Day(6,2) = 'VEN'
Day(7,1) = 'Sabato'
Day(7,2) = 'SAB'

Ora un riferimento al Day(6,1) ritorna Venerdìmentre un riferimento a Day(6,2)
ritorna VEN.
La maggior parte dei vecchi giochi in stile 'colpisci il mostro' hanno usato array
multidimensionali per gestire il layout del labirinto/mappa. DIM Maze(5, 12, 10) AS
INTEGER era un modo comune di definire una mappa con 5 livelli con 12 righe e 10
colonne per ciascuna riga.
Constanti Constanti, come le variabili, sono nomi simbolici a cui può essere
assegnato un valore. Diversamente dalle variabili, il valore di una costante è unico
per tutta la durata del programma ed una volta impostato non può essere cambiato da
qualsiasi istruzione. La scelta del nome della costante segue le stesse regole dei
nomi delle variabili. Le constanti sono create mediante la direttiva CONST . La
sintassi è la seguente:

CONST nome_costante[token del tipo di dato] = valore_costante

L'uso del token del tipo di dato è opzionale, quindi le costanti possono essere
create nei seguenti modi:

CONST daysInWeek? = 7 oppure:
CONST daysInYear = 365.4

Se il token indicante il tipo di dato viene omesso, il compilatore determinerà quale
è il tipo di dato migliore per contenere quel valore assegnato.
Dati definiti dall'utente oUDTI dati definiti dall'utente (UDT) sono un modo per il
programmatore di associare diversi tipi di variabili in un singolo record che può
poi essere usato come una semplice variabile.
Per creare un tipo di dato definito dall'utente bisogna impiegare il costrutto
TYPE...END TYPE . La sintassi è la seguente:

TYPE udtNome
elemento1 as tipo di dato
elemento2 as tipo di dato
(...)
elementoN as tipo di dato
END TYPE

Ciascun elemento di una UDT viene definito come una variabile normale eccetto che
non è preceduto dalla istruzione DIM prima del suo nome.
Esempio:
TYPE PersonType
    FirstName AS STRING * 20
    LastName AS STRING * 20
    Age AS BYTE
END TYPE
Una volta che la UDT è stata definita con il costrutto TYPE...END TYPE, può essere
usata per dichiarare delle variabili del suo tipo con DIM. Esempio:
DIM Personrecord AS PersonType
Una volta che si è creata una variabile di tipo UDT definita, abbiamo creato una
variabile con nome PersonRecord che contiene l'insieme di variabili dichiarate nella
nostra UDT PersonType. Se vogliamo accedere alle singole variabili della nostra
variabile UDT, dobbiamo usare una speciale sintassi chiamata Notazione punto (Dot
Notation) per riferirsi ad uno specifico elemento. Essa consiste nello scrivere il
nome della variabile seguita da un punto e poi dal nome dell'elemento della UDT a
cui vogliamo accedere. Ecco un esempio:
PersonRecord.FirstName = 'Steven'
PersonRecord.LastName = 'Edwards'
PersonRecord.Age = 30



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