| ABS |
MATH Function |
Windows/Unix |
|
| |
una funzione matematica che ritorna il valore assoluto di una espressione numerica.
Sintassi: ABS(numeric-expression) A% = ABS(-123)
Dettagli: Il valore assoluto di una funzione ritorna il valore senza segno del suo argomento. Infatti sia ABS(-1) sia ABS(1) ritornano 1. |
|
| ACOS |
MATH Function |
Windows/Unix |
|
| |
una funzione matematica che ritorna l'arcocoseno di una espressione numerica. .
Sintassi: ACOS(numeric-expression) D# = ACOS(0.55)
Dettagli: L'espressione numerica "Numeric-expression" ha un intervallo tra -1 e 1. |
|
| ASC |
STRING Function |
Windows/Unix |
|
| |
una funzione per le stringhe che ritorna un valore numerio che è il codice ASCII del primo carattere di una espression stringa.
Sintassi: ASC(string-expression) A% = ASC("A")
|
|
| ASIN |
MATH Function |
Windows/Unix |
|
| |
una funzione matemetica che ritorna l'arcoseno di una espressione numerica.
Sintassi: ASIN(numeric-expression) D# = ASIN(0.55)
Dettagli: Numeric-expression è compresa nell'intervallo -1 e 1. |
|
| ATN/ATAN |
MATH Function |
Windows/Unix |
|
| |
una funzione matematica che ritorna l'arcotangente di una espressione numerica
Sintassi: ATN(numeric-expression) D# = ATN(0.9)
Dettagli: Numeric-expression è l'angolo espresso in radianti. |
|
| BIN$ |
CONVERSION Function |
Windows/Unix |
|
| |
una funzione di conversione binaria che converte un numero intero positivo INTEGER nella sua rappresentazione binaria.
Sintassi: BIN$(numeric-expression) S$ = BIN$(123)
Dettagli: I numeri negativi non sono supportati, e quindi il risultato non è prevedibile. |
|
| BIND |
POINTER Function |
Windows/Unix |
|
| |
BIND lega una variabile ad un puntatore a funzione.
Sintassi: BIND variable TO function DECLARE SUB MyFunc(X AS INTEGER) BIND A% TO MyFunc
Dettagli: Per chiamare questo puntatore a funzione usa CALLFUNC. |
|
| CALLBACK/CODEPTR |
ADDRESS Function |
Windows |
|
| |
CODEPTR (o CALLBACK) ritornerà l'indirizzo assoluto di una SUB o FUNCTION.
Sintassi: CODEPTR(MySUB) SUB MySUB END SUB A& = CODEPTR(MySUB)
Dettglia: Usa questa funzione per ritornare (CALLBACK) dalle routines. Non tutti i casi sono implementati, e i risultati pososno variare in base al CALLBACK ed al tipo di parametri che ha ricevuto. |
|
| CALLFUNC |
POINTER Function |
Windows/Unix |
|
| |
CALLFUNC esegue un puntatore a funzione che era legato mediante la parola chiave BIND.
Sintassi: CALLFUNC(fptr, param1, param2, ...) CALLFUNC(FPtr, 10, 20) PRINT CALLFUNC(FPtr2, 10, 20)
Dettagli: In base a come hai legato (BIND) il tuo puntatore alla funzione, puoi sia chiamare CALLFUNC come puntatore sia come funzione. Sii sicuro di fornire il numero necessario di paramentri, altrimenti rceverai un errore dal compilatore. Passare i puntatori alle funzioni come parametri non è ancora implementato, ma puoi leggere il Capitolo 11 e vedere come emulare questa operazione. |
|
| CEIL |
MATH Function |
Windows/Unix |
|
| |
una funzione matematica che arrotonada una espressione numerica al numero positivo infinito superiore
Sintassi: CEIL(numeric-expression) A% = CEIL(66.2) '-- Ritorna 67
|
|
| CHDIR |
SYSTEM Statement |
Windows/Unix |
|
| |
CHDIR cambia la corrente directory di lavoro per la uta applicazione.
Sintassi: CHDIR string-expression CHDIR "c:\windows"
|
|
| CHR$ |
STRING Function |
Windows/Unix |
|
| |
una funzione che processa le stringhe e che ritorna il carattere ASCII come stringa corrispondente al codice passato come argomento.
Sintassi: CHR$(numeric-expression) A$ = CHR$(66)
Dettagli: Numeric-expression dovrebbe essre compresa tra 0 e 255. |
|
| CINT |
CONVERSION Function |
Windows/Unix |
|
| |
una funzione di conversione numerica che converte ad un intero arrotondando la parte frazionale dell'espressione.
Sintassi: CINT(numeric-expression) A% = CINT(66.7)
Dettagli: E' implementatoper compatibilità con QBasic, puoi usare la funzione più logica , ROUND. |
|
| CLNG |
CONVERSION Function |
Windows/Unix |
|
| |
una funzione di conversione che converte una espressione numerica ad intero arrotondando la parte frazionale dell'espresione. Sintassi: CLNG(numeric-expression) A% = CLNG(66.7) '-- equals 67
Dettagli: Implementata per compatibilità con QBasic, puoi usare la funzione più logica , ROUND. |
|
| CONST |
Statement |
Windows/Unix |
|
| |
una parola chiave non eseguibile che dichiara le costanti simboliche da usare al posto di numeri o stringhe
Sintassi: CONST constantname [ as Datatype ]= expression CONST False = 0 CONST True AS LONG = NOT False CONST A$ = "Hi world!" CONST Char = CHR$(66) CONST Combine = A$ + Char
Dettagli: L'espressione può essere usata per qualsiasi valore numerico o stringa. Rapid-Q decifrerà che tipo di valore costante è collegato al nome della costante (una stringa o un valore numerico) se il nome della costante non è seguito da un carattere definente il tipo di dato (%. &, !, #, $, etc...).
|
|
| CONVBASE$ |
CONVERSION Function |
Windows/Unix |
|
| |
una funzione di conversione che prende una stringa presente in frombase e la converte in una altra con specifica base determinata dall'argomento passato
.
Sintassi: CONVBASE$(string-expression, frombase, tobase) S$ = CONVBASE$("FFD", 16, 2) '-- Convert from base 16 to 2 S$ = CONVBASE$("287", 10, 16) '-- Convert from base 10 to 16
Dettagli: I numeri negativi non sono supportati |
|
| COS |
MATH Function |
Windows/Unix |
|
| |
una funzione matematica che ritorna il coseno di un angolo espresso in radianti come argomento
Sintassi: COS(numeric-expression) PI = 3.14153 C# = COS(PI)
Dettagli: Numeric-expression è l'angolo espresso in radianti |
|
| DATA |
Statement |
Windows/Unix |
|
| |
una istruzione non eseguibile che immagazzina le costanti numeriche e stringa usate dall'istruzione READ del programma.
Sintassi: DATA {constant|EXECUTE(...)}[,...] DATA my dog ate my homework, "oh, boy!", 34.4 DATA EXECUTE(LEFT$("Hello", 2, 3))
Dettagli: Constant è qualsiasi valore numerico o stringa valido per costante. Se una stringa costante contiene una virgola o un punto o spazi iniziali o finali per memorizzarla nel tuo programma devi includerla tra 2 virgolette. Puoi anche eseguire il codice usando la parola chiave EXECUTE. Il valore ritornato di questo codice eseguito sarà il valore ritornato dal tuo codice READ. |
|
| DATE$ |
SYSTEM Function |
Windows/Unix |
|
| |
una funzoine che ritorna una stringa che contiene la data corrente formattata secondo il formato MM-DD-YYYY. Dove MM = mese (1-12), DD = giorni (1-31) e YY = anni (1980-2099)
Sintassi: DATE$ PRINT DATE$
Dettagli: Diversamente da QBasic dove puoi impostare la data corrente usando DATE$, non puoi farlo con tale funzione Rapid-Q. |
|
| DEC |
Statement |
Windows/Unix |
|
| |
Decrementa valore numerico di una unità, oppure del valore specificato.
Sinassi: DEC(variable [, amount]) DEC(I) DEC(I, 10)
|
|
| DEF... |
Statement |
Windows/Unix |
|
| |
DEFBYTE, DEFDBL, DEFDWORD, DEFINT, DEFLNG, DEFSHORT, DEFSNG, DEFSTR, DEFWORD sono istruzioni di dichiarazione che dichiarano una o più variabili e allocano lo spazio necessario per loro
Sintassi: DEFINT variable[(subscripts)] [, ...] DEFSTR A, B, C="Hello", D, E DEFINT I=99, J(100,10), K
Dettagli: Non puoi specificare un range di variabili, per esempio: DEFINT A-Z funziona bene in QBasic, ma non in Rapid-Q. Puoi inizializzare ciascuna variabile come dimostrato sopra. Le istruzioni DEF... sono equivalenti a chiamare DIM, ma possono risparmiarti molti caratteri da digitare. Per inizializzare un array, immetti i valori dei singoli elementi tra le parentesi graffe {...}. ad esempio, DEFINT A(1 TO 10) = {1,2,3,4,5,6,7,8,9,10}
Inizializza gli elementi da 1 a 10 con i valori 1, 2, 3, 4, 5, 6, 7, 8, 9, e 10 rispettivamente. |
|
| DELETE$ |
STRING Function |
Windows/Unix |
|
| |
una funzione che cancella una parte di una stringa
Sintassi: DELETE$(string-expression, start, length) A$ = DELETE$("Hello world", 2, 3) '-- Result: Ho world
|
|
| DIM |
Statement |
Windows/Unix |
|
| |
l'istruzione di dichiarazione che da il nome a una o più variabili e alloca lo spazio per loro.
Sintassi: DIM variable[(subscripts)] AS type DIM A AS INTEGER, B(2,5,3,9,2) AS INTEGER DIM S AS STRING DIM Form AS QFORM
Dettagli: Usa le parentesi tonde (limite superiore) per dichiarare le dimensioni di un arrays, fio a 5 dimensioni. |
|
| DIR$ |
SYSTEM Function |
Windows |
|
| |
una funzione di sistema usata per ottenere il primo/prossimo file corripondente ad uno specifico file indicato in file-spec.
Sintassi: DIR$[(file-spec, attribute)] FileName$ = DIR$("*.*", 0) '-- Get first file FileName$ = DIR$ '-- Get next file
Dettagli: File-spec specifica un nome di file o path (percorso che comprende i caratteri wildcards es *.*). Chiamare DIR$ senza parametri equivale a ottenere il successivo file. Se non ci sono file che rispondono a tali caratteristiche (o tutti quelli con tali caratteristiche sono stati già mostrati), DIR$ ritorna una stringa vuota. DIR$ ritorna tutti i file regolari come pure i file speciali specificati nel parametro attributo. qui sono mostrati alcuni attributi validi del file, puoi associarli
usando OR (ie. faReadOnly OR faDirectory)
&H1 = faReadOnly (sola lettura) &H8 = faVolumeID (ID volume/disco)
&H2 = faHidden (nascosto) &H10 = faDirectory (directory)
&H4 = faSysFile (di configurazione/sys ) &H20 = faArchive (archivio)
&H3F = faAnyFile (qualsiasi)
per ottneere informazioni ulteriori sul file attualmente ritrovato, usa le proprietà FileRec. FileRec.FileName - Ritorna il nome lungo di Windows del file
FileRec.ShortName - Ritorna il nome corto del file
FileRec.Date - Ritorna la data del date come stringa
FileRec.Time - Ritorna il tempo di creazione del file come stringa
FileRec.Size - Ritorna le dimensioni del file
FileRec.FileTime - Ritorna il tempo di creazione del file come integer
Puoi usare FileRec.FileTime per confrontare il tempo di creazione del file. Quindi un file più recente avrà un FileTime più grande rispetto ad uno più vecchio. |
|
| DIREXISTS |
SYSTEM Function |
Windows |
|
| |
funzoine che ritorna 0 se la directory non esiste, non-zero nei casi contrari.
Sintassi: DIREXISTS(string-expression) A = DIREXISTS("c:\windows")
|
|
| DOEVENTS |
RAPID-Q Specific |
Windows |
|
| |
Ritorna il controllo al sistema operativo per eseguire gli eventi in coda, e ritorna il controllo indietro al programma una volta fatto.
Sintassi: DOEVENTS DO DOEVENTS LOOP
Dettagli: DoEvents dovrebbe essere usato normalmente nei processi impiegati per molto tempo (ie. lunghi cicli o qualsiasi altro che mangia CPU), in modo che l'utente possa fermare il prcesso se è necessario. DoEvents può anche essere usato per gestire multipe finestre/forms. |
|
| END |
Statement |
Windows/Unix |
|
| |
Termina il tuo programma.
Sintassi: END END
Dettagli: Chiama END per terminare la tua applicazione, ma se ci sono delle finestre ancora aperte, dovresti prima chiuderle.. |
|
| ENVIRON |
SYSTEM Statement |
Windows/Unix |
|
| |
una istruzione usata per impostare o modificare le variabili dell'ambiente del sistema operativo.
Sintassi: ENVIRON string-expression ENVIRON "PATH=c:\windows" ENVIRON "TEST what"
Dettagli: String-expression deve avere la forma nomeparametro=testo o nomeparametro testo Ogni cosa a sinistra del segno = o spazio è ritenuta essere un parametro, e ogni cosa a destra il testo. Se il nomeparametro non esiste già nella tabella stringa dell'ambiente operativo, esso viene aggiunto alla fine della tabella. Se il parametro esiste già allora esso cancella il precedente e si sostuisce ad esso aggiungendosi alla fine della tabella. |
|
| ENVIRON$ |
SYSTEM Function |
Windows/Unix |
|
| |
una unzione che ritorna una stringa dell'ambiente di sistema "environment".
Sintassi: ENVIRON$(environment-string) A$ = ENVIRON$("PATH")
Dettagli: Attualmente non è possibile ricercare nella stringa ambiente mediante un indice. |
|
| EXP |
MATH Function |
Windows/Unix |
|
| |
funzione matematica che ritorna la funzione esponenziale (e elevata alla potenza di n).
Sintassi: EXP(numeric-expression) A# = EXP(1)
|
|
| EXTRACTRESOURCE |
RESOURCE Statement |
Windows/Unix |
|
| |
una istruzione che estrae una risorsa, dal programma corrente al file indicato.
Sintassi: EXTRACTRESOURCE resource-value, filename EXTRACTRESOURCE Resource(0), "test.bmp"
Dettagli: Il valore risorsa è la posizione assoluta della risorsa dentro il corrente programma. Per trovare la posizione assoluta della risorsa vedi le parole chiave RESOURCE(), e RESOURCECOUNT. |
|
| FIELD$ |
STRING Function |
Windows/Unix |
|
| |
una funzione che ritorna un campo (o token separato da delimitatori.
Syntax: FIELD$(Source-string, deliminator-string, field-number) A$ = FIELD$("John&Doe&555-1234", "&", 2) '-- Ritorna Doe A$ = FIELD$("John&&Doe&&555-1234", "&&", 3) '-- Ritorna 555-1234
|
|
| FILEEXISTS |
SYSTEM Function |
Windows/Unix |
|
| |
una funzione che ritorna 0 se il file non esiste, altrimenti non-zero. La directory di lavoro attuale viene impiegata per la ricerca del file se il percorso non viene specificicato.
Sintassi: FILEEXISTS(string-expression) A = FILEEXISTS("rapidq.exe")
|
|
| FIX |
MATH Function |
Windows/Unix |
|
| |
una funzione che rimuove la parte frazionale di un numero.
Sintassi: FIX(numeric-expression) A% = FIX(342.97)
|
|
| FLOOR |
MATH Function |
Windows/Unix |
|
| |
funzione matematica che arrotonada una espressione numerica al valore interio inferiore, tendendo ad infinito negativo.
Sintassi: FLOOR(numeric-expression) A% = FLOOR(66.7) '-- Returns 66
|
|
| FORMAT$ |
STRING Function |
Windows/Unix |
|
| |
funzione che ritorna una stringa formattata assemblata in formato stile Pascal ed una serie di argomenti. La stringa formato Pascal assomiglia molto alle stringhe formato C, ma sicuramente non compatibili con VB.
Sintassi: FORMAT$(Format-string, arg1, arg2, ...) A$ = FORMAT$("Location: %s %4d %-10.4g", "Any", 1234, 55.39) '-- Returns Location: Any 1234 55.39 Dettagli: le stringhe formato passate alla routine formattante la stringa contengono 2 tipi di oggetti: il testo in piano e il formato specifico. I caratteri in piano sono copiati alla stringa finale. Gli specificatori del formato prendono gli argomenti dalla lista argomenti e li applicano alla formattazione. Gli specificatori di formato hanno la seguente forma"%" [indice ":"] ["-"] [larghezza] ["." prec] tipo
uno specificatore di formato inizia con un carattere % . Dopo il % viene il seguente in questo ordine: un specificatore opzionale dell'indice degli argomenti, [index ":"]
un indicatore opzionale della giustificazione a sinistra, ["-"]
uno specificatore opzionale della larghezza, [width]
uno specificator opzionale di precisione, ["." prec]
il tipo di carattere di conversione, type
la seguente tabella riassume i valori per type:
| d |
Decimale. L'argomento dovrebbe essre iun valore intero. Il valore è convertito ad una stringa di cifre decimali. Se la stringa formato contiene uno specificatore di precisione, essa indica che la stringa risultante deve contenere almento il numero specificato di cifre; se il valore ha un numero minore di cifre, la stringa risultante presenterà degli zeri iniziali a sinistra riempitivi. |
| e |
Scientifico. L'argomento dovrebbe essre un valore in virgola moible. Il valore è convertito in una stringa con forma "-d.ddd...E+ddd". La stringa risultante inizia con un segno meno se il numero è negativo. Una cifra precede sempre il punto decimale. Il numero totale di cifre nella stringa finale (comprendendo quella prima del punto decimale) è determinata dallo specificatore della precisione nel formato stringa : --una precisione default di 15 viene usata se non è presente lo specificatore di precisione. Il carattere esponente "E" nella stringa risultante è sempre seguito da un segno più o meno e almeno da 3 cifre. |
| f |
Fisso. L'argomento dovrebbe esser un valore in virgola mobile. Il valore è convertito in una stringa con il formato "-ddd.ddd...". La stringa risultante inizia con un segno meno se il numero è negativo. Il numero di cifre dopo il punto decimale è determinato dallo specificatore di precisione nella stringa formato: un valore di default di 2 cifre decimali è impostato se non è presente lo specificatore di precisione. |
| g |
Generale. L'argomento dovrebbe esere un valore in virgola mobile. Il valore è convertito nella stringa decimale più breve possibile usando un formato fisso o scientifico. Il numero di cifre significative nella stringa finale è fornito dallo specificatore di precisione nella stringa formato: un valore di 15 è quello default se non è presente lo specificatore di precisione. Gli zeri finali sono rimossi dalla stringa finale ed il punto decimale appare solo se è necessario. La stringa finale usa un formato con punto fisso se il numero di cifre a sinistra del punto decimale del valore è minore o uguale a quello dello specificatore di precisione, e se il valore è maggiore o uguale a 0.00001. Altrimenti la stringa risultante usa il formato scientifico. |
| n |
Numero. L'argomento dovrebbe essere un valore in virgola mobile. Il valore è convertito in una stringa con la forma "-d,ddd,ddd.ddd...". Il formato "n" corrisponde al formato "f", eccetto che la stringa finale contiene i speratori delle migliaia. |
| m |
Valuta (Money). L'argomento dovrebbe essere un valore in virgola mobile. Il valore è convertito in una stringa che rappresenta la quantità di valuta corrente. |
| s |
Stringa. L'argomento deve essere una stringa. La stringa o carattere è inserito al posto dello specificatore di formato. Lo specificatore di formato, se presente nel formato stringa, specifica la lunghezza massima della stringa risultante. Se l'argomento è una stringa che è più lunga di questo limite massimo la stringa viene troncata. |
| x |
Esadecimale (Hex). L'argomento deve essere un valore intero.Il valore è convertito in una stringa di cifre esadecimali. Se la stringa formato contiene uno specificatore di precisione, esso indica che la stringa finale deve contenere almeno il numero specificato di cifre esadecimali; se il valore ha un numero minore di cifre, vengono posti degli zero iniziali a sinistra nella stringa. |
La conversione dei caratteri potrebbe essere specificata come maiuscole o minuscole: entrambe determinano lo stesso risultato. Uno specificatore indice imposta l'indice della attuale lista di argomenti. L'indice del primo argomento in una lista di argomenti è 0. Usando gli specificatori dell'indice, è possibile formattare lo stesso argomento molte molte.Per esempio Format$("%d %d %0:d %d", 10, 20) determina la stringa "10 20 10 20".
|
|
| FRAC |
MATH Function |
Windows/Unix |
|
| |
una funzione matematica che ritorna la frazione di un numero
Sintassi: FRAC(numeric-expression) A# = FRAC(342.97)
|
|
| HEX$ |
CONVERSION Function |
Windows/Unix |
|
| |
funzione che ritorna la rappresentazione esadecimale (hex in base 16) di un numero in base decimale (base 10).
Sintassi: HEX$(numeric-expression) A$ = HEX$(123)
Dettagli: I numeri negativi sono supportati. Nella versione Windows, la stringa è preriempita da 0 per riempire la stringa di lunghezza 8. |
|
| IIF |
Function |
Windows/Unix |
|
| |
La funzione immediata IF ritorna una delle 2 parti in base alla valutazione di una espressione. Notare che entrambe le parti sono valutate, se l'espressione ritorna il valore vero o falso, quindi attenzione agli effetti collaterali indesiderati.
Sintassi: IIF(expression, true-expr, false-expr) A$ = IIF(6 > 5, "TRUE", "FALSE") '-- ritorna TRUE
|
|
| INC |
Statement |
Windows/Unix |
|
| |
Incrementa una variabile numerica di 1, o di una quantità specificata.
Sintassi: INC(variable [, amount]) INC(I) INC(I, 10)
|
|
| INITARRAY |
ARRAY Statement |
Windows/Unix |
|
| |
Inizializza un array con i valori corrispondenti.
Sintassi: INITARRAY(Array, value [, ...]) DIM A(1 TO 100) AS INTEGER INITARRAY(A, 55, 234, 45, 99)
Dettagli: Equivalentemente: DEFINT A(1 TO 100) = {55, 234, 45, 99}
Inizializzando arrays in alternativa a cicli di inizializzazioneas e risparmiando un po' di tempo. |
|
| INP |
I/O Function |
Windows/Unix |
|
| |
una funzione per dispositivi/device I/O che ritorna il valore byte letto da una porta I/O.
Sintassi: INP(port) A% = INP(&H3C9)
Dettagli: Port è qualsiasi valore word compreso tra 0 e 65535. Il valore ritornato è nell'intervallo 0 e 255. |
|
| INPW |
I/O Function |
Windows/Unix |
|
| |
una funzione per dispositivi/device I/O che ritorna un valore word letto da una porta I/O.
Sintassi: INPW(port) A = INPW(&H3C9)
Dettagli: Port è qualsiasi valore word compreso tra 0 e 65535. Il valore ritornato è compreso tra 0 e 65535. |
|
| INSERT$ |
STRING Function |
Windows/Unix |
|
| |
funzione che ritorna una stringa con una sottostringa inserita a partire dalla posizione indicata da index.
Sintassi: INSERT$(insert-string, source-string, index-number) A$ = INSERT$("hi", "Hello", 3) '-- ritorna Hehillo
|
|
| INSTR |
STRING Function |
Windows/Unix |
|
| |
una funzione che confronta 2 stringhe e ritorna la posizione della stringa trovata rispetto alla stringa in cui ha cercato. Se trovata, INSTR ritorna la posizione indice dell'inizio della stringa cercata, altrimenti ritorna 0.
Sintassi: INSTR([start,] search-string, find-string) A% = INSTR("Hello", "ll") '-- ritorna 3 A% = INSTR(4, "hehe they", "he") '-- ritorna 7
|
|
| INT |
MATH Function |
Windows/Unix |
|
| |
una funzione che ritorna la cifra intera più grande minore o uguale all'espressione numerica passata.La parte frazione è troncata.
Sintassi: INT(numeric-expression) A& = INT(342.97)
|
|
| KILL |
SYSTEM Statement |
Windows/Unix |
|
| |
una istruzione che rimuove un file di disco.
Sintassi: KILL filespec KILL "mydocuments.txt" KILL "*.c"
|
|
| KILLMESSAGE |
RAPID-Q Specific |
Windows |
|
| |
una istruzione che rimuove un messaggio dalla coda.
Sintassi: KILLMESSAGE hWnd, Message KILLMESSAGE form.handle, WM_CHAR
Dettagli: Idealmente, KillMessage dovrebbe essere usata all'interno di un evento, quale OnKeyDown, per rimuovere qualsiasi messaggio che non vuoi che venga processato ulteriormente. |
|
| LBOUND |
ARRAY Function |
Windows/Unix |
|
| |
una funzione che ritorna il limite inferiore di un array.
Sintassi: LBOUND(arrayname [,dimension]) DIM A(-50 TO 100) AS INTEGER L% = LBOUND(A) '-- Ritorna -50
Dettagli: Se l'array ha multiple dimensioni, devi usare l'argomento opzionale dimensione per testare il limite inferiore di ciascuna dimensione. |
|
| LCASE$ |
STRING Function |
Windows/Unix |
|
| |
una funzione stringa che ritorna una espressione stringa con tutte le lettere minuscole.
Sintassi: LCASE$(string-expression) A$ = LCASE$("HELLO") '-- ritorna hello
|
|
| LEFT$ |
STRING Function |
Windows/Unix |
|
| |
una funzione stringa che ritorna una stringa costituita dagli n caratteri più a sinistra di una stringa.
Sintassi: LEFT$(string-expression, n) A$ = LEFT$("Hello",2) '-- ritorna he
|
|
| LEN |
STRING Function |
Windows/Unix |
|
| |
una funzione che ritorna il numero di caratteri presenti in una stringa.
Sintassi: LEN(string-expression) A% = LEN("HELLO") '-- returns 5
Dettagli: LEN non ritorna il numero di bytes richiesti da una variabile. Questa opzione è disponibile solo in QBasic. |
|
| LFLUSH |
PRINTER Statement |
Windows |
|
| |
una istruzione usata per iniziare una stampa.
Sintassi: LFLUSH LPRINT " stampa questa linea" LFLUSH '-- chiama questa all'inizio della stampa
Dettagli: Potresti chiamare LFLUSH dopo che sei sicuro di voler iniziare a stampare. Se non chiami LFLUSH, poi qualsiasi tua applicazione termina quando il tuo documento inizia a stampare. |
|
| LIBRARYINST |
DLL Function |
Windows |
|
| |
Ritorna il gestore (handle) del modulo DLL. Se la DLL non è stata caricata ancora o non viene trovata, questa funzione ritorna 0.
Sintassi: LIBRARYINST(DLLName) DECLARE FUNCTION UpdateWindow LIB "USER32" ALIAS _ "UpdateWindow" (hWnd AS LONG) AS LONG UpdateWindow(0) '-- Using function will load DLL hInst& = LIBRARYINST("USER32")
Dettagli: Dichiarando una funzione come una funzione di DLL non fa automaticamente caricare la DLL. La DLL è caricata una sola volta quando la funzione è usata. Nota che il nome della libreria deve essere trovato, quindi nella tua dichiarazione per LIB "USER32" ... per trovare questa libreria, devi trovare lo stesso nome. ie. LIBRARYINST("USER32.DLL") ritorna 0, il nome deve essere "USER32" in questo caso di esempio. Vedi anche UNLOADLIBRARY. |
|
| LOG |
MATH Function |
Windows/Unix |
|
| |
una funzione matematica che ritorna il logaritmo naturale di una espressione numerica.
Sintassi: LOG(numeric-expression) A# = LOG(10)
|
|
| LPRINT |
PRINTER Statement |
Windows |
|
| |
una istruzione come PRINT eccetto che tutto l'output è diretto alla stampante di default. Accertati di chiamare LFLUSH per iniziare il lavoro di stampa.
Sintassi: LPRINT [expressions][{;|,}][...] LPRINT "stampa questa linea" LFLUSH
Dettagli: Dovresti chiamare LFLUSH dopo che hai deciso cosa vuoi iniziare a stampare. Se non chiami LFLUSH, poi qualsiasi tua applicazione termina quando il tuo documento inizia ad essere stampato. |
|
| LTRIM$ |
STRING Function |
Windows/Unix |
|
| |
una funzione stringa che ritorna una stringa senza gli spazi iniziali.
Sintassi: LTRIM$(string-expression) A$ = LTRIM$(" Hello") '-- ritorna Hello
|
|
| MEMCMP |
MEMORY Function |
Windows/Unix |
|
| |
una funzione di memoria che confronta 2 indirizzi di memoria e ritorna 0 se il contenuto della memoria non è uguale o non-zero negli altri casi.
Sintassi: MEMCMP(ptr1, ptr2, count) DEFINT I=10, J=10 A% = MEMCMP(VARPTR(I), VARPTR(J), SIZEOF(INTEGER))
|
|
| MEMCPY |
MEMORY Function |
Windows/Unix |
|
| |
una funzione di memoria che copia n bytes di memoria dalla sorgente (source) alla destinazione (destination).
Sintassi: MEMCPY(destination, source, n) DEFINT I=90, J=10 '-- After MEMCPY, I should equal 10 MEMCPY(VARPTR(I), VARPTR(J), SIZEOF(INTEGER))
|
|
| MEMSET |
MEMORY Function |
Windows/Unix |
|
| |
una funzione di memoria che inizializza un blocco di memoria.
Sintassi: MEMSET(ptr, char, size) DIM IntArray(1 TO 10) AS INTEGER MEMSET(VARPTR(I(1)), 0, 10*SIZEOF(INTEGER))
|
|
| MESSAGEBOX |
RAPID-Q Specific |
Windows |
|
| |
Mostra una semplice finestra messaggio con prompts. Questa implementa una funzione Window MessageBox API.
Sintassi: MESSAGEBOX(message, title, flags%) IF MessageBox("Chiudere questa finestra?", " Close", 1) = 1 THEN '-- Chiude la finestra END IF
Dettagli: Vedi la guida a Windows API per i flag validi. |
|
| MESSAGEDLG |
RAPID-Q Specific |
Windows |
|
| |
Mostra una finestra di messaggio con una icona ed un titolo definito dall'utente. Questo implementa una funzione Window MessageBoxEx API.
Sintassi: MESSAGEDLG(string-expression, msgType, msgButtons, helpContext) IF MessageDlg("Chiusere questa finestra?" , mtWarning, mbYes OR mbNo, 0) = mrNo THEN '-- Non chiude la finestra END IF
Dettagli: msgType è usato per mostrare il tipo di icona che sarà sulla finestra messaggio.
0 = mtWarning (attenzione) 3 = mtConfirmation (conferma)
1 = mtError (errore) 4 = mtCustom (personalizzato)
2 = mtInformation (informazione)
msgButtons è usato per mostrare il tipo di pulsanti di dialogo personalizzati.Per mostrare più di uno dei pulsanti della casella messaggio aggiungili con OR. 1 = mbYes (si) 32 = mbAbort (annulla)
2 = mbNo (no) 64 = mbRetry (riprova)
4 = mbOK (ok) 128 = mbIgnore (ignora)
8 = mbCancel (cancella) 256 = mbAll (tutti)
16 = mbHelp (guida)
helpContext è per ora ignorato. |
|
| MID$ |
STRING Function |
Windows/Unix |
|
| |
una funzione stringa che ritorna una sottostringa di n caratteri ad iniziare dalla posizione i di string-expression.
Sintassi: MID$(string-expression, i, n) A$ = MID$("Hello",3,2) '-- ritorna ll
Dettagli: non puoi usare MID$ in questo modo: MID$(A$, 1, 1) = "G" In QBasic, questa istruzione valida sostituisce il primo carattere da A$ con "G". Per ottenere lo stesso effetto in Rapid-Q, usa la funzione stringa REPLACE$. |
|
| MKDIR |
SYSTEM Statement |
Windows/Unix |
|
| |
Una istruzione che crea una nuova directory
Sintassi: MKDIR pathspec MKDIR "abc"
Dettagli: MKDIR non sovrascrive una directory se già esiste, se il percorso non è specificato, la directory è creata nella corrente directory di lavoro. |
|
| OUT |
I/O Statement |
Windows/Unix |
|
| |
Una istruzione I/O su dispositivo/device che manda un valore byte alla porta hardware I/O.
Sintassi: OUT port, value OUT &H3C9, 128
Dettagli:
Port è qualsiasi valore word tra 0 e 65535.
Valore è qualsiasi valore byte tra 0 e 255. |
|
| OUTW |
I/O Statement |
Windows/Unix |
|
| |
una istruzione I/O su dispositivo/device che manda un valore word alla porta hardware I/O.
Sintassi: OUTW port, value OUTW &H378, 128
Dettagli:
Port è un qualsiasi valore word tra 0 e 65535.
Value è qualsiasi valore word tra 0 e 65535. |
|
| PLAYWAV |
RAPID-Q Specific |
Windows |
|
| |
Suona un file .WAV o una risorsa .WAV.
Sintassi: PLAYWAV wavfilename|wavresource, sndOptions $RESOURCE Welcome_WAV AS "welcome.wav" PLAYWAV "welcome.wav", SND_ASYNC OR SND_LOOP PLAYWAV Welcome_WAV, SND_ASYNC OR SND_LOOP
Dettagli: sndOptions determina come il file wav viene suonato. 0 = SND_SYNC '-- attende che il wav finisce
1 = SND_ASYNC '-- suona in background
3 = SND_LOOP '-- risuona il wav una volta terminato
Puoi associare SYNC o ASYNC con LOOP tramite OR. Se il tuo file WAV non ha finito di suonare quando tu chiudi la tua applicazione, riceverai un errore di violazione di accesso. Puoi fermare il file .WAV passando una stringa vuota come nomefile/filename. |
|
| POSTMESSAGE |
RAPID-Q Specific |
Windows |
|
| |
una chiamata di WinAPI a PostMessage, non blocca.
Sintassi: POSTMESSAGE hWnd, uMsg, wParam, lParam POSTMESSAGE Form.Handle, WM_SYSCOMMAND, SC_MINIMIZE, 0
Dettagli: PostMessage è una chiamata WinAPI, vedi su questa funzione nel tuo file/manuale su WinAPI. |
|
| QUICKSORT |
SORTING Statement |
Windows/Unix |
|
| |
QUICKSORT, può essere usato per ordinare i tuoi arrays di ogni tipo, eccetto naturalmente Objects/UDT. Esso, ovviamente usa l'algoritmo QuickSort per effettuare l'ordinamento.
Sintassi: QUICKSORT(Array-begin, Array-end, ASCEND|DESCEND) DIM A(1000) AS INTEGER '-- put stuff in A QUICKSORT(A(10), A(500), ASCEND) '-- sorts elements 10..500
Dettagli: L'elemento pivot nell'esempio di sopra è A(10), quindi se vuoi randomizzare, dovrai sostituire A(10) con alcuni elementi random da A(10) a A(500) nell'esempio di sopra. Puoi anche ordinare un array multidimensionale e arrays "span sort".
Span sorting: DIM A(1 TO 100) AS LONG
DIM B(1 TO 100) AS LONG
DIM C(1 TO 100) AS LONG
'--- mette alcuni valori negli array A, B, C
RANDOMIZE TIMER
FOR I = 1 TO 100
A(I) = RND(50000)
B(I) = RND(50000)
C(I) = RND(50000)
NEXT
QUICKSORT A(1), C(100), ASCEND
PRINT A(1)," ",B(1)," ",C(1)
Quanto più dichiari gli arrays con DIM "da limite a limite" essi useranno uno spazio contiguo di memoria, questo significa che puoi ordinare a partire dall'inidirizzo di memoria iniziale A(1) a quello finale di C(100). Questa tecnica non è raccomandata, ma se puoi trovare un utile uso impiegala. |
|
| RANDOMIZE |
MATH Statement |
Windows/Unix |
|
| |
Inizializza (reimposta) il generatore di numeri random.
Sintassi: RANDOMIZE [numeric-expression] RANDOMIZE TIMER
Dettagli: Se argomento è omesso, randomize usa come default RANDOMIZE TIMER. |
|
| READ |
Statement |
Windows/Unix |
|
| |
una istruzione che legge valori da una istruzione DATA ed assegna i valori a variabili.
Sintassi: READ variablelist READ A%, S$, P(1,2)
Dettagli: Variablelist è fatta di una o più variabili, separate da una virgola, che riceveranno i dati letti. Le variabili potrebbero essere numeri o stringhe. |
|
| REDIM |
Statement |
Windows/Unix |
|
| |
Istruzione di dichiarazione che cambia lo spazio allocato per un array che è già stato dichiarato con DIM, preservando quanti dati possibili.
Sintassi: REDIM variable[(subscripts)] AS type DIM B(20) AS INTEGER REDIM B(100) AS INTEGER
Dettagli: Se array non è stato ancora dichiarato con DIM, REDIM è equivalente a DIM (eccetto quando si tratta di un componente, nel qual caso riceverai un errore di compilatore). Tu non puoi cambiare il tipo di dati dell'array, ie. non puoi ridefinire array B per qualcosa di diverso di dati INTEGER (come nell'esempio di sopra). Combinare arrays è un sottoprodotto di REDIM. DIM A(1 to 100) AS INTEGER
DIM B(1 to 100) AS INTEGER
REDIM A(1 to 200) AS INTEGER '-- Combina A e B insieme
Quello che fa il codice suesposto è preservare i dati in A come pure combinare l'array B. Quindi l'indice da 101 a 200 indica i dati di B e da 1 a 100 indica i dati di A. Chiarimento: Array B non è stato modificato, mantiene ancora il suo spazio di memoria e non sovrascrive i dati di A e viceversa. Nota che questo sottoprodotto non si applica in caso di array di stringhe a lunghezza fissa, dati variant e componenti.

DIM Button(1 TO 2, 1 TO 2) AS QBUTTON
REDIM Button(1 TO 2, 1 TO 4) AS QBUTTON
Nota che quando tratti con array multidimensionali gli elementi sono spostati per riempire ogni colonna. Quindi l'elemento 2,2) è attualmente spostato nella posizione(1,4). |
|
| REM |
Comment |
Windows/Unix |
|
| |
una dichiarazione BASIC che permette commenti esplicatori da inserire nel codice del programma. Si suggerisce l'impiego di ' per i commenti.
Sintassi: REM remark REM Questo è un commento, non viene eseguito ' Questo è un altro commento
|
|
| RENAME |
SYSTEM Statement |
Windows/Unix |
|
| |
una istruzione che rinomina un file. Se il file già esiste l'operazione non viene eseguita.
Sintassi: RENAME file1, file2 RENAME "abc.txt", "xyz.txt"
|
|
| REPLACE$ |
STRING Function |
Windows/Unix |
|
| |
una istruzione che sostituisce una parte di una stringa con una altra.
Sintassi: REPLACE$(source-string, replace-string, index) A$ = REPLACE$("Hello", "J", 1) '-- ritorna Jello
|
|
| REPLACESUBSTR$ |
STRING Function |
Windows/Unix |
|
| |
una funzione che restituisce una sottostringa con una altra stringa. Tutte le sottostringhe presenti saranno sostituite. La lunghezza della stringa inserita non deve essere uguale alla stringa sostituita.
Sintassi: REPLACESUBSTR$(source-string, replace-string, replacement-string) A$ = REPLACESUBSTR$("abcdefgabcdefg", "abc", "99") '-- ritorna 99defg99defg
|
|
| RESOURCE |
RESOURCE Function |
Windows/Unix |
|
| |
una funzione che ritorna la posizione assoluta della risorsa del programma corrente.
Sintassi: RESOURCE(numeric-expression) EXTRACTRESOURCE Resource(0), "test.bmp"
Dettagli: RESOURCE() è un array costituito da 0 a RESOURCECOUNT-1 elementi. L'elemento 0 corrisponde al primo gestore RESOURCE che tu specifichi e così a seguire. Se numeric-expression non è nell'intervallo 0 a RESOURCECOUNT-1, questa funzione ritorna 0. |
|
| RESOURCECOUNT |
RESOURCE Function |
Windows/Unix |
|
| |
una funzione che ritorna il numero di risorse nel programma corrente.
Sintassi: RESOURCECOUNT A% = RESOURCECOUNT
|
|
| RESTORE |
Statement |
Windows/Unix |
|
| |
una istruzione che permette alle istruzioni DATA di essere lette di nuono da una specifica linea di codice.
Sintassi: RESTORE [{linelabel | linenumber}] RESTORE
Dettagli: Se l'argomento è omesso, la prossima istruzione READ eseguita leggerà il primo elemento delle istruzioni DATA del programma. Linelabel o Linenumber identificano la istruzione DATA che vuoi far leggere dalla prossima istruzione READ. Il primo elemento di quella linea sarà letto. |
|
| REVERSE$ |
STRING Function |
Windows/Unix |
|
| |
una funzione che inverte (o pone in ordine inverso) una stringa.
Sintassi: REVERSE$(string-expression) A$ = REVERSE$("Hello") '-- ritorna olleH
|
|
| RGB |
CONVERSION Function |
Windows/Unix |
|
| |
una funzione di conversione che prende i parametri rosso, verde e blu e li combina per formare la rappresentazione numerica BGR.
Sintassi: RGB(redvalue, greenvalue, bluevalue) C = RGB(255, 0, 255)
Dettagli: i valori sono compresi tra 0 e 255. I valori al di fuori di tale intervallo producono risultati non definiti. |
|
| RIGHT$ |
STRING Function |
Windows/Unix |
|
| |
una funzione che ritorna gli ncaratteri più a destra di una stringa.
Sintassi: RIGHT$(string-expression, n) A$ = RIGHT$("Hello", 3) '-- ritorna llo
|
|
| RINSTR |
STRING Function |
Windows/Unix |
|
| |
Inverso di INSTR è una funzione che confronta 2 stringhe e ritorna la posizione della stringa trovata rispetto alla stringa di ricerca. Invece di iniziare la ricerca da sinistra a destra, come INSTR, RINSTR cerca da destra a sinistra (ie. l'inverso di INSTR). Se trovata, RINSTR ritorna la posizione indice della stringa trovata, altrimenti ritorna 0.
Sintassi: RINSTR([start,] search-string, find-string) A% = RINSTR("Hello World", "l") '-- ritorna 10 A% = RINSTR(4, "hehe they", "he") '-- ritorna 3
|
|
| RMDIR |
SYSTEM Statement |
Windows/Unix |
|
| |
una istruzione che rimuove una directory.
Sintassi: RMDIR directory RMDIR "abc"
|
|
| RND |
MATH Function |
Windows/Unix |
|
| |
una funzione che ritorna un numero random la cui sequenza è generata da RANDOMIZE.
Sintassi: RND[(upper-bound)] A% = RND(10)
Dettagli: Se non è fornito un limite superiore, RND ritorna un numero decimale compreso tra 0 e 1. |
|
| ROUND |
MATH Function |
Windows/Unix |
|
| |
funzione matematica che converte un numero a un intero arrotondando la parte frazionale dell'espressione.
Sintassi: ROUND(numeric-expression) A% = ROUND(3.49) '-- Ritorna 3 A% = ROUND(3.50) '-- Ritorna 4
|
|
| RTRIM$ |
STRING Function |
Windows/Unix |
|
| |
una funzione stringa che ritorna una stringa con gli spazi finali rimossi.
Sintassi: RTRIM$(string-expression) A$ = RTRIM$("Hello ") '-- ritorna Hello
|
|
| RUN |
SYSTEM Statement |
Windows/Unix |
|
| |
una istruzione che esegue un specifico programma senza bloccare.
Sintassi: RUN filespec RUN "rapidq.exe"
|
|
| SENDMESSAGE |
RAPID-Q Specific |
Windows |
|
| |
una chiamata WinAPI a SendMessage, blocca fino a che il messaggio non viene processato.
Sintassi: SENDMESSAGE hWnd, uMsg, wParam, lParam SENDMESSAGE Form.Handle, WM_SYSCOMMAND, SC_MINIMIZE, 0
Dettagli: SendMessage è una chiamata WinAPI quindi vedere la documentazione su file o manuali o guida a WinAPI. |
|
| SGN |
MATH Function |
Windows/Unix |
|
| |
una funzione matematica che indica il segno di una espressione numerica.
Sintassi: SGN(numeric-expression) A% = SGN(-123) '-- Returns -1
Dettagli: If numeric-expression è positivo, SGN ritorna +1. If numeric-expression è zero, SGN ritorna 0. If numeric-expression è negativo, SGN ritorna -1.
|
|
| SHELL |
SYSTEM Statement/Function |
Windows |
|
| |
SHELL può essere chiamato come una istruzione o come una funzione. Essa ha la stessa funzionalità di RUN eccetto che blocca la tua applicazione fino a quando quella mandata in esecuzione non termina.
Sintassi: SHELL command SHELL "rapidq.exe" Sintassi: SHELL(command, showCMD) PID = SHELL("rapidq.exe", SW_SHOWNORMAL)
Dettagli: Se si chiama SHELL come una funzione, il valore ritornato è il ID del processo del programma eseguito, e non blocca il tuo programma. showCMD può essere qualsiasi dei seguenti valori: 0 = SW_HIDE (nascosto) 6 = SW_MINIMIZE (minimizzato a icona)
1 = SW_SHOWNORMAL (mostra normale) 7 = SW_SHOWMINNOACTIVE (mostra minimizzato non attivo)
2 = SW_SHOWMINIMIZED (mostra minimizzato) 8 = SW_SHOWNA
3 = SW_SHOWMAXIMIZED (mostra a tutto schermo) 9 = SW_RESTORE (ripristina)
4 = SW_SHOWNOACTIVATE (mostra non attivo) 10 = SW_SHOWDEFAULT (mostra default)
5 = SW_SHOW (mostra) |
|
| SHOWMESSAGE |
RAPID-Q Specific |
Windows/Unix |
|
| |
una istruzione usata per mostrare una generica finestra di messaggi popup.
Sintassi: SHOWMESSAGE string-expression SHOWMESSAGE "Ciao Mondo!"
|
|
| SIN |
MATH Function |
Windows/Unix |
|
| |
funzione matematica che ritorna il seno di un angolo fornito in radianti come argomento.
Sintassi: SIN(numeric-expression) PI = 3.14153 C# = SIN(PI)
Dettagli: Numeric-expression è l'angolo espresso in radianti. |
|
| SIZEOF |
MEMORY Function |
Windows/Unix |
|
| |
funzione che ritorna la dimensione, in bytes, di un tipo di dati.
Sintassi: SIZEOF(datatype|variable) PRINT SIZEOF(MyUDT) PRINT SIZEOF(MyVar) PRINT SIZEOF(INTEGER)
Dettagli: Per calcolare le dimensioni di una UDT, devi prima usare DIM. ie. DIM MyUDT AS TMyUDT |
|
| SOUND |
I/O Statement |
Windows |
|
| |
istruzione di periferica/device I/O che genera un suono attraverso lo speaker del PC.
Sintassi: SOUND frequency, duration SOUND 4000, 18
Dettagli:
Frequency è una espressione numerica il cui valore è compreso tra 37 e 32767. Frequency è misurata in cicli/secondo, o hertz.
Duration una espressione numerica il cui valore è compreso tra 0 e 65535. Ci sono 18.2 ticchettii di orologio per secondo quindi 18 = 1 secondo, ecc... |
|
| SPACE$ |
STRING Function |
Windows/Unix |
|
| |
una funzione stringa che ritorna una stringa di spazi di lunghezza n .
Sintassi: SPACE$(n) A$ = SPACE$(5)
|
|
| SQR |
MATH Function |
Windows/Unix |
|
| |
una funzione matematica che ritorna la radice quadrata di un numero.
Sintassi: SQR(numeric-expression) A# = SQR(9) '-- ritorna 3
|
|
| STATIC |
Statement |
Windows/Unix |
|
| |
Similmente a DIM, questa istruzione nomina una o più variabili e alloca lo spazio di memoria necessario. Tuttavia dichiarando come STATIC le variabili implica che i valori sono conservati tra una chiamata ed una altra della procedura. Nota che solo i tipi semplici possono essere dichiarati.
Sintassi: STATIC variable[(subscripts)] AS type STATIC A AS INTEGER, B AS BYTE, S AS STRING
Dettagli: STATIC non ha no effetti (ie. lo stesso che usare DIM) quando dichiari nel modulo principale. Usa STATIC solo nelle SUB/I o FUNCTION/I.
Esempio :
'-- count non è static
SUB Count (N AS INTEGER)
DIM B AS LONG
B = N
IF N = 10 THEN EXIT SUB
Count(N+1)
PRINT B
END SUB
Count(1)
'-- count è Static , B mantiene lo stesso valore
SUB StaticCount (N AS INTEGER)
STATIC B AS LONG
B = N
IF N = 10 THEN EXIT SUB
StaticCount(N+1)
PRINT B
END SUB
StaticCount(1)
|
|
| STR$ |
CONVERSION Function |
Windows/Unix |
|
| |
funzione di conversione che ritorna una stringa che rappresenta il valore di una espressione numerica.
Sintassi: STR$(numeric-expression) A$ = STR$(99)
|
|
| STRF$ |
CONVERSION Function |
Windows |
|
| |
funzione di coversione che ritorna una stringa formattata che rappresenta il valore di una espressione numerica.
Sintassi: STRF$(numeric-expression, Format%, Precision%, Digits%) A$ = STRF$(99.9934, ffGeneral, 4, 4) A$ = STRF$(12345678, ffNumber, 8, 0)
Dettagli: Precision% specifica quanti decimali porre per calcolare. I seguenti formati sono validi: 0 = ffGeneral (generale) 2 = ffFixed (fisso)
1 = ffExponent (esponente) 3 = ffNumber (numero)
ffGeneral converte alla stringa decimale più breve possibile, dove gli zeri finali sono rimossi. Digits% ha un intervallo da 0 a 4. ffExponent converte alla notazione scientifica con la forma -d.ddd...E+dddd. Digits% ha un intervallo da 0 a 4. ffFixed converte alla forma con punto fisso -ddd.ddd... Digits% ha un intervallo da 0 a 18. ffNumber converte in un formato numerico -d,ddd,ddd.ddd... dove la stringa risultante contiene il separatore per le migliaia.
|
|
| STRING$ |
STRING Function |
Windows/Unix |
|
| |
una funzione stringa che ritorna una stringa i cui caratteri sono tutti come codice ASCII o i cui caratteri sono tutti il primo carattere di una espressione stringa.
Sintassi: STRING$(count, byte) A$ = STRING$(9, 65) '-- Ritorna AAAAAAAAA Sintassi: STRING$(count, string-expression) A$ = STRING$(9, "ABC") '-- Ritonra AAAAAAAAA
Dettagli: Il primo parametro indica il numero di volte da ripetere il carattere. Il secondo parametro può sia essere una espressione stringa, di cui viene ripetuto il primo carattere, sia un numero byte compreso tra 0 e 255 che rappresenta un carattere del codice ASCII. |
|
| SWAP |
Statement |
Windows/Unix |
|
| |
una istruzione di assegnazione che scambia i 2 valori di 2 variabili.
Sintassi: SWAP variable1, variable2 SWAP A$, B$
Dettagli: Variabile1 e variabile2 dovrebbero essere dello stesso tipo, ma Rapid-Q non controlla. Quindi, non scambiare variabili variant usando SWAP se i loro tipi non sono compatibili. |
|
| TALLY |
STRING Function |
Windows/Unix |
|
| |
Tally conta il numero di presenza di MatchString dentro la SearchString.
Sintassi: TALLY(search-string, match-string) Count& = TALLY("abcdefghijklmnabc", "abc") '-- ritorna 2
|
|
| TAN |
MATH Function |
Windows/Unix |
|
| |
funzione matematica che ritorna la tangente di un angolo fornito in radianti.
Sintassi: TAN(numeric-expression) T# = TAN(90)
Dettagli: Numeric-expression è l'angolo espresso in radianti. |
|
| TIME$ |
SYSTEM Function |
Windows/Unix |
|
| |
funzione che ritorna una stringa contenente il tempo corrente formattato come HH:MM:SS. Dove HH = ore (0-23), MM =minuti (0-59) e SS = secondi (0-59)
Sintassi: TIME$ PRINT TIME$
Dettagli: Diversamente da QBasic dove puoi anche impostare la data corrente usando l'istruzione TIME$, non puoi farlo in Rapid-Q. |
|
| TIMER |
SYSTEM Function |
Windows/Unix |
|
| |
funzione che ritorna il numero di secondi passati dalla mezzanotte.
Sintassi: TIMER T! = TIMER
Dettagli: il valore Timer in Linux/Unix è il numero di secondi passati da quando il tuo programma è stato lanciato. |
|
| UBOUND |
ARRAY Function |
Windows/Unix |
|
| |
funzione che ritorna il limite superiore di un array.
Sintassi: UBOUND(arrayname [,dimension]) DIM A(-50 TO 100) AS INTEGER L% = UBOUND(A) '-- Ritorna 100
Dettagli: Se l'array ha dimensioni multiple,puoi usare l'argomento dimensione opzionale per indicare ciascuna dimensione da valutare. |
|
| UCASE$ |
STRING Function |
Windows/Unix |
|
| |
funzione stringa che ritorna una espressione stringa con tutte le lettere in maiuscolo.
Sintassi: UCASE$(string-expression) A$ = UCASE$("Hello") '-- ritorna HELLO
|
|
| UNLOADLIBRARY |
DLL Statement |
Windows |
|
| |
Rimuove una DLL dalla memoria (solo quelle dichiarate in Rapid-Q). Se la DLL non è stata caricata o non viene trovata, questa istruzione non fa niente.
Sintassi: UNLOADLIBRARY(DLLName) DECLARE FUNCTION UpdateWindow LIB "USER32" ALIAS _ "UpdateWindow" (hWnd AS LONG) AS LONG UNLOADLIBRARY("USER32") '-- Rimuove USER32.DLL dalla memoria
Dettagli: Non è necessario scaricare una DLL, questo è fatto da Rapid-Q automaticamente quando il tuo programma termina. Scaricare una libreria DLL dalla memoria non significa che la funzione chiamata che necessita della DLL non funzioni. La DLL viene di nuovo caricara in memoria prima della chiamata alla funzione, quindi puoi togliere dalla memoria di nuovo se lo vuoi. Nota che i nomi della libreria devono coincidere, quindi nella tua dichiarazione per LIB "USER32" ... per scaricare questa libreria, devi scrivere lo stesso nome. UNLOADLIBRARY("USER32.DLL") fa niente , deve essere "USER32" in questo caso specifico. Vedi anche LIBRARYINST. |
|
| VAL |
CONVERSION Function |
Windows/Unix |
|
| |
funzione di conversione che ritorna una rappresentazione numerica di una espressione stringa.
Sintassi: VAL(string-expression) A = VAL("995")
|
|
| VARPTR |
ADDRESS Function |
Windows/Unix |
|
| |
una funzione che ritorna l'indirizzo ad es di un puntatore, di un nome di variabile specificato. La variabile deve essere dichiarata, es. non una variabile componente come QForm.Caption
Sintassi: VARPTR(variablename) Addr& = VARPTR(MyString$) Addr& = VARPTR(MyArray(0))
|
|
| VARPTR$ |
ADDRESS Function |
Windows/Unix |
|
| |
una funzione che ritorna la rappresentazione stringa di un indirizzo fornito.
Sintassi: VARPTR$(address) S$ = VARPTR$(279027343)
|
|
| VARTYPE |
VARIANT Function |
Windows/Unix |
|
| |
funzione che ritorna un tipo di dato del valore corrente presente in una variabile variant.
Sintassi: VARTYPE(variant) DIM myvariant(100) AS VARIANT myvariant(1) = "G" VType = VARTYPE(myvariant(1))
Dettagli: i valori validi ritornati sono:
0 - Numero (comprende Byte, Word, Dword, Short, Long/Integer)
1 - numero in virgola mobile/Float (comprende Single, Double)
2 - Stringa
tutte le varianti variant non definite sono inizializzate come Numeri. |
|