Programarea in Visual Basic For Application VBA 1

"Limbaje de programare folosite în informatice de gestiune" P A R T E A -ICUPRINS
Cap I. Programarea în Visual Basic for

Application(VBA)...................................5
I.1 Domeniul de folosire al
VBA ...............................................................................
.......................5 I.1.1 Modulele de cod în
Access.............................................................................
..........................6 I.2 Elementele generale ale limbajului Visual
Basic ....................................................................7 I.2.1
Tipuri de
date. .............................................................................
.............................................8
I.2.1.1 Date numerice
întregi............................................................................
...................................8 I.2.1.2 Date numerice
reale..............................................................................
...................................8 I.2.1.3 Tipul de date BOOLEAN -
logic..............................................................................
...............8 I.2.1.4 Tipul de date STRING - şir de
caractere..........................................................................
.....8 I.2.1.5 Tipul de date DATE - data calendaristică şi
timpul..........................................................10 I.2.1.6 Tipul de
date ARRAY -
tablou.............................................................................
..................10 I.2.1.7 TYPE - Crearea tipurilor de date definite de
utilizator. ..................................................11 I.2.1.8 Tipul de
date
VARIANT............................................................................
..............................11 I.2.1.8.1 Valorile EMPTY, NULL, STRING
VID.........................................................................12
I.2.1.9 Tipul de date
OBJECT.............................................................................
...............................12 I.2.2.1 Declararea
variabilelor.......................................................................
..................................12 I.2.2.2 Caractere folosite ca Type-
declaration........................................................................
.......13 I.2.2.3 Option Explicit (Opţiune de
explicitare).......................................................................
......13 I.2.2.4 Variabile Locale şi
Globale............................................................................
......................13 I.2.2.5 Variabile Publice şi
Private............................................................................
......................14 I.2.2.6 Variabila
Statice............................................................................
.........................................15 I.2.2.7 Domeniul şi durata de
valabilitate a
variabilelor ............................................................15 I.2.2.8
Declararea şi folosirea variabilelor ARRAY -
TABLOU..................................................16 I.2.2.8.1 Declararea
tablourilor cu dimensiuni fixe -
statice........................................................16
I.2.2
Variabile..........................................................................
.........................................................12
Observaţia 1. Ca orice declaraţie care nu specifică tipul şi tablourile declarate

fără tip sunt de tip Variant. În acest caz fiind Variant, fiecare element va ocupa
16 bytes, dacă este numeric sau 22 bytes, dacă este string. Deci la tablouri mari
se poate ajunge la un consum mare de memorie, ceea ce determină o rezervă în
folosirea tablourilor de Variant........................................16
I.2.2.8.2 Declararea tablourilor cu dimensiuni variabile -
dinamice............................................16 I.2.2.8.3 Utilizarea
tablourilor........................................................................
.................................17 I.2.2.8.4 Tablouri de
octeţi.............................................................................
.................................17
I.2.3
Constante..........................................................................
........................................................19 I.2.4 Instrucţiunile
executive ale limbajului Visual
Basic........................................................19
I.2.4.1 Instrucţiunea de
atribuire..........................................................................
............................20 I.2.4.1.1 Formarea expresiilor în Visual
Basic..............................................................................
20
Observaţia 1. Aşa cum am mai arătat, dacă un termen al unei expresii este NULL,
atunci şi rezultatul expresiei este tot NULL. Spunem că NULL-ul se propagă în
expresii. Totuşi există o excepţie, şi anume la operatorul de concatenare a
şirurilor, &: Dacă un termen este NULL, iar celălalt nu este NULL, atunci
rezultatul va fi chiar termenul diferit de NULL...........................22
Observaţia 2. Valoarea EMPTY, în expresii este considerată, funcţie de tipul de
date pe care îl reprezintă, chiar valoarea cu care se iniţializează variabilele de
tipul respectiv(astfel în expresii dacă un termen numeric este EMPTY
Created by Serban Criscota
Page 1
19 ianuarie 2001
atunci se va considera =0; dacă este logice =False; dacă este string = şir vid;
etc.) 22
I.2.4.2 Structurile de
control............................................................................
.................................22 I.2.4.2.1 Structura
secvenţială........................................................................
.................................22 I.2.4.2.2 Structura
alternativă........................................................................
..................................22
I.2.4.2.2.1 Structura alternativă simplă. Instrucţiunea:

If...Then...Else............................................................22
I.2.4.2.2.2 Structura alternativă multiplă. Instrucţiunile: Select Case şi
If...Then...ElseIF…Else...................23
Observaţia 1. Dacă mai multe condiţii sunt adevărate, atunci se vor executa toate
grupurile corespunzătoare de instrucţiuni. Deci instrucţiunea Select Case nu se
opreşte la întâlnirea primei condiţii adevărate, ci va evalua toate
condiţiile.........................................................................
...................................................23 Observaţia 2. În ValoareX se
pot folosi reuniuni de mulţimi (operator virgula - ex: 1,2,5) intervale (operator
TO - ex: 1 To 7), sau submulţimi(operator IS ex: Is >
7).................................................................................
..........................................23
I.2.4.2.3 Structura
repetitivă.........................................................................
...................................24
I.2.4.2.3.1 Structura repetitivă cu test. Instrucţiunea
DO.................................................................................
24
Observaţia 1. Instrucţiunea Exit Do, provoacă ieşirea forţată din ciclu. De obicei
se execută funcţie de evaluarea unei condiţii într-o instrucţiune IF.......25
Observaţia 2. Condiţia este evaluată funcţie de locul unde este plasată în
instrucţiune şi
anume:.............................................................................
.......................25 Observaţia 3. Ciclul se execută minim
de................................................................25
I.2.4.2.3.2 Structura repetitivă cu contor. Instrucţiunea
FOR...NEXT.............................................................26
Observaţia 1. Instrucţiunea Exit For, provoacă ieşirea forţată din ciclu şi

continuarea programului cu instrucţiunile de după NEXT. De obicei se execută
funcţie de evaluarea unei condiţii într-o instrucţiune
IF.......................................26 Observaţia 2. Sunt admise imbricări ale
structurilor For, dacă sunt folosite variabile contor diferite ca în exemplul
următor:...................................................26 Observaţia 3. Într-un
For, trebuie evitată schimbarea valorii contorului......27 Observaţia 4. Structura
For ... Next este folosită atunci când sunt un număr exact de iteraţii de
executat...........................................................................
...............27
I.2.5 Rutine - proceduri şi
funcţii............................................................................
.....................27
I.2.5.1 Ce este o rutină? Elementele care definesc o
rutină.........................................................27
Observaţia 1. Definirea unei rutine se face prin atribuirea unui nume(obligatoriu)

acesteia şi prin stabilirea listei de parametrii(opţional). Parametrii definiţi în
rutină se numesc parametrii formali. ...............................27 Observaţia
2. Declararea parametrilor formali se face după regulile aplicate la declararea
variabilelor.......................................................................
.......................28 Observaţia 3. Apelarea unei rutine se face prin numele
ei.................................28 Observaţia 4. În momentul apelării, trebuie
să se realizeze o corespondenţă între nişte date(variabile, constante, literali)
ale modulului apelant cu parametrii formali ai rutinei. Aceasta se face prin
stabilirea unei liste de parametrii actuali, declaraţi în momentul apelării.
Evident parametrii actuali şi formali trebuie să fie de acelaşi tip şi să ocupe
acelaşi loc în cele două liste. 28
Created by Serban Criscota Page 2 19 ianuarie 2001
Observaţia 5. Parametrii de intrare ai rutinei pot fi în lista parametrilor
actuali: variabile, constante, literali sau
expresii....................................................28 Observaţia 6.
Parametrii de ieşire ai rutinei pot fi în lista parametrilor actuali numai
variabile, deoarece aceştia prin definiţie îşi pot schimba valoarea în timpul
execuţiei
rutinei............................................................................
28
I.2.5.1.1 Transmiterea datelor prin
parametrii.........................................................................
......28 I.2.5.2 Crearea(definirea) unei
rutine.............................................................................
................29 I.2.5.2.1
Proceduri(Subrutine)...............................................................
..........................................29 I.2.5.2.2
Funcţii............................................................................
....................................................30
Observaţia 1. Se observă că singura deosebire esenţială faţă de proceduri, se

datorează faptului că numele funcţiei are două semnificaţii fiind în acelaşi timp
şi numele rutinei şi parametru de ieşire al rutinei. Din această cauză acestuia
trebuie să i se precizeze tipul de date. Dacă acest lucru nu se face atunci
implicit se va considera Boolean tipul
funcţiei............................................30 Observaţia 2. În loc de Exit
Sub şi End Sub, la funcţii sunt Exit Function şi End Function, evident cu acelaşi
rol. ........................................................................30
I.2.5.3 Apelarea unei
rutine.............................................................................
..................................31 I.2.5.3.1 Apelarea unei
proceduri(subrutine)...............................................................
..................31
Observaţia 1. Diferenţa între cele două apeluri este că la apelarea cu Call,

parametrii actuali ai procedurii trebuie scrişi între paranteze, pe când la
apelarea directă prin numele procedurii, este obligatoriu să nu se folosească
paranteze..........................................................................
.................................................31
I.2.5.3.2 Apelarea unei
funcţii............................................................................
............................31
Observaţia 1. O procedură nu poate fi folosită în locul unei funcţii într-o

expresie, deoarece nu returează valori (chiar dacă are parametrii de ieşire). .31
Observaţia 2. Funcţiile pot fi apelate şi ca pe o procedură în oricare din cele
două modalităţi
prezentate.........................................................................
..................31
I.2.5.4 I.2.5.5 I.2.5.6 I.2.5.7 I.2.5.8 Domeniul de valabilitate(vizibilitatea) al
rutinelor..........................................................32 Rutine
definite de utilizator. Introducerea codului
VBA...................................................32 Procedurile
evenimentelor......................................................................
...............................32 Utilizarea combinată a rutinelor utilizator şi a
procedurilor eveniment.......................34 Parametri
opţionali..........................................................................
......................................35
I.2.6 Bibliotecile standard de funcţii şi

proceduri. ...................................................................36
I.2.6.1 Funcţii
matematice.........................................................................
........................................37 I.2.6.1.1 Int(număr);
Fix(număr).........................................................................
...........................37 I.2.6.1.2
Abs(număr).........................................................................
...............................................37 I.2.6.1.3
Sgn(număr).........................................................................
...............................................37 I.2.6.1.4
Sqr(număr).........................................................................
................................................37 I.2.6.1.5
Exp(număr).........................................................................
...............................................38 I.2.6.1.6
Log(număr).........................................................................
...............................................38 I.2.6.1.7
Rnd[(număr)].......................................................................
..............................................38 I.2.6.1.8
Sin(număr).........................................................................
................................................39 I.2.6.1.9
Cos(număr).........................................................................
...............................................39 I.2.6.1.10
Tan(număr).........................................................................
.............................................39 I.2.6.1.11
Atn(număr).........................................................................
.............................................39 I.2.6.1.12 Expresii pentru calculul
funcţiilor matematice derivate..............................................40
I.2.6.2 Funcţii TEXT - pentru
stringuri..........................................................................
..................40 I.2.6.2.1
Asc(string)........................................................................
.................................................40 I.2.6.2.2
Chr(CodCaracter)...................................................................
...........................................40 I.2.6.2.3 AscB(string); AscW(string);
ChrB(CodChar); ChrW(CodChar)..................................41
Observaţia 1. Se observă că în codul UNICODE, primele 128 de coduri sunt ca în

codul
ASCII..............................................................................
..............................41
I.2.6.2.4
LCase(string)......................................................................
...............................................42 I.2.6.2.5
UCase(string)......................................................................
...............................................42 I.2.6.2.6 LTrim(string);
RTrim(string);
Trim(string)....................................................................42
I.2.6.2.7 Len(string |
NumeVariabila).....................................................................
.......................42 I.2.6.2.8 Left(string,
lungime)...........................................................................
..............................43 I.2.6.2.9 Right(string,
lungime)...........................................................................
...........................43 I.2.6.2.10 Mid(string,
start[,lungime])...................................................................
.........................44 I.2.6.2.11 InStr([start, ]string1, string2[,
compare])......................................................................44
I.2.6.2.12 String(număr,
caracter)..........................................................................
.........................45 I.2.6.2.13 Space
(număr)............................................................................
......................................45 I.2.6.2.14 Format(expresie[,
format])...........................................................................
.................46 I.2.6.3 Funcţii pentru
tablouri(array)....................................................................
..........................47 I.2.6.3.1 UBound(arrayname[,
dimension])........................................................................
...........47 I.2.6.3.2 LBound(arrayname[,
dimension])........................................................................
...........47 I.2.6.4 Funcţii pentru
mesaje.............................................................................
................................48 I.2.6.4.1 MsgBox(prompt[, buttons] [,
title] )...........................................................................
.....48
Observaţia 2. Aceste constante sunt specificate de Visual Basic for Applications.

În consecinţă, numele acestea pot fi utilizate oriunde în program în locul
valorilor
respective.........................................................................
.................49 Observaţia 3. MsgBox poate fi utilizată şi ca procedură. În
acest caz parametrii nu se mai scriu între paranteze. În această formă este
folosită pentru afişarea unui
mesaj..............................................................................
.............49
I.2.6.4.2 InputBox(prompt[, title] [, default] [, xpos] [,
ypos] )...................................................50 I.2.6.5 Funcţii cu
tipul:
Date/Time .........................................................................
.........................51 I.2.6.5.1 DatePart(interval,
date)..............................................................................
.......................51 I.2.6.5.2 DateDiff(interval, date1,
date2).............................................................................
..........51 I.2.6.5.3 DateAdd(interval, number,
date)..............................................................................
.......52 I.2.6.5.4 Day(date); Month(date);
Year(date).........................................................................
.......52 I.2.6.5.5 Second(date); Minute(date);
Hour(date).........................................................................
52 I.2.6.5.6
Now................................................................................
....................................................52 I.2.6.5.7
Date...............................................................................
.....................................................52 I.2.6.5.8
Timp...............................................................................
....................................................52 I.2.6.5.9 DateSerial(year,
month,
day)...............................................................................
............52 I.2.6.6 Funcţii: structuri de
control............................................................................
......................53 I.2.6.6.1 IIf(condiţie, TruePart,
FalsePart).........................................................................
............53
Observaţia 1. TruePart sau FalsePart, pot la rândul lor să conţină o altă funcţie,
deci şi IIF, ceea ce permite realizarea unor structuri complexe de teste. 53
I.2.6.6.2 Choose(index, caz-1[, caz-2, ... [, caz-
n]])......................................................................53
I.2.6.6.3 Switch(expr-1, value-1[, expr-2, value-2 … [, expr-n,value-
n]])..................................54 I.2.6.7 Funcţii de
inspecţie..........................................................................
......................................54 I.2.6.7.1
VarType(NumeVariabilă).............................................................
....................................54 I.2.6.7.2
IsNull(expresie)...................................................................
..............................................55
Observaţia 1. Valoarea Null, îndică faptul că un Variant nu conţine date valide.

Mai există încă două valori Empty şi String vid(gol) care pot fi uşor confundate cu
Null, ceea ce constituie o eroare. Deci vom avea:.........................56
I.2.6.7.3
IsEmpty(NumeVariabila).............................................................
....................................56 I.2.6.7.4
IsMissing(NumeParametru)...........................................................
...................................56
Observaţia 1. Funcţia IsMissing, se aplică numai dacă parametrul opţional este de

tip variant. Dacă parametrul opţional nu este de tip variant ea va întoarce
întotdeauna(fie că parametrul opţional este sau nu este folosit la apelarea
funcţiei) valoarea
FALSE. ...........................................................................5
7
I.2.6.8 Funcţiile agregate
SQL................................................................................
..........................57 I.2.6.9 Funcţiile agregate de
domeniu............................................................................
.................57 I.2.6.10 Funcţii de
conversie..........................................................................
...................................58
I.2.6.10.1
Str(Număr).........................................................................
..............................................58
Observaţia 1. După conversie, la începutul stringului va fi un spaţiu pentru

numerele pozitive / sau semnul (-) pentru numerele
negative..............................59 Observaţia 2. Punctul zecimal va fi
reprezentat întotdeauna de semnul punct(.), indiferent de cum este setat acesta în
Windows(ca punct sau ca virgulă). 59
I.2.7 Mediul de depanare şi dezvoltare
VBA..............................................................................60
I.2.6.10.2
Val(string)........................................................................
................................................59
Cap I.
Programarea în Visual Basic for Application(VBA).
Basic, este unul din cele mai vechi limbaje de programare. El a fost creat în idea
de a se realiza un limbaj de programare necesar unui specialist dintr-un anumit
domeniu, care nu are cunoştinţe aprofundate despre sistemele de calcul. Basic a
fost implementat iniţial, în sistemele de operare, ca un interpretor, adică ca un
sistem care în momentul în care preia o instrucţiune sursă Basic, o transformă
imediat în instrucţiuni obiect(cod maşină) şi le execută. Pentru a îl face cât mai
accesibil, au existat variante de Basic care au implementat şi comenzi specifice
unui sistem de operare, ajungându-se până a se realiza calculatoare dedicate pentru
lucrul sub Basic, fără sisteme de operare. Evident, fiind conceput pe aceste
principii, aplicaţiile realizate nu erau performante, ele ne utilizând eficient
facilităţile unui sistem de calcul. Treptat, s-a trecut la realizare unor
implementări, tehnic mai performante, prin realizarea de compilatoare pentru Basic
sub diferite sisteme de operare, adică a unor module care transformă un fişier cu
instrucţiuni sursă Basic într-un fişier care conţine instrucţiuni direct
executabile, în cod obiect. Firma Microsoft, a realizat o versiune de Basic, numită
Visual Basic, care pe lângă principiile iniţiale s-a dorit a rezolva următoarea
problemă: • Un limbaj de programare universal, unic, care să poată fi folosit atât
în aplicaţiile de sistem(în locul limbajului C) cât şi în cele utilizator,
performant atât din punct de vedere a limbajului(implementând conceptele de
programare modulară, programare structurată şi programare la nivel de obiect) cât
şi din punct de vedere al utilizării tuturor facilităţilor sistemului de operare.
Astfel s-au creat, pe baza aceluiaşi nucleu de programare Basic, trei sisteme: 
Microsoft Visual Basic, ca limbaj universal de programare;  Visual Basic for
Application(Visual Basic pentru aplicaţii), prescurtat uzual VBA, ca un limbaj
complex pentru dezvoltarea aplicaţiilor în cadrul programelor din Microsoft Office.
Aceasta înseamnă că nucleul limbajului, componentele sale şi mediul sunt aceleaşi
în Access, Word sau Excel. VBA este aproape identic cu limbajul universal de
programare Microsoft Visual Basic;  Visual Basic Script(VB Script), utilizat în
special pentru aplicaţiile Internet; I.1 Domeniul de folosire al VBA Aplicaţiile
mai simple din Access pot fi scrise fără a fi nevoie de vre-o instrucţiune,
eventual folosind comenzile macro. Deşi comenzile macro sunt foarte bune pentru
rezolvarea rapidă a unor prelucrări necesare pentru dezvoltarea majorităţii
aplicaţiilor de bază, realizarea unor aplicaţii complexe, profesioniste în Access
se face folosind limbajul VBA. Acest lucru se datorează faptului că, spre deosebire
de comenzile macro, Visual Basic for Application oferă posibilităţi de lucru
specifice limbajelor de nivel înalt de programare orientată pe obiecte. Câteva
dintre aceste posibilităţi sunt: • Tratarea erorilor prin proceduri speciale create
de proiectant. În timpul execuţiei unei aplicaţii pot interveni diverse erori(de
exemplu o împărţire la zero sau ieşirea din domeniul de definiţie al unei
variabile, etc.) pe care sistemul le tratează în general prin stoparea modulului
unde apar sau chiar a întregii aplicaţii. VBA oferă posibilitatea ca la apariţia
unei erori, controlul să fie dat unui modul de cod
VBA, realizat de proiectant care să rezolve în funcţie de context situaţia apărută,
fără a mai fi necesară stoparea modulului respectiv sau a aplicaţiei. • crearea
unor structuri ciclice pentru parcurgerea seturilor de înregistrări . Datele unei
tabele sau cereri de selecţie se pot manipula ca pe un fişier specific, numit set
de înregistrări. • execuţia proceselor tranzacţionale. Acestea reprezintă practic
posibilitatea de a efectua actualizările într-un set de înregistrări, global, la un
anumit moment. În cazul apariţiei unei erori se pot anula toate actualizările din
procesul respectiv, setul de înregistrări rămânând ne modificat. • apelarea
funcţiilor Windows API, prin care se pot folosi module ale sistemului de operare. •
crearea şi manipularea prin program a obiectelor necesare aplicaţiei • utilizarea
constantelor şi a variabilelor • crearea de clase de obiecte De asemenea VBA
uşurează scrierea bibliotecilor de funcţii reutilizabile, precum şi proiectarea şi
depanarea proceselor complexe de către programatori. În concluzie, deşi comenzile
macro pot da soluţii rapide problemelor simple, limitările lor determină
necesitatea folosirii limbajului VBA pentru dezvoltarea soluţiilor mai complexe.
I.1.1 Modulele de cod în Access Codul VBA este scris în unităţi numite rutine, care
pot fi subrutine(proceduri) sau funcţii. Aceste subrutine şi funcţii sunt păstrate
în obiecte numite module de cod, şi anume:  Module specifice unui anumit formular
sau raport. Modulele specifice unui formular sau raport sunt în general numite
coduri din spatele formularelor (Code Behind Forms – CBF). Rutinele din acest loc
pot fi vizibile(cunoscute, apelabile) doar din modulul respectiv de cod. Codul din
spatele formularului sau raportului se poate accesa prin acţionarea pictogramei
specifice codului VBA (după selecţia obiectului respectiv) sau prin apăsarea celor
trei puncte (…) din dreptul unui eveniment al paginii respective a unui obiect
aparţinând formularului sau raportului respectiv *. Notă: * Dacă procedura
eveniment nu este creată, atunci automat un Wizard, va crea structura acesteia,
adică instrucţiunile de declarare şi sfârşit precum şi completarea listei de
parametrii dacă este cazul. Dacă procedura eveniment a fost creată anterior, atunci
se va afişa porţiunea din pagina de cod a formularului sau raportului care conţine
respectiva procedură.  Modulele globale, se pot afişa prin acţionarea paginii
Module, din fereastra Database. Foarte important este faptul că rutinele scrise în
această zonă pot fi vizibile (dacă sunt declarate Public) nu numai din toate
modulele de cod ale aplicaţiei, dar chiar din obiecte ale aplicaţiei, din
formulare, rapoarte, cereri sau tabele. Exemplu. De exemplu dacă în modulul global
se găseşte o funcţie declarată public, cu numele 'Prag', aceasta va putea fi
folosită în expresii din orice:  modul general sau din spatele unui formular sau
raport;  controale calculate din formulare sau rapoarte;  proprietăţi ale
controalelor sau ale tabelelor(de exemplu Validation Rule, Default Value); 
criterii din cereri;  câmpuri calculate din cereri; practic de oriunde este
acceptată o expresie. Orice modul de cod, este format din două părţi: • În prima
parte se introduc declaraţiile generale ale modulului, valabile în întreg modulul.
Acestea sunt:  Opţiunile modulului. De exemplu: Option Explicit, care forţează
declararea tuturor variabilelor folosite în modul.
 Declararea tipurilor, variabilelor şi constantelor, vizibile în tot modulul de
cod. • În a doua parte se introduc rutinele modulului de cod. O
subrutină(procedură) este o rutină care execută o acţiune:  la apariţia unui
eveniment al unui obiect al aplicaţiei ori  la apelarea(lansarea) ei dintr-o altă
rutină VBA. O funcţie este un tip special de rutină, datorită faptului că poate
întoarce o valoare, chiar în numele ei. Deci codul VBA poate fi găsit în rapoarte,
formulare şi module de cod. În formulare şi rapoarte, codul VBA poate fi plasat în
funcţiile definite de utilizator, în subrutine, ca şi în procedurile eveniment, pe
când în modulele generale codul VBA este plasat numai în rutine(funcţii sau
proceduri) definite de utilizatori. De fapt, pentru a construi cu succes rutine în
cod VBA, sunt foarte importante două lucruri: • cum se stabileşte domeniul de
valabilitate al variabilelor şi rutinelor • cum se transmit şi se întorc valorile
din rutine. Toate aceste componente vor fi analizate în cadrul prezentului capitol.
În concluzie, putem spune că programarea în VBA nu este procedurală, adică nu avem
de a face cu un program clasic, cu început şi sfârşit, care rezolvă paşii unui
algoritm. Codul VBA este practic format din rutine, care sunt executate numai
atunci când se produc anumite evenimente. Deci codul VBA implică realizarea unui
programări discontinue. I.2 Elementele generale ale limbajului Visual Basic
Definirea unui limbaj de programare, se face în general prin configurarea
următoarelor elemente de bază: ♦ ♦ ♦ ♦ Tipuri de date, Variabile; Constante;
Instrucţiuni  Instrucţiunea de atribuire;  Structuri de control; ♦
Rutine(proceduri şi funcţii) ♦ Biblioteci; Dacă limbajul de programare este
orientat la nivel de obiect, aşa cum este Visual Basic sau VBA, atunci trebuiesc
definite şi elemente referitoare la: ♦ Referirea obiectelor; ♦ Crearea claselor de
module de obiecte; ♦ Crearea şi manipularea obiectelor (instanţe ale claselor de
obiecte); ♦ Crearea şi manipularea colecţiilor de obiecte Limbajele de programare
dezvoltate mai pun la dispoziţie programatorilor: ♦ Proceduri specifice de tratare
ale erorilor; ♦ Modalităţi de verificare şi depanare a erorilor de programare; ♦
Proceduri de import/export de obiecte exterioare aplicaţiei; ♦ Interacţiunea cu
sistemul de operare. ♦ Manipularea datelor organizate în fişiere sau baze de date.
Page 7
19 ianuarie 2001
I.2.1 Tipuri de date. Prin dată se înţelege orice entitate asupra căreia poate
opera calculatorul. În cod maşină datele se reprezintă sub forma unei secvenţe de
cifre binare. În cazul limbajelor de nivel înalt se face abstracţie de detaliile de
reprezentare a datelor, dezvoltând conceptul de tip de date. În memoria
calculatorului orice dată apare ca o succesiune de biţi. Modul în care pentru o
astfel de succesiune se asociază o valoare depinde de interpretarea ce i se dă. La
nivelul limbajelor de programare o astfel de interpretare este reprezentată de
tipul datelor. Un tip de date este noţiunea folosită pentru a defini mulţimea
valorilor pe care le pot avea datele ce aparţin acestui tip, dimensiunea efectiva
pe care o ocupă în memorie datele, precum şi operaţiile ce se pot efectua asupra
acestor date. Orice limbaj de programare pune la dispoziţia programatorului câteva
tipuri de date predefinite (standard), cum ar fi tipurile pentru datele întregi,
reale, caracter sau booleene(logice). Acestea sunt tipuri simple de date care se
referă la valori elementare. Limbajul VBA oferă mai multe tipuri simple de date
predefinite, cele mai folosite fiind prezentate în continuare:
I.2.1.1 Date numerice întregi
Numele tipului de date Byte (octet) Integer (întreg) Long (întreg lung) Currency
(valută) ------------------
Spaţiul de memorare 1 octet 2 octeţi 4 octeţi 8 octeţi
Domeniul de valori 0 … 255 –32,768…32,767 - 2,147,283,648 …. 2,147,483,647 +/-

922,337,203, 685,477.5808
Numărul de valori 2^8 2^16 2^32 15 cifre şi 4 zecimale
Valoarea iniţială 0 0 0 0
Ex. de nume variabilă btValue iCounter lAmount cValuta
I.2.1.2 Date numerice reale
♦ Datele numerice reale se exprimă sub forma: Numele tipului de date Single
(precizie simplă) Double (precizie dublă) -----------------Spaţiul de memorare 4
octet 8 octeţi
+/-M * 10^+/-E
Domeniu Exponent(E) E-45…E38 E-324…E308 Valoarea iniţială 0 0 Ex. de nume variabilă
sngValue dValue
Domeniu Mantisa(M) Aproximativ 7 cifre zecimale Aproximativ 14 cifre zecimale
I.2.1.3 Tipul de date BOOLEAN - logic
Numele tipului de date Boolean (logic) ------------------
Spaţiul de memorare 2 octet
Domeniu De valori True(-1); False(0)
Valoarea iniţială False(0)
Ex. de nume variabilă bRaspuns
I.2.1.4 Tipul de date STRING - şir de caractere
• •
Există două tipuri de date de tip String şi anume: String de lungime variabilă,
care poate conţine până la aproximativ 2 milioane caractere (2^31). String de
lungime fixă, care poate conţine până la aproximativ 64,000 caractere (2^16).
Codul folosit este codul ANSI şi are date în intervalul 0-255, Primele 128
caractere (0–127) corespund literelor şi simbolurilor de pe o tastatură US, adică
codului ASCII. Dintre acestea primele 32 sunt caractere netipăribile, dar care pot
avea efect în afişarea datelor. De exemplu:  caracterul cu codul 13, CR - retur de
car, care produce trecerea la început de rând  caracterul cu codul 10, LF - rând
nou, care produce trecerea rândul următor  caracterul cu codul 7, Bell - semnal
sonor  caracterul cu codul 8, Back Space - înapoi  caracterul cu codul 9, Tab -
salt la următorul marcaj Codul ASCII 0 · 16 · 32 [space] 48 0 64 @ 80 P 96 ` 112 p
1 · 17 · 33 ! 49 1 65 A 81 Q 97 a 113 q 2 · 18 · 34 " 50 2 66 B 82 R 98 b 114 r 3 ·
19 · 35 # 51 3 67 C 83 S 99 c 115 s 4 · 20 · 36 $ 52 4 68 D 84 T 100 d 116 t 5 · 21
· 37 % 53 5 69 E 85 U 101 e 117 u 6 · 22 · 38 & 54 6 70 F 86 V 102 f 118 v 7 Bell
23 · 39 ' 55 7 71 G 87 W 103 g 119 w 8 BS 24 · 40 ( 56 8 72 H 88 X 104 h 120 x 9
Tab 25 · 41 ) 57 9 73 I 89 Y 105 i 121 y 10 LF 26 · 42 * 58 : 74 J 90 Z 106 j 122 z
11 · 27 · 43 + 59 ; 75 K 91 [ 107 k 123 { 12 · 28 · 44 , 60 < 76 L 92 \ 108 l 124 |
13 CR 29 · 45 61 = 77 M 93 ] 109 m 125 } 14 · 30 · 46 . 62 > 78 N 94 ^ 110 n 126 ~
15 · 31 · 47 / 63 ? 79 O 95 _ 111 o 127 · -----------------Următoarele 128
caractere (128–255) corespund caracterelor speciale, diacriticelor, accente,
simboluri valutare, litere în alfabete internaţionale etc. Literalii string se
scriu între ghilimele("…."). La iniţializare variabilele de tip string, vor avea
valoarea şir vid, adică "". Operatorul pentru concatenarea datelor este & (se poate
folosi şi semnul + )La formarea numelor variabilelor de tip string, se foloseşte de
obicei prefixul s. De exemplu sNume. Notă: Deşi ne-am aştepta ca un caracter să
ocupe un octet(8 bits) de memorie(fiind 256=2^8 caractere în codul ANSI), totuşi
spaţiul ocupat de un caracter în memorie este de 2 octeţi. Aceasta se datorează
faptului că în memorie caracterele sunt în codul UNICODE, cod care are 2^16
caractere. De exemplu în memorie caracterele ASCII, vor avea pe primul octet codul
ASCII al caracterului iar în al doilea 0, iar caracterele ANSI cu cod mai mare de
127, vor avea în al doilea octet 1. Deci, în limbajul Visual Basic, caracterele se
folosesc în codul ANSII(ASCII), deşi în memorie ele sunt în codul UNICODE.
------------------
Page 9
19 ianuarie 2001
I.2.1.5 Tipul de date DATE - data calendaristică şi timpul
Numele Spaţiul de Domeniu Ex. de nume tipului de date memorare de valori variabilă
Date Data: 1/1/100 la 12/31/9999 8 octet dtStartDate (data + timpul) Timp: 0:00:00
la 23:59:59. -----------------Literalii date se scriu între diezi(#….#). De
exemplu: #January 1, 1993# sau #1 Jan 93#. Afişarea datelor şi timpului se face
conform formatului specificat în Windows. Notă: Un număr poate fi convertit în tip
Date, partea din stânga punctului zecimal reprezentând data, iar cea din stânga
timpul. Ora 24 este 0.0, ora 12 este 0.5, numerele negative reprezintă date
anterioare celei de 30/Decembrie/1899. La formarea numelor variabilelor de tip
string, se foloseşte de obicei prefixul dt. De exemplu dtStop.
-----------------Visual Basic include mecanismele necesare construirii unor tipuri
noi, prin restrângeri sau combinări ale tipurilor deja definite. Aceste mecanisme
poartă numele de constructori de tipuri şi joacă un rol esenţial în programare.
I.2.1.6 Tipul de date ARRAY - tablou
Un Tablou - Array, defineşte o mulţime de valori care sunt de acelaşi tip de dată.
Un Array, deşi reprezintă o singură variabilă poate stoca mai multe date de acelaşi
tip în compartimentele(elementele) sale. Structura unui asemenea tip poate avea o
dimensiune sau mai multe. Un Array, se caracterizează prin 3 elemente dintre care
primele două definesc structura:  Numărul de dimensiuni.  Numărul de
elemente(celule) al fiecărei dimensiuni. Practic numărul de ordine al
primului(implicit 0) şi al ultimului element al fiecărei dimensiuni.  Tipul de
date al elementelor tabloului. Poate fi orice tip de date, eventual chiar tot
array. Referirea la un tablou se poate face fie pentru întreaga structură(folosind
numele tabloului), fie pentru fiecare element în parte(folosind numele tabloului
indexat la elementul respectiv). Exemplu. Pentru a stoca cheltuielile pe care le
facem în fiecare zi al unui an vom declara bineînţeles o singură variabilă de tip
Array, cu 365 elemente de tip numeric, decât 365 variabile individuale. Fiecare
element din tablou va conţine o singură valoare. Implicit un tablou se indexează de
la 0. Declararea variabilei se va face: Dim cCheltuieli(364) As Currency Pentru a
introduce în primele 100 de zile valoarea 22 vom folosi următoarea procedură: Sub
ExempluArray() Dim cCheltuieli (364) As Currency Dim intI As Integer For intI = 0
to 99 cCheltuieli (intI) = 22 Next End Sub ------------------
Page 10
19 ianuarie 2001
I.2.1.7 TYPE - Crearea tipurilor de date definite de utilizator.
Există posibilitatea ca să se creeze structuri noi de date, definite de proiectant,

formate din combinări din alte tipuri de date. ------------------
[Public | Private] Type NumeTip NumeElement1 As type NumeElement2 As type ... End
Type
-----------------Referirea la variabilele de un tip definit de utilizator, se poate
face fie pentru întreaga structură (folosind numele variabilei), fie pentru fiecare
element în parte(folosind numele elementul respectiv calificat -cu semnul punct -
cu numele variabilei). Notă: Declararea unui tip de date nu se poate face decât la
nivelul unui modul de cod. Deci nu se pot declara tipuri de date la nivelul unei
rutine. Exemplu. Option Compare Database Option Explicit Public Type Person 'se
declară tipul de date la nivelul modulului Nume As String Prenume As String Virsta
As Integer End Type Sub TypeTest() Dim Primul As Person, Doilea As Person 'se
declară 2 variabile de tipul de date Person Primul.Nume = "Ionescu" ' se folosesc
elementele tipului de dată Person Primul.Prenume = "Ion" Primul.Virsta = 21 Doilea
= Primul ' se referă întregul tip de dată Person MsgBox Doilea.Nume & " " &
Doilea.Prenume & ", varsta=" & Doilea.Virsta & " ani" End Sub
-----------------I.2.1.8 Tipul de date VARIANT
Acest tip de date, specific limbajului Visual Basic, este deosebit de puternic
fiind compatibil cu: ♦ toate tipurile numerice ♦ tipul Date ♦ tipul String ♦ tipul
Object Deşi uşurează munca de programare, totuşi folosirea variabilelor de tip
variant, diminuează performanţele programului, atât ca memorie ocupată cât şi ca
timp de execuţie.
Page 11
19 ianuarie 2001
Numele tipului de date Variant (numere) Variant (string) ------------------
Spaţiul de memorare 16 octet 22 octeţi
Domeniu La fel ca la tipul numeric La fel ca la tipul string
Valoarea iniţială Empty (Gol) Empty (Gol)
Ex. de nume variabilă vntValue vntNume
I.2.1.8.1 Valorile EMPTY, NULL, STRING VID. • EMPTY - reprezintă valoarea pe care o
are o variabilă variant care nu a fost încă îniţializată. La prima introducere a
unei date într-o variabilă de tip variant, aceasta se va configura în conformitate
cu tipul respectiv de date. • NULL - reprezintă o valoare pe care o ia o variabilă
variant în care datele nu sunt valide. • String de lungime 0 (vid, gol) - string
care nu are nimic în el, adică este "". -----------------I.2.1.9 Tipul de date
OBJECT
Acest tip de date va fi prezentat într-un alt modul. -----------------I.2.2

Variabile. Variabilele sunt nume de locaţii de memorie care conţin valori de un
anumit tip, ce se modifică în timpul execuţiei programului. Variabilele se
caracterizează prin: • Domeniul de valabilitate(vizibilitate) : se referă la
momentul când acestea apar şi dispar din 'codul sursă'. Variabilele apar atunci
când sunt declarate prima dată, după care apar şi dispar în funcţie de domeniu. În
momentul când acestea apar, variabilele devin vizibile, li se pot atribui valori de
un anumit tip şi pot fi folosite în cadrul instrucţiunilor. În rest, ele sunt
invizibile. • Durata de viaţă(valabilitate) : se referă la timpul cât variabila
ocupă loc în memorie. Când se creează variabile trebuiesc avute în vedere mai multe
lucruri. Modul şi locul în care se declară o variabilă determină domeniul de
valabilitate, durata de valabilitate şi alte caracteristici ale acesteia.
Următoarele subiecte analizate vă vor să înţelegeţi mai bine declararea
variabilelor în limbajul Visual Basic.
I.2.2.1
Declararea variabilelor
Forma acestei
Declararea variabilelor se face de obicei cu instrucţiunea declarativă DIM.

instrucţiuni este:
Dim NumeVariabilă As TipulDeDateAlVariabilei

• Numele variabilei respectă regulile folosite la formarea numelor. În practica
programării, se obişnuieşte să se pună un prefix convenţional la nume, care să
indice tipul de date al variabilei. (Vezi exemplele de nume de variabile din
modulul ' Tipuri de date '). • O variabilă poate fi declarată specificându-se
următoarele tipuri de date: Byte, Integer, Long, Currency, Single, Double, Date,
String (pentru variabile de lungime variabilă), String * length (pentru variabile
de lungime fixă), Object, sau Variant, sau a unui tip de date definit cu declaraţia
Type. Notă: Ne specificarea unui tip de date duce la crearea unor variabile de tip
Variant. • Se pot declara mai multe variabilele pe acelaşi rând, separate prin
virgulă, dar este obligatorie folosirea explicită a tipului de dată pentru fiecare
variabilă. Exemplu. Dim intX As Integer, intY As Integer, intZ As Integer O
greşeală obişnuită este declararea mai multor variabile pe aceeaşi linie, fără a se
specifica tipul pentru fiecare variabilă declarată ca în exemplul de mai jos
Dim iCounter, iAge, iWeight As Integer În acest caz, numai ultima variabilă este
declarată ca o variabilă de tip Integer (întreg). Celelalte variabile sunt
declarate de tipul Variant.(tipul implicit al unei variabile este variant). Această
eroare este foarte periculoasă, deoarece unele limbaje de programare(PASCAL),
folosesc o asemenea notare pentru a declara toate variabilele de pe aceiaşi linie
de acelaşi tip.
I.2.2.2 Caractere folosite ca Type-declaration.
Anumite variabilele mai pot fi create automat de un anumit tip, folosindu-se în loc
de specificaţia As, anumite caractere speciale, denumite caractere de tip, la
sfârşitul numelui variabilei, în declaraţia Dim. Astfel: Tipul de date Caracterele
de tip Integer Long Currency Single Double String Variant
&
implicit
Acest tip de declaraţii este importat din variantele mai vechi de Basic, dar nu
este recomandabil. Exemplu. Următoarele declaraţii sunt echivalente. Dim Nume As
String - Dim Nume$ Dim Virsta As Integer - Dim Virsta% Dim Anul As Variant - Dim
Anul -----------------I.2.2.3 Option Explicit (Opţiune de explicitare)
Este o instrucţiune declarativă care poate fi inclusă în secţiunea General

Declarations a unui modul, formular sau raport. Când Option Explicit este plasat
într-un modul de cod, toate variabilele din interiorul obiectului respectiv (modul,
formular sau raport) trebuie să fie declarate înainte de folosire, altfel
producându-se o eroare de compilare. Introducerea instrucţiunii Option Explicit în
fiecare modul, formular sau raport, se poate face automat Acest lucru se face prin
activarea opţiunii Require Variable Declarations (cere declaraţii de variabile) din
meniul Tools | Options | Module. Este foarte important ca această comandă (Option
Explicit) să fie plasată în toate modulele de cod. Asiguraţi-vă că aţi configurat
opţiunea la valoarea True ! Dacă proprietatea specificată mai sus nu este
setată(False), atunci practic se poate să nu se declare deloc variabilele.
Declararea acestora se face implicit, funcţie de datele cu care se încarcă la prima
folosire variabila(ca în limbajul FORTRAN). De exemplu, instrucţiunea: x=10, ar
genera şi declararea unei variabile de tip întreg. Folosirea acestei metode este
foarte periculoasă, deoarece poate cauza multe probleme. În concluzie, cea mai
eficientă şi mai lipsită de erori metodă de declarare a variabilelor este de a
folosi în totalitate instrucţiunea declarativă Dim, pentru fiecare declarare de
variabilă, ca în exemplul următor: Dim iCounter As Integer Dim sName As string Aşa
cum se vede, acest tip de declaraţie conţine atât numele variabilei, cât şi tipul
datelor pe care le poate conţine. Acest lucru permite compilatorului să
intercepteze erori de genul memorării unui şir într-o variabilă de tip întreg. La o
implementare corespunzătoare, prin selectarea celui mai scurt tip de date folosit
pentru fiecare variabilă, se pot reduce resursele necesare executării programului.
I.2.2.4 Variabile Locale şi Globale.
•
Funcţie de locul de declarare, variabilele pot fi:  Locale - variabile declarate
în interiorul rutinei, vizibile(domeniul de valabilitate) numai în interiorul
acesteia.
Page 13
19 ianuarie 2001
 Globale(nivel modul) - variabile declarate în secţia de declaraţii generale de la
începutul unui modul de cod. În acest caz variabila va fi vizibilă în interiorul
tuturor rutinelor din modulul respectiv de cod. Exemplu. Fie declararea variabilei:
Dim sName As String Dacă această declaraţie se face într-o rutină, atunci ea va
putea fi folosită numai în aceasta. Dacă declararea ei se face în secţiunea de
declaraţii generale ale modulului de cod, atunci ea se va putea folosi în toate
rutinele modulului, dar nu şi în alte module de cod. Această caracteristică o au
numai variabilele declarate Public. Exemplu. Variabilele de nivel global(modul)
sunt declarate prin plasarea unei comenzi Dim în secţiunea General Declarations a
formularului, raportului sau modulului de cod, ca mai jos: [ General Declarations]
Option Explicit Dim miCounter As Integer -----------------Variabilele de nivel
modul pot fi vizualizate din orice rutină aparţinând modulului în care au fost
declarate.. Valoarea variabilei poate fi schimbată de orice subrutină sau funcţie
din modulul respective. De exemplu, următoarea subrutină schimbă valoarea
variabilei de nivel modul miCounter la 20. Reţineţi convenţia de numire a
variabilei prin folosirea literei m ca prefix al numelui acesteia. Aceasta o face
să fie recunoscută ca o variabilă de nivel modul. Ar trebui să folosiţi declaraţii
de nivel modul numai pentru variabilele care trebuie să fie văzute de mai multe
rutine. Ar trebui să încercaţi să declaraţi majoritatea variabilelor dumneavoastră
de tip local. Această metodă face codul dumneavoastră mai modular şi mai uşor de
depanat. Private Sub cmdModule_Click() miCounter = 20 MsgBox miCounter End Sub
-----------------I.2.2.5 Variabile Publice şi Private.
O variabilă publică poate fi accesată (este vizibilă, are domeniul de valabilitate)

de oriunde din aplicaţie. Variabilele publice se folosesc de obicei pentru
identificatori de acces, valori de configurare pentru mediul de lucru şi alte
variabile care trebuie să fie vizibile pentru întreaga aplicaţie. Declaraţiile
variabilelor publice trebuie să fie plasate în secţiunea General Declarations a
modulului general de cod. Pentru declararea variabilelor publice se foloseşte
cuvântul cheie PUBLIC, în loc de DIM. Exemplu. O declaraţie de variabilă publică
arată aşa: Option Explicit Public piCounter As Integer Reţineţi folosirea
prefixului p, cu care convenţional se poate indica tipul public al variabilei.
Secvenţa de cod următoare, plasată în evenimentul Click al butonului de comandă
cmdPublic schimbă valoarea variabilei publice piCounter la 50, şi o afişează.
Private Sub cmdPublic_Click () piCounter = 50 Msgbox piCounter End Sub
-----------------Created by Serban Criscota Page 14 19 ianuarie 2001
Se poate folosi cuvântul cheie PRIVATE, în loc de DIM, pentru a declara variabile
private în secţiunea de declaraţii generale a modulul de cod, adică variabile care
nu sunt vizibile, decât de rutinele aparţinând modulului respectiv de cod. Exemplu.
Private MyName As String Notă: Cuvântul cheie DIM, este echivalent cu PRIVATE,
atunci când se folosesc la declararea variabilelor în modulele de cod. Este totuşi
indicată folosirea expresiei private, pentru a face codul mai lizibil.(mai uşor de
citit şi mai rapid de interpretat) -----------------I.2.2.6 Variabila Statice
Se poate folosi cuvântul cheie STATIC, în loc de cuvântul cheie DIM, pentru a
declara variabile statice în rutine, adică variabile care au proprietatea de aşi
reţine valoarea între două chemări ale respectivei rutine, Exemplul următor
ilustrează diferenţa dintre variabilele locale şi cele statice. Variabilele locale
sunt iniţializate la fiecare apel al codului. De fiecare dată când lansaţi în
execuţie această procedură, se va afişa numărul 1. Private Sub cmdLocal_Click ()
Dim iCounter As Integer iCounter = iCounter + 1 MsgBox iCounter End Sub De fiecare
dată când acest cod este executat, instrucţiunea declarativă Dim reiniţializează
variabila iCounter. Este puţin diferită faţă de următoarea secvenţă de cod, care
ilustrează folosirea variabilelor statice: Private Sub cmdLocal_Click () Static
iCounter As Integer iCounter = iCounter + 1 MsgBox iCounter End Sub De fiecare dată
când acest cod este executat, variabila cu numele iCounter este incrementată şi
reţinută. -----------------I.2.2.7 Domeniul şi durata de valabilitate a
variabilelor
Aşa cum am arătat, domeniul de valabilitate sau vizibilitatea variabilelor, este

determinată de cuvântul utilizat în declararea variabilei: Dim, Private, Public şi
de locul unde acesta e plasat, determinând ca variabila respectivă să fie locală,
modulară(globală) sau publică şi să poată fi folosită numai într-o rutină, la
nivelul unui modul de cod, sau în toate modulele de cod. Ar trebui să faceţi tot
posibilul ca majoritatea variabilelor din codul dumneavoastră să fie locale,
deoarece acestea sunt ferite de o eventuală modificare (accidentală) de către alte
rutine. Durata de viaţă(valabilitate) a variabilelor, reprezintă, aşa cum am mai
arătat, timpul cât variabila are alocat spaţiu în memorie. Fără alte instrucţiuni
speciale, o variabilă se creează în momentul în care modulul în care este
declarată, este apelat, şi dispare în momentul terminării modulului respectiv.
Astfel, o variabilă locală declarată într-o procedură eveniment, va fi alocată
numai în timpul execuţiei procedurii respective (bineînţeles dacă nu este statică).
O variabilă globală declarată într-un modul de cod al unui formular, va fi alocată
cât timp formularul respectiv va fi în execuţie. O variabilă publică declarată
într-un modul general de cod al va fi alocată în tot timpul execuţiei aplicaţiei.
I.2.2.8 Declararea şi folosirea variabilelor ARRAY - TABLOU.
Tablourile se declară la fel ca orice altă variabilă folosindu-se instrucţiunile

declarative Dim, Static, Private, sau Public. Diferenţa faţă de declararea unei
variabile simple, este aceea că la tablouri, între paranteze, trebuie să se
specifice pentru fiecare dimensiune - în ordine şi separate prin virgulă dacă sunt
mai multe dimensiuni - valoarea minimă şi maximă a indicelui dimensiunii
respective. I.2.2.8.1 Declararea tablourilor cu dimensiuni fixe - statice.
Dim NumeTablou(N1 [, N2 [, N3….]) As TipDe Dată

Aşa cum se observă marginea de jos a indicelui a fost omisă. Ea se consideră a avea
valoarea 0. Totuşi poate fi luată şi 1, numai dacă este introdusă în modulul
respectiv de cod, instrucţiunea declarativă Option Base 1. Exemplu. Declaraţia Dim
MyArray(9, 10) As Integer va crea un tabel cu 2 dimensiuni cu 10 pe 11 elemente, cu
primul indice cu valori între (0 - 9) şi al doilea indice cu valori între (0 - 10),
în care toate cele 110 elemente(celule) sunt de tip Integer. Observaţia 1. Ca orice
declaraţie care nu specifică tipul şi tablourile declarate fără tip sunt de tip
Variant. În acest caz fiind Variant, fiecare element va ocupa 16 bytes, dacă este
numeric sau 22 bytes, dacă este string. Deci la tablouri mari se poate ajunge la un
consum mare de memorie, ceea ce determină o rezervă în folosirea tablourilor de
Variant. Exemplu. În continuare se prezintă ce memorie vor ocupa tablourile. Tablou
Variant - cel puţin 176 bytes(11 el. * 16 bytes). Dim MyIntegerArray(10) As Integer
' Tablou Integer foloseşte 22 bytes (11 elemenste * 2 bytes). ReDim
MyDoubleArray(10) As Double ' Tablou Double-precision .. 88 bytes(11 el. * 8
bytes). ReDim MyVariantArray(10) ' Tablou Variant .. cel puţin 176 bytes(11 el. *
16 bytes). ReDim MyIntegerArray (99, 99) As Integer ' Tablou Integer foloseşte 100
* 100 * 2 bytes (20,000 bytes). ReDim MyDoubleArray (99, 99) As Double ' Tablou
Double-precision .. 100 * 100 * 8 bytes (80,000 bytes). ReDim MyVariantArray(99,
99) ' Tablou Variant .. cel puţin 160,000 bytes (100 * 100 * 16 bytes).
-----------------Se pot declara tablouri specificându-se explicit şi marginea de
jos a indicelui.
Dim NumeTablou(J1 To N1 [, J2 To N2 [, J3 To N3….]) As TipDe Dată • Cu J s-a notat

marginea de jos a indicelui, iar cu N marginea de sus a indicelui
I.2.2.8.2 Declararea tablourilor cu dimensiuni variabile - dinamice. În timp ce
tablourile cu dimensiuni fixe vor ocupa din etapa de compilare, o anumită
dimensiune de memorie care nu mai poate fi modificată în timpul execuţiei,
tablourile dinamice pot să-şi modifice dimensiunile în timpul execuţiei. Un tablou
dinamic se declară la fel, cu Static, Dim, Private sau Public, fără a se specifica
însă nimic între paranteze.
Dim NumeTablou() As TipDe Dată

Exemplu. Dim sngArray() As Single
Page 16
19 ianuarie 2001
Notă: Cu instrucţiunea executabilă ReDim (cu o structură asemănătoare cu cea a lui
Dim), care se poate plasa oriunde în cod după declararea unui tablou dinamic, se va
redimensiona în momentul execuţiei acesteia tabloul cu noile dimensiuni, eventual
putându-se schimba şi tipul de date. Exemplu. ReDim sngArray(11) va redimensiona
tabloul, însă nu modifică tipul de date al elementelor şi provoacă pierderea
datelor din tablou. Notă: Folosirea lui ReDim, va provoca pierderea datelor din
tabloul pe care îl redimensionăm. Pentru a se evita acest lucru se poate folosi
clauza Preserve. Folosirea acestei clauze nu permite modificarea numărului de
dimensiuni sau a marginii de jos ai indecşilor. Exemplu. ReDim Preserve sngArray
(UBound(sngArray) + 10) - va redimensiona tabloul, mărind cu 10 numărul lui de
elemente şi va păstra datele ce erau în tablou înainte de executarea instrucţiunii.
I.2.2.8.3 Utilizarea tablourilor Un tablou poate fi utilizat ca pe orice variabilă
simplă de tipul respectiv. Referirea unui element al tabloului se face prin numele
tabloului, urmat între paranteze de indicele(indicii) elementului respectiv.
Exemplu. Sub FillArrayMulti() Dim intI As Integer, intJ As Integer Dim sngMulti(1
To 5, 1 To 10) As Single For intI = 1 To 5 For intJ = 1 To 10 sngMulti(intI, intJ)
= intI * intJ ' indroduce în fiecre element produsul indicilor elementului. '
afişează indicii elementului şi valoarea din acesta. MegBox " Tablou( " & intI &
" , " & intJ & " ) = " & sngMulti(intI, intJ) Next intJ Next intI End Sub I.2.2.8.4
Tablouri de octeţi Un tablou de octeţi este un tablou dinamic de tipul BYTE. El
poate fi utilizate ca orice tablou dar mai are o proprietate care îl face util în
lucrul cu stringuri, şi anume: • Un tablou de octeţi se poate referi şi direct,
numai prin numele lui, fără indici. În felul acesta în el se poate muta direct un
string. Trebuie remarcat că în această operaţie fiecare caracter este codificat pe
2 octeţi în UNICODE, deci va ocupa 2 elemente din string. Exemplu. Pentru
înţelegerea acestei secvenţe trebuie studiat mai întâi, în capitolul despre
funcţiile text, precizările făcute pentru codul UNICODE. Public Sub TestMatOcteti()
Dim Caracter As String, Sir As String * 3 Dim X() As Byte ' Tablou de octeţi, va
avea 6 elemente deoarece pentru ReDim X(5) ' un caracter din string sunt necesare 2
elemente de 1 octet Dim k As Integer, j As Integer, i As Integer Sir = "1AŞ" X =
Sir For i = 0 To 2
j = i + 1 ' In “J” se va calcula numărul caracterului in string ... 1, 2, 3 -
necesar pt. MID Caracter = Mid(Sir, j, 1) ' in "Caracter" se vor introduce
caracterele k = 2 * (i) ‘ În “K” – poziţia în tablou a caracterelor… 0, 2, 4
Debug.Print "Caracterul = " & Caracter & "; CodUnicode= " & AscW(Caracter) & _ ";
CodAnsii= " & Asc(Caracter) & "; Octetul 1= " & X(k) & "; Octetul 2= " & X(k + 1) '
Ceea ce se afişează cu Debug.Print se poate vizualiza prin comanda View | Debug
Window MsgBox "Caracterul = " & Caracter & "; CodUnicode= " & AscW(Caracter) & _ ";
CodAnsii= " & aSc(Caracter) & "; Octetul 1= " & X(k) & "; Octetul 2= " & X(k + 1)
Next I For i = 0 To 5 Debug.Print "Octetul " & i & " = " & X(i) MsgBox "Octetul " &
i & " = " & X(i) Next i End Sub ‘-------------------După execuţie se va găsi afişat
în Debug.Print: Caracterul = 1; CodUnicode= 49; CodAnsii= 49; Octetul 1= 49;
Octetul 2= 0 Caracterul = A; CodUnicode= 65; CodAnsii= 65; Octetul 1= 65; Octetul
2= 0 Caracterul = Ş; CodUnicode= 350; CodAnsii= 170; Octetul 1= 94; Octetul 2= 1
Octetul 0 = 49 Octetul 1 = 0 Octetul 2 = 65 Octetul 3 = 0 Octetul 4 = 94 Octetul 5
= 1 -----------------Explicaţie. În memoria internă, dacă o variabilă nestructurată
ocupă mai mulţi octeţi(de exemplu o variabilă integer ocupă 2 octeţi), atunci cel
mai semnificativ dintre aceştia se găseşte la dreapta. Deci dacă într-o variabilă
integer se găseşte valoarea:
266(zecimal)=0000.0001.0000.1010(binar)=01.0A(hexazecimal) atunci aceasta se va
găsi în memorie: (0000.1010)(0000.0001) - deci cu octetul cel mai
semnificativ(0000.0001) aşezat la dreapta. Din tabelul de mai jos, se observă cum
se găseşte în memoria internă, într-o variabilă de tip tablou de octeţi, datele
dintr-un string.
Caracterele din string Cod ANSI(1 octet/caracter) - zecimal Cod UNICODE(2
octeţi/caracter) -zecimal Memorie -Tabloul X (6 octeţi) - binar Memorie -Tabloul X
(6 octeţi) - hexa Memorie -Tabloul X (6 octeţi) - zecimal
‘1’ 49 49
0011.0001 0000.0000
‘A’ 65 65
0100.0001 0000.0000
‘Ş’ 170 350

0101.1110 0000.0001
31 49
00 0
41 65
00 0
5E 94
01 1
Page 18
19 ianuarie 2001
I.2.3 Constante Prin declararea unei constante, se poate atribui unui nume, o
valoare. Aceasta se face prin instrucţiunea declarativă Const. După declarare, o
constantă nu îşi mai poate modifica valoarea. Forma acestei instrucţiuni este:
[Public | Private] Const NumeConstantă [As TipulDeDateAlVariabilei] = Valoare

O constantă, se comportă practic ca o variabilă, iniţializată cu o anumită valoare,
care nu se mai poate schimba în timpul execuţiei aplicaţiei. Regulile aplicate
variabilelor privind domeniul şi durata de valabilitate, sunt efective şi în cazul
constantelor. Deci vom avea: ♦ constante locale sau globale, funcţie de locul de
declarare(în rutină sau secţiunea de declaraţii generale a modulului de cod). ♦
constante publice sau private, dacă folosim sau nu în faţa cuvântului cheie Const,
cuvintele cheie Private, Public. Exemplu. Constanta conAge, este o constantă
publică, Integer, cu valoarea 34. Public Const conAge As Integer = 34
-----------------Constantele se pot declara :  Cu tip explicit, şi anume: Boolean,
Byte, Integer, Long, Currency, Single, Double, Date, String, sau Variant, ca în
exemplul de mai sus sau;  Cu tip implicit, în care clauza As lipseşte iar tipul va
fi determinat de tipul datei cu care se încarcă variabila. De exemplu dacă avem
declaraţiile: Const Ziua = "Miercuri" Const Virsta = 44 atunci prima constantă va
fi de tip string, iar a doua integer. Ca şi la variabile se pot declara mai multe
constante pe acelaşi rând, cu specificarea (dacă este explicită) a tipului pentru
fiecare constantă în parte, Const conAge As Integer = 34, conWage As Currency =
35000, conNume="Soare" În exemplul de mai sus primele două constante sunt declarate
explicit Integer respectiv Currency, iar a treia, implicit, string. I.2.4
Instrucţiunile executive ale limbajului Visual Basic. Limbajele de programare au un
set de instrucţiuni care constituie lista completă a posibilităţilor de care
dispune programatorul pentru a determina rezolvarea unei probleme(aplicaţie) pe un
sistem de calcul. Instrucţiunile unui limbaj de programare sunt de două feluri: •
Instrucţiuni declarative, care practic nu determină executarea unei acţiuni de
către sistemul de calcul, ci numai nişte indicaţii care se dau compilatorului. De
exemplu instrucţiunile de declarare ale tipurilor de date, variabilelor sau
constantelor(Dim, Const, Type etc.), opţiunile de compilare(Option Explicit, Option
Compare Database, etc.) • Instrucţiuni executive, care reprezintă descrierea unei
acţiuni pe care o va efectua sistemul de calcul, în special privind datele
aplicaţiei(If, For, Do etc.). Execuţia unei instrucţiuni reprezintă efectuarea
operaţiei specificate de codul instrucţiunii, interpretate la un moment dat de
unitatea centrală a unui sistem de calcul sau de un procesor. De obicei, execuţia
instrucţiunii presupune obţinerea operanzilor din memoria internă sau din
registrele unităţii centrale, formarea rezultatului şi depunerea acestuia într-un
registru al unităţii centrale sau în memoria internă. Ca exemplu de operaţii pe
care le face unitatea centrală a sistemului de calcul sunt operaţiile de adunare,
scădere, citire, scriere, comparaţie, etc.
Limbajele moderne de programare au un set redus de instrucţiuni complexe: •
Declararea structurilor de date. • Instrucţiunea de atribuire - prin care se
calculează expresii. • Structurile de control - prin care se determină 'traseul'
printre instrucţiuni, adică ordinea în care se execută instrucţiunile. • Declararea
şi apelarea rutinelor • Crearea claselor de module de obiecte • Crearea şi
manipularea obiectelor Practic, instrucţiunile executive ale limbajelor moderne de
programare sunt instrucţiunea de atribuire şi instrucţiunile prin care se
realizează structurile de control. Alte operaţii necesare unei aplicaţii(ca de
exemplu executarea operaţiilor de Input / Output), sunt realizate prin rutine din
bibliotecile de obiecte, funcţii şi proceduri disponibile limbajului respectiv de
programare.
I.2.4.1 Instrucţiunea de atribuire
Forma acestei instrucţiuni este:
NumeVariabilă = Expresie
Acţiunea acestei instrucţiuni constă în calcularea expresiei (din dreapta semnului
=) şi depunerea rezultatului în variabila (din dreapta semnului =). Pentru a se
executa cu succes instrucţiunea, este necesar ca rezultatul expresei să aparţină
unui tip de date compatibil cu cel al variabilei. În caz contrar se va produce o
eroare de execuţie(pe care le vom trata în alt modul). Totuşi compilatorul încearcă
trecerea peste anumite incompatibilităţi, a căror rezolvare este evidentă,
efectuând automat conversiile între tipuri diferite de date, dacă este posibil.
Exemplu. Private Sub TestExpresie() Dim Vstr As String Dim Vnr As Integer Vstr =
"251" Vnr = 251 + 40 ' prelucrari normale Vstr = 251 + 40 ' nu produce eroare de
execuţie.Transforma constanta numerică 291 în stringul "291" Vnr = Vstr ' nu
produce o eroare de execuţie. Transforma stringul "291" în constanta numerică 291
Vstr = Vnr + "ABC" ' va produce eroare de execuţie- TYPE MISMATCH. Nu se poate
efectua adunarea. Vstr = Vnr & "ABC" ' nu produce eroare. Vnr = "ABC" ' va produce
eroare de execuţie- TYPE MISMATCH End Sub I.2.4.1.1 Formarea expresiilor în Visual
Basic. O expresie este formată din termeni, asupra cărora se efectuează anumite
operaţii. O expresie al cărei evaluare este o valoare logică(True sau False) se mai
numeşte condiţie. Termenii pot fi : variabile, constante, literali(valori date
direct) sau funcţii(proprii sau din biblioteci) Operatorii sunt de trei tipuri
• •
Page 20
19 ianuarie 2001
♦ Operatorii aritmetici, care acţionând asupra unor termeni scalari(numere,
stringuri, date calendaristice, etc.) vor determina tot un rezultat de aceiaşi
natură(scalar).
/
Împărţire reală 5/2=2.5
\
Împărţire întreagă 10\3=3
Mod
Restul împărţirii 10 Mod 3=1
+
Adunare 5+2=7
Scăder e 5-2=3
&
Concatenare şiruri. "Ab"&2="Ab2"
Ridicare Înmulţire la putere 5^2=25 5*2=10 ------------------
♦ Operatorii relaţionali, care acţionând asupra unor termeni scalari(numere,

stringuri, date calendaristice, etc.) vor determina un rezultat logic(boolean)
<
mai mic (1<1) =False
<=
mai mic sau egal (5<=5) =True
>
mai mare (5>4) =True
>=
mai mare sau egal (5>=5) =True
=
egal (5=5) =True
<>
ne egal (5<>5) = False
Is
apartenenţa la o mulţime (5 Is [1,2,3]) = False
Like
compară două stringuri, dar ţine cont de caracterele generice(*,?,#) din al doilea
string ("ARAD" Like "AR*") = True
 Caracterele generice generează o mulţime de caractere astfel: ? Un singur

caracter. ("a2B3a" Like "a?a") = False * Zero sau mai multe caractere. ("a2B3a"
Like "a*a") = True # Un singur număr (0–9). ("a2a" Like "a#a") = True [Listă char]
ex. [A-R] Un singur caracter din listă. ("F" Like "[A-Z]") = True [!Listă
caractere] Un singur char care nu este în listă. (("F" Like "[!A-Z]") = False
-----------------♦ Operatorii logici, având valori logice(True , False) ca
operanzi, vor determina un rezultat tot logic.
Op
Op 1Op 2ANDTrueTrueTrueTrueFalse FalseFalseTrueFalseFalseFalseFa lse
Op 1Op 2ORTrueTrueTrueTrueFalse TrueFalseTrueTrueFalseFalse False
NOTTrueFalse
FalseTrue
Mai există două funcţii logice, mai puţin folosite, şi anume: Op 1 Op 2 XOR  EQV -
utilizată pentru verificarea echivalenţei True True False logice a două expresii 
IMP - utilizată pentru verificarea implicării True False True logică între două
expresii False True True -----------------Notă: Operatorii sunt aşezaţi de la
stânga la dreapta în False False False ordinea priorităţii lor în execuţie, care
este în general cea obişnuită din matematică. Parantezele rotunde sunt folosite
pentru stabilirea unei ordini explicite a priorităţii în execuţie a operaţiilor.
Observaţia 1. Aşa cum am mai arătat, dacă un termen al unei expresii este NULL,
atunci şi rezultatul expresiei este tot NULL. Spunem că NULL-ul se propagă în
expresii. Totuşi există o excepţie, şi anume la operatorul de concatenare a
şirurilor, &: Dacă un termen este NULL, iar celălalt nu este NULL, atunci
rezultatul va fi chiar termenul diferit de NULL. Observaţia 2. Valoarea EMPTY, în
expresii este considerată, funcţie de tipul de date pe care îl reprezintă, chiar
valoarea cu care se iniţializează variabilele de tipul respectiv(astfel în expresii
dacă un termen numeric este EMPTY atunci se va considera =0; dacă este logice
=False; dacă este string = şir vid; etc.)
I.2.4.2 Structurile de control
Aşa cum am mai arătat, structurile de control stabilesc ordinea în care se execută
instrucţiunile. Există trei structuri de control, şi anume: structura secvenţială,
structura alternativă(decizională) şi structura repetitivă(în buclă, în ciclu)
I.2.4.2.1 Structura secvenţială Reprezintă execuţia secvenţială a instrucţiunilor,
în ordinea în care au fost scrise. -----------------I.2.4.2.2 Structura alternativă
Reprezintă execuţia unui anumit grup de instrucţiuni sau a altuia, funcţie de
evaluarea unor condiţii. I.2.4.2.2.1 Structura alternativă simplă. Instrucţiunea:
If...Then...Else If condiţie Then Grup 1 de instrucţiuni [Else Grup 2 de

instrucţiuni] End IF
-----------------Structura If ... Then ... Else evaluează dacă condiţia este
adevărată sau falsă. • Dacă condiţia este adevărată, vor fi executate toate
instrucţiunile dintre If şi Else (Grup 1 de instrucţiuni). • Dacă condiţia este
falsă, vor fi executate toate instrucţiunile dintre Else şi End If (Grup 2 de
instrucţiuni). Notă: Folosirea comenzii Else este opţională. Notă: O condiţie cu
rezultatul NULL este tratată ca şi cum ar fi FALSE Exemplu. Private Sub
cmdIf_Click() ' evenimentul click al unui buton de comandă If IsNull (Me!txtValue)
Then ' Condiţia testează dacă în controlul txtValue, este introdusă o valoare. '
Acest lucru se face cu funcţia IsNULL, studiată în alt modul MsgBox “Trebuie sa
introduceti o valoare” Else MsgBox “Ati introdus:” & Me!txtValue End If End Sub
Notă: Un control, în care nu este introdus nimic va avea valoarea NULL
-----------------I.2.4.2.2.2 Structura alternativă multiplă. Instrucţiunile: Select
Case şi If...Then...ElseIF…Else În locul folosirii mai multe instrucţiuni If ...
Then ... Else atunci când decizia se ia prin evaluarea mai multor
condiţii(Structura alternativă multiplă) este mult mai simplu, fără îndoială,
utilizarea instrucţiunii Select Case sau a instrucţiunii If ... Then ... ElseIF…
Else Instrucţiunea Select Case
Select Case NumeVariabilă Case Valoare1 Grup 1 de instrucţiuni [Case Valoare2 Grup
2 de instrucţiuni] [Case ValoareX Grup X de instrucţiuni] ……………………… [Case Else Grup
else de instrucţiuni] End Select
Această instrucţiune evaluează mai multe condiţii formate prin verificarea
egalităţii între valoarea variabilei ataşate instrucţiunii (NumeVariabilă), şi
valorile din dreptul cuvintelor cheie CASE (ValoareI). Deci: Condiţia I va fi:
NumeVariabilă= ValoareI Dacă o condiţie este advărată atunci se va executa grupul
corespunzător de instrucţiuni. Dacă toate condiţiile sunt false atunci se vor
executa - dacă există - instrucţiunile dintre Else …. End Select (Grup else de
instrucţiuni) Observaţia 1. Dacă mai multe condiţii sunt adevărate, atunci se vor
executa toate grupurile corespunzătoare de instrucţiuni. Deci instrucţiunea Select
Case nu se opreşte la întâlnirea primei condiţii adevărate, ci va evalua toate
condiţiile. Observaţia 2. În ValoareX se pot folosi reuniuni de mulţimi (operator
virgula - ex: 1,2,5) intervale (operator TO - ex: 1 To 7), sau submulţimi(operator
IS ex: Is > 7) Exemplu. Private Sub cmdCase_Click () Dim IResponse As Integer if
IsNull (Me!txtValue) Then iResponse = 0 Else IResponse = Val (Me!txtValue) 'Funcţia
VAL transformă într-o valoare numerică un string. End If Select Case iResponse Case
0 MsgBox "Trebuie sa introduceti un numar” Case 1 To 5 MsgBox "Ati introdus o
valoare intre 1 si 5”
Case 7, 11, 21 MsgBox "Ati introdus 7, 11 sau 21” Case Else MsgBox "Ati introdus un
numar incorect” End Select End Sub -----------------Această procedură utilizează în
prima parte o instrucţiune If pentru a evalua dacă txtValue este nul. În acest caz,
procedură memorează un zero într-o variabilă numită iResponse. În caz contrar,
valoarea conţinută în txtValue este memorată în iResponse. Instrucţiunea Case
evaluează conţinutul variabilei iResponse. Dacă valoarea este 0, este afişată o
casetă de text cu mesajul „Trebuie să introduceţi un număr”. Dacă valoarea este
între 1 şi 5 inclusiv, este afişată o casetă de text conţinând mesajul „Aţi
introdus o valoare între 1 şi 5”. Dacă utilizatorul introduce 7, 11 sau 21, este
afişat un mesaj corespunzător. În celelalte cazuri, utilizatorul primeşte un mesaj
care indică introducerea unui număr incorect. Instrucţiunea If ... Then ... ElseIF
…Else
If condiţie-1 Then [grup 1 de instrucţiuni] [ElseIf condiţie-n Then [grup n de

instrucţiuni] …………….….. [Else [grup else de instrucţiuni]] End If
-----------------Instrucţiunea funcţionează similar instrucţiunii Select Case,
numai că :  o dată găsită o condiţie adevărat, execuţia instrucţiunii este
terminată  condiţiile introduse sunt independente, ne mai fiind obligatorie
prezenţa ca un termen a unei anumite variabile. Deci instrucţiunea va evalua pe
rând, în ordine, condiţia 1, 2, etc. • Prima condiţie găsită adevărată va determina
execuţia grupului respectiv de instrucţiuni, şi terminarea instrucţiunii. • Dacă
toate condiţiile sunt false, vor fi executate toate instrucţiunile dintre Else şi
End If (Grup else de instrucţiuni). Notă: Folosirea comenzii Else este opţională.
Notă: O condiţie cu rezultatul NULL este tratată ca şi cum ar fi FALSE
-----------------I.2.4.2.3 Structura repetitivă Reprezintă execuţia repetată a unui
anumit grup de instrucţiuni numit ciclu sau buclă până când o condiţie ia o anumită
valoare. I.2.4.2.3.1 Structura repetitivă cu test. Instrucţiunea DO • Execută în
mod repetat un ciclu şi anume cât timp(While) o condiţie este TRUE sau
•
până când(Until) o condiţie devine TRUE Există două forme ale instrucţiunii Do:
------------------
Do [{While | Until} conditie] [grup instrucţiuni] [Exit Do] [grup instrucţiuni]

Loop
------------------
Do SAU [grup instrucţiuni] [Exit Do] [grup instrucţiuni] Loop [{While | Until}
conditie]
Observaţia 1. Instrucţiunea Exit Do, provoacă ieşirea forţată din ciclu. De obicei
se execută funcţie de evaluarea unei condiţii într-o instrucţiune IF. Observaţia 2.
Condiţia este evaluată funcţie de locul unde este plasată în instrucţiune şi anume:
 la prima formă a instrucţiunii(cea din stânga) - înaintea executării ciclului sau
 la a doua formă a instrucţiunii(cea din dreapta) - după executarea ciclului
Observaţia 3. Ciclul se execută minim de  la prima formă a instrucţiunii(cea din
stânga) - se poate ca ciclul să nu se execute de loc  la a doua formă a
instrucţiunii(cea din dreapta) - ciclul se va executa minim o dată. Notă: O
condiţie cu rezultatul NULL este tratată ca şi cum ar fi FALSE Exemplu. Private Sub
cmdLoop1_Click() Dim iCounter As Integer iCounter = 1 Do While iCounter < 5 MsgBox
iCounter ICounter = iCounter + 1 Loop End Sub -----------------Procedura va afişa 4
mesaje, cu numere de la 1 la 4. Această structură nu asigură întotdeauna executarea
secvenţei de cod din interiorul buclei. Dacă iCounter este iniţializat cu o valoare
mai mare sau egală cu 5, codul din interiorul buclei nu va fi executat niciodată.
Dacă doriţi ca secvenţa de cod să fie executată necondiţionat cel puţin o dată, va
trebui să folosiţi următoarea structură: Exemplu. Private Sub cmdLoop2_Click() Dim
iCounter As Integer iCounter = 5 Do MsgBox iCounter ICounter = iCounter + 1 Loop
While iCounter < 5 End Sub -----------------Procedura va afişa 1 mesaj, cu numărul
1.
Acest cod va fi executat cel puţin o dată, chiar dacă iCounter are valoarea 5.
Structura Do While ... Loop face evaluarea înainte de executarea codului şi de
aceea nu asigură execuţia codului din interiorul buclei. Structura Do ... Loop
While face evaluarea la sfârşitul buclei şi de aceea execuţia codului este
asigurată. -----------------I.2.4.2.3.2 Structura repetitivă cu contor.
Instrucţiunea FOR...NEXT Repetă un ciclu de un anumit număr de ori. Notă: Mai
există o structură: FOR EACH...NEXT, care se aplică colecţiilor de obiecte sau
tablourilor. Acesta permite parcurgerea automată a tuturor elementelor unei
colecţii sau tablou. Se va prezenta ulterior în modulul referitor la programarea
orientată pe obiecte.
For contor = start To end [Step pas] [grup instrucţiuni] [Exit For] [grup
instrucţiuni] Next [contor]
-----------------• contor - Variabilă numerică folosită pentru stabilirea numărului
de execuţii ale ciclului. • start - Valoarea iniţială a contorului • end - Valoarea
finală a contorului • pas - Valoarea de incrementare a controlului după execuţia
fiecărui ciclu (implicit este 1) Explicaţie. Se începe prin executarea ciclului.
După aceasta va avea loc adunarea pasului la contor. Acum se va evalua următoarea
condiţie, funcţie de semnul(+/-) pe care îl are pasul şi anume  Dacă PAS >=0,
condiţia va fi: contor <= end  Dacă PAS < 0, condiţia va fi: contor >= end Dacă
condiţia este TRUE, atunci se va repeta ciclul, iar dacă condiţia este FALSE, se va
termina instrucţiunea FOR, programul continuând cu instrucţiunile de după NEXT.
Deci, practic dacă pasul, este :  pozitiv, atunci contorul va parcurge la fiecare
ciclu, crescător (prin adăugarea valorii pasului), toate valorile dintre start şi
end (start < end)  negativ, atunci contorul va parcurge la fiecare ciclu,
descrescător (prin scăderea valorii absolute a pasului), toate valorile dintre
start şi end (start > end) Observaţia 1. Instrucţiunea Exit For, provoacă ieşirea
forţată din ciclu şi continuarea programului cu instrucţiunile de după NEXT. De
obicei se execută funcţie de evaluarea unei condiţii întro instrucţiune IF.
Observaţia 2. Sunt admise imbricări ale structurilor For, dacă sunt folosite
variabile contor diferite ca în exemplul următor: For I = 1 To 10 For J = 1 To 10
For K = 1 To 10 ... Next K Next J Next I -----------------Created by Serban
Criscota Page 26 19 ianuarie 2001
Observaţia 3. Într-un For, trebuie evitată schimbarea valorii contorului.
Observaţia 4. Structura For ... Next este folosită atunci când sunt un număr exact
de iteraţii de executat. Exemplu. Private Sub cmdForNext_Click() Dim iCounter As
Integer For iCounter = 1 To 5 MsgBox iCounter Next iCounter End Sub
-----------------Procedura va afişa 5 mesaje, cu numere de la 1 la 5 Observaţi că
iCounter se auto-incrementează. Atât valoarea de start, cât şi cea de sfârşit pot
fi ambele variabile. Unei structuri For ... Next i se poate da, de asemenea, o
valoare de incrementare (pas) Exemplu. Private Sub cmdForNext_Click() Dim iCounter
As Integer For iCounter = 5 To 1 Step -1 MsgBox iCounter Next iCounter End Sub
Procedura va afişa 5 mesaje, cu numere de la 5 la 1 -----------------I.2.5 Rutine -
proceduri şi funcţii.
I.2.5.1 Ce este o rutină? Elementele care definesc o rutină.
Rutina este o structură de sine stătătoare, asemănătoare unui program, prin care se
execută o anumită acţiune. Ea este executată numai atunci când este lansată,
apelată de către un obiect al aplicaţiei. Rutina poate fi apelată de un număr
nelimitat de ori din diferite locuri(obiecte). Toate declaraţiile(variabile,
constante) făcute în interiorul rutinei sunt locale, fiind vizibile numai din
interiorul acesteia. De asemenea, durata de viaţă a datelor locale, este numai în
intervalul de timp cât rutina se află în execuţie, la terminarea rutinei, având loc
automat şi eliberarea din memorie a tuturor variabilelor şi constantelor locale ale
acesteia. Notă: În Visual Basic nu sunt permise imbricări de rutine. Deci într-o
rutină nu se poate declara o altă rutină. Diferit faţă de programe, rutina inter-
acţionează cu obiectul care a provocat lansarea(apelarea) ei, prin transferarea de
date din şi înspre acesta. Acest lucru se realizează în două moduri şi anume: 
Prin lista de parametrii. Aceasta reprezintă practic nişte variabile, prin
intermediul cărora se face: ♦ în momentul apelării rutinei, un transfer de date de
la modulul care apelează - parametrii de intrare. ♦ în momentul terminării rutinei
şi preluării controlului de modulul apelant, un transfer de date de la rutină
înspre modulul apelant - parametrii de ieşire.  Prin variabile globale. Aceste
variabile fiind vizibile şi din modulul apelant şi din rutină, evident că prin ele
se pot face transferuri de date în ambele sensuri între cele două obiecte.
Observaţia 1. Definirea unei rutine se face prin atribuirea unui nume(obligatoriu)
acesteia şi prin stabilirea listei de parametrii(opţional). Parametrii definiţi în
rutină se numesc parametrii formali.
Observaţia 2. Declararea parametrilor formali se face după regulile aplicate la
declararea variabilelor. Observaţia 3. Apelarea unei rutine se face prin numele ei.
Observaţia 4. În momentul apelării, trebuie să se realizeze o corespondenţă între
nişte date(variabile, constante, literali) ale modulului apelant cu parametrii
formali ai rutinei. Aceasta se face prin stabilirea unei liste de parametrii
actuali, declaraţi în momentul apelării. Evident parametrii actuali şi formali
trebuie să fie de acelaşi tip şi să ocupe acelaşi loc în cele două liste.
Observaţia 5. Parametrii de intrare ai rutinei pot fi în lista parametrilor
actuali: variabile, constante, literali sau expresii. Observaţia 6. Parametrii de
ieşire ai rutinei pot fi în lista parametrilor actuali numai variabile, deoarece
aceştia prin definiţie îşi pot schimba valoarea în timpul execuţiei rutinei.
I.2.5.1.1 Transmiterea datelor prin parametrii Există două modalităţi de
transmitere a datelor prin parametrii şi anume prin valoare sau prin
adresă(referinţă).
Apelarea rutinelor şi transmitera parametrilor (prin valoare)

Modul apelant ………. Instr N….. X1=…. Instr N+1.. X2=…. Apelare rutină - Nume: Rtest
Parametri actuali:X1, X2, Y Instr. ….= …Y ……….. Instr J…… M1=…. Instr J+1… M2=….
Apelare rutină - Nume: Rtest Parametri actuali:M1, M2, T Instr. ….= …T ………..
X1,X2 Y
A1,A2 B1
M1,M2 T
A1,A2 B1
Rutina Nume: Rtest Parametrii formali: Intrare: A1, A2 Ieşire: B1 Instr1 ……….. ..=
A1 + A2 ' folosirea 'parametrilor de intrare ……….. B1= …… ' folosirea 'parametrilor
de ieşire ……….. Sfârşit rutină
 Transmiterea prin valoare. Din figura de mai sus se obsevă că avem perechi de
parametrii, actuali şi formali, care reprezintă practic două variabile care se
sincronizează la apelarea şi terminarea rutinei. Astfel observăm că la apelarea
rutinei se face practic pentru fiecare pereche de parametrii operaţia de transfer:
ParametruFormal=ParametruActual (de ex: A1=X1 sau A2=X2 etc.), iar la terminarea
rutinei transferul invers: ParametruActual=ParametruFormal (de ex: T=B1 sau Y=B1
etc.). Deci avem de a face cu transferarea unei valori între parametrii formali şi
cei actuali. Spunem că facem transmiterea prin valoare a parametrilor.
Page 28
19 ianuarie 2001
Apelarea rutinelor şi transmitera parametrilor (prin adresă)
 Transmiterea prin adresă (referinţă).. În acest caz lucrurile se petrec altfel.
Transferul se face numai la apelarea rutinei, dar nu se vor transfera valori, ci
rutina va primi adresele
Modul apelant ………. Instr N….. X1=…. Instr N+1.. X2=…. Apelare rutină - Nume: Rtest
Parametri actuali:X1, X2, Y Instr. ….= …Y ……….. Instr J…… M1=…. Instr J+1… M2=….
Apelare rutină - Nume: Rtest Parametri actuali:M1, M2, T Instr. ….= …T ………..
Parametrii actualiX1X2Y a d
r e s eA1A2B1Parametrii
formali Parametrii actualiM1M2T a d
r e s eA1A2B1Parametrii
formali
Rutina Nume: Rtest Parametrii formali: Intrare: A1, A2 Ieşire: B1 Instr1 ……….. ..=
A1 + A2 ' folosirea 'parametrilor de intrare ……….. B1= …… ' folosirea 'parametrilor
de ieşire ……….. Sfârşit rutină
parametrilor actuali. În acest fel în rutină parametrii formali se vor genera în

memorie peste parametrii actuali. Deci rutina va lucra practic cu parametrii
actuali, deşi va folosi numele parametrii formali în expresii. Notă: În Visual
Basic, dacă nu se fac precizări suplimentare, transmiterea parametrilor se face
prin adresă (referinţă). -----------------I.2.5.2 Crearea(definirea) unei rutine.
Rutinele sunt de două feluri: proceduri(sau subrutine) şi funcţii. Diferenţa dintre

ele constă în faptul că : • Funcţiile au un parametru implicit de ieşire care este
chiar numele funcţiei. • Procedurile sunt apelate prin instrucţiuni, iar funcţiile
sunt apelate prin introducerea numelui acesteia într-o expresie(ca şi cum ar fi o
variabilă sau constantă). Notă: Funcţiile pot fi folosite direct aproape oriunde
unde este cerută o expresie, cu condiţia vizibilităţii ei din locul de unde este
apelată. Astfel putem folosi funcţii ca: parametrii de intrare pentru rutine, la
definirea proprietăţilor din controale, la cereri etc. I.2.5.2.1
Proceduri(Subrutine)
[Private | Public] [Static] Sub NumeProcedura [(ListaParametriiFormali)]

[declaraţii locale de: variabile, constante, etc.] [instrucţiuni] [Exit Sub]
[instrucţiuni] End Sub
-----------------• Instrucţiunea, Exit Sub, provoacă dacă este întâlnită terminarea
procedurii şi redarea controlului modulului apelant, la instrucţiunea care se
găseşte imediat după cea de apelare. În mod normal procedurile se termină la
instrucţiunea End Sub.
• Opţiunile Private sau Public, au acelaşi rol ca cel prezentat la variabile.
Adică, procedurile declarate Public în modulul general de cod vor fi vizibile din
toate modulele de cod ale aplicaţiei. Declararea Private a unei proceduri o face
locală, adică vizibilă numai din modulul în care este declarată. Dacă nu se
foloseşte nici una din cele două opţiuni, procedura va fi considerată publică. •
Opţiunile Static face ca toate variabilele locale declarate în procedură să fie
statice. • Toate instrucţiunile sunt permise. Datele cu care lucrează acestea pot
fi :  parametrii formali;  variabilele şi constantele globale;  variabilele şi
constantele locale; Notă: Este indicat ca să se evite pe cât posibil în crearea
rutinelor folosirea variabilelor globale, fiind recomandată utilizarea numai a
parametrilor formali pentru schimburile de date ale rutinei cu modulul apelant.
Aceasta deoarece o rutină care foloseşte variabile globale este de multe ori foarte
puţin lizibilă, greu de depanat sau de întreţinut. • Lista Parametrilor Formali:
Reprezintă o listă de variabile, declarate după regulile prezentate la variabile şi
separate prin virgulă. Un parametru se declară conform structurii de mai jos:
[ByVal | ByRef] NumeParametru As TipDate  Opţiunile ByVal sau ByRef, precizează

modalitatea de transmitere a parametrului
respectiv şi anume prin valoare sau prin adresă(referinţă). Aceasta din urmă se ia
implicit dacă nu se face nici o precizare. I.2.5.2.2 Funcţii
[Public | Private] [Static] Function NumeFuncţie [(ListaParametriiFormali)] [As

TipFuncţie] [declaraţii locale de: variabile, constante, etc.] [instrucţiuni] [Exit
Function] [instrucţiuni] End Function
-----------------Observaţia 1. Se observă că singura deosebire esenţială faţă de
proceduri, se datorează faptului că numele funcţiei are două semnificaţii fiind în
acelaşi timp şi numele rutinei şi parametru de ieşire al rutinei. Din această cauză
acestuia trebuie să i se precizeze tipul de date. Dacă acest lucru nu se face
atunci implicit se va considera Boolean tipul funcţiei. Deci o funcţie, după ce
este executată se va comporta practic ca o variabilă - care s-a încărcat cu
valoarea parametrului de ieşire - putând fi introdusă direct în partea dreaptă a
oricărei expresii. Observaţia 2. În loc de Exit Sub şi End Sub, la funcţii sunt
Exit Function şi End Function, evident cu acelaşi rol. Exemplu. Următorul exemplu
reprezintă o funcţie care va testa două valori primite ca parametrii şi va returna
suma sau diferenţa dintre ele. Function TestF(Numar1 As Integer, Numar2 As Integer)
As Integer If Numar1 > Numar2 then TestF = Numar1 - Numar2 ' valoarea de retur se
introduce în numele funcţiei Else TestF = Numar1 + Numar2 ' valoarea de retur se
introduce în numele funcţiei End If End Function
…….Se va folosi această funcţie astfel…. MsgBox TestF(20, 5) ' afişează 15 MsgBox
TestF(2, 5) ' afişează 7 -----------------I.2.5.3 Apelarea unei rutine.
Notă: Orice funcţie poate fi apelată ca o procedură, dar o procedură nu poate fi

folosită ca o funcţie (în partea din dreapta a unei expresii). I.2.5.3.1 Apelarea
unei proceduri(subrutine) Există două modalităţi de apelare a unei proceduri: 
Prin instrucţiunea Call
Call NumeProcedură (ListaParametrilorActuali)

 Direct folosind numele procedurii.
NumeProcedură ListaParametrilorActuali
Notă: Parametrii se separă prin virgulă. Observaţia 1. Diferenţa între cele două
apeluri este că la apelarea cu Call, parametrii actuali ai procedurii trebuie
scrişi între paranteze, pe când la apelarea directă prin numele procedurii, este
obligatoriu să nu se folosească paranteze. I.2.5.3.2 Apelarea unei funcţii. O
funcţie se apelează în partea dreapta a unei expresie, folosindu-se numele ei urmat
de lista parametrilor actuali incluşi între paranteze. Numele funcţiei, se va
comporta în expresie ca o variabilă, încărcată în timpul execuţiei funcţiei cu o
valoare, ca şi cum ar fi un parametru de ieşire al unei proceduri. Spunem că
funcţia întoarce(returează) o valoare după execuţia ei. Această valoare va
participa la evaluarea expresiei respective. Observaţia 1. O procedură nu poate fi
folosită în locul unei funcţii într-o expresie, deoarece nu returează valori (chiar
dacă are parametrii de ieşire) Observaţia 2. Funcţiile pot fi apelate şi ca pe o
procedură în oricare din cele două modalităţi prezentate. Exemplu. Refacem exemplul
prezentat înainte folosind o procedura TestS în locul funcţiei TestF Sub
TestS(Numar1 As Integer, Numar2 As Integer, Rezultat As Integer) If Numar1 > Numar2
then Rezultat = Numar1 - Numar2 ' valoarea calculată se introduce în parametru de
ieşire Else Rezultat = Numar1 + Numar2 ' valoarea calculată se introduce în
parametru de ieşire End If End Sub …….Se va folosi această procedură astfel…. Dim
Rez As Integer Call TestS(20, 5, Rez) ' calculează în Rez MsgBox Rez ' afişează 15
TestS 2, 5, Rez ' calculează în Rez MsgBox Rez ' afişează 7 ------------------
Page 31
19 ianuarie 2001
I.2.5.4 Domeniul de valabilitate(vizibilitatea) al rutinelor.
Regulile prezentate la variabile, privind această problemă sunt valabile şi pentru

rutine. Codul VBA este scris numai în unităţi numite rutine. Aceste rutine sunt
păstrate fie în modulul general (global), fie în modulele specifice din spatele
formularelor (Code Behind Forms – CBF). Domeniul de valabilitate sau de
vizibilitatea a rutinei, este determinat de cuvântul utilizat în declararea
acesteia: Private sau Public şi de locul unde rutina e plasată. Rutina este
modulară(globală), numai dacă este declarată Public şi este plasată în modulul
global(general), ea fiind vizibilă în toată aplicaţia. Restul rutinelor, sunt
locale şi sunt vizibile numai din modulul unde au fost declarate.
I.2.5.5 Rutine definite de utilizator. Introducerea codului VBA
Explicaţie. Pentru a crea o rutină definită de utilizator într-un modul global de

cod, urmaţi paşii de mai jos: • Executaţi clic pe marcajul de tabulare Modules
(Module) din fereastra bazei de date. • Începeţi un modul nou sau selectaţi un
modul existent şi executaţi clic pe opţiunea Design. • Selectaţi opţiunea Insert
Procedure (Inserează procedură) de pe bara cu instrumente sau selectaţi opţiunea
Procedure din meniul Insert (Inserează). Va apărea pe ecran caseta de dialog
alăturată. • Introduceţi numele procedurii şi selectaţi tipul acesteia: funcţie,
subrutină sau proprietate. Indicaţi dacă doriţi ca procedura dumneavoastră să fie
publică (pentru întreaga aplicaţie) sau privată (numai pentru acest modul). În
final, specificaţi dacă doriţi ca toate variabilele din rutina dumneavoastră să fie
Apoi, executaţi clic pe OK. Explicaţie. Pentru a crea o rutină definită de
utilizator în modulul de cod din spatele unui formular sau raport, se procedează la
fel, în afară de afişarea modulului care se face astfel: • În timp ce vă aflaţi în
modul de afişare Design al unui formular sau raport, vizualizaţi codul din spatele
formularului sau raportului executând clic pe butonul Code (Cod) de pe bara cu
instrumente sau prin selectarea opţiunii Code din meniul View, sau prin pictograma
specifică de pe bara cu instrumente.
I.2.5.6 Procedurile evenimentelor
Procedurile evenimentelor sunt apelate automat când are loc un eveniment pentru un
obiect. De exemplu, când un utilizator execută clic pe un buton de comandă, este
executat codul evenimentului Click pentru acel buton de comandă. Procedurile
evenimentelor sunt create automat când scrieţi codul evenimentului pentru un
control. De exemplu, rutina: Private Sub cmdOkay_Click este creată atunci când
plasaţi instrucţiuni de cod în evenimentul Click al butonului de comandă cu Caption
= 'Apasa' şi numele cmdOkay. Exemplu. Codul evenimentului Click, al butonului
cmdOkay. Private Sub cmdOkay_Click() If IsNull (Me!txtNume) Or IsNull (Me!
txtVirsta) _ Or isNull(Me!txtSex) Then MsgBox "Trebuie introduse numele, virsta şi
sexul” Exit Sub Else MsgBox "Numele d-tra este: " & Me!txtNume & _ Chr(10) &
Chr(13) & ”Virsta dv este acum de : " & _
CalculVirsta(Fix(Val(Me!txtVirsta)), Me!txtSex) & " ani" End If End Sub
-----------------Function CalculVirsta(V As Integer, S As Variant) As Integer If V
> 35 And S = "F" Then CalculVirsta = V - 10
Page 33
19 ianuarie 2001
• • • • •
ElseIf V > 25 And S = "F" Then CalculVirsta = V - 5 ElseIf V > 20 And S = "F" Then
CalculVirsta = V - 2 ElseIf S = "M" Then CalculVirsta = V + 5 Else CalculVirsta = V
End If End Function -----------------Explicaţie. Pentru a edita codul unui
eveniment , executaţi paşii următori: Executaţi click pe control(cmdOkay) în modul
de afişare Design şi apoi pe butonul Properties din bara cu instrumente sau
executaţi click cu butonul drept al mouse-ului pe obiect şi selectaţi opţiunea
Properties din meniul contextual. Executaţi click pe marcajul de tabulare al
proprietăţilor evenimentului (Event). Selectaţi proprietatea pentru care doriţi să
scrieţi instrucţiuni de cod (de exemplu, evenimentul On Click). Selectaţi [Event
Procedure] din lista derulantă. Executaţi clic pe butonul (…). Cursorul
dumneavoastră va fi plasat în codul evenimentului pentru obiectul respectiv.
Automat sistemul va crea instrucţiunea de declarare a procedurii, eventual cu lista
de parametrii formali . daca este cazul - şi instrucţiunea de sfârşit a procedurii.
Proiectantul va introduce acum codul VBA necesar tratării evenimentului.
-----------------I.2.5.7 Utilizarea combinată a rutinelor utilizator şi a
procedurilor
eveniment. Am arătat că atât subrutinele, cât şi funcţiile pot primi

argumente(parametrii), dar numai funcţiile pot returna valori. Exemplu. Subrutina
următoare primeşte doi parametri, txtFirst şi txtLast. Aceasta afişează apoi un
mesaj cu primul caracter al fiecăruia dintre cei primiţi. Private Sub Initialele
(sFirst As String, sLast As String) MsgBox “Initialele dumneavostră sunt: “ & _
Left (sFirst, 1) & Left (sLast, 1) ' Funcţia Left returează caracterele de la
inceputul unui string End Sub  Ea va fi apelată din procedura eveniment On Click a
butonului de comandă cmdNume. Private Sub cmdNume_Click() Initialele Me !
txtFirstName, Me!txtLastName End Sub -----------------Explicaţie. Observaţi că
textul din controalele txtFirstName şi txtLastName din formularul curent (Me) sunt
transmise subrutinei cu numele Initialele. Parametrii sunt recepţionaţi ca sFirst
şi sLast. Primul caracter din stânga al fiecărui parametru este afişat în caseta de
mesaje. Codul precedent transmite pur şi simplu valori şi apoi operează cu ele.
Exemplu. În continuare se ilustrează folosirea unei funcţii care întoarce o
valoare.
Private Function ReturnInit (sFName As String, sLName As String) As String
ReturnInit = Left (sFName, 1) & Left (sLName, 1) End Function  Ea va fi apelată
din procedura eveniment On Click a butonului de comandă cmdNume. Private Sub
cmdNume_Click() Dim sInitials As Integer sInitials = ReturnInit (Me!txtFirstName,
Me!txtLastName) MsgBox "Initialele dumneavostra sunt: " & sInitials End Sub
Explicaţie. Reţineţi că acest exemplu apelează o funcţie ReturnInit, trimiţând
valorile celor două casete de text ca parametri ai funcţiei. Funcţia asociază
numelui funcţiei (ReturnInit) o valoare egală cu primele două caractere ale
şirurilor. Apoi, funcţia returnează această valoare, rutinei apelante
(cmdNume_Click) şi o atribuie variabilei sInitials. -----------------I.2.5.8
Parametri opţionali
Visual Basic vă permite să utilizaţi parametri opţionali. Cu alte cuvinte, nu este

necesar să ştiţi câţi parametri vor fi transmişi. Funcţia numită ReturnInit din
secvenţa de cod următoare primeşte ultimii doi parametri ca opţionali. Apoi
evaluează prezenţa sau nu a parametrilor şi acţionează în consecinţă. Function
ReturnInit (sFName As String, Optional sMI, Optional sLName) As String If IsMissing
(sMI) Then ' IsMissing returează True dacă s-a apelat funcţia fara parametrul sMI
SMI = InputBox ("Introduceţi initiala cuvantului din mijloc”) End If If IsMissing
(sLName) Then ' IsMissing returează True dacă s-a apelat funcţia fara parametrul
sLName SLName = InputBox („Introduceţi ultimul nume”) End If ReturnInit = sLName &
" " & sMI & " " sFName End Function -----------------• Această funcţie poate fi
apelată de exemplu în felul următor:
sName = ReturnInit ("Bill” , , "Gates”)

Explicaţie. Aşa cum aţi putut vedea, lipseşte al doilea parametru. În loc să
rezulte o eroare de compilare, funcţia ReturnInit va sesiza acest lucru şi prin
funcţia InputBox va cere utilizatorului introducerea valorii respective. • Sau mai
poate fi apelată şi:
sName = ReturnInit ("Bill” , "X", "Gates”)

Explicaţie. În acest caz funcţia prin folosirea lui IsMissing, va sesiza prezenţa
tuturor celor trei parametrii actuali. -----------------Notă: Lucrul cu parametrii
opţionali, deci care pot să lipsească la apelarea rutinei, necesită:  Declararea
ca opţional a parametrului, prin folosirea clauzei Optional, în faţa numelui
parametrului. O restricţie a limbajului este faptul că numai ultimii parametrii pot
fi declaraţi opţionali.  Testarea prin funcţia IsMissing, dacă a fost sau nu
introdus la apelare parametrul respectiv în lista parametrilor actuali. Dacă nu se
doreşte introducerea în lista parametrilor
actuali a unui parametru opţional, atunci se va scrie numai separatorul(virgula)
parametrului respectiv.  Numai pentru parametrii declaraţi opţional, se poate
introduce o valoare implicită, cu care se va iniţializa parametrul dacă acesta
lipseşte din lista parametrilor actuali. Dacă se folosesc parametrii opţionali,
declararea acestora în lista parametrilor formali este:
[Optional] NumeParametru As TipDate [ = ValoareImplicita ]

I.2.6 Bibliotecile standard de funcţii şi proceduri. O bibliotecă este un obiect de
sine stătător care permite realizarea unei colecţii de funcţii, proceduri, clase de
module de obiecte şi obiecte. Noile tehnologii şi standarde introduse de Microsoft,
permit ca modulele unei biblioteci să poată să fie utilizate de toate aplicaţiile
client de pe platforma S.O., care respectă standardele de utilizare a unei
biblioteci. În Visual Basic, există posibilitatea creării mai multor tipuri de
biblioteci. Microsoft Office, oferă mai multe biblioteci, care pot fi utilizate în
Access, Visual Basic sau alte aplicaţii. Pentru aceasta trebuie ca în prealabil
aplicaţia client să înregistreze şi să creeze referinţa(adresa) către biblioteca
respectivă. Acest lucru se face prin comanda References. Implicit, o aplicaţie are
chiar din faza de instalare create referinţele către cele mai utilizate biblioteci
specifice. Aplicaţiile Access au referinţe create către anumite biblioteci, ale
căror module pot fi utilizate oriunde acestea sunt permise. În acest subcapitol,
vor fi prezentate în special cele mai utilizate funcţii ale acestor biblioteci. Un
bun programator, trebuie să cunoască şi să folosească cât mai multe din obiectele
puse la dispoziţie de biblioteci. De exemplu dacă avem de realizat o aplicaţie care
trebuie la un moment dat să calculeze SINUSUL dintr-o valoare, un programator ne
experimentat s-ar putea apuca să creeze un modul care să rezolve acest lucru, pe
când un bun programator ştiind că există în biblioteci funcţia Sin, care calculează
sinusul unei valori, va rezolva instantaneu această problemă, folosind pur şi
simplu funcţia din bibliotecă. Pentru a putea utiliza o funcţie dintr-o bibliotecă,
programatorul trebuie să cunoască trei lucruri:  Numele funcţiei;  Parametrii şi
ce reprezintă fiecare;  Ce reprezintă valoarea pe care o returnează funcţia (adică
ce operaţii efectuează funcţia). În crearea expresiilor, în Access se poate folosi
un constructor de funcţii Expressions Builder, lansat de obicei din meniul
contextual (Build). Acesta este foarte util, prezentând toate funcţiile, parametrii
acestora modulul de Help referitor la obiectul respectiv, operaţiile permise, etc.
În concluzie, în codul VBA, în controalele din formulare sau rapoarte, în
proprietăţile tabelelor sau cererilor, se pot folosi în crearea expresiilor atât
funcţiile definite(create) de utilizator cât şi funcţiile din bibliotecile către
care există referinţe. Toate acestea se pot vizualiza prin Expressions Builder
( prin cele două foldere din Functions, aşa cum se vede din figură) Access are
referinţe implicite către o bibliotecă de funcţii foarte bogată şi cuprinzătoare.
Câteva dintre cele mai utilizate funcţii sunt prezentate în continuare.
I.2.6.1 Funcţii matematice
I.2.6.1.1
I n t ( n u m ă r ) ; F i x ( n u m ăr )
Întoarce partea întreagă a numărului introdus ca parametrul de intrare. Tipul de

dată al rezultatului va fi acelaşi cu tipul de dată al parametrul de intrare.
Ambele funcţii Int şi Fix îndepărtează partea fracţionară a numărului şi întorc
valoarea întreagă care rezultă. Diferenţa între Int şi Fix este că numai dacă
numărul este negativ. Astfel: Int întoarce primul număr negativ de tip întreg mai
mic sau egal cu numărul; Int(–8.4) = -9 Fix întoarce primul număr negativ de tip
întreg mai mare sau egal cu numărul; Fix (–8.4) = -8 Exemplu. Dim MyNumber '
variabilele declarate fără specificarea tipului de dată sunt VARIANT. MyNumber =
Int(99.8) ' Întoarce 99. MyNumber = Fix(99.2) ' Întoarce 99. MyNumber = Int(-99.8)
' Întoarce -100. MyNumber = Fix(-99.8) ' Întoarce -99. -----------------I.2.6.1.2
Abs(număr) Întoarce valoarea absolută a numărului introdus ca parametrul de
intrare. Tipul de dată al rezultatului va fi acelaşi cu tipul de dată al parametrul
de intrare. Exemplu. Dim MyNumber MyNumber = Abs(50.3) ' Întoarce 50.3. MyNumber =
Abs(-50.3) ' Întoarce 50.3. -----------------I.2.6.1.3 Sgn(număr) Întoarce un
Variant (Integer) care reprezintă semnul unui număr. Dacă parametrul <0 >0 =0 este:
Sgn întoarce Exemplu. Dim MyVar1, MyVar2, MyVar3, MySign MyVar1 = 12: MyVar2 =
-2.4: MyVar3 = 0 MySign = Sgn(MyVar1) ' Întoarce 1. MySign = Sgn(MyVar2) ' Întoarce
-1. MySign = Sgn(MyVar3) ' Întoarce 0. -----------------I.2.6.1.4 Sqr(număr)
Întoarce o valoare de tip Double(virgulă mobilă dublă precizie) care reprezintă
radicalul(square root) unui număr(>=0). Exemplu.
-1
0
Dim MySqr MySqr = Sqr(4) ' Întoarce 2. MySqr = Sqr(23) ' Întoarce 4.79583152331272.
MySqr = Sqr(0) ' Întoarce 0. MySqr = Sqr(-4) ' Generează o eroare.
-----------------I.2.6.1.5 Exp(număr) Întoarce o valoare de tip Double care
reprezintă e (baza logaritmului natural) ridicat la o putere. Exemplu. Dim MyAngle,
MyHSin ' Defineşte unghiul în radiani. MyAngle = 1.3 ' Calculează sinusul
hiperbolic. MyHSin = (Exp(MyAngle) - Exp(-1 * MyAngle)) / 2
-----------------I.2.6.1.6 Log(număr) Întoarce o valoare de tip Double care
reprezintă logaritmul natural al unui număr (>0). Logaritmul natural este
logaritmul în baza e. Constanta e este aproximativ 2.718282. Exemplu. Dim MyAngle,
MyLog ' Defineşte unghiul în radiani. MyAngle = 1.3 ' Calculează inversul sinusului
hiperbolic. MyLog = Log(MyAngle + Sqr(MyAngle * MyAngle + 1))
-----------------I.2.6.1.7 Rnd[(număr)] Întoarce o valoare de tip Single(virgulă
mobilă simplă precizie) care va conţine un număr aleator. Argumentul(parametrul)
este opţional şi poate fi un Single sau o expresie numerică corectă. Valoarea
întoarsă de Rnd Dacă parametrul este Rnd generează
<0 Acelaşi număr de fiecare dată, folosind numărul ca valoare de iniţializare. >0
Următorul număr din secvenţă. =0 Cel mai recent număr generat. Fără (de obicei)
Următorul număr din secvenţă. -----------------Funcţia Rnd întoarce o valoare în
intervalul [0..1) Valoarea parametrului determină cum Rnd generează un număr
aleator. Pentru orice valoare iniţială, aceiaşi secvenţă de numere este generată
din cauza faptului că fiecare apel succesiv al funcţiei Rnd, foloseşte numărul
generat anterior ca valoare pentru calculul următorului număr din secvenţă.
Înainte de prima folosire a funcţiei Rnd, dacă se doreşte generarea unei secvenţe
de numere aleatoare, atunci generatorul de numere aleatoare trebuie iniţializat cu
o valoare întâmplătoare. Pentru aceasta se va folosi procedura Randomize, fără
parametrii, care va folosi pentru iniţializarea generatorului de numere aleatoare,
ceasul sistemului de calcul. Notă: Dacă se doreşte generarea unor numere întregi,
în intervalul [a.. b], se foloseşte formula: Int((b - a + 1) * Rnd + a) Exemplu.
Dim MyValue Randomize MyValue = Int((6 * Rnd) + 1) ' Generează o valoare aleatoare
între 1 şi 6. -----------------I.2.6.1.8 Sin(număr) Întoarce o valoare de tip
Double care reprezintă sinusul unui unghi în radiani Rezultatul va fi în intervalul
[-1..1] Pentru a transforma gradele în radiani se înmulţesc gradele cu pi/180.
Invers se vor înmulţi radianii cu 180/pi. Exemplu. Dim MyAngle, MyCosecant MyAngle
= 1.3 ' Defineşte unghiul în radiani. MyCosecant = 1 / Sin(MyAngle) ' Calculează
cosecanta. -----------------I.2.6.1.9 Cos(număr) Întoarce o valoare de tip Double
care reprezintă cosinusul unui unghi în radiani Exemplu. Dim MyAngle, MySecant
MyAngle = 1.3 ' Defineşte unghiul în radiani. MySecant = 1 / Cos(MyAngle) '
Calculează secanta. -----------------I.2.6.1.10 Tan(număr) Întoarce o valoare de
tip Double care reprezintă tangenta unui unghi în radiani Pentru a transforma
gradele în radiani se înmulţesc gradele cu pi/180. Invers se vor înmulţi radianii
cu 180/pi. Exemplu. Dim MyAngle, MyCotangent MyAngle = 1.3 ' Defineşte unghiul în
radiani MyCotangent = 1 / Tan(MyAngle) ' Calculează cotangenta
-----------------I.2.6.1.11 Atn(număr) Întoarce o valoare de tip Double care
reprezintă arctangenta unui număr. Exemplu. pi = 4 * Atn(1) ' Calculează valoarea
lui pi. -----------------Created by Serban Criscota Page 39 19 ianuarie 2001
I.2.6.1.12 Expresii pentru calculul funcţiilor matematice derivate Secant Cosecant
Cotangent Inverse Sine Inverse Cosine Inverse Secant Inverse Cosecant Inverse
Cotangent Hyperbolic Sine Hyperbolic Cosine Hyperbolic Tangent Hyperbolic Secant
Hyperbolic Cosecant Hyperbolic Cotangent Inverse Hyperbolic Sine Inverse Hyperbolic
Cosine Inverse Hyperbolic Tangent Inverse Hyperbolic Secant Inverse Hyperbolic
Cosecant Inverse Hyperbolic Cotangent Logarithm to base N -----------------Sec(X) =
1 / Cos(X) Cosec(X) = 1 / Sin(X) Cotan(X) = 1 / Tan(X) Arcsin(X) = Atn(X / Sqr(-X *
X + 1)) Arccos(X) = Atn(-X / Sqr(-X * X + 1)) + 2 * Atn(1) Arcsec(X) = Atn(X /
Sqr(X * X – 1)) + Sgn((X) – 1) * (2 * Atn(1)) Arccosec(X) = Atn(X / Sqr(X * X - 1))
+ (Sgn(X) – 1) * (2 * Atn(1)) Arccotan(X) = Atn(X) + 2 * Atn(1) HSin(X) = (Exp(X) –
Exp(-X)) / 2 HCos(X) = (Exp(X) + Exp(-X)) / 2 HTan(X) = (Exp(X) – Exp(-X)) /
(Exp(X) + Exp(-X)) HSec(X) = 2 / (Exp(X) + Exp(-X)) HCosec(X) = 2 / (Exp(X) – Exp(-
X)) HCotan(X) = (Exp(X) + Exp(-X)) / (Exp(X) – Exp(-X)) HArcsin(X) = Log(X + Sqr(X
* X + 1)) HArccos(X) = Log(X + Sqr(X * X – 1)) HArctan(X) = Log((1 + X) / (1 –
X)) / 2 HArcsec(X) = Log((Sqr(-X * X + 1) + 1) / X) HArccosec(X) = Log((Sgn(X) *
Sqr(X * X + 1) + 1) / X) HArccotan(X) = Log((X + 1) / (X – 1)) / 2 LogN(X) = Log(X)
/ Log(N)
I.2.6.2 Funcţii TEXT - pentru stringuri.
I.2.6.2.1 Asc(string) Întoarce o valoare de tip Integer, în intervalul 0…255, care

reprezintă codul în ASCII(ANSI) a primului caracter din şirul de caractere ce se
află în argumentul (parametrul de intrare) funcţiei. Exemplu. Dim MyNumber MyNumber
= Asc("A") ' Întoarce 65. MyNumber = Asc("a") ' Întoarce 97. MyNumber =
Asc("Apple") ' Întoarce 65. -----------------I.2.6.2.2 Chr(CodCaracter) Întoarce o
valoare de tip string care reprezintă caracterul asociat codului caracterului în
ASCII(ANSI), introdus ca argument al funcţiei. Notă: Numerele între 0-31 au ca
corespondent în codul ASCII caractere netipăribile, dar care pot eventual să
determine anumite acţiuni în timpul afişării. De exemplu Chr(10) întoarce un
linefeed character - LF, care determină trecerea la o linie nouă. Intervalul normal
pentru 'CodCaracter' este 0-255. Exemplu.
Dim MyChar MyChar = Chr(65) MyChar = Chr(97) MyChar = Chr(62) MyChar = Chr(37)
------------------
' Întoarce A. ' Întoarce a. ' Întoarce >. ' Întoarce %.
I.2.6.2.3 AscB(string); AscW(string); ChrB(CodChar); ChrW(CodChar) Funcţiile AscB,

AscW, ChrB, ChrW ţin seama că în memorie caracterele sunt codificate pe 2 octeţi în
standardul UNICODE, ele considerând şirul de caractere ca pe un tablou de octeţi,
în care fiecare caracter ocupă doi octeţi(byte) • • • • Funcţia AscB - În loc să
întoarcă codul pentru primul caracter, întoarce primul byte, din codul în UNICODE
al primului caracter, . Funcţia AscW - Întoarce codul caracterului în UNICODE (pe 2
octeţi, în intervalul 0…2^16) Funcţia ChrB . În loc să întoarcă un caracter al
cărui cod(aflat în parametrul funcţiei) poate fi pe 1 sau 2 bytes, ea va întoarce
întotdeauna caracterul al cărui cod este pe primul byte.
Funcţia ChrW - Întoarce un string care conţine caracterul al cărui cod este
introdus în argument în standardul UNICODE. Notă: Aceste funcţii au efect numai pe
platformele care acceptă codul UNICODE. Dacă acesta nu este acceptat, atunci ele se
comportă la fel ca funcţiile Asc respectiv Chr. Exemplu. Public Sub TestUnicode()
MsgBox Asc("A") ' Întoarce Cod Ascii = 65 MsgBox AscB("A") ' Întoarce primul byte
din Codul Unicode= 65 MsgBox AscW("A") ' Întoarce Codul Unicode= 65 MsgBox Asc("Ş")
' Întoarce Cod Ascii = 170 MsgBox AscB("Ş") ' Întoarce primul byte din Codul
Unicode= 94 MsgBox AscW("Ş") ' Întoarce Codul Unicode= 350
'----------------------------------------------------------------------------------
--MsgBox Chr(65) ' Întoarce Caracterul = A MsgBox ChrB(65) ' Întoarce Caracterul =
A MsgBox ChrW(65) ' Întoarce Caracterul = A MsgBox Chr(170) MsgBox ChrB(94) MsgBox
ChrW(350) End Sub Caracterul Cod ANSI(1 octet) Cod UNICODE(valoare) Cod UNICODE(2
octeţi) ' Întoarce Caracterul = Ş ' Întoarce Caracterul = ^ ' Întoarce Caracterul =
Ş
A 65 65 65 0 94
Ş 170 350 1
Observaţia 1. Se observă că în codul UNICODE, primele 128 de coduri sunt ca în

codul ASCII.
-----------------I.2.6.2.4 LCase(string) Întoarce un string în care literele mari
au fost convertite în litere mici. Restul caracterelor rămân nemodificate Exemplu.
Dim UpperCase, LowerCase UpperCase = "Hello World 1234" LowerCase =
LCase(UpperCase) -----------------I.2.6.2.5 UCase(string) Întoarce un Variant
(String) în care literele mici au fost convertite în litere mari. Restul
caracterelor rămân nemodificate Exemplu. Dim LowerCase, UpperCase LowerCase =
"Hello World 1234" UpperCase = UCase(LowerCase) -----------------' String pentru
convertit. ' Întoarce "HELLO WORLD 1234". ' String pentru a fi convertit. '
Întoarce "hello world 1234".
I.2.6.2.6 LTrim(string); RTrim(string); Trim(string) Întoarce o valoare de tip

Variant (String) ce cuprinde o copie a unui string specificat fără spaţiile de
început la funcţia LTrim, fără spaţiile de sfârşit la funcţia RTrim, sau fără
spaţiile din ambele capete la funcţia Trim. Exemplu. Dim MyString, TrimString
MyString = " <-Trim-> " ' Iniţializează stringul. TrimString = LTrim(MyString) '
TrimString = "<-Trim-> ". TrimString = RTrim(MyString) ' TrimString = " <-Trim->".
TrimString = LTrim(RTrim(MyString)) ' TrimString = "<-Trim->". ' Utilizând funcţia
Trim se obţine acelaşi rezultat. TrimString = Trim(MyString) ' TrimString = "<-
Trim->". -----------------I.2.6.2.7 Len(string | NumeVariabila) Întoarce o valoare
de tip Long cuprinzând : • Dacă argumentul este un string câte caractere are. •
Dacă argumentul este o variabilă, câte caractere pot să fie introduse în ea. Notă:
Dacă argumentul este NULL , funcţia va întoarce tot NULL, ca de altfel ca şi la
celelalte funcţii. Unul (şi numai unul) din cele două argumente posibile trebuie
specificat. Notă: Se poate utiliza funcţia LenB, care ţine cont de reprezentarea în
memorie în UNICODE a stringului. În loc să întoarcă numărul de caractere dintr-un
string , LenB întoarce numărul de bytes utilizaţi pentru a reprezenta acel string.
Exemplu.
Type CustomerRecord ' Defineşte tipul dorit dorit de utilizator. ID As Integer '
Această definiţie trebuie să fie la nivel de modul de cod Name As String * 10
Address As String * 30 End Type Dim Customer As CustomerRecord ' Declararea
variabilelor. Dim MyInt As Integer, MyCur As Currency Dim MyString, MyLen MyString
= "Hello World" ' Iniţializează variabila. MyLen = Len(MyInt) ' Întoarce 2. MyLen =
Len(Customer) ' Întoarce 42. MyLen = Len(MyString) ' Întoarce 11. MyLen =
Len(MyCur) ' Întoarce 8. -----------------I.2.6.2.8 Left(string, lungime) Întoarce
un sub-şir de caractere din partea stângă a stringului al căror număr este stabilit
de lungime. ♦ Lungimea este o expresie numerică indicând câte caractere se vor
întoarce:  Dacă este 0, un string de lungime 0 ("") va fi întors - şir vid.  Dacă
este mai mare sau egal cu numărul de caractere din string, se va întoarce întregul
string. Pentru a determina numărul de caractere dintr-un string se va utiliza
funcţia, Len . Exemplu. Dim AnyString, MyStr AnyString = "Hello World" MyStr =
Left(AnyString, 1) MyStr = Left(AnyString, 7) MyStr = Left(AnyString, 20)
-----------------' Defineşte stringul. ' Întoarce "H". ' Întoarce "Hello W". '
Întoarce "Hello World".
I.2.6.2.9 Right(string, lungime) Întoarce un sub-şir de caractere din partea

dreapta a stringului al căror număr este stabilit de lungime. ♦ Lungimea este o
expresie numerică indicând câte caractere se vor întoarce:  Dacă este 0, un string
de lungime 0 ("") va fi întors - şir vid.  Dacă este mai mare sau egal cu numărul
de caractere din string, se va întoarce întregul string. Pentru a determina numărul
de caractere dintr-un string se va utiliza funcţia, Len . Exemplu. Dim AnyString,
MyStr AnyString = "Hello World" MyStr = Right(AnyString, 1) MyStr =
Right(AnyString, 6) MyStr = Right(AnyString, 20)
' Defineşte stringul. ' Întoarce "d". ' Întoarce " World". ' Întoarce "Hello
World".
Page 43 19 ianuarie 2001
-----------------I.2.6.2.10 Mid(string, start[,lungime]) Întoarce o valoare de tip
Variant (String) cuprinzând un număr specificat de caractere dintr-un string.
Parametrii reprezintă:  string (obligatoriu). Expresie string din care sunt
întoarse caractere. Dacă stringul conţine NULL, atunci NULL se va întoarce.  start
(obligatoriu); Este de tip Long. Reprezintă poziţia caracterului din string de la
care începe partea ce va fi preluată. Dacă poziţia este mai mare decât numărul de
caractere din string, Mid va întoarce un string vid ("") - de lungime 0.
Numerotarea caracterelor începe de la 1.  lungime (opţional); Este de tip Variant
(Long). Reprezintă numărul de caractere ce vor fi întoarse. Dacă lipseşte sau dacă
este mai mare decât numărul maxim de caractere care mai sunt până la sfârşitul
stringului (inclusiv caracterul de început), vor fi întoarse toate caracterele de
la poziţia de start până la sfârşit. Pentru a determina numărul de caractere dintr-
un string se va utiliza funcţia Len . Exemplu. Dim MyString, FirstWord, LastWord,
MidWords MyString = "Mid Function Demo" ' Crează stringul. FirstWord =
Mid(MyString, 1, 3) ' Întoarce "Mid". LastWord = Mid(MyString, 14, 4) ' Întoarce
"Demo". MidWords = Mid(MyString, 5) ' Întoarce "Function Demo". Notă: Mid, poate fi
folosit şi în partea stânga a unei instrucţiuni de atribuire, caz în care va
înlocui din string, subşirul specificat, cu stringul specificat de expresia din
dreapta instrucţiunii, dar fără a modifica lungimea şirului de caractere. Această
facilitate nu este implementată şi la funcţiile Left sau Right Exemplu. Public Sub
TestMid() Dim S As String S = "123456789" Mid(S, 4, 2) = "A" MsgBox S ' Afişează
123A56789 Mid(S, 4, 2) = "AB" MsgBox S ' Afişează 123AB6789 Mid(S, 4, 2) = "ABC"
MsgBox S ' Afişează 123AB6789 End Sub -----------------I.2.6.2.11 InStr([start, ]
string1, string2[, compare]) Întoarce o valoare de tip Variant (Long) reprezentând
poziţia primei apariţii a string2 în string1.  start (opţional). Expresie numerică
care stabileşte poziţia de început pentru fiecare căutare. Dacă este omis, căutarea
începe de la poziţia primului caracter. Argumentul este obligatoriu dacă se
specifică o comparaţie.  string1 (obligatoriu). Şirul de caractere în care se va
face căutarea.  string2 (obligatoriu). Şirul de caractere care este căutat
 compare (opţional). Prezintă modalitatea în care se poate face compararea a două
stringuri. Poate fi 0,1,sau2.  0-implicit - comparare binară  1 - comparare
textuală, ne-senzitivă, adică fără să se ţină cont de caracterele mari sau mici. 
2 - comparare bazată pe informaţiile din baza de date.  Dacă parametrul compare
lipseşte, atunci setarea Option Compare din modulul de cod determină tipul
comparaţiei. Notă: Dacă nu se găseşte şirul specificat se întoarce valoarea 0. Dacă
unul din şiruri este NULL, atunci NULL se întoarce. Exemplu. Dim SearchString,
SearchChar, MyPos SearchString ="XXpXXpXXPXXP" ' String în care se caută.
SearchChar = "P" ' Se caută "P". MyPos = Instr(4, SearchString, SearchChar, 1) ' O
comparaţie textuală începe de la poziţia 4. Întoarce 6. MyPos = Instr(1,
SearchString, SearchChar, 0) ' O comparaţie binară începe la poziţia 1. Întoarce 9.
MyPos = Instr(1, SearchString, "W") ' Întoarce 0. ' Comparaţia este binară implicit
(lipseşte ultimul argument). MyPos = Instr(SearchString, SearchChar) ' Întoarce 9.
Exemplu. Private Sub cmdInstr_Click() Debug. Print InStr("Alison Balter”, "Balter”)
Debug. Print InStr ("Hello”, "1”) End Sub -----------------I.2.6.2.12 String(număr,
caracter) Întoarce un şir de caractere, care conţine de număr de ori caracterul
specificat. Notă: Dacă în loc de caracter este un număr N caracterul multiplicat va
fi Chr(N). Dacă N>255 se va folosi Chr(N Mod 256). Notă: Dacă al doilea argument
conţine un şir de mai multe caractere se va multiplica primul. Exemplu. Dim
MyString MyString = String(5, "*") MyString = String(5, 42) MyString = String(10,
"ABC") -----------------' Întoarce "*****". ' Întoarce "*****". - codul Ascii al
caracterului * este 42 ' Întoarce "AAAAAAAAAA". ‘Returnează 8 ‘Returnează 3
I.2.6.2.13 Space (număr) Întoarce un şir de caractere, care conţine de număr de ori
caracterul spaţiu. Exemplu. Dim MyString MyString = Space(8)
' întoarce un string cu 8 spaţii

MyString = "Hello" & Space(10) & "World" ' Inserează 10 spaţii între cele două
cuvinte. I.2.6.2.14
Format(expresie[, format])
Funcţia Format formatează (transformă) într-un şir de caractere care respectă un

şablon(format),o expresie. • Expresie - este expresia pe care doriţi să o
formataţi. • Format (opţional) reprezintă tipul de format, şablon pe care doriţi să
îl aplicaţi El este un nume valid de format[de ex "Long Time" sau "hh:mm:ss AMPM"]
sau un format creat(definit) de utilizator. Exemplu. Private Sub cmdFormat_Click()
Dim MyTime, MyDate, MyStr MyTime = #5:04:23 PM# MyDate = #1/27/93# ' Se vor folosi
şi următoarele funcţii care întorc timpul şi data curentă a sistemului de calcul: '
NOW() =întoarce data şi timpul ' TIME() =întoarce timpul ' DATE() =întoarce data
MyStr = Format(Time(), "Long Time") MsgBox MyStr ' Afişează timpul curent al
sistemului de calcul, în formatul definit în Windows pentru 'Long Time' MyStr =
Format(Date, "Long Date") MsgBox MyStr ' Afişează data curentă a sistemului de
calcul, în formatul definit în Windows pentru 'Long Date MyStr = Format(MyTime,
"h:m:s") ' Întoarce "17:4:23". MsgBox MyStr MyStr = Format(MyTime, "hh:mm:ss AMPM")
' Întoarce "05:04:23 PM". MsgBox MyStr MyStr = Format(MyDate, "dddd, mmm d yyyy") '
Întoarce "Miercuri, Ian 27 1993". MsgBox MyStr ' Dacă parametrul format lipseşte se
va întoarce un string. MyStr = Format(23) ' Întoarce "23". MsgBox MyStr ' Formate
definite de utilizator. Se folosesc în continuare următoarele caractere pentru
format: ' # - Întoarce cifra dacă există. Dacă nu există se întoarce 'blanc' ' 0 -
Întoarce cifra dacă există. Dacă nu există se întoarce 0 ' , - Întoarce separatorul
de grupe de cifre(în sistemul românesc <,> sau american <.>) definit în
Windows(System settings) ' . - Întoarce semnul pentru punctul zecimal în sistemul
definit în Windows ' % - Întoarce în procente MyStr = Format(5459.4, "##,##0.00") '
Întoarce "5,459.40". MsgBox MyStr MyStr = Format(334.9, "###0.00") ' Întoarce
"334.90". MsgBox MyStr
MyStr = Format(5, "0.00%") ' Întoarce "500.00%". MsgBox MyStr ' Formate definite de
utilizator. Se folosesc în continuare următoarele caractere pentru format: ' < -
Întoarce stringul cu litere mici ' > - Întoarce stringul cu litere mari MyStr =
Format("HELLO", "<") ' Întoarce "hello". MsgBox MyStr MyStr = Format("This is it",
">") ' Întoarce "THIS IS IT". MsgBox MyStr MsgBox Format(50, "Currency") '50.00 LEI
- Afişează în sistemul de valută definit în Windows(System settings) MsgBox
Format(Now(), "Short Date") ' 8/5/95 - Afişează în formatul definit pentru 'dată
scurtă' MsgBox Format(Now(), "DDDD") 'Afişează cuvantul pentru zi MsgBox
Format(Now(), "DDD") 'Afişează ziua prescurtat(pe 2,3 caractere) MsgBox
Format(Now(), "YYYY") 'Afişează anul din patru cifre End Sub '-----------------
I.2.6.3 Funcţii pentru tablouri(array)
I.2.6.3.1 UBound(arrayname[, dimension]) I.2.6.3.2
LBound(arrayname[, dimension])
Întoarce o valoare de tip Long, care va conţine pentru o anumită dimensiune a unui
tablou:  Pentru UBound : valoarea indicelui cel mai mare disponibil (marginea
superioară).  Pentru LBound : valoarea indicelui cel mai jos disponibil (marginea
inferioară). Sintaxa funcţiei UBound cuprinde:  arrayname(obligatoriu). Denumirea
variabilei care defineşte tabloul.  dimension(opţional). Este de tip Variant
(Long). Indică dimensiunea a cărei margine (superioară sau inferioară) este
întoarsă. Se utilizează 1 pentru prima dimensiune, 2 pentru a doua etc. Dacă
lipseşte , automat va fi 1. Funcţia UBound se utilizează împreună cu funcţia LBound
pentru a determina mărimea unui tablou, şi anume:  LBound - pentru a găsi cea mai
joasă valoare a dimensiunii unui tablou.  UBound - pentru a găsi cea mai mare
valoare a dimensiunii unui tablou.
Page 47
19 ianuarie 2001
Exemplu. UBound şi LBound întoarce următoarele valori pentru un tablou cu
dimensiunile: Dim A(1 To 100, 0 To 3, -3 To 4) Valoare Funcţia Parametrii a
întoarsă (A,1) 100 UBound (A,2) 3 (A,3) 4 (A,1) 1 LBound (A,2) 0 (A,3) -3
-----------------Marginea cea mai de jos, implicită, pentru orice dimensiune a unui
tablou creat prin declaraţie(Dim, Private, Public, ReDim sau Static) , este 0 sau
1. Ea depinde de setarea declaraţiei Option Base.(de obicei 0) Excepţie. Baza unui
tablou creat cu funcţia Array este 0, ea ne fiind afectată de Option Base.
Tablourile, pentru care dimensiunile sunt setate folosind To în declaraţiile Dim,
Private, Public, ReDim sau Static pot lua orice valoare întreagă ca fiind marginea
cea mai de jos (cel mai mic indice).
I.2.6.4 Funcţii pentru mesaje
I.2.6.4.1 MsgBox(prompt[, buttons] [, title] ) Afişează un mesaj într-o căsuţă de

dialog, aşteaptă utilizatorul să apese un buton şi întoarce o valoare de tip
Integer care indică ce buton a fost apăsat de utilizator. Sintaxa funcţiei MsgBox
cuprinde următoarele argumente:  Prompt(obligatoriu). Expresie de tip string
afişată ca mesaj în caseta de dialog. Lungimea sa maximă este de aproximativ 1024
caractere, depinzând de mărimea caracterelor folosite. Dacă promptul este compus
din mai mult de un rând, se pot separa liniile utilizând un caracter CR (carriage
return) Chr(13), un caracter LF (line feed) Chr(10), sau o combinaţie (Chr(13) &
Chr(10)) după fiecare rând.  Buttons(optional). Expresie numerică care este suma
valorilor reprezentând: Dacă lipseşte, valoarea implicită a acestui parametru este
0. Setările pentru butoanele argument sunt: Constanta vbOKOnly VbOKCancel
VbAbortRetryIgnore VbYesNoCancel VbYesNo VbRetryCancel VbCritical VbQuestion
VbExclamation VbInformation
Valoare 0 1 2 3 4 5 16 32 48 64
Descrierea Afişează numai butonul OK. Afişează butoanele OK şi Cancel. Afişează

butoanele Abort, Retry şi Ignore. Afişează butoanele Yes, No şi Cancel. Afişează
butoanele Yes şi No. Afişează butoanele Retry şi Cancel. Afişează pictograma
Critical Message . Afişează pictograma Warning Query . Afişează pictograma Warning
Message Afişează pictograma Information Message .
Page 48
Ce reprezintă
Numărul şi tipul butoanelor afişate în caseta de dialog
Felul pictogramei utilizate în partea din stânga sus
19 ianuarie 2001
VbDefaultButton1 VbDefaultButton2 VbDefaultButton3 VbDefaultButton4
VbApplicationModal
0 256 512 768 0
Primul buton este implicit Al doilea buton este implicit. Al treilea buton este
implicit. Al patrulea buton este implicit. Aplicaţie modală-utilizatorul trebuie să
răspundă casetei de mesaj înainte de a continua să lucreze în aplicaţia curentă
Sistem modal - toate aplicaţiile sunt blocate până când utilizatorul răspunde
casetei de mesaj.
Care este butonul implicit
VbSystemModal
4096
Dacă caseta de text este modală la nivelul aplicaţiei curente sau a tuturor
taskurilor.
 Title(optional). Expresie de tip string afişată pe bara de titlu a casetei de

dialog. Dacă titlul lipseşte, se va plasa pe bara de titlu numele aplicaţiei.
Valoarea întoarsă de funcţie este: Constanta Valoare Butonul pe care s-a apăsat
vbOK vbCancel vbAbort vbRetry vbIgnore vbYes vbNo 1 2 3 4 5 6 7 OK Cancel Abort
Retry Ignore Yes No
Observaţia 2. Aceste constante sunt specificate de Visual Basic for Applications.

În consecinţă, numele acestea pot fi utilizate oriunde în program în locul
valorilor respective. Observaţia 3. MsgBox poate fi utilizată şi ca procedură. În
acest caz parametrii nu se mai scriu între paranteze. În această formă este
folosită pentru afişarea unui mesaj. Exemplu. Public Sub TestMsgBox() Dim Rasp As
Integer Dim Nr As Integer Const LimInf = -100 Const LimSup = 100 ' Generează o
valoare aleatoare _ întreagă între LimInf şi LimSup Randomize Nr = Int((LimSup -
LimInf + 1) * Rnd + LimInf) 'MsgBox folosit ca funcţie ' Afişează mesaj, şi
introduce în Rasp, butonul apăsat de utilizator _ Se observă folosirea lui at( @ )
ca separator de rânduri!! Rasp = MsgBox("Doriti modificarea semnului numarului " &
Nr & _ " extras ? @ -Yes=Il face pozitiv; @ -No=Il face negativ; ", _ vbYesNoCancel
+ vbQuestion + vbDefaultButton3 + vbSystemModal, _ "Exemplu parametrii MsgBox")
Page 49
19 ianuarie 2001
If Rasp = vbYes Then Nr = Abs(Nr) ElseIf Rasp = vbNo Then Nr = Abs(Nr) * -1 Else '
cazul Cancel ' Lasa numarul neschimbat End If MsgBox "Numarul 'MsgBox ca procedura
End Sub ------------------
prelucrat este: " & Nr, vbInformation
I.2.6.4.2 InputBox(prompt[, title] [, default] [, xpos] [, ypos] ) Afişează un

mesaj într-o casetă de dialog, aşteaptă ca utilizatorul să introducă un text sau să
apese un buton şi întoarce o valoare de tip string ce conţine textul introdus de
utilizator într-un Text Box. Sintaxa funcţiei InputBox cuprinde următoarele
argumente:  Prompt(obligatoriu). Expresie de tip string afişată ca mesaj în caseta
de dialog. Lungimea sa maximă este de aproximativ 1024 caractere, depinzând de
mărimea caracterelor folosite. Dacă promptul este compus din mai mult de un rând,
se pot separa liniile utilizând un caracter CR (carriage return) Chr(13), un
caracter LF (line feed) Chr(10), sau o combinaţie (Chr(13) & Chr(10)) după fiecare
rând.  Title(optional). Expresie de tip string afişată pe bara de titlu a casetei
de dialog. Dacă titlul lipseşte, se va plasa pe bara de titlu numele aplicaţiei. 
Default(opţional). Expresie de tip string afişată în caseta de text ca răspuns
implicit dacă utilizatorul nu introduce nimic. Dacă lipseşte, caseta de text va fi
afişată goală.  Xpos (opţional). Expresie numerică care reprezintă, în twips,
distanţa pe orizontală de la marginea din stânga a casetei de dialog la marginea
din stânga a ecranului. Dacă lipseşte, caseta de dialog este centrată orizontal. 
Ypos (opţional). Expresie numerică care reprezintă, în twips, distanţa pe verticală
de la marginea de sus a casetei de dialog la marginea de sus a ecranului. Dacă
lipseşte, caseta de dialog este poziţionată vertical la aproximativ o treime din
distanţa până în subsolul ecranului. Exemplu. Următorul exemplu utilizează InputBox
pentru a citi o dată introdusă de utilizator şi folosirea lui MsgBox şi ca funcţie
şi ca procedură (pentru afişarea unor mesaje). Se observă utilizarea semnului @
pentru a delimita diversele părţi ale şirului de caractere. Sub CustomMessage() Dim
strMsg As String, strInput As String ' Iniţializează stringul. strMsg = "Număr în
afara intervalului. @ Aţi introdus un număr care este” _ & "mai mic decât 1 şi mai
mare ca 10. @ Apăsaţi OK pentru a introduce”_ & "numărul din nou." ' Se observă
rolul lui @ de delimitator de rânduri ' Se cere utilizatorului să introducă ceva.
strInput = InputBox("Introduceţi un număr între 1 şi 10.")
' Determină dacă utilizatorul introduce un şir vid <"">, adică nimic. If strInput
<> "" Then ' Testează valoarea intodusă de utilizator Do While (strInput < 0 Or
strInput > 10) If MsgBox(strMsg, vbOKCancel, "Error!") = vbOK Then strInput =
InputBox("Introduceţi un număr între 1şi 10.") Else Exit Sub End If Loop ' Afişează
data corectă introdusă de utilizator. MsgBox "Aţi introdus numărul” & strInput &
"." Else ' nu s-a introdus nimic Exit Sub End If End Sub -----------------I.2.6.5
Funcţii cu tipul:
D at e / T i m e
I.2.6.5.1 DatePart(interval, date) Funcţia DatePart întoarce o partea unei date,

specificată de argumentul interval Argumentul interval, de tip string, poate lua
următoarele valori:
interval yyyy q m y d
Exemplu.
Descriere Anul Trimestrul Luna Ziua din an Ziua
interval w ww h n s
Descriere Ziua din săptămâna Săptămâna Ora Minute Secunde
Private Sub cmdDatePart_Click() MsgBox DatePart ("YYYY”, Now) MsgBox DatePart ("M”,
Now) MsgBox DatePart ("Q”, Now) MsgBox DatePart ("Y”, Now) End Sub
------------------
‘Afişează anul curent ‘Afişează numarul lunii curente ‘Afişează numarul

trimestrului curent ‘Afişează ziua din anul curent
I.2.6.5.2 DateDiff(interval, date1, date2) Funcţia DateDiff întoarce intervalul de

timp dintre două date, deci date2-date1. Unitatea de timp este , specificată de
argumentul interval Exemplu. Private SubcmdDateDiff_Click() MsgBox DateDiff ("d”,
Now, #12/31/02#)
‘Numarul zilelor pana la 12/31/02

MsgBox DateDiff ("m”, Now, #12/31/02#) MsgBox DateDiff ("yyyy”, Now, #12/31/02#)
MsgBox DateDiff ("q”, Now, #12/31/02#) End Sub ------------------
‘Numarul lunilor pana la 12/31/02 ‘Numarul anilor pana la 12/31/02 ‘Numarul

trimestrelor pana la 12/31/02
I . 2 . 6 . 5 . 3 D a t e A d d ( i n t e r v a l , n u m b er , d a t e ) Funcţia
DateAdd întoarce rezultatul adăugării sau scăderii unei perioade specifice de timp
precizată prin argumentul interval - la o (dintr-o) dată stabilită. Private Sub
cmdDateAdd_Click () MsgBox DateAdd (”d”, 3, Now) ‘Ziua de azi plus 3 zile MsgBox
DateAdd (”m”, 3, Now) ‘Ziua de azi plus 3 luni MsgBox DateAdd (”yyyy”, 3, Now)
‘Ziua de azi plus 3 ani MsgBox DateAdd ("q”, 3, Now) ‘Ziua de azi plus 3 trimestre
End Sub -----------------I.2.6.5.4 Day(date); Month(date); Year(date) Întoarce un
Variant (Integer), care va conţine ziua sau luna sau anul, conţinut în data din
argument. -----------------I.2.6.5.5 Second(date); Minute(date); Hour(date)
Întoarce un Variant (Integer), care va conţine secunda sau minutul sau ora,
conţinut în data din argument. -----------------I.2.6.5.6 Now Întoarce un Variant
(Date), care specifică data şi timpul curent, care este în sistemul de calcul.
-----------------I.2.6.5.7 Date Întoarce un Variant (Date), care specifică data
curentă, care este în sistemul de calcul. -----------------I.2.6.5.8 Timp Întoarce
un Variant (Date), care specifică timpul curent, care este în sistemul de calcul.
-----------------I.2.6.5.9 DateSerial(year, month, day) Întoarce un Variant (Date)
care va conţine data specificată în argumentele: year, month, and day. Descrierea
argumentelor: • year obligatoriu; Integer. Număr între 100 and 9999, inclusiv, sau
expresie numerică. • month obligatoriu; Integer. Orice expresie numerică. • day
obligatoriu; Integer. Orice expresie numerică. Remarks
Page 52
19 ianuarie 2001
Pentru a specifica o dată, de exemplu December 31, 1991, valoarea fiecărui
parametru trebuie să fie validă, adică ziua între 1-31 şi luna între 1-12. Exemplu
următor va întoarce o dată, exprimată relativ faţă de altă dată. Se observă că
operaţiile se fac specific pentru zile şi luni, ţinându-se cont de numărul de zile
şi luni. Astfel ziua (1 - 1) din luna (8 2), ar trebui să fie 0/6, dar practic dacă
scădem o zi din 1 iunie, avem 31/Mai.Deci, DateSerial(1990 - 10, 8 - 2, 1 - 1) va
fi: 31/Mai/1980. Dacă argumentul pentru an este între 0 şi 99, se vor considera
anii din două cifre setaţi în Windows. Pentru ceilalţi ani trebuiesc introduse 4
cifre. Dacă un argument este dat în afara intervalului acceptat, atunci se va
întoarce o dată care este practic mărită cu numărul de zile sau luni care depăşesc
valoarea maximă pentru argumentul respectiv. De exemplu MsgBox(DateSerial(1998, 11,
32)) va afişa 2/12/1998 Exemplu. Dim MyDate MyDate = DateSerial(1969, 2, 12)
-----------------' Întoarce data February 12, 1969.
I.2.6.6 Funcţii: structuri de control
I.2.6.6.1 IIf(condiţie, TruePart, FalsePart) Această funcţie are o acţiune

asemănătoare cu a instrucţiunii If…Then…Else Funcţia IIf întoarce unul din cele
două argumente, TruePart sau FalsePart, funcţie de rezultatul evaluării condiţiei
ce se găseşte în primul argument. Astfel, dacă:
condiţie= true - funcţia întoarce parametrul TruePart • condiţie= false - funcţia

întoarce parametrul FalsePart
• Notă: Toţi cei trei parametrii ai funcţiei sunt obligatorii. Observaţia 1.
TruePart sau FalsePart, pot la rândul lor să conţină o altă funcţie, deci şi IIF,
ceea ce permite realizarea unor structuri complexe de teste. Exemplu. Function
TestIF(TestMe As Integer) TestIF = IIf(TestMe > 1000, "Large", "Small") End
Function Dacă va fi folosită în: MsgBox TestIF(1500) ' afişează Large MsgBox
TestIF(500) ' afişează Small -----------------I.2.6.6.2 Choose(index, caz-1[, caz-
2, ... [, caz-n]]) Funcţia Choose, selecţionează şi întoarce, unul din argumentele
listei, şi anume caz-1 sau caz-2 sau ... caz_n, funcţie de valoarea pe care o are
argumentul index, şi anume:    Exemplu. Function GetChoice(Ind As Integer)
Dacă index=1 atunci se întoarce caz-1 Dacă index=2 atunci se întoarce caz-2 Dacă
index=n atunci se întoarce caz-n
Notă: Dacă index < 1, sau index > n, atunci Choose întoarce valoarea Null
GetChoice = Choose(Ind, "Speedy", "United", "Federal") End Function 'La apelul
funcţiei vom avea: MsgBox GetChoice (2) ' afişează United -----------------Dim X As
Variant X = GetChoice (5) ' X se va face Null -----------------I.2.6.6.3
Switch(expr-1, value-1[, expr-2, value-2 … [, expr-
n,value-n]])
Această funcţie are o acţiune asemănătoare cu a instrucţiunii If…Then…ElseIf…Else
Funcţia Switch va evalua la în ordine, condiţiile, expr-1, expr-2, expr-n, pînă
când va obţine o valoare true. În acest moment, cercetarea se opreşte, şi funcţia
întoarce valoarea pereche care se găseşte în argumentul value_?. Daci:     
Exemplu. Function MatchUp (CityName As String) Matchup = Switch(CityName =
"London", "English", CityName _ = "Rome", "Italian", CityName = "Paris", "French")
End Function -----------------'La apelul funcţiei vom avea: MsgBox MatchUp
("Paris") ' afişează French -----------------I.2.6.7 Funcţii de inspecţie
Dacă expr-1 = True atunci se întoarce value-1, şi gata… Dacă expr-1 = False atunci
trece la evaluarea următoare Dacă expr-2 = True atunci se întoarce value-2, şi
gata… Dacă expr-2 = False atunci trece la evaluarea următoare Etc.
Notă: Dacă nici una din expresiile evaluate nu este True, atunci Switch întoarce
valoarea Null
I.2.6.7.1 VarType(NumeVariabilă) Întoarce un Integer, care precizează ce tip de

date se găseşte în variabila NumeVariabilă, de tip variant, care este argumentul
funcţiei. Reamintim că variabilele de tip variant, se caracterizează prin faptul că
în ele se pot introduce valori de diferite tipuri. Funcţia VarType, tocmai acest
rol are, să ne indice la un moment dat, ce tip de date se găsesc într-o variabilă
de tip variant.
Page 54
19 ianuarie 2001
Rezultatul întors de funcţia VarType Constanta
vbEmpty vbNull vbInteger vbLong vbSingle vbDouble vbCurrency vbDate vbString
vbObject vbError vbBoolean vbVariant vbDataObject vbDecimal vbByte vbArray
Valoare 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 17 8192
Descriere
Empty (neiniţializat) Null (lipsa datelor valide) Integer Long integer Single-
precision - număr în virgulă mobilă Double-precision - număr în virgulă mobilă
Currency - valoare Date - valoare de tip Date/Text String Object Error Boolean -
valoare Variant (folosit numai ]n tablouri de Variant) Obiect de acces la date
Decimal - valoare Byte - valoare Array - Tablou
Notă: Constantele fiind definite în Visual Basic for Applications, ele pot fi
folosite oriunde în loc de valorile specificate. Exemplu. Dim IntVar, StrVar,
DateVar, MyCheck 'Variabile declarate variant, deoarece lipseşte tipul de data '
Iniţializarea variabilelor. IntVar = 459: StrVar = "Hello World": DateVar =
#2/12/69# 'Aşa se pot scrie mai multe instrucţiuni pe rând MyCheck =
VarType(IntVar) ' Întoarce 2. Se separă aşa cum se vede cu două puncte. MyCheck =
VarType(DateVar) ' Întoarce 7. MyCheck = VarType(StrVar) ' Întoarce 8.
-----------------I.2.6.7.2 IsNull(expresie) Întoarce o valoare de tip Boolean care
indică dacă expresia transmisă ca parametru de intrare conţine date care nu sunt
valide, adică au valoarea <Null>. Parametrul este de tip variant şi conţine o
expresie de tip numeric sau string. Funcţia IsNull întoarce: • • True - dacă
parametrul are valoarea Null False - dacă parametrul nu are valoarea Null
Page 55
19 ianuarie 2001
Notă: Aşa cum am mai arătat dacă un termen al expresiei este Null, atunci expresia
va fi tot Null, şi funcţia va întoarce evident True. Observaţia 1. Valoarea Null,
îndică faptul că un Variant nu conţine date valide. Mai există încă două valori
Empty şi String vid(gol) care pot fi uşor confundate cu Null, ceea ce constituie o
eroare. Deci vom avea: • NULL - variabilă variant în care datele nu sunt valide. •
EMPTY - variabilă variant care nu a fost îniţializată. • String de lungime 0 (vid,
gol) - string care nu are nimic în el, adică este "". Exemplu. Dim MyVar, MyCheck
MyCheck = IsNull(MyVar) MyVar = "" MyCheck = IsNull(MyVar) MyVar = Null MyCheck =
IsNull(MyVar) -----------------' variabile variant ' Întoarce False, deoarece este
Empty ' Întoarce False, deoarece este string vid(de lungime 0). ' Întoarce True.
I.2.6.7.3 IsEmpty(NumeVariabila) Întoarce o valoare de tip Boolean care indică dacă

o variabilă, transmisă ca parametru de intrare este sau nu iniţializată. Parametrul
este de tip variant şi conţine o dată de tip numeric sau string. Funcţia IsEmpty
întoarce: • True - dacă variabila NumeVariabila nu este iniţializată, sau a fost
introdusă în ea direct Empty. • False - variabila a fost iniţializata(chiar cu Null
sau un string vid) Exemplu. Dim MyVar, MyCheck ' variabile variant MyCheck =
IsEmpty(MyVar) ' Întoarce True. MyVar = Null ' Assign Null. MyCheck =
IsEmpty(MyVar) ' Întoarce False. MyVar = Empty ' Assign Empty. MyCheck =
IsEmpty(MyVar) ' Întoarce True. -----------------I.2.6.7.4 IsMissing(NumeParametru)
IsMissing se foloseşte într-o rutină, pentru a testa dacă un parametru opţional al

acesteia, a fost
sau nu introdus în lista parametrilor actuali de la apelarea acestei rutine.
Parametrul funcţiei IsMissing, <NumeParametru> este de tip variant şi este chiar
parametrul optional. Funcţia IsMissing întoarce o valoare de tip Boolean, care va
avea valoarea TRUE, numai dacă parametrul opţional testat, nu a fost introdus în
lista parametrilor actuali, deci el practic lipseşte Exemplu. Dim ReturnValue ' Se
va apela funcţia ReturnTwice definită de utilizator cu un parametru declarat
opţional ReturnValue = ReturnTwice() ' Întoarce Null.
ReturnValue = ReturnTwice(2) ' Întoarce 4. ' Declararea funcţiei. Function
ReturnTwice(Optional A) If IsMissing(A) Then ' Funcţia a fost apelată fără
parametrul A ReturnTwice = Null Else ' Funcţia a fost apelată cu parametrul A
ReturnTwice = A * 2 End If End Function -----------------Observaţia 1. Funcţia
IsMissing, se aplică numai dacă parametrul opţional este de tip variant. Dacă
parametrul opţional nu este de tip variant ea va întoarce întotdeauna(fie că
parametrul opţional este sau nu este folosit la apelarea funcţiei) valoarea FALSE.
I.2.6.8 Funcţiile agregate SQL
O funcţie agregată SQL, este specifică prin faptul că datele ei de intrare sunt
valorile unui câmp dintr-o tabelă(cerere) - care este legată de obiectul în care se
foloseşte, adică cerere, tabel, formular sau raport - , din toate sau o parte din
înregistrări. Ele calculează expresii al căror domeniu de aplicabilitate este un
câmp al tabelei(cererii) care se utilizează în obiectul unde sunt folosite. În
cazul rapoartelor sau formularelor, funcţii agregate SQL, se calculează pe
tabela(cererea) legată la acesta. Funcţiile agregate SQL se folosesc fără argumente
Funcţiile agregate SQL sunt:  SUM - calculează suma valorilor pe un câmp.  MAX,
MIN - întoarce valoarea maximă / minimă a unui câmp.  AVG - calculează media
aritmetică a valorilor unui câmp.  COUNT - numărul de înregistrări ale
câmpului(diferite de NULL). Dacă se doreşte ca să se ia în calcul şi câmpurile cu
valoarea NULL, atunci se va folosi expresia COUNT(*).  VAR, VARP, STDEV, STDEVP -
calcule statistice(varianţa şi deviaţia standard) Notă: Valoarea NULL, în funcţiile
agregate (SQL sau de domeniu), nu se ia în considerare. În celelalte funcţii sau
operaţii, valoarea NULL a unui termen duce, la rezultatul NULL al expresiei,
indiferent de felul în care e constituită aceasta. -----------------I.2.6.9
Funcţiile agregate de domeniu.
Funcţiilor agregate de domeniu întorc date de calcul agregate, la fel ca şi

funcţiile agregate SQL. Diferenţa rezultă din faptul că domeniul de definiţie al
acestor funcţii, este reprezentat de un câmp al unei tabele(cereri) - din baza de
date curentă - asupra căruia se aplică, eventual, un criteriu de selecţie a
înregistrărilor. Domeniului de definiţie este stabilit de valorile ce se găsesc în
parametrii(argumentele) funcţiei. Funcţiilor agregate de domeniu, (au aceiaşi
denumire ca a funcţiilor agregate SQL, dar cu litera D în faţă) sunt  DSum -
calculează suma valorilor pe un câmp.  D Max, Dmin - întoarce valoarea maximă /
minimă a unui câmp.  DAvg - calculează media aritmetică a valorilor unui câmp.
 DCount - numărul de înregistrări ale câmpului(diferite de NULL).  DVar, DVarP,
DStDev, DStDevP - calcule statistice(varianţa şi deviaţia standard)  DLookUp -
întoarce prima valoare întâlnită în domeniul selecţionat. (aceasta nu are
echivalent în funcţiile agregate SQL) Argumentele folosite sunt aceleaşi în toate
aceste funcţii, şi stabilesc aşa cum am mai arătat, care este domeniul de definiţie
pe care se calculează valoarea agregată.
Dfuncţie((NumeCâmp, NumeTabela[, Criteriu])

• NumeCâm, NumeTabela - sunt stringuri care stabilesc care este câmpul din
tabela(cererea) asupra căreia se fac calculele agregate. • Criteriu - este un
string prin care se introduce un criteriu de selecţie a înregistrărilor din
domeniul specificat de primii doi parametrii. Dacă nu este prezent acest parametru
se vor lua în calcul datele din câmpul respectiv din toate înregistrările tabelei
specificate. Notă: Dacă nu se selecţionează datorită criteriului nici o
înregistrare, funcţia întoarce valoarea NULL. Exemplu. Dim varX As Variant, iNr As
Integer, sSir As String ' cazul 1 - selecţia înregistrărilor cu CodStudent având
valoarea <100 - întoarce dintre acestea valoarea Nume cea mai mare în ordinea de
sortare. varX = DMax("[Nume]", "Studenti", "[CodStudent]<1oo") ' CodStudent este de
tip numeric ' cazul 2 - selecţia înregistrărilor cu Nume având valoarea 'Doru' -
întoarce dintre acestea valoarea Anul cea mai mică varX = DMin("[Anul]",
"Studenti", "[Nume]='Doru' ") ' Nume este de tip text ' cazul 3 - selecţia
înregistrărilor cu CodStudent având valoarea < cea din variabila numerică iNr
întoarce dintre acestea valoarea Nume cea mai mare în ordinea de sortare. iNr = 100
varX = DMax("[Nume]", "Studenti", "[CodStudent]<" & Nr) ' CodStudent este de tip
numeric ' cazul 4 - selecţia înregistrărilor cu Nume având valoarea ce se găseşte
în variabila string sSir întoarce dintre acestea valoarea Anul cea mai mică sSir =
"Doru" varX = DMin("[Anul]", "Studenti", "[Nume]='" & sSir & "'") ' Nume este de
tip text -----------------Se observă că în formarea criteriului este foarte
important dacă criteriul se va aplica pe un câmp numeric sau de tip text. În cazul
când avem de-a face cu un câmp text valoarea cu care se face compararea trebuie la
rândul ei să fie string, deci încadrată din nou între ghilimele (2 ghilimele într-
un string delimitat de ghilimele sunt considerate ca un semn ghilimea) sau un
apostrof. Deci "[Nume]='Doru' " este echivalent cu "[Nume]=""Doru"" " Lucrurile se
complică în momentul în care criteriul pe care îl introducem va compara un câmp cu
o valoare ce se află într-o variabilă, ca în cazurile 3 şi 4. Important este să
ştim că forma de scriere a criteriului este diferită funcţie de natura câmpului
folosit de criteriu, număr sau text. Notă: Reamintesc că valoarea NULL, în
funcţiile agregate (de domeniu sau SQL), nu se ia în considerare. În celelalte
funcţii sau operaţii, valoarea NULL a unui termen duce, la rezultatul NULL al
expresiei, indiferent de felul în care e constituită aceasta.
-----------------I.2.6.10 Funcţii de conversie
I.2.6.10.1 Str(Număr) Transformă un număr într-un şir de caractere, care vor

reprezenta numărul respectiv.
• Număr - argumentul funcţiei, de tip Long, care va conţine o expresie numerică ce
va fi convertită într-un şir de caractere. Observaţia 1. După conversie, la
începutul stringului va fi un spaţiu pentru numerele pozitive / sau semnul (-)
pentru numerele negative. Observaţia 2. Punctul zecimal va fi reprezentat
întotdeauna de semnul punct(.), indiferent de cum este setat acesta în Windows(ca
punct sau ca virgulă). Notă: Pentru transformările numerelor în stringuri dar care
să respecte alte reguli de prezentare, se foloseşte funcţia Format. Exemplu. Dim
MyString MyString = Str(459) ' Întoarce " 459". MyString = Str(-459.65) ' Întoarce
"-459.65". MyString = Str(459.001) ' Întoarce " 459.001".
-----------------I.2.6.10.2 Val(string) Întoarce numărul conţinut în string, ca pe
o valoare numerică de tipul cel mai apropiat reprezentării valorii respective.
Notă: Funcţia Val, în momentul în care întâlneşte un caracter care nu poate face
parte din reprezentarea unui număr, opreşte inspecţia în continuare, şi face
conversia numai până la acest caracter. • Printre caracterele care nu sunt
recunoscute de funcţia Val, sunt şi virgula(,) sau semnul dolar($). • &O şi &H,
sunt considerate ca rădăcina pentru numere în reprezentarea octală, respectiv
hexazecimală. • Spaţiile, tab-ul şi LF, nu se iau în considerare(se sar) • Punctul
zecimal va fi reprezentat întotdeauna de semnul punct. (.) Exemplu. Dim MyValue
MyValue = Val("2457") ' Întoarce 2457. MyValue = Val(" 2 45 7") ' Întoarce 2457.
MyValue = Val("24 and 57") ' Întoarce 24. MyValue = Val(" 1615 198th Street N.E.")
' Întoarce 1615198 ------------------
Page 59
19 ianuarie 2001
I.2.7 Mediul de depanare şi dezvoltare VBA. Meniul de execuţie şi depanare al VBA,
este prezentat mai jos: Resetează toate variabilele globale ale aplicaţiei
Afişează fereastra Debug. În aceasta se vor regăsi toate afişările făcute cu
instrDebug.Print
Bara pentru Visual Basic
Stop Run
Execută instrucţiune cu instrucţiune dar cursorul galben de execuţie se va opri

numai pe:Toate g instr.Nu va mai intra în rutinele apelateNu se va mai i opri o în
rutina în care este
Cursorul de marcare a instrucţiunii care se va executa
Comenzile de compilare
Punctul de întrerupere
Va determina oprirea rulării programului acolo unde este întâlnit . Se recunoaşte
prin culoarea maro a instrucţiunii, şi a unui punct în faţa ei
Page 60
19 ianuarie 2001

Programarea in Visual Basic For Application VBA 1

Încărcat de

Drepturi de autor:

Formate disponibile

S-ar putea să vă placă și

Programarea in Visual Basic For Application VBA 1

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Programarea in Visual Basic For Application VBA 1

Încărcat de

Drepturi de autor:

Formate disponibile

"Limbaje de programare folosite în informatice de gestiune" P A R T E A -ICUPRINS

Cap I. Programarea în Visual Basic for

Observaţia 1. Ca orice declaraţie care nu specifică tipul şi tablourile declarate

Created by Serban Criscota

I.2.4.2.2.1 Structura alternativă simplă. Instrucţiunea:

Observaţia 1. Instrucţiunea Exit For, provoacă ieşirea forţată din ciclu şi

Observaţia 1. Definirea unei rutine se face prin atribuirea unui nume(obligatoriu)

Observaţia 1. Se observă că singura deosebire esenţială faţă de proceduri, se

Observaţia 1. Diferenţa între cele două apeluri este că la apelarea cu Call,

Observaţia 1. O procedură nu poate fi folosită în locul unei funcţii într-o

I.2.6 Bibliotecile standard de funcţii şi

Observaţia 1. Se observă că în codul UNICODE, primele 128 de coduri sunt ca în

Observaţia 2. Aceste constante sunt specificate de Visual Basic for Applications.

Observaţia 1. Valoarea Null, îndică faptul că un Variant nu conţine date valide.

Observaţia 1. Funcţia IsMissing, se aplică numai dacă parametrul opţional este de

Observaţia 1. După conversie, la începutul stringului va fi un spaţiu pentru

Programarea în Visual Basic for Application(VBA).

Created by Serban Criscota

Spaţiul de memorare 1 octet 2 octeţi 4 octeţi 8 octeţi

Domeniul de valori 0 … 255 –32,768…32,767 - 2,147,283,648 …. 2,147,483,647 +/-

Numărul de valori 2^8 2^16 2^32 15 cifre şi 4 zecimale

Ex. de nume variabilă btValue iCounter lAmount cValuta

I.2.1.2 Date numerice reale

Domeniu Mantisa(M) Aproximativ 7 cifre zecimale Aproximativ 14 cifre zecimale

I.2.1.3 Tipul de date BOOLEAN - logic

Numele tipului de date Boolean (logic) ------------------

Spaţiul de memorare 2 octet

Domeniu De valori True(-1); False(0)

Valoarea iniţială False(0)

Ex. de nume variabilă bRaspuns

I.2.1.4 Tipul de date STRING - şir de caractere

Created by Serban Criscota

Created by Serban Criscota

Există posibilitatea ca să se creeze structuri noi de date, definite de proiectant,

Created by Serban Criscota

Spaţiul de memorare 16 octet 22 octeţi

Domeniu La fel ca la tipul numeric La fel ca la tipul string

Valoarea iniţială Empty (Gol) Empty (Gol)

Ex. de nume variabilă vntValue vntNume

Acest tip de date va fi prezentat într-un alt modul. -----------------I.2.2

Declararea variabilelor se face de obicei cu instrucţiunea declarativă DIM.

Dim NumeVariabilă As TipulDeDateAlVariabilei

Este o instrucţiune declarativă care poate fi inclusă în secţiunea General

Created by Serban Criscota

O variabilă publică poate fi accesată (este vizibilă, are domeniul de valabilitate)

Aşa cum am arătat, domeniul de valabilitate sau vizibilitatea variabilelor, este

Tablourile se declară la fel ca orice altă variabilă folosindu-se instrucţiunile

Dim NumeTablou(N1 [, N2 [, N3….]) As TipDe Dată

Dim NumeTablou(J1 To N1 [, J2 To N2 [, J3 To N3….]) As TipDe Dată • Cu J s-a notat

Dim NumeTablou() As TipDe Dată

Created by Serban Criscota

‘Ş’ 170 350

Created by Serban Criscota

[Public | Private] Const NumeConstantă [As TipulDeDateAlVariabilei] = Valoare

Forma acestei instrucţiuni este:

Created by Serban Criscota

Ridicare Înmulţire la putere 5^2=25 5*2=10 ------------------

♦ Operatorii relaţionali, care acţionând asupra unor termeni scalari(numere,