Sunteți pe pagina 1din 54

Şerban CRIŞCOTĂ

Programarea în VISUAL BASIC


for Application
CUPRINS

CAP.I ELEMENTELE DE BAZA ALE LIMBAJULUI DE PROGRAMARE VBA - VISUAL BASIC


FOR APPLICATION I-5

I.1. Noţiuni generale despre VBA.............................................................................................................. I-5


I.1.1. Utilizarea limbajului de programare VBA....................................................................................... I-5
I.1.2. Necesitatea utilizării codului VBA în aplicaţii Access.................................................................... I-5
I.1.3. Modulele de cod VBA în Access..................................................................................................... I-6
I.1.4. Elementele generale ale limbajului VBA ........................................................................................ I-7
I.1.5. Structura rutinelor VBA .................................................................................................................. I-7
I.1.6. VBA – mediul de dezvoltare şi depanare ........................................................................................ I-7
I.2. Tipuri de date ..................................................................................................................................... I-12
I.2.1. Tipuri de date elementare .............................................................................................................. I-12
I.2.1.1. Date numerice întregi ..............................................................................................................................I-12
I.2.1.2. Date numerice reale.................................................................................................................................I-12
I.2.1.3. Tipul de date BOOLEAN – logic..............................................................................................................I-12
I.2.1.4. Tipul de date STRING – şir de caractere .................................................................................................I-13
I.2.1.5. Tipul de date DATE – data calendaristică şi timpul ................................................................................I-14
I.2.2. Tipuri de date structurate ............................................................................................................... I-14
I.2.2.1. Tipul de date ARRAY – tablou..................................................................................................................I-14
I.2.2.2. TYPE – Crearea tipurilor de date definite de utilizator...........................................................................I-14
I.2.3. Tipul de date VARIANT ............................................................................................................... I-15
I.3. Variabile.............................................................................................................................................. I-16
I.3.1. Declararea variabilelor................................................................................................................... I-16
I.3.2. Caractere folosite ca Type-declaration .......................................................................................... I-16
I.3.3. Option Explicit (declararea explicită a variabilelor)...................................................................... I-16
I.3.4. Variabile Locale şi Globale ........................................................................................................... I-17
I.3.5. Variabile Publice şi Private ........................................................................................................... I-18
I.3.6. Variabile Statice ............................................................................................................................ I-18
I.3.7. Variabile – domeniul şi durata de valabilitate ............................................................................... I-19
I.3.8. Declararea şi folosirea variabilelor ARRAY ................................................................................. I-19
I.4. Constante ............................................................................................................................................ I-21
I.5. Limbajul VBA – Instrucţiuni executabile........................................................................................ I-22
I.5.1. Instrucţiunea de atribuire ............................................................................................................... I-22
I.5.2. Structurile de control ..................................................................................................................... I-24
I.5.2.1. Structura secvenţială................................................................................................................................I-24
I.5.2.2. Structura alternativă ................................................................................................................................I-24
I.5.2.2.a) Structura alternativă simplă...............................................................................................................I-24
I.5.2.2.b) Structura alternativă multiplă ............................................................................................................I-25
I.5.2.3. Structura repetitivă ..................................................................................................................................I-27
I.5.2.3.a) Structura repetitivă cu test. Instrucţiunea Do…Loop........................................................................I-27
I.5.2.3.b) Structura repetitivă cu contor. Instrucţiunea For…Next ...................................................................I-28
I.6. Rutine – proceduri şi funcţii ............................................................................................................. I-29
I.6.1. Ce este o rutină şi ce elemente o definesc?.................................................................................... I-29
I.6.2. Transmiterea datelor prin parametri .............................................................................................. I-30
I.6.3. Crearea (definirea) unei rutine....................................................................................................... I-31
I.6.3.1. Proceduri (Subrutine) ..............................................................................................................................I-31
I.6.3.2. Funcţii ......................................................................................................................................................I-32
I.6.4. Apelarea unei rutine....................................................................................................................... I-32
I.6.4.1. Apelarea unei proceduri (subrutine)........................................................................................................I-32
I.6.4.2. Apelarea unei funcţii ................................................................................................................................I-33
I.6.5. Domeniul de vizibilitate al rutinelor.............................................................................................. I-33
I.6.6. Durata de viaţă a rutinelor ............................................................................................................. I-33
I.6.7. Rutine definite de utilizator. Introducerea codului VBA ............................................ I-33
I.6.8. Procedurile evenimentelor ............................................................................................................. I-34
I.6.9. Utilizarea combinată a procedurilor eveniment cu rutinele utilizator ........................................... I-35
I.6.10. Parametri opţionali ...................................................................................................................... I-36

I-2
I.7. Biblioteci standard de proceduri şi funcţii ...................................................................................... I-36
I.7.1. Funcţii matematice ........................................................................................................................ I-37
I.7.1.1. Int(număr); Fix(număr) ...........................................................................................................................I-37
I.7.1.2. Abs(număr)...............................................................................................................................................I-37
I.7.1.3. Sgn(număr)...............................................................................................................................................I-37
I.7.1.4. Sqr(număr) ...............................................................................................................................................I-38
I.7.1.5. Exp(număr) ..............................................................................................................................................I-38
I.7.1.6. Log(număr) ..............................................................................................................................................I-38
I.7.1.7. Rnd [(număr)] ..........................................................................................................................................I-38
I.7.1.8. Sin(număr) ...............................................................................................................................................I-39
I.7.1.9. Cos(număr) ..............................................................................................................................................I-39
I.7.1.10. Tan(număr) ............................................................................................................................................I-39
I.7.1.11. Atn(număr) .............................................................................................................................................I-39
I.7.1.12. Calculul funcţiilor matematice derivate.................................................................................................I-39
I.7.2. Funcţiile TEXT – pentru stringuri ................................................................................................. I-39
I.7.2.1. Asc(string)................................................................................................................................................I-39
I.7.2.2. Chr(CodCaracter)....................................................................................................................................I-40
I.7.2.3. AscB(string ); AscW(strin g ); Ch rB(Cod Ch ); Ch rW(Cod Ch ) .................................................I-40
I.7.2.4. LCase(string) ...........................................................................................................................................I-40
I.7.2.5. UCase(string)...........................................................................................................................................I-41
I.7.2.6. LTrim(string); RTrim(string); Trim(string) .............................................................................................I-41
I.7.2.7. Len(String | NumeVariabila)....................................................................................................................I-41
I.7.2.8. Left(string, lungime).................................................................................................................................I-41
I.7.2.9. Right(string, lungime) ..............................................................................................................................I-42
I.7.2.10. Mid(string, start [,lungime]) ..................................................................................................................I-42
I.7.2.11. InStr([start,]string1,string2[,compare]) ................................................................................................I-43
I.7.2.12. String(număr,caracter) ..........................................................................................................................I-43
I.7.2.13. Space(număr) .........................................................................................................................................I-43
I.7.2.14. Format(expresie[,format]) .....................................................................................................................I-44
I.7.3. Funcţii pentru tablouri (array) - UBound şi LBound..................................................................... I-45
I.7.4. Funcţii de conversie....................................................................................................................... I-45
I.7.4.1. Str(Număr) ...............................................................................................................................................I-45
I.7.4.2. Val(string) ................................................................................................................................................I-45
I.7.5. Funcţii pentru mesaje..................................................................................................................... I-46
I.7.5.1. MsgBox(prompt[,buttons][,title]) ............................................................................................................I-46
I.7.5.2. InputBox(prompt[,title][,default][,X][,Y])...............................................................................................I-47
I.7.6. Funcţii cu tipul: Date/ Time........................................................................................................... I-48
I.7.6.1. DatePart(interval,date) ............................................................................................................................I-48
I.7.6.2. DateDiff(interval,date1,date2) .................................................................................................................I-48
I.7.6.3. DateAdd(interval,number,date) ...............................................................................................................I-49
I.7.6.4. Day(date); Month(date); Year(date) ........................................................................................................I-49
I.7.6.5. Second(date); Minute(date); Hour(date) .................................................................................................I-49
I.7.6.6. Now(); Date(); Time() ..............................................................................................................................I-49
I.7.6.7. DateSerial(year, month, day) ...................................................................................................................I-49
I.7.6.8. TimeSerial(hour, minute, second) ............................................................................................................I-49
I.7.7. Funcţii: structuri de control ........................................................................................................... I-50
I.7.7.1. IIf(condiţie, TruePart, FalsePart) ............................................................................................................I-50
I.7.7.2. Choose(index, caz-1[,caz-2,... [,caz-n]]) .................................................................................................I-50
I.7.7.3. Switch(expr-1,value-1[,expr-2,value-2… [,expr-n,value-n]]..])................................................I-50
I.7.8. Funcţii de inspecţie........................................................................................................................ I-51
I.7.8.1. IsNull(expresie) ........................................................................................................................................I-51
I.7.8.2. IsEmpty(NumeVariabila) .........................................................................................................................I-51
I.7.8.3. IsMissing(NumeParametru) .....................................................................................................................I-51
I.7.8.4. VarType(NumeVariabilă).........................................................................................................................I-52
I.7.9. Funcţiile agregate SQL .................................................................................................................. I-52
I.7.10. Funcţiile agregate de domeniu..................................................................................................... I-53

I-3
I-4
Cap.I Elementele de bază ale limbajului de programare VBA - Visual
Basic for Application
I.1. Noţiuni generale despre VBA
I.1.1. Utilizarea limbajului de programare VBA
Basic este unul din cele mai vechi limbaje de programare. El a fost creat în ideea 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ă la 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 neutilizând
eficient facilităţile unui sistem de calcul.
Treptat, s-a trecut la realizarea 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. În felul
acesta s-au separat cele două acţiuni efectuate de un interpretor în acelaşi timp şi anume: compilarea
programului sursă şi execuţia programului 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 al 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 (VB), 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.2. Necesitatea utilizării codului VBA în aplicaţii Access
Aplicaţiile mai simple din Access pot fi scrise fără a fi nevoie de vreo 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, VBA 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 nemodificat;
• apelarea funcţiilor Windows API, prin care se pot folosi module ale sistemului de operare;

I-5
• utilizarea variabilelor, constantelor şi a literalilor;
• crearea şi manipularea prin program a obiectelor necesare aplicaţiei;
• 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.3. Modulele de cod VBA în Access

Codul VBA este scris în unităţi numite rutine, care pot fi proceduri (subrutine) sau funcţii.
Aceste proceduri ş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.
 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 parametri 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 (generale), 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. 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 (proceduri sau funcţii) modulului de cod.
O procedură (subrutină) este o rutină care execută o acţiune:
− la apariţia unui eveniment al unui obiect al aplicaţiei;
− 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 rutinele (funcţii sau proceduri) definite de utilizator, ca şi în procedurile
eveniment, pe când în modulele generale, codul VBA este plasat numai în rutinele definite de utilizator.
De fapt, pentru a construi cu succes rutine în cod VBA, sunt foarte importante două lucruri:
• ce determină stabilirea domeniului de vizibilitate (valabilitate) al variabilelor şi rutinelor;
• cum se transmit şi se întorc valorile din rutine;

I-6
Î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.1.4. Elementele generale ale limbajului VBA
Definirea unui limbaj de programare (ca şi a VBA) 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 trebuie definite şi elemente referitoare la:
• referirea obiectelor;
• crearea modulelor de clase 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 a 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.
I.1.5. Structura rutinelor VBA
Scrierea rutinelor se face respectând următoarele reguli:
• prima instrucţiune defineşte tipul rutinei, procedură sau funcţie;
• ultima instrucţiune executabilă este End Sub | Function;
• la început se pun de obicei (dar nu este obligatoriu) instrucţiunile declarative (tipuri de date,
variabile, constante);
• toate instrucţiunile au o anumită sintaxă care ţine seama de numărul de rânduri pe care sunt
scrise;
• semnul de continuare a unui rând este format din două caractere, spaţiu şi liniuţă cu shift ( _ );
• semnul pentru începutul unui comentariu este apostroful ('). Sfârşitul comentariului este la
sfârşitul rândului.
I.1.6. VBA – mediul de dezvoltare şi depanare
Odată intrat într-un modul de cod, Access oferă proiectantului de aplicaţii un sistem complex pentru
realizarea şi asistarea activităţii de programare în VBA. Printre cele mai utilizate instrumente ale acestui
sistem sunt:
 Editarea rutinelor
Sunt oferite facilităţile curente de editare promovate de Microsoft în produsele sale. Există şi mai
multe trucuri speciale destinate activităţii de programare, printre care:
− recunoaşterea cuvintelor cheie ale limbajului;
− afişarea listelor cu proprietăţile şi metodele obiectelor utilizate;
− marcarea recunoaşterii unei denumiri date de utilizator (unei variabile, rutine etc.) prin
refacerea formei introduse la declararea acesteia;
 În VBA sistemul nu face deosebire între literele mari şi mici. Dacă la declararea unui obiect, sunt
folosite combinaţii de litere mari şi mici, (după anumite convenţii), atunci când se vor introduce

I-7
denumirile respective cu acelaşi tip de literă, sistemul va reface forma iniţială a lor. În acest fel
programatorul va sesiza imediat eventualele greşeli comise la introducerea denumirii obiectelor.
 Compilarea rutinelor
Există 3 comenzi de compilare (vezi figura):
− compilarea întregii aplicaţii şi salvarea codului obiect rezultat;
− compilarea întregii aplicaţii dar fără modificarea codului obiect existent;
− compilarea numai a modulelor de cod deschise (încărcate în memorie).
Prezenţa erorilor de compilare este marcată punctual şi este însoţită de informaţiile necesare unei
depanări rapide.
De asemenea, sistemul încă din faza de editare semnalează imediat erorile de compilare depistabile
în acel moment (de exemplu cele referitoare la corectitudinea sintaxei instrucţiunilor).
 Execuţia după o comandă manuală (deci nu ca urmare a producerii unui eveniment) a
rutinelor
O rutină fără parametri se poate executa direct din modulul de cod. Acest lucru se face:
• prin plasarea cursorului pe instrucţiunea de la care se doreşte începerea execuţiei; în felul acesta
rutina se poate executa pornind de la oricare dintre instrucţiunile sale executabile;
• prin acţionarea uneia dintre cele 4 comenzi de RUN (vezi figura) şi anume:
− Run: execuţia tuturor instrucţiunilor rutinei (eventual şi a rutinelor apelate) fără oprire;
− Step Into: execuţia tuturor instrucţiunilor rutinei (eventual şi a rutinelor apelate) cu oprire
după fiecare instrucţiune executată;
− Step Over: execuţia tuturor instrucţiunilor rutinei (eventual şi a rutinelor apelate) cu oprire
după fiecare instrucţiune executată în rutina apelantă, dar fără oprire în rutinele apelate;
− Step Out: execuţia tuturor instrucţiunilor până la sfârşitul rutinei principale (apelante), dar cu
oprire numai în rutinele de rang superior celei din care s-a dat această comandă; se foloseşte
când se doreşte reluarea execuţiei dintr-o rutină apelată, dar fără oprire la instrucţiunile din
aceasta.
 În rutine se pot introduce breakpoint-uri (puncte de oprire) printr-un click pe marginea formularului
modulului de cod în dreptul instrucţiunii pe care se doreşte oprirea execuţiei. Acest marcaj se vizualizează
printr-un punct de culoare maro. Ştergerea breakpoint-urilor se face printr-un nou click sau prin comanda
specifică din meniu (vezi figura).
 Se pot introduce în sursă breakpoint-uri prin instrucţiunea STOP.
 Urmărirea traseului programului şi evoluţiei încărcării cu date a variabilelor, în vederea
depanării.
Pentru depanare, aşa cum am mai arătat, programul se poate executa şi cu oprire după fiecare
instrucţiune sau la un breakpoint. Pentru a marca acest lucru (program în execuţie şi oprit) sistemul va
face galben fondul instrucţiunii pe care s-a oprit.
După oprirea programului pe o instrucţiune, se poate vedea valoarea pe care o are în acel moment o
variabilă, prin plasarea cursorului pe aceasta.
 Este posibil ca în ieşirea virtuală, Debug Windows, să se introducă toate expresiile provenite de la
instrucţiunea: Debug.Print expresie. Vizualizarea obiectului Debug Windows se poate face la un
moment dat prin Ctrl + G sau prin pictograma specifică (vezi figura).

I-8
Meniul de execuţie şi depanare al VBA este prezentat mai jos:
Bara Visual Basic Afişează fereastra Debug. În aceasta se vor
regăsi toate afişările făcute cu instrDebug.Print
Resetează toate variabilele Execută instrucţiune cu instrucţiune dar cursorul
globale ale aplicaţiei. galben de execuţie se va opri numai pe:
Toate Nu va mai intra în Nu se va mai opri în
Run Stop instr. rutinele apelate rutina în care este

Comenzi de compilare
Cursorul de marcare
a instrucţiunii care se
va executa.
Punctul de întrerupere(Breakpoint)
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.

Lansarea unei acţiuni de pe bara Debug se face printr-un click pe opţiunea dorită, sau în unele
cazuri, prin utilizarea grupurilor de comenzi rapide ce se găsesc în dreptul lor.
 Urmărirea execuţiei pas cu pas a unei rutine
• În Debug Windows | Locals se permite vizualizarea informaţiilor de stare în momentul lansării
în execuţie a unei rutine.
Informaţiile vizează:
− numele variabilelor folosite în cadrul rutinei curente;
− valorile acestora în momentul execuţiei rutinei;
− tipurile de date corespunzătoare variabilelor folosite.
 În momentul executării unei proceduri apelate, utilizatorul are
posibilitatea vizualizării informaţiilor de stare din cadrul procedurii
apelante.
Pentru o bună înţelegere prezentăm un exemplu (suma a două numere):
Public Sub SumaNumere()
Dim A As Byte
Dim B As Byte
Dim C As Integer
A = 10
B = 16
C=A+B
MsgBox "Suma este" & C
End Sub
În continuare vom urmări grafic modul în care procedura este executată.
Pas 1. Lansarea în execuţie a rutinei.

I-9
Se vor efectua următoarele două acţiuni:
− se plasează cursorul în cadrul procedurii în locul de unde va porni execuţia acesteia (pe primul
rând pentru execuţia de la început);
− se execută instrucţiunea prin folosirea tastei Step Into ( sau F8).
Apariţia culorii galbene pe instrucţiunea Sub arată începutul execuţiei rutinei (cursorul a fost plasat
iniţial pe această instrucţiune). Dacă se va deschide fereastra Debug Windows | Locals (Ctrl + G) se va
vedea starea elementelor procedurii (nume variabile, valoarea acestora, tipul de date corespunzător).
Valoarea variabilelor A, B şi C este, în acest moment 0, deoarece, ele fiind de tip Byte şi respectiv
Integer, se iniţializează cu 0.
Pas 2. Se accesează din nou Step Into (sau comanda rapidă F8).

Cursorul (culoarea galbenă) s-a mutat pe instrucţiunea A = 10. Execuţia rutinei a sărit peste cele trei
instrucţiuni de declarare a variabilelor, deoarece acestea determină alocarea pentru variabile a spaţiului de
memorie necesar înainte de execuţia rutinei şi anume în faza de compilare. Faptul că în panoul Locals,
valoarea variabilei A este tot 0, arată că în momentul în care culoarea galbenă se găseşte pe o instrucţiune,
aceasta nu este încă executată.
Pas 3. Se accesează din nou Step Into (sau comanda rapidă F8)

Culoarea galbenă s-a mutat pe instrucţiunea B = 16 iar în panoul Locals se observă că valoarea
variabilei A este în acest moment 10 iar valoarea variabilei B este tot 0 (instrucţiunea nu este executată).
Pas 4. Se accesează din nou Step Into (sau comanda rapidă F8).

Culoarea galbenă s-a mutat pe instrucţiunea C = A + B. Se observă că, deşi A are valoare 10 iar B
are valoare 16, în acest moment, suma lor este tot 0, ceea ce confirmă încă o dată că în momentul în care
culoarea galbenă se găseşte pe o instrucţiune, aceasta nu este executată, ci numai după ce culoarea
galbenă a trecut de instrucţiunea respectivă ea se execută.
 Pentru vizualizarea valorii unei variabile în momentul execuţiei rutinei se poate utiliza şi o altă
metodă prezentată deja: se poziţionează cursorul mouse-ului pe variabila căreia dorim să-i aflăm valoarea şi

I-10
se aşteaptă un interval scurt de timp. Se va observa apariţia unei casete imediat sub variabilă în care este
specificată valoarea acesteia.
Pas 5. Se accesează din nou Step Into (sau comanda rapidă F8)

Dacă se poziţionează cursorul mouse-ului pe variabila C se observă cum valoarea acesteia în acest
moment este 26 (suma valorilor celor două variabile A şi B: 10 + 16).
Pas 6. Se accesează din nou Step Into (sau comanda rapidă F8).

După executarea instrucţiunii <<MsgBox "Suma="& C>> va apărea un mesaj (o casetă) cu


stringul "Suma=" la care este concatenată valoarea variabilei C (valoarea 26 – calculată anterior).
De asemenea dacă poziţionăm cursorul mouse-ului pe variabila C din cadrul instrucţiunii
<<MsgBox "Suma=" & C>>, se afişează valoarea 26.
La o nouă accesare a butonului Step Into se observă dispariţia culorii galbene, semn că execuţia
rutinei s-a încheiat.
În continuare vom crea un punct de întrerupere cu ajutorul mouse-ului prin click în partea stângă pe
bara verticală în dreptul instrucţiunii dorite.

Bara
verticală
Punctul de
întrerupere

Dacă se operează la lansarea în execuţie a procedurii conform cu pasul nr. 1 se va observa apariţia
culorii galbene pe prima instrucţiune (semn că execuţia rutinei a început). După lansarea în execuţie a
rutinei, dacă se va folosi opţiunea RUN (comanda rapidă F5) se va observa că marcajul galben trece direct
pe instrucţiunea care are punctul de întrerupere (sărind peste instrucţiunile A = 10, B = 16, C = A + B).

Analizând acum valorile variabilelor, observăm că s-au executat totuşi toate instrucţiunile până la
punctul de întrerupere. La o nouă accesare a opţiunii RUN se va afişa mesajul specific (Suma = 26) după
care execuţia se va încheia.
Pentru demarcarea punctului de întrerupere vom face click pe acesta.
I-11
În concluzie, din cele prezentate putem afirma că mediul de depanare reprezintă un instrument
foarte eficient în determinarea erorilor de execuţie şi a optimizării aplicaţiilor.
I.2. 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 efectivă pe care o ocupă în memorie datele, precum şi operaţiile ce se pot
efectua asupra acestor date.
VBA pune la dispoziţia programatorului tipuri de date predefinite (standard), cum ar fi cele pentru
numerele întregi, numerele reale, caractere sau booleene (logice), precum şi posibilitatea de declarare a
unor tipuri de date proprii (definite de programator) cu ajutorul instrucţiunii Type.
Tipurile de date pot fi:
− elementare (simple) – o variabilă de acest tip va conţine o singură valoare;
− structurate – o variabilă de acest tip va conţine mai multe valori elementare.
I.2.1. Tipuri de date elementare

I.2.1.1. Date numerice întregi


Numele Memoria Domeniul Numărul Valoarea Ex. de nume
tipului de date ocupată de valori de valori iniţială variabilă
Byte (octet) 1 octet 0 … 255 2^8 0 btValue

Integer (întreg) 2 octeţi –32.768…+32.767 2^16 0 iCounter


Long – 2.147.283.648
4 octeţi 2^32 0 lAmount
(întreg lung) +2.147.483.647
Currency +/– 922.337.203. 15 cifre şi
8 octeţi 0 cValuta
(valută) 685.477,5808 4 zecimale
Literalii numere întregi se scriu funcţie de sistemul de numeraţie folosit, astfel:
− pentru sistemul zecimal: numărul respectiv; Ex.: 1000; –100; 33;
− pentru sistemul hexazecimal: prefixul &H; Ex.: &HA1; &H9;
− pentru sistemul octal: prefixul &O; Ex.: &O8; &O17.
 Un literal reprezintă o valoare, de tip numeric, string, dată etc., care se introduce direct în codul
sursă VBA (de exemplu într-o expresie) fiind evaluată exact aşa cum este scrisă.
I.2.1.2. Date numerice reale
Numele Memoria Domeniu Domeniu Valoare Ex. de nume
tipului de date ocupată Mantisa(M) Exponent(E) iniţială variabilă
Single 4 octeţi aprox 7 cifre E-45…E38 0 sngValue
(precizie simplă) zecimale
Double 8 octeţi aprox 14 cifre E-324…E308 0 dValue
(precizie dublă) zecimale
 Datele numerice reale se exprimă sub forma: +/–M * 10^+/–E
I.2.1.3. Tipul de date BOOLEAN – logic
Numele Spaţiul de Domeniu Valoarea Ex. de nume
tipului de date memorare de valori iniţială variabilă
Boolean True (–1)
2 octeţi False (0) bRaspuns
(logic) False (0)
 Tipul de date BOOLEAN este compatibil cu tipul de date INTEGER.

I-12
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 2^31 caractere (aproximativ 2 miliarde);
− string de lungime fixă, care poate conţine până la 2^16 caractere (aproximativ 64 de mii).
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 7, Bell – semnal sonor;
• caracterul cu codul 8, Back Space – caracter înapoi;
• caracterul cu codul 9, Tab – salt la următorul marcaj;
• caracterul cu codul 10, LF – trecerea la rând nou (următor);
• caracterul cu codul 13, CR – face retur de car (început de rând).
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 sem- nul +).
La formarea numelor variabilelor de tip string, se foloseşte de obicei prefixul s. De exemplu sNume.
Codul ASCII
 În tabela de mai jos codurile ASCII sunt date în:
• sistemul de numeraţie zecimal – în celule, înaintea fiecărui caracter;
• sistemul de numeraţie hexazecimal – pe cele 2 margini, astfel:
− prima cifră hexazecimală pe primul rând;
− a doua cifră hexazecimală pe prima coloană.

H 0 1 2 3 4 5 6 7
0 0 · 16 · 32 [space] 48 0 64 @ 80 P 96 ` 112 p
1 1 · 17 · 33 ! 49 1 65 A 81 Q 97 a 113 q
2 2 · 18 · 34 " 50 2 66 B 82 R 98 b 114 r
3 3 · 19 · 35 # 51 3 67 C 83 S 99 c 115 s
4 4 · 20 · 36 $ 52 4 68 D 84 T 100 d 116 t
5 5 · 21 · 37 % 53 5 69 E 85 U 101 e 117 u
6 6 · 22 · 38 & 54 6 70 F 86 V 102 f 118 v
7 7 Bell 23 · 39 ' 55 7 71 G 87 W 103 g 119 w
8 8 BS 24 · 40 ( 56 8 72 H 88 X 104 h 120 x
9 9 Tab 25 · 41 ) 57 9 73 I 89 Y 105 i 121 y
A 10 LF 26 · 42 * 58 : 74 J 90 Z 106 j 122 z
B 11 · 27 · 43 + 59 ; 75 K 91 [ 107 k 123 {
C 12 · 28 · 44 , 60 < 76 L 92 \ 108 l 124 |
D 13 CR 29 · 45 - 61 = 77 M 93 ] 109 m 125 }
E 14 · 30 · 46 . 62 > 78 N 94 ^ 110 n 126 ~
F 15 · 31 · 47 / 63 ? 79 O 95 _ 111 o 127 ·

 Deşi ne-am aştepta ca un caracter să ocupe un octet (8 bits) de memorie –codul ANSI are 256 = 2^8 de
simboluri (caractere) –, totuşi spaţiul ocupat de un caracter în memorie este de 2 octeţi. Aceasta se
datorează faptului că memorarea caracterelor se face în codul UNICODE, cod care ocupă 2 octeţi şi care
conţine un număr de 2^16 simboluri. 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.

I-13
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ă
Data: 1/1/100 la 12/31/9999
Date (data + timpul) 8 octeţi Timp: 0:00:00 la 23:59:59 dtStartDate
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 S.O. Windows prin
comanda Regional Settings.
De obicei se pune prefixul dt la numele unei variabilele de tip Date.
 Un număr poate fi convertit în tip Date, folosindu-se convenţia:
− data calendaristică – se află în partea stângă a punctului zecimal;
− timpul – în partea din dreapta punctului zecimal.
 Ora 24 este 0.0 iar ora 12 este 0.5;
 Numerele negative reprezintă date anterioare celei de 30/Decembrie/1899.
I.2.2. Tipuri de date structurate
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.2.1. 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 se
materializează printr-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) ale fiecărei dimensiuni. Practic se foloseşte 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.
Utilizarea tablourilor se face numai prin referirea fiecărui element în parte (folosind numele
tabloului indexat la elementul respectiv). Deci în VBA nu se pot efectua operaţii direct cu întreaga
structură a tabloului; de exemplu o mutare de date dintr-un tablou în altul cu aceeaşi structură se poate
face numai prin mutarea separată a tuturor elementelor tabloului.
 Tablourile de octeţi constituie o excepţie la ultima afirmaţie.
Exemplu. Pentru a stoca cheltuielile pe care le facem în fiecare zi a unui an vom declara 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
Cu procedura de mai jos introducem valoarea 22 în primele 100 de zile:
Sub ExempluArray ()
Dim cCheltuieli (364) As Currency
Dim intI As Integer
For intI = 0 to 99
cCheltuieli (intI) = 22
Next
End Sub
I.2.2.2. TYPE – Crearea tipurilor de date definite de utilizator
Există posibilitatea să se creeze structuri noi de date, definite de proiectant (utilizator), formate din
combinări din alte tipuri de date.
Declararea unui nou tip de date se face cu instrucţiunea TYPE astfel:
[Public | Private] Type NumeTip
NumeElement1 As type
I-14
NumeElement2 As type
...
End Type
Referirea la variabilele de un tip definit de utilizator, se poate face:
− pentru întreaga structură (folosind numele variabilei);
− pentru fiecare element în parte (folosind numele elementului respectiv calificat – cu semnul
punct – cu numele variabilei).
 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 var. de tip Person
Primul.Nume = "Ionescu" 'se folosesc elementele tipului Person
Primul.Prenume = "Ion"
Primul.Virsta = 21
Doilea = Primul 'se transferă întregul tip de dată Person
MsgBox Doilea.Nume & " " & Doilea.Prenume & ", _
varsta=" & Doilea.Virsta & " ani"' afişează şi valoriea unei expresie
End Sub
 Caracterul (') se foloseşte pentru marcarea comentariilor.
 Caracterele ( _ ) se folosesc pentru continuarea unei instrucţiuni pe următorul rând.
I.2.3. Tipul de date V ARI ANT
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.
Numele Spaţiul de Valoarea Ex. de nume
Domeniu
tipului de date memorare iniţială variabilă
Variant 16 octeţi ca la numeric Empty (Gol) vntValue
(numere)
Variant 22 octeţi ca la stringuri Empty (Gol) vntNume
(string)

Valorile EMPTY, NULL, STRING VID


− EMPTY – reprezintă valoarea pe care o are o variabilă variant care nu este iniţializată. Aceasta
înseamnă că variabila a fost declarată dar nu a fost încă introdusă o valoare în ea. 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 conţine nici o valoare (nici un caracter), adică
este "".
 Tipul de date OBJECT – va fi prezentat în următorul capitol.

I-15
I.3. 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 vizibilitate (valabilitate): 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
domeniul lor de vizibilitate. În momentul când variabilele apar (devin vizibile), li se pot atribui valori de
un anumit tip şi pot fi folosite în cadrul instrucţiunilor. În rest, ele sunt invizibile şi nu se pot referi.
• Durata de viaţă (valabilitate): se referă la timpul cât variabila ocupă loc în memorie.
Când se creează variabile trebuie avut în vedere mai multe lucruri. Modul şi locul în care se declară
o variabilă determină domeniul de vizibilitate, durata de viaţă şi alte caracteristici ale acesteia.
Următoarele subiecte analizate vă vor face să înţelegeţi mai bine declararea variabilelor în limbajul Visual
Basic.
I.3.1. Declararea variabilelor
Declararea variabilelor se face de obicei cu instrucţiunea declarativă DIM. Forma acestei
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.
 Nespecificarea unui tip de date duce la crearea unor variabile de tip Variant.
• Se pot declara mai multe variabile 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 aceeaşi linie de acelaşi tip.
I.3.2. Caractere folosite ca Type-declaration
Anumite variabile 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 Integer Long Currency Single Double String Variant
Caracterele de tip % & @ ! # $ 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.3.3. Option Explicit (declararea explicită a variabilelor)
Este o instrucţiune declarativă care poate fi inclusă în secţiunea General Declarations a unui modul
de cod (prima parte a acestuia). Când Option Explicit este plasat într-un modul de cod, toate variabilele
din interiorul acestuia trebuie să fie declarate înainte de folosire, în caz contrar producându-se o eroare de
compilare.

I-16
Introducerea instrucţiunii declarative Option Explicit în fiecare modul, formular sau raport se poate
face automat prin activarea opţiunii Require Variable Declarations (cere declaraţii de variabile) din
meniul Tools | Options | Module. Este foarte important ca această instrucţiune (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 variabilele pot să nu fie
de loc declarate. Declararea acestora se face implicit, în 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 sigură metodă de declarare a variabilelor este de a folosi în
totalitate instrucţiunea declarativă Dim, pentru fiecare 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.
De asemenea, prin selectarea celui mai scurt tip de date pentru fiecare variabilă, se reduc substanţial
resursele necesare executării programului.
I.3.4. Variabile Locale şi Globale
În funcţie de locul de declarare, variabilele pot fi:
− locale – variabile declarate în interiorul rutinei, care sunt vizibile (domeniul de valabilitate)
numai în aceasta;
− globale (modale) – variabile declarate în secţia de declaraţii generale de la începutul unui
modul de cod. În acest caz variabila va fi vizibilă în toate rutinele modulului respectiv de cod.
Exemplu. Fie declararea variabilei:
Dim sName As String
Dacă această declaraţie se face:
• într-o rutină – ea va putea fi folosită numai în aceasta, fiind o variabilă locală;
• în secţiunea de declaraţii generale ale modulului de cod – ea este globală şi va putea fi utilizată
în toate rutinele modulului respectiv, dar nu şi în alte module de cod (această caracteristică o au numai
variabilele declarate Public în modulul general de cod).
Deci variabilele globale sunt vizibile 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 respectiv.
În următorul exemplu variabila globală miCounter:
− ia valoarea 20 în procedura Fac20;
− ia valoarea 10 în procedura Fac10;
− este afişată valoarea care se găseşte în ea în procedura Afisez.
Option Explicit ' [General Declarations]
Dim miCounter As Integer
Private Sub Fac20 ()
miCounter = 20
End Sub
Private Sub Fac10 ()
miCounter = 10
End Sub
Private Sub Afisez ()
MsgBox miCounter
End Sub

 Reţineţi câteva observaţii:


− convenţia de numire a variabilei modale prin folosirea literei m ca prefix al numelui acesteia.
Aceasta o face să fie uşor recunoscută de programator ca o variabilă de nivel modul (globală);
− folosiţi declaraţiile de nivel modul numai pentru variabilele care trebuie să fie văzute din mai
multe rutine;

I-17
− încercaţi să evitaţi (atunci când este posibil) utilizarea variabilelor globale. Această metodă face
codul mai modular şi mai uşor de depanat.
I.3.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 ca identificatori de acces, valori de configurare pentru
mediul de lucru şi alte date 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
De obicei, convenţional se indică tipul public al unei variabile, folosind prefixul p la numele
acesteia.
Rutina următoare, ataşată evenimentului Click al butonului de comandă cmdPublic, după ce face 50
variabila publică piCounter, o afişează.
Private Sub cmdPublic_Click ()
piCounter = 50
Msgbox piCounter
End Sub
Se poate folosi cuvântul cheie PRIVATE, în loc de DIM, pentru a declara variabile private în secţiunea
de declaraţii generale a modulului de cod, adică variabile care nu sunt vizibile decât de rutinele aparţinând
modulului respectiv de cod.
Exemplu. Private MyName As String
 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.3.6. Variabile Statice
Variabile statice se pot declara numai în rutine, prin folosirea cuvântului cheie STATIC, în loc de
cuvântul cheie DIM. Variabilele statice au proprietatea de a-şi păstra valoarea între două apeluri ale
rutinei în care au fost declarate.
Exemplul următor ilustrează diferenţa dintre variabilele locale şi cele statice. Deoarece variabilele
locale sunt iniţializate la fiecare apel al codului, de fiecare dată când executaţi 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 defineşte variabila
iCounter şi o iniţializează cu 0.
Ea 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ă. Deci la prima execuţie se va afşa 1, la a doua se va afişa 2, la a treia se va afişa 3 etc.
 Practic o variabilă statică este definită numai la primul apel al rutinei în care a fost declarată.
Deoarece, fiind statică, nu mai este distrusă la terminarea rutinei, la următoarea apelare nu va mai fi
definită şi va avea deci valoarea anterioară apelului.

I-18
I.3.7. Variabile – domeniul şi durata de valabilitate
Aşa cum am arătat, domeniul de valabilitate sau vizibilitate a 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ă, modală (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ţă sau 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 (se distruge, eliberează spaţiul de memorie
ocupat) î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 va fi alocată în tot timpul execuţiei
aplicaţiei.
I.3.8. Declararea şi folosirea variabilelor ARRAY
Variabilele Array (tablou) 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ă (de obicei se omite fiind implicită) şi maximă
a indicelui dimensiunii respective.
 Declararea tablourilor cu dimensiuni fixe - statice
Dim NumeTablou (N1 [, N2 [, N3…. ]) As TipDeDată
Aşa cum se observă, marginea de jos a indicelui a fost omisă. Ea implicit se consideră a avea
valoarea 0. Totuşi marginea de jos a indicelui se poate fixa la valoarea 1, dacă este introdusă în modulul
respectiv de cod, în secţiunea de declaraţii generale, instrucţiunea declarativă Option Base 1.
Exemplu. Declaraţia Dim MyArray (9, 10) As Integer va crea un tabel cu 2 dimensiuni, cu 10 şi
respectiv 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.
 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 trebuie să determine
o rezervă în folosirea tablourilor de Variant.
Exemplu. În continuare se prezintă ce memorie vor ocupa tablourile.
Dim MyVariantArray (10) As Variant ' 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).
Dim MyDoubleArray (10) As Double ' Tablou Double-precision _ 88 bytes (11 el. * 8 bytes).
Dim MyVariantArray (10) ' Tablou Variant – cel puţin _ 176 bytes (11 el. * 16
bytes).
Dim MyIntegerArray (99, 99) As Integer ' Tablou Integer foloseşte _ 100 * 100 * 2 bytes
(20.000 bytes).
Dim MyDoubleArray (99, 99) As Double ' Tablou Double-precision.. _ 100 * 100 * 8 bytes
(80.000 bytes).
Dim 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 …. ]) As TipDeDată
 Cu J s-a notat marginea de jos a indicelui, iar cu N marginea de sus a indicelui.
I-19
 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ă însă a se specifica
nimic între paranteze.
Dim NumeTablou () As TipDeDată
Exemplu. Dim sngArray () As Single
 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) redimensionează tabloul, dar nu modifică tipul de date al elementelor
şi provoacă pierderea datelor din tablou.
 Instrucţiunea ReDim provoacă 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 însă 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;
− funcţia Ubound întoarce indicele superior maxim al unui tablou;
 Utilizarea tablourilor
Un tablou poate fi utilizat ca 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 fiecare 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
 Tablouri de octeţi
Un tablou de octeţi este un tablou dinamic de tipul BYTE.
El poate fi utilizat ca orice tablou dinamic, 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 el
devine compatibil cu tipul de date string, permiţând transferurile directe de date între tablourile de octeţi
şi stringuri.
 Trebuie remarcat că în această operaţie fiecare caracter al strigului va ocupa 2 elemente din tabloul
de octeţi, deoarece, aşa cum am mai arătat, caracterele sunt memorate în UNICODE (deci pe 2 octeţi).
Exemplu. Pentru înţelegerea acestei secvenţe trebuie studiate 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 un caracter din _ string sunt necesare 2
elemente de 1 octet
ReDim X(5)
I-20
Dim k As Integer, j As Integer, i As Integer
Sir = "1AŞ"
X = Sir
For i = 0 To 2
j = i + 1 ' în "J" se va calcula numărul caracterului în string.. 1, 2, 3 _ necesar pt. funcţia MID
Caracter = Mid (Sir, j, 1) ' în "Caracter" se vor introduce caracterele
k = 2 * (i)'În K–poziţia în tablou a primului octet al caracterului: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
Î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 sub forma: (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 ‘1’ ‘A’ ‘Ş’
Cod ANSI
1octet/caracter - zecimal
49 65 170
Cod UNICODE
2 octeţi/caracter-zecimal
49 65 350
Memorie -Tabloul X
0011.0001 0000.0000 0100.0001 0000.0000 0101.1110 0000.0001
6 octeţi - binar
Memorie -Tabloul X
6 octeţi - hexa
31 00 41 00 5E 01
Memorie -Tabloul X
6 octeţi - zecimal
49 0 65 0 94 1

I.4. 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 instrucţiunii declarative CONST este:
[Public | Private] Const NumeConstantă [As TipData] = 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.
I-21
Regulile aplicate variabilelor privind domeniul şi durata de valabilitate sunt efective şi în cazul
constantelor. Deci vom avea:
− constante locale sau globale, în 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. Public Const conAge As Integer = 34 ' conAge este o constantă _ Publică, Integer, cu
valoarea 34.
Constantele se pot declara în două moduri şi anume:
− cu tip explicit, şi anume: Boolean, Byte, Integer, Long, Currency, Single, Double, Date, String,
sau Variant, ca în exemplul de mai sus;
− cu tip implicit, în care clauza As lipseşte iar tipul va fi determinat de tipul datei cu care se încarcă
constanta. 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.5. Limbajul VBA – Instrucţiuni executabile
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 Base, Option Compare Database, etc.)
− Instrucţiuni executabile, 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 modulelor de clase de obiecte;
− crearea şi manipularea obiectelor.
Practic, instrucţiunile executabile 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.5.1. Instrucţiunea de atribuire
Forma acestei instrucţiuni este:
NumeVariabilă = Expresie
I-22
Acţiunea acestei instrucţiuni constă în calcularea expresiei (din dreapta semnului =) şi depunerea
rezultatului în variabilă (din stânga semnului =).
Pentru a se executa cu succes instrucţiunea, este necesar ca rezultatul expresiei 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 capitol).
 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 ' prelucrări normale
Vstr = 251 + 40 ' nu produce eroare de execuţie;
' efectuează adunarea după care transformă constanta numerică 291 _ în stringul "291"
Vnr = Vstr ' nu produce o eroare de execuţie;
' transformă 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
 Formarea expresiilor în Visual Basic
O expresie este formată din termeni asupra cărora se efectuează anumite operaţii.
O expresie a 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 şi anume:
− aritmetici, care acţionând asupra unor termeni scalari (numere, stringuri, date calendaristice,
etc.) vor determina tot un rezultat de aceeaşi natură (scalar):
^ * / \ Mod + - &
Ridicare la Împărţire Împărţire Restul Concate-
Înmulţire Adunare Scădere
putere reală întreagă împărţirii nare şiruri
"Ab" &
5^2=25 5*2=10 5/2=2,5 10\3=3 10 Mod 3=1 5+2=7 5-2=3
2="Ab2"
− relaţionali, care acţionând asupra unor termeni scalari (numere, stringuri, date calendaristice,
etc. ) vor determina un rezultat logic (boolean):
< <= > >= = <>
mai mic mai mare
mai mic mai mare egal ne egal
sau egal sau egal
(1<1) =False (5<=5) =True (5>4) =True (5>=5) =True (5=5) =True (5<>5) = False

Is Like
apartenenţa la o mulţime La fel ca = pt. stringuri/evaluează caracterele generice din al doilea string
(5 Is [1, 2, 3]) = False ("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] Un singur caracter din listă.
("F" Like "[A-Z]") = True
ex. [A-R]
[!Listă caractere] Un singur char care nu este în listă. ( ("F" Like "[!A-Z]") = False
− logici, având valori logice (True, False) ca operanzi, vor determina un rezultat tot logic:

I-23
Op NOT Op 1 Op 2 AND Op 1 Op 2 OR Op 1 Op 2 XOR
True False True True True True True True True True False
False True True False False True False True True False True
False True False False True True False True True
False False False False False False False False False

Mai există două funcţii logice, mai puţin folosite, şi anume:


• EQV – utilizată pentru verificarea echivalenţei logice a două expresii;
• IMP – utilizată pentru verificarea implicării logice între două expresii.
 Operatorii sunt aşezaţi de la stânga la dreapta în 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.
 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.
 Valoarea EMPTY în expresii este considerată, în 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 logic = False; dacă este string = şir vid; etc.).
I.5.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.5.2.1. Structura secvenţială
Reprezintă execuţia secvenţială a instrucţiunilor, în ordinea în care au fost scrise. Nu necesită
folosirea unei instrucţiuni.
I.5.2.2. Structura alternativă
Reprezintă execuţia din mai multe grupuri de instrucţiuni introduse numai a unui singur grup, în
funcţie de evaluarea unor condiţii.
I.5.2.2.a) 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);
• condiţia este falsă, vor fi executate toate instrucţiunile dintre Else şi End If (Grup 2 de
instrucţiuni).
 Folosirea clauzei Else este opţională.
 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

I-24
End If
End Sub
 Un control în care nu este introdus nimic va avea valoarea NULL.

I.5.2.2.b) Structura alternativă multiplă


În locul folosirii a mai multor instrucţiuni If... Then... Else, atunci când decizia se ia prin evaluarea
mai multor condiţii (Structura alternativă multiplă), este mult mai simplă, 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ăţilor între valoarea
variabilei ataşate instrucţiunii (NumeVariabilă), şi valorile din dreptul cuvintelor cheie CASE (ValoareI).
Deci:
Condiţia I va fi: NumeVariabilă=ValoareI
Condiţiile sunt evaluate pe rând, în ordinea plasării lor în instrucţiune, până când se găseşte una
adevărată.
După găsirea unei condiţii advărate atunci se va executa grupul corespunzător de instrucţiuni, după
care instrucţiunea Select Case se termină, programul continuând cu prima instrucţiune plasată după
aceasta.
 Dacă toate condiţiile sunt false atunci se vor executa – dacă există – instrucţiunile dintre Else ….
End Select (Grup else de instrucţiuni).
 Dacă mai multe condiţii sunt adevărate, atunci se va executa numai un singur grup de instrucţiuni şi
anume cel aflat după prima condiţie găsită adevărată.
 În ValoareI se pot introduce:
− reuniuni de mulţimi – operatorul virgulă (ex: 1, 2, 5);
− intervale – operatorul TO (ex: 1 To 7);
− submulţimi – operatorul IS (ex: Is > 7).
 Folosirea clauzei Case Else este opţională.
 O condiţie cu rezultatul NULL este tratată ca şi cum ar fi FALSE.
Exemplu.
Sub TestCase()
Dim NumeV As Integer
NumeV = 5
Select Case NumeV
Case 7 'condiţia: NumeV=7 - False
MsgBox "Grup 1 de instrucţiuni"
Case 5, 9 'condiţia: (NumeV=5) OR (NumeV=9) - True
MsgBox "Grup 2 de instrucţiuni"
'execuţia instrucţiunii(lor) la care condiţia=True
'după execuţie, instrucţiunea Case se termină
Case 1 To 9 'condiţia: (NumeV>=1) AND (NumeV<=9) - True
'deşi şi această condiţie=true, acest grup nu va fi executat
MsgBox "Grup 3 de instrucţiuni"

I-25
Case Else
MsgBox "Grup else de instrucţiuni"
End Select
End Sub
Exemplu. Procedura următoare este ataşată evenimentului Click a unui buton de comandă cu numele
cmdCase, care se află într-un formular, în care se mai află şi un control textbox cu numele txtValue.
Această secvenţă se va executa numai atunci când se va face click pe butonul de comandă cu
numele cmdCase.
Private Sub cmdCase_Click ()
Dim IResponse As Integer
' Me!NumeControl este o expresie prin care se accesează datele aflate _ într-un control plasat în
formularul respectiv.
' Un control se comportă ca o variabilă de tip variant.
' Dacă controlul este NULL atunci nu este introdusă nici o valoare.
If IsNull(Me!txtValue) Then
iResponse = 0
Else
IResponse = Val(Me!txtValue) 'VAL transformă în număr 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 Null,
caz în care se memorează un zero într-o variabilă numită iResponse. În caz contrar, valoarea conţinută în
controlul 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ă:
− condiţiile introduse sunt independente, ne mai fiind obligatorie prezenţa unei variabile ca un
termen al condiţiei.
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).
 Folosirea clauzei Else este opţională.
I-26
 O condiţie cu rezultatul NULL este tratată ca şi cum ar fi FALSE.
Exemplu.
Sub TestElseIf()
Dim V1 As String
Dim V2 As String
V1 = InputBox("V1=")
V2 = InputBox("V2=")
If V1 = "" Then 'nu se introduce valoare în V1- şir gol
MsgBox "In V1 nu este nici o valoare"
ElseIf V2 = "" Then
MsgBox "In V1 este ceva, dar nu si in V2"
Else
MsgBox "Valorile introduse:V1=" & V1 & "; V2=" & V2
End If
End Sub
I.5.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.5.2.3.a) Structura repetitivă cu test. Instrucţiunea Do…Loop
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, în funcţie de locul unde se găseşte plasată condiţia şi anume
la început sau sfârşit:
Do [{While | Until} condiţie] Do
[grup instrucţiuni] [grup instrucţiuni]
[Exit Do] sau [Exit Do]
[grup instrucţiuni] [grup instrucţiuni]
Loop Loop [{While | Until} condiţie]
 Instrucţiunea Exit Do provoacă ieşirea forţată din ciclu. De obicei se execută în funcţie de evaluarea
unei condiţii într-o instrucţiune IF.
 Este permisă folosirea instrucţiunii Do şi fără nici o condiţie. În acest caz este obligatorie inserarea
în ciclul Do a unei instrucţiuni Exit Do sau Exit Sub | Function, pentru a nu se genera un ciclu fără sfârşit.
 Condiţia este evaluată în 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;
− la a doua formă a instrucţiunii (cea din dreapta) – după executarea ciclului.
 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;
− a doua formă a instrucţiunii (cea din dreapta) – ciclul se va executa minim o dată.
 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 patru mesaje, cu numere de la 1 la 4.
Această structură nu asigură întotdeauna executarea secvenţei de cod din interiorul buclei. Dacă în
iCounter este introdusă o valoare mai mare sau egală cu 5, codul din interiorul buclei nu va fi executat
niciodată.
I-27
Dacă secvenţa de cod trebuie să fie executată necondiţionat cel puţin o dată, se va folosi 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 un mesaj cu numărul 5. Acest cod va fi executat cel puţin o dată, indiferent de
valoarea din iCounter, deoarece evaluarea condiţiei se face după executatea ciclului.
 Structura Do While|Until... Loop face evaluarea condiţiei înainte de executarea ciclului şi de aceea
nu asigură execuţia acestuia.
 Structura Do... Loop While|Until face evaluarea condiţiei după executarea ciclului şi de aceea
execuţia acestuia este asigurată cel puţin o dată.
I.5.2.3.b) Structura repetitivă cu contor. Instrucţiunea For…Next
Repetă un ciclu de un anumit număr de ori.
 Mai există o structură: FOR EACH... NEXT, care se aplică colecţiilor de obiecte sau tablourilor şi
care va fi prezentată în următorul capitol. Această instrucţiune permite parcurgerea automată a tuturor
elementelor unei colecţii sau tablou.
Forma instrucţiunii FOR este:
For contor = start To end [Step pas]
[grup instrucţiuni]
[Exit For]
[grup instrucţiuni]
Next [contor]
în care:
− 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 cu care contorul se incrementează; poate fi pozitivă sau negativă (implicit este 1);
incrementarea se efectuează după execuţia fiecărui ciclu.
Funcţionarea instrucţiunii FOR se face prin parcurgerea următoarelor etape:
a) se determină în funcţie de valoarea (pozitivă sau negativă) pe care o are pasul (step), condiţia de
terminare a ciclului şi anume:
− Dacă PAS >=0, condiţia va fi: contor > end;
− Dacă PAS < 0, condiţia va fi: contor < end;
b) se evaluează condiţia de terminare a ciclului;
c) în continuare, dacă condiţia este:
− FALSE – se execută ciclul şi se continuă instrucţiunea FOR cu etapa d);
− TRUE – nu se execută ciclul şi se termină instrucţiunea FOR. Programul continuă cu
instrucţiunile de după NEXT;
d) după executarea ciclului se adună pasul la contor. După această operaţie instrucţiunea FOR
continuă cu repetarea evaluării condiţiei, adică cu etapa b).
 Deci, practic, la fiecare ciclu, contorul va parcurge toate valorile de la start la end. Dacă pasul este:
• pozitiv, atunci:
− dinamica contorului va fi crescătoare, prin adăugarea valorii pasului la fiecare ciclu;
− pentru ca să se execute cel puţin un ciclu, trebuie ca la început start<=end;
− numărul de cicluri efectuate va fi: end-start+1.
• negativ, atunci:

I-28
− dinamica contorului va fi descrescătoare, prin scăderea valorii absolute a pasului la fiecare
ciclu;
− pentru ca să se execute cel puţin un ciclu, trebuie ca la început start>=end;
− numărul de cicluri efectuate va fi: start-end+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ă în funcţie de evaluarea unei condiţii într-o instrucţiune IF.
 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
 Într-un For trebuie evitată schimbarea valorii contorului.
 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 cinci mesaje, cu numere de la 1 la 5.
 Observaţi că:
− iCounter se auto-incrementează;
− se pot folosi variabile atât pentru valoarea de start, cât şi pentru cea de sfârşit;
− dacă valoarea de incrementare a contorului este diferită de 1, se dă după cuvântul cheie STEP,
printr-un literal sau o variabilă (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 cinci mesaje, cu numere de la 5 la 1.
I.6. Rutine – proceduri şi funcţii
I.6.1. Ce este o rutină şi ce elemente o definesc?
Rutina este o structură de sine stătătoare, asemănătoare unui program, prin care se efectuează o
anumită acţiune. Ea este executată numai atunci când este lansată (apelată), de către un obiect al
aplicaţiei care poate fi:
− programul – numai în cazul limbajului Visual Basic, dar nu şi în cel al VBA;
− o altă rutină;
− un eveniment al unui obiect al aplicaţiei;
− un macro.
Rutina poate fi apelată de un număr nelimitat de ori din diferite locuri.
După execuţia unei rutine, controlul revine obiectului care a provocat apelarea rutinei.
Toate declaraţiile (variabile, constante) făcute în interiorul rutinei sunt locale, fiind deci 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, are loc automat eliberarea din memorie a tuturor
variabilelor şi constantelor locale ale acesteia.

I-29
 Î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 interacţ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 parametri. Aceasta reprezintă practic nişte variabile, prin intermediul cărora se
face:
− un transfer de date de la modulul care apelează la rutină – parametri de intrare – produs în
momentul apelării rutinei;
− un transfer de date de la rutină înspre modulul apelant – parametri de ieşire – produs în
momentul terminării rutinei şi preluării controlului de către modulul apelant;
 Prin variabile globale sau publice. 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.
• Definirea unei rutine se face prin atribuirea unui nume (obligatoriu) acesteia şi prin stabilirea
listei de parametri (opţional). Parametrii definiţi în rutină se numesc parametri formali.
• Declararea parametrilor formali se face după regulile aplicate la declararea variabilelor.
• Apelarea unei rutine se face prin numele ei.
• La apelarea unei rutine, corespunzător fiecărui parametru formal, trebuie să existe o dată de
acelaşi tip în modulul apelant, care poate fi o variabilă, o constantă, o expresie sau un literal. Aceste date
formează lista parametrilor actuali şi este declarată o dată cu apelarea rutinei. Evident parametrii
actuali şi formali trebuie să fie de acelaşi tip şi să ocupe acelaşi loc în cele două liste.
• Parametrii de intrare ai rutinei pot fi în lista parametrilor actuali: variabile, constante, literali sau
expresii.
• 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.
 Din punct de vedere al terminologiei se mai obişnuieşte să se folosească în loc de parametru
termenul argument.
I.6.2. Transmiterea datelor prin parametri
Există două modalităţi de transmitere a datelor prin parametri şi anume, prin valoare sau prin
adresă (referinţă).
 Apelarea rutinelor şi transmitera parametrilor prin valoare
Din figura următoare se obsevă că avem perechi de parametri, actuali şi formali, care reprezintă
practic două variabile care se sincronizează de două ori: prima dată la apelarea rutinei şi a doua dată la
terminarea rutinei.
Astfel la apelarea rutinei se face practic pentru fiecare pereche de parametri 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.)

Rutina Nume: Rtest


Modul apelant
………. X1,X2 A1,A2 Parametrii formali:
Instr N….. X1=…. Intrare: A1, A2
Instr N+1.. X2=…. Ieşire: B1
Apelare rutină - Rtest Y B1 Instr1
Parametri actuali:X1, X2, Y ………...
Instr. ….= …Y ..= A1 + A2 ' folosirea
……….. 'parametrilor de intrare
Instr J…… M1=….
Instr J+1… M2=…. ………..
M1,M2 A1,A2
Apelare rutină - Rtest B1= …… ' folosirea
Parametri actuali:M1, M2, T 'parametrilor de ieşire
Instr. ….= …T T B1 ………..
…….. Sfârşit rutină

I-30
Deci în acest caz se transferă anumite valori, în ambele sensuri, între perechile de parametri formal
şi actuali. Spunem că transmisia parametrilor se face prin valoare.
 Apelarea rutinelor şi transmitera parametrilor prin adresă

Modul apelant Rutina Nume: Rtest


………. Parametri actuali Parametrii formali:
Intrare:A1,A2
Instr N….. X1=…. X1 X2 Y
Ieşire:B1
Instr N+1.. X2=…. a d r e s e Instr1
Apelare rutină - Rtest
Parametri actuali:X1,X2,Y A1 A2 B1 ………..
Instr. ….= …Y Parametri formali ..= A1+A2 'folosirea
'parametrilor de intrare
………..
………..
Instr J…… M1=….
Parametri actuali B1= ….. 'folosirea
Instr J+1… M2=…. 'parametrilor de ieşire
Apelare rutină - Rtest X1 X2 Y ………..
Parametri actuali:M1,M2,T
a d r e s e Sfârşit rutină
Instr. ….= …T
……….. A1 A2 B1
Parametri formali

Î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 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 parametrilor formali în expresii.
 În Visual Basic, dacă nu se fac precizări suplimentare, transmiterea parametrilor se face prin adresă
(referinţă).
I.6.3. 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ă).
 Funcţiile pot fi folosite direct oriunde este cerută o expresie, cu condiţia vizibilităţii ei din locul de
apelare. Astfel putem folosi funcţii ca: parametri de intrare pentru rutine, la definirea proprietăţilor din
controale, la cereri etc.
I.6.3.1. Proceduri (Subrutine)
[Private|Public][Static] Sub NumeProcedura [(ListaParametriFormali)]
[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. Astfel, procedura
declarată Public în modulul general de cod va fi vizibilă din toate modulele de cod ale aplicaţiei, iar cea
declarată Private va fi 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ţiunea Static determină ca toate variabilele locale declarate în procedură să funcţoineze ca
variabilele statice.
• Toate instrucţiunile sunt permise în proceduri,folosind date care pot fi:
− parametrii formali;
I-31
− variabilele şi constantele globale;
− variabilele şi constantele locale;
 Este indicat ca să se evite, pe cât posibil, în crearea rutinelor, folosirea variabilelor globale. Pentru
schimburile de date dintre rutină şi modulul apelant este recomandată utilizarea numai a parametrilor
formali. Acest lucru se datorează faptului că o rutină care foloseşte multe 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:
− ByVal – prin valoare;
− ByRef – prin adresă (referinţă);
Implicit, transferul parametrilor se face prin adresă.
I.6.3.2. Funcţii
[Public|Private][Static]Function NumeF-cţie[(ParFormali)] [As TipFuncţie]
[declaraţii locale de: variabile, constante, etc. ]
[instrucţiuni]
[Exit Function]
[instrucţiuni]
End Function
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 tipul funcţiei se va
considera implicit Boolean.
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.
 Î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 parametri şi va
întoarce 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.6.4. Apelarea unei rutine
 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.6.4.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, urmat eventual de lista parametrilor actuali:
NumeProcedură ListaParametrilorActuali
 Parametrii se separă prin virgulă.
I-32
 Diferenţa între cele două forme este că la apelarea cu Call, parametrii actuali ai procedurii trebuie
scrişi între paranteze, pe când la apelarea directă prin numele procedurii nu se foloseasc parantezele.
I.6.4.2. Apelarea unei funcţii
O funcţie se apelează dintr-o 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ă după execuţia
funcţiei cu o valoare, ca şi cum ar fi un parametru de ieşire al unei proceduri. Spunem că funcţia întoarce
(returnează) o valoare după execuţia ei. Această valoare va participa la evaluarea expresiei respective.
 O procedură nu poate fi folosită într-o expresie în locul unei funcţii, deoarece nu întoarce valori prin
numele ei (chiar dacă are parametri de ieşire).
 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 procedură 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 _ parametrul de ieşire
Else
Rezultat = Numar1 + Numar2 ' valoarea calculată se introduce în _ parametrul 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
I.6.5. Domeniul de vizibilitate 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) de cod, fie în modulele specifice din spatele formularelor sau rapoartelor (Code Behind
Forms – CBF).
Domeniul de valabilitate sau de vizibilitate a rutinei este determinat de cuvântul utilizat în
declararea acesteia: Private sau Public şi de locul unde rutina e plasată.
O rutină este publică dacă este declarată Public şi este plasată în modulul general de cod. Ea este
vizibilă în toată aplicaţia.
Restul rutinelor sunt locale şi sunt vizibile numai din modulul unde au fost declarate.
I.6.6. Durata de viaţă a rutinelor
Durata de viaţă a unei rutine, adică timpul în care ea se găseşte în memorie, este în funcţie de locul
unde a fost declarată şi anume:
• pe toată durata aplicaţiei dacă se găseşte în modulul general de cod;
• cât timp este în execuţie un formular sau raport, dacă se găseşte în codul din spatele acestuia.
I.6.7. Rutine definite de utilizator. Introducerea codului VBA

 Pentru a crea o rutină definită de utilizator într-un modul general (global) de cod, urmaţi
paşii de mai jos:
• executaţi clic pe marcajul de tabulare Modules 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ă rutină) de pe
bara cu instrumente sau selectaţi opţiunea Procedure din meniul
Insert. Va apărea pe ecran caseta de dialog prezentată anterior.
• introduceţi numele rutinei şi selectaţi tipul acesteia: funcţie,
procedură (subrutină) sau proprietate (se va prezenta în alt capitol).

I-33
Indicaţi dacă doriţi ca rutina să fie publică (pentru întreaga aplicaţie) sau privată (numai pentru acest
modul). De asemenea, specificaţi dacă toate variabilele locale din rutină sunt statice sau nu. Terminaţi
definirea rutinei cu clic pe OK.
 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 de pe bara de instrumente sau prin
selectarea opţiunii Code din meniul View, sau prin pictograma specifică de pe bara de instrumente.
I.6.8. Procedurile evenimentelor
Procedurile evenimentelor sunt apelate automat când are loc un eveniment pentru un anumit
obiect.
De exemplu, când un utilizator execută click cu mouse-ul pe un buton de comandă dintr-un
formular, este executat automat, dacă există, codul evenimentului Click pentru acel buton de comandă,
cod care se va găsi plasat sub forma unei proceduri eveniment în modulul de cod din spatele formularului
respectiv.
Procedura unui eveniment al unui control este creată automat (prima şi ultima instrucţiune a
procedurii, adică Sub şi End Sub) când se selectează dintre proprietăţile controlului evenimentul respectiv.
Numele procedurii va fi obligatoriu stabilit de sistem, în funcţie de numele controlului şi al evenimentului
respectiv. De asemenea, dacă este cazul, este ataşată, tot de către sistem, lista parametrilor formali.
Exemplu. Într-un formular se găseşte un control de tip buton de comandă, cu numele cmdOkay (şi
proprietatea Caption="Apasa") şi trei controale de tip textbox, cu numele txtNume, txtVirsta şi txtSex.
Instrucţiunea de declarare a procedurii eveniment: Private Sub cmdOkay_Click, ca şi aceea de sfârşit
(End Sub), sunt create automat atunci când se selectează evenimentul Click din lista proprietăţilor
butonului de comandă cmdOkay. În continuare programatorul introduce codul sursă al procedurii
eveniment:
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 'Dacă nu sunt date în toate cele trei textbox-uri se afişează _ mesajul şi se termină
procedura
Else 'Afişează val. din txtNume şi ce întoarce funcţia CalculVirsta
MsgBox "Numele d-tra este: " & Me!txtNume & _
Chr(10) & Chr(13) & "Virsta dv este acum de: " & _
CalculVirsta(Int(Val(Me!txtVirsta)), Me!txtSex) & " ani"
End If
End Sub
Procedura de mai sus va fi executată de fiecare dată când se va face
click pe butonul de comandă cmdOkay al formularului.
Dacă în toate cele trei controale textbox sunt introduse date, atunci
se afişează un mesaj ca în figura alăturată; altfel se va afişa mesajul:
"Trebuie introduse numele, vârsta şi sexul"
 Procedura foloseşte următoarele funcţii ce se găsesc în bibliotecile
sistem (prezentate în continuarea acestui capitol):
• IsNull(pm) – întoarce TRUE dacă parametrul pm este Null;
• Chr(10) – întoarce caracterul LF - Line Feed (rând nou);
• Chr(13) – întoarce caracterul CR - Carriage Return (retur de
car);
• Val(pm) – întoarce valoarea numerică din stringul pm;
• Int(pm) – întoarce partea întreagă din pm.
 Un control se comportă ca o variabilă de tip variant. Datele din control pot fi accesate cu sintaxa
Me!NumeControl, dar numai din codul din spatele formularului respectiv. Dacă nu sunt date introduse în
control, atunci valoarea acestuia este Null.

I-34
Procedura eveniment utilizează o funcţie utilizator, declarată în acelaşi modul de cod din spatele
formularului respectiv, care are doi parametri formali de intrare şi anume: V – în care se va transfera
valoarea numerică întreagă din textbox txtVirsta şi S – în care se va transfera valoarea din textbox txtSex.
Function CalculVirsta (V As Integer, S As Variant) As Integer
If V > 35 And S = "F" Then
CalculVirsta = V - 10
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
 Pentru a edita codul evenimentului, executaţi următorii paşi:
• 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
parametri formali, dacă este cazul – şi instrucţiunea de sfârşit a procedurii. Proiectantul va introduce acum
codul VBA necesar tratării evenimentului.
I.6.9. Utilizarea combinată a procedurilor eveniment cu rutinele utilizator
Am arătat că atât subrutinele, cât şi funcţiile pot primi argumente (parametri), dar numai funcţiile
pot întoarce 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 întoarce caracterele_ de la începutul 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
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
I-35
End Sub
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 întoarce această valoare rutinei apelante (cmdNume_Click) şi o
atribuie variabilei sInitials.
I.6.10. 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 întoarce True dacă s-a apelat _ funcţia fără parametrul
sMI
SMI = InputBox ("Introduceţi initiala cuvantului din mijloc")
End If
If IsMissing (sLName) Then ' IsMissing întoarce True dacă s-a _ apelat funcţia fără
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")
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")
În acest caz funcţia, prin folosirea lui IsMissing, va sesiza prezenţa tuturor celor trei parametri
actuali.
 Lucrul cu parametri 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 parametri 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. Funcţia IsMissing este
valabilă numai pentru parametri de tip variant.
− 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 parametri opţionali, declararea acestora în lista parametrilor formali este:
[Optional] NumeParametru As TipDate [ = ValoareImplicita ]
I.7. Biblioteci standard de proceduri şi funcţii
O bibliotecă este un obiect de sine stătător care permite realizarea unei colecţii de funcţii, proceduri,
clase de obiecte, colecţii de obiecte şi obiecte.
Noile tehnologii şi standarde introduse de Microsoft permit ca modulele unei biblioteci să fie
utilizate de toate aplicaţiile client de pe platforma S.O. care respectă standardele de utilizare ale acestora.
Î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 şi proceduri ale acestor
biblioteci.
I-36
Un bun programator trebuie să cunoască şi să folosească cât mai multe din obiectele puse la
dispoziţie de biblioteci. De exemplu dacă se realizează o aplicaţie care la un moment dat trebuie să
calculeze sinusul dintr-o valoare, un programator neexperimentat ar putea 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 imediat această problemă, folosind pur şi simplu funcţia respectivă.
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 întoarce 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, 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 şi
proceduri, foarte bogată şi cuprinzătoare, din care vor fi prezentate
în continuare cele mai utilizate.
I.7.1. Funcţii matematice

I.7.1.1. Int(număr); Fix(număr)


Ambele funcţii întorc partea întreagă a numărului introdus ca parametru de intrare.
Tipul de dată al rezultatului va fi acelaşi cu cel al parametrului 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 se manifestă numai în cazul numerelor negative. 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 Nr ' variabilă declarată fără specificarea tipului de dată-VARIANT.
Nr = Int (99. 8) ' Întoarce 99.
Nr = Fix (99. 2) ' Întoarce 99.
Nr = Int (-99. 8) ' Întoarce -100.
Nr = Fix (-99. 8) ' Întoarce -99.
I.7.1.2. Abs(număr)
Întoarce valoarea absolută a numărului introdus ca parametru de intrare.
Tipul de dată al rezultatului va fi acelaşi cu cel al parametrului de intrare.
Exemplu.
Dim Nr
Nr = Abs (50. 3) ' Întoarce 50. 3.
Nr = Abs (-50. 3) ' Întoarce 50. 3.
I.7.1.3. Sgn(număr)
Întoarce un Variant (Integer) care reprezintă semnul unui număr.
Dacă parametrul este: <0 >0 =0
Sgn întoarce: –1 1 0
Exemplu.
Dim Semn aA Variant

I-37
Const Valoare1= 12, Valoare2= -2. 4, Valoare3= 0
Semn = Sgn (Valoare1) ' Întoarce 1.
Semn = Sgn (Valoare2) ' Întoarce -1.
Semn = Sgn (Valoare3) ' Întoarce 0.
I.7.1.4. Sqr(număr)
Întoarce o valoare de tip Double (virgulă mobilă dublă precizie) care reprezintă radicalul (square
root) unui număr pozitiv (≥ 0).
Exemplu.
Dim Radical
Radical = Sqr(4) ' Întoarce 2.
Radical = Sqr(23) ' Întoarce 4. 79583152331272.
Radical = Sqr(0) ' Întoarce 0.
Radical = Sqr(-4) ' Generează o eroare de execuţie.
I.7.1.5. Exp(număr)
Întoarce o valoare de tip Double care reprezintă constanta e ridicată la o putere (în care e este baza
logaritmului natural).
Exemplu.
Dim Unghi, SinHiper
Unghi = 1. 3 ' Defineşte unghiul în radiani
SinHiper = (Exp (Unghi) - Exp (-1 * Unghi) ) / 2' Calcul sin hiperbolic
I.7.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~2,718282.
Exemplu.
Dim Unghi, Logaritm
Unghi = 1.3 ' Defineşte unghiul în radiani
Logaritm=Log(Unghi+Sqr(Unghi*Unghi+1))' inversul sin hiperbolic
I.7.1.7. Rnd [(număr)]
Întoarce o valoare de tip Single (virgulă mobilă simplă precizie) care va conţine un număr aleator.
Valoarea întoarsă de Rnd este:
Dacă parametrul este: Rnd generează
Acelaşi număr de fiecare dată, folosind parametrul ca valoare
<0
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ţă.
Argumentul (parametrul) este opţional şi poate fi un Single sau o expresie numerică corectă.
Funcţia Rnd întoarce o valoare în intervalul [0.. 1).
Valoarea parametrului determină cum Rnd generează un număr aleator.
Pentru o anumită valoare iniţială, este generată aceeaşi secvenţă de numere, deoarece 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ă parametri, care va folosi pentru iniţializarea generatorului
de numere aleatoare ceasul sistemului de calcul.
 Dacă se doreşte generarea unor numere întregi, în intervalul [a.. b], se foloseşte formula: Int(a + (b
- a + 1) * Rnd)
Exemplu.
Dim Valoare
Randomize
Valoare=Int(1+(6*Rnd)) ' Generează o valoare aleatoare între 1 şi 6.
I-38
I.7.1.8. Sin(număr)
Întoarce o valoare de tip Double care este 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 Unghi, Cosecanta
Unghi = 1.3 ' Defineşte unghiul în radiani.
Cosecanta = 1 / Sin(Unghi) ' Calculează cosecanta.
I.7.1.9. Cos(număr)
Întoarce o valoare de tip Double care este cosinusul unui unghi în radiani.
Exemplu.
Dim Unghi, S
Unghi = 1. 3 ' Defineşte unghiul în radiani.
S = 1 / Cos (MyAngle) ' Calculează secanta.
I.7.1.10. Tan(număr)
Întoarce o valoare de tip Double care este 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 Unghi, Cotangenta
Unghi = 1. 3 ' Defineşte unghiul în radiani
Cotangenta = 1 / Tan (Unghi) ' Calculează cotangenta
I.7.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.
I.7.1.12. Calculul funcţiilor matematice derivate
Secant Sec (X) = 1 / Cos (X)
Cosecant Cosec (X) = 1 / Sin (X)
Cotangent Cotan (X) = 1 / Tan (X)
Inverse Sine Arcsin (X) = Atn (X / Sqr (-X * X + 1) )
Inverse Cosine Arccos (X) = Atn (-X / Sqr (-X * X + 1) ) + 2 * Atn (1)
Inverse Secant Arcsec (X) = Atn(X / Sqr(X*X –1)) + Sgn( (X)–1) * (2*Atn(1))
Inverse Cosecant Arccosec (X) = Atn(X / Sqr(X*X-1)) + (Sgn(X)–1) * (2*Atn(1))
Inverse Cotangent Arccotan (X) = Atn (X) + 2 * Atn (1)
Hyperbolic Sine HSin (X) = (Exp (X) – Exp (-X) ) / 2
Hyperbolic Cosine HCos (X) = (Exp (X) + Exp (-X) ) / 2
Hyperbolic Tangent HTan (X) = (Exp (X) – Exp (-X) ) / (Exp (X) + Exp (-X) )
Hyperbolic Secant HSec (X) = 2 / (Exp (X) + Exp (-X) )
Hyperbolic Cosecant HCosec (X) = 2 / (Exp (X) – Exp (-X) )
Hyperbolic Cotangent HCotan (X) = (Exp (X) + Exp (-X) ) / (Exp (X) – Exp (-X) )
Inverse Hyperbolic Sine HArcsin (X) = Log (X + Sqr (X * X + 1) )
Inverse Hyperbolic Cosine HArccos (X) = Log (X + Sqr (X * X – 1) )
Inverse Hyperbolic Tangent HArctan (X) = Log ( (1 + X) / (1 – X) ) / 2
Inverse Hyperbolic Secant HArcsec (X) = Log ( (Sqr (-X * X + 1) + 1) / X)
Inverse Hyperbolic Cosecant HArccosec (X) = Log ( (Sgn (X) * Sqr (X * X + 1) + 1) / X)
Inverse Hyperbolic Cotangent HArccotan (X) = Log ( (X + 1) / (X – 1) ) / 2
Logarithm to base N LogN (X) = Log (X) / Log (N)

I.7.2. Funcţiile TEXT – pentru stringuri


I.7.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 Numar
Numar = Asc ("A") ' Întoarce 65.
I-39
Numar = Asc ("a") ' Întoarce 97.
Numar = Asc ("Apple") ' Întoarce 65.
I.7.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.
 Codurile dintre 0-31 au ca corespondent în ASCII caractere netipăribile, care însă pot să determine
anumite acţiuni în timpul afişării. De exemplu:
• Chr(10) întoarce caracterul Line Feed (LF) - trecerea pe linie nouă;
• Chr(13) întoarce Carriage Return (CR) - trecerea la început de linie.
Intervalul normal pentru parametrul CodCaracter este: 0-255.
Exemplu.
Dim Caracter
Caracter = Chr (65) ' Întoarce A.
Caracter = Chr (97) ' Întoarce a.
Caracter = Chr (62) ' Întoarce >.
Caracter = Chr (37) ' Întoarce %.
I.7.2.3. AscB(string); AscW(string); ChrB(CodCh); ChrW(CodCh)
Funcţiile AscB, AscW, ChrB, ChrW ţin seama că în memorie caracterele sunt codificate pe 2 octeţi
în standardul UNICODE. Ele consideră ş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.
 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) ' Întoarce Caracterul = Ş
MsgBox ChrB (94) ' Întoarce Caracterul = ^
MsgBox ChrW (350) ' Întoarce Caracterul = Ş
End Sub
Caracterul A Ş
Cod ANSI (1 octet) 65 170
Cod UNICODE (valoare) 65 350
Cod UNICODE (2 octeţi) 65 0 94 1
 Se observă că în codul UNICODE, primele 128 de coduri sunt ca în codul ASCII.
I.7.2.4. LCase(string)
Întoarce o valoare de tip Variant (String) în care literele mari au fost convertite în litere mici. Restul
caracterelor rămân nemodificate.

I-40
Exemplu.
Dim Valoare, ValoareMica
Valoare = "Nota EXAmen" ' String pentru a fi convertit.
ValoareMica = LCase (Valoare) ' Întoarce "nota examen".
I.7.2.5. UCase(string)
Întoarce o valoare de tip Variant (String) în care literele mici au fost convertite în litere mari. Restul
caracterelor rămân nemodificate.
Exemplu.
Dim Valoare, ValoareMare
Valoare = "Nota EXAmen" ' String pentru a fi convertit.
ValoareMare = UCase (Valoare) ' Întoarce "NOTA EXAMEN".
I.7.2.6. LTrim(string); RTrim(string); Trim(string)
Întoarce o valoare de tip Variant (String) care este copia stringului, dar:
− la funcţia LTrim: fără spaţiile de început;
− la funcţia RTrim: fără spaţiile de sfârşit;
− la funcţia Trim: fără spaţiile din ambele capete.
Exemplu.
Dim Valoare, Modific
Valoare = " <-Trim-> " ' Iniţializează stringul.
Modific = LTrim(Valoare) ' Modific = "<-Trim-> ".
Modific = RTrim(Valoare) ' Modific = " <-Trim->".
Modific = LTrim(RTrim(Valoare)) ' Modific = "<-Trim->".
' Utilizând funcţia Trim se obţine acelaşi rezultat.
Modific = Trim(Valoare)' Modific = "<-Trim->"
I.7.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.
 Dacă argumentul este NULL, funcţia va întoarce tot NULL; această regulă, aşa cum am mai amintit,
este comună şi celorlalte funcţii.
 Unul (şi numai unul) din cele două argumente posibile trebuie specificat.
 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 (octeţi) utilizaţi
pentru a reprezenta acel string.
Exemplu.
Type CustomerRecord ' Defineşte tipul de date dorit de utilizator.
ID As Integer 'Această definiţie este la nivelul modului de cod
Name As String * 10
Address As String * 30
End Type
'------------------------------
Dim Customer As CustomerRecord ' Declararea variabilelor.
Dim MyInt As Integer, MyBan As Currency
Dim MyString, MyLen
MyString = "Hello World" ' Iniţializează variabila.
MyLen = Len(MyString) ' Întoarce 11.
MyLen = Len(Customer) ' Întoarce 42.
MyLen = Len(MyInt) ' Întoarce 2.
MyLen = Len(MyBan) ' Întoarce 8.
I.7.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ă:
I-41
− Lungimea = 0 – se întoarce un string de lungime 0 – cunoscut cu numele de şir vid ("").
− Lungimea >= Len(string) – se întoarce întregul string dacă lungimea este mai mare decât
numărul de caractere din string.
Pentru a determina numărul de caractere dintr-un string se va utiliza funcţia Len.
Exemplu.
Dim Sir, Subsir
Sir = "Nota examen" ' Defineşte stringul.
Subsir = Left(Sir, 1) ' Întoarce "N".
Subsir = Left(Sir, 7) ' Întoarce "Nota ex".
Subsir = Left(Sir, Len(Sir)-2) ' Întoarce "Nota exam".
Subsir = Left("Sir",1) ' Întoarce "S"
 A se face distincţie între variabila Sir care este încărcată cu valoarea "Nota examen" şi stringul
"Sir" care este scris între ghilimele, el fiind astfel tratat ca o valoare de tip String.
I.7.2.9. Right(string, lungime)
Întoarce un sub-şir de caractere din partea dreaptă a stringului al căror număr este stabilit de
lungime (vezi explicaţia anterioară).
Exemplu.
Dim Sir, Subsir
Sir = "Nota examen" ' Defineşte stringul.
Subsir = Right(Sir, 1) ' Întoarce "n" (caracterul de la final))
Subsir = Right(Sir, 8) ' Întoarce "a examen".
Subsir = Right(Sir, Len(Sir)-2) ' Întoarce "ta examen".
Subsir = Right("Sir",1) ' Intoarce "r" (vezi observaţie funcţia left)
I.7.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.
 Determinarea numărului de caractere din string se face cu funcţia Len.
Exemplu.
Dim SirPrincipal, SubSir1, SubSir2, SubSir3
SirPrincipal = "Universitatea din Pitesti" ' Creează stringul.
SubSir1 = Mid(SirPrincipal, 1, 13) ' Întoarce "Universitatea".
SubSir2 = Mid(SirPrincipal, 19, 7) ' Întoarce "Pitesti".
SubSir3 = Mid(SirPrincipal, 15) ' Întoarce "din Pitesti".
 Mid poate fi folosit şi în partea stângă 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 în aşa fel încât să
nu se modifice 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
I-42
Mid(S, 4, 2) = "ABC"
MsgBox S ' Afişează 123AB6789
End Sub
I.7.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, sau 2.
− 0 – implicit – comparare binară, senzitivă;
− 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.
 Dacă nu se găseşte şirul specificat se întoarce valoarea 0. Dacă unul din şiruri este NULL, atunci
NULL se întoarce.
Exemplu.
Dim Sir, SirCautat, Pozitie
Sir = "Popescu Panait" ' String în care se caută.
SirCautat = "P" ' Se caută "P".
'Următoarele 4 instrucţiuni încep cercetarea de la poziţia 4
Pozitie = Instr (4, Sir, SirCautat, 1) ' Comparaţie textuală. Întoarce 9.
Pozitie = Instr (4, Sir, "P", 1) ' Comparaţie textuală. Întoarce 9.
Pozitie = Instr (4, Sir, "p", 1) ' Comparaţie textuală. Întoarce 9.
Pozitie = Instr (4, Sir, "p", 0) ' Comparaţie binară. Întoarce 0.
Pozitie = Instr (1, Sir, "W") ' Implicit comparaţia e binară _
(lipseşte ultimul argument).Întoarce 0.
Exemplu.
Private Sub cmdInstr_Click ()
Debug.Print InStr ("Alison Balter", "Balter") ' întoarce 8
Debug.Print InStr ("Hello", "1") ' întoarce 3
End Sub
I.7.2.12. String(număr,caracter)
Întoarce un şir de caractere, care conţine de număr de ori caracterul specificat.
 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).
 Dacă al doilea argument conţine un şir de mai multe caractere se va multiplica primul.
Exemplu.
Dim MyString
MyString = String(5, "*") ' Întoarce "*****"
MyString = String(5, 42) ' Întoarce "*****" – codul Ascii al lui * este 42
MyString = String(10, "ABC") ' Întoarce "AAAAAAAAAA".
I.7.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-43
I.7.2.14. Format(expresie[,format])
Funcţia Format transformă o expresie într-un şir de caractere care respectă un şablon (format).
• 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 ori un
nume valid de format (de ex. "Long Time" sau "hh:mm:ss AMPM") ori 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,_ virgula sau american,
punctul) definit în Windows (System settings). _
. – Întoarce semnul pentru punctul zecimal definit în Windows _
% – Întoarce în procente
MyStr = Format(5459.4, "##, ##0.00") ' Întoarce "5,459.40" - _ System settings în Windows
este U.S.
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ă cuvântul 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-44
I.7.3. Funcţii pentru tablouri (array) - UBound şi LBound
UBound (arrayname[,dimension])
LBound (arrayname[,dimension])
Întorc o valoare de tip Long, care va conţine, pentru o anumită dimensiune a unui tablou:
 Pentru UBound: valoarea indicelui celui mai mare disponibil (marginea superioară).
 Pentru LBound: valoarea indicelui celui mai mic disponibil (marginea inferioară).
Sintaxa celor două funcţii cuprind:
− 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.
Exemplu. Pentru tabloul cu dimensiunile: Dim A(1 To 100, 0 To 3, -3 To 4) UBound şi LBound întorc
următoarele valori:
Funcţia Parametrii Valoarea î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 nefiind 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.7.4. Funcţii de conversie


I.7.4.1. Str(Număr)
Transformă un număr într-un şir de caractere.
• Număr – argumentul funcţiei, de tip Long, va conţine o expresie numerică ce va fi convertită
într-un şir de caractere.
• După conversie, la începutul stringului va fi un spaţiu pentru numerele pozitive sau semnul (–)
pentru numerele negative.
• Punctul zecimal va fi reprezentat întotdeauna de semnul punct(.), indiferent de cum este setat
acesta în Windows (ca punct sau ca virgulă).
• Pentru transformarea numerelor în stringuri, cu folosirea altor 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.7.4.2. Val(string)
Întoarce numărul conţinut în string, ca pe o valoare numerică de tipul cel mai apropiat reprezentării
valorii respective.
• 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 ş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
($).

I-45
• &O şi &H, sunt considerate ca rădăcină 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
I.7.5. Funcţii pentru mesaje
I.7.5.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ă codul butonului apăsat.
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=Chr(13), un caracter
LF=Chr(10), sau o combinaţie (Chr(13) & Chr(10) ) după fiecare rând.
 În VBA, există definită constanta de tip string: vbCr=Chr(13) & Chr(10)
• Buttons (opţional - implicit este 0). Expresie numerică care este suma valorilor reprezentând
patru caracteristici ale căsuţei de mesaj şi anume:
− ce butoane se afişează (OK, Cancel, Yes, No, Retry, Ignore);
− care este butonul care se va considera implicit;
− ce pictogramă se afişează;
− faţă de ce este modală caseta de mesaj: aplicaţie sau sistem (nu se poate ieşi din aceasta în
aplicaţie/ sistem până nu se închide).
Setările pentru butoanele argument sunt:
Constanta Val Descrierea Ce reprezintă
VbOKOnly 0 Afişează numai butonul OK.
VbOKCancel 1 Afişează butoanele OK şi Cancel. Numărul şi tipul
VbAbortRetryIgnore 2 Afişează butoanele Abort, Retry şi Ignore. butoanelor afişate
VbYesNoCancel 3 Afişează butoanele Yes, No şi Cancel. în caseta de dialog
VbYesNo 4 Afişează butoanele Yes şi No.
VbRetryCancel 5 Afişează butoanele Retry şi Cancel.
VbCritical 16 Afişează pictograma Critical Message.
Afişează pictograma Warning Query. Felul pictogramei
VbQuestion 32
utilizate în partea
VbExclamation 48 Afişează pictograma Warning Message
din stânga sus
VbInformation 64 Afişează pictograma Information Message.
VbDefaultButton1 0 Primul buton este implicit.
VbDefaultButton2 256 Al doilea buton este implicit. Care este butonul
VbDefaultButton3 512 Al treilea buton este implicit. implicit
VbDefaultButton4 768 Al patrulea buton este implicit.
Aplicaţie modală – utilizatorul trebuie să
VbApplicationModal 0 răspundă casetei de mesaj înainte de a Dacă caseta de text
continua să lucreze în aplicaţia curentă. este modală la
nivelul aplicaţiei
Sistem modal – toate aplicaţiile sunt curente sau a
VbSystemModal 4096 blocate până când utilizatorul răspunde tuturor taskurilor
casetei de mesaj.
− Title (opţional). Expresie de tip string afişată pe bara de titlu a casetei de dialog. Dacă lipseşte,
se va plasa pe bara de titlu numele aplicaţiei.
Valoarea întoarsă de funcţie este:

I-46
Constanta Valoare Butonul pe care s-a apăsat
vbOK 1 OK
vbCancel 2 Cancel
vbAbort 3 Abort
vbRetry 4 Retry
vbIgnore 5 Ignore
vbYes 6 Yes
vbNo 7 No
 Aceste constante sunt definite în VBA. În consecinţă, numele acestea pot fi utilizate oriunde în
program în locul valorilor respective.
 MsgBox poate fi utilizată şi ca procedură. În acest caz parametrii nu se mai scriu între paranteze. În
această formă este folosită numai 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")
If Rasp = vbYes Then
Nr = Abs(Nr)
ElseIf Rasp = vbNo Then
Nr = Abs(Nr) * -1
Else 'Cancel - Lasă numărul neschimbat
End If
MsgBox "Numarul prelucrat este: " & Nr, vbInformation
End Sub 'Se observă mai sus folosirea lui MsgBox ca pe o procedură
I.7.5.2. InputBox(prompt[,title][,default][,X][,Y])
Afişează un mesaj într-o casetă, aşteaptă ca utilizatorul să introducă un text sau/şi să apese un buton
şi întoarce o valoare (string) ce conţine acest text.
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 (opţional). 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ă.
• X (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.
• Y (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.

I-47
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." ' @ - rol de delimitator de rânduri
' Se cere utilizatorului să introducă o valoare.
strInput = InputBox("Introduceţi un număr între 1 şi 10. ")
If strInput <> "" Then ' Testează ca valoarea intodusă să nu fie şir vid
Do While (strInput < 0 Or strInput > 10)
If MsgBox(strMsg, vbOKCancel, "Error!") = vbOK Then
strInput = InputBox("Introduceţi 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.7.6. Funcţii cu tipul: Date/ Time
I.7.6.1. DatePart(interval,date)
Funcţia DatePart întoarce o parte dintr-o dată, care este specificată de argumentul interval.
Argumentul interval, de tip string, poate lua următoarele valori:
interval Descriere interval Descriere
yyyy Anul w Ziua din săptămână
q Trimestrul ww Săptămâna
m Luna h Ora
y Ziua din an n Minute
d Ziua s Secunde
Exemplu.
Private Sub cmdDatePart_Click ()
MsgBox DatePart("YYYY", Now) ' Afişează anul curent
MsgBox DatePart("M", Now) ' Afişează numărul lunii curente
MsgBox DatePart("Q", Now) ' Afişează nr. trimestrului curent
MsgBox DatePart("Y", Now) ' Afişează ziua din anul curent
End Sub
I.7.6.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#) ' Nr. zile până la 12/31/02
MsgBox DateDiff("m",Now,#12/31/02#) ' Nr. luni până la 12/31/02
' Numărul de ani până la 12/31/02
MsgBox DateDiff("yyyy",Now,#12/31/02#)
' Numarul trimestrelor până la 12/31/02
MsgBox DateDiff("q",Now,#12/31/02#)
End Sub

I-48
I.7.6.3. DateAdd(interval,number,date)
Funcţia DateAdd întoarce rezultatul adăugării sau scăderii unei perioade specifice de timp, precizate
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.7.6.4. Day(date); Month(date); Year(date)
Întoarce un Variant (Integer), care conţine ziua sau luna sau anul, din data care se găseşte în
argumentul funcţiei.
I.7.6.5. Second(date); Minute(date); Hour(date)
Întoarce un Variant (Integer), care conţine secunda sau minutul sau ora, din data care se găseşte
în argumentul funcţiei.
I.7.6.6. Now(); Date(); Time()
Now() - întoarce un Variant (Date), care conţine data şi timpul curent (cu care este setat în
momentul respectiv sistemul de calcul).
Date() - întoarce un Variant (Date), care conţine data curentă (cu care este setat în momentul
respectiv sistemul de calcul).
Time() - întoarce un Variant (Date), care conţine timpul curent (cu care este setat în momentul
respectiv sistemul de calcul).
I.7.6.7. DateSerial(year, month, day)
Întoarce un Variant(Date) care va conţine data calendaristică specificată în argumentele: year,
month şi day.
Descrierea argumentelor:
− Year (obligatoriu); Integer. Număr între 100 şi 9999 inclusiv, sau expresie numerică.
− Month (obligatoriu); Integer. Orice expresie numerică.
− Day (obligatoriu); Integer. Orice expresie numerică.
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.
Exemplul 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 OData As Date
OData = DateSerial(1969, 2, 12) 'Întoarce data - February 12, 1969.
I.7.6.8. TimeSerial(hour, minute, second)
Întoarce un Variant(Date) care va conţine timpul pentru o anumită oră, minut şi secundă, specificată
în argumentele: hour, minute, second.
Exemplu.
Dim Timpul As Date
Timpul = TimeSerial(16, 35, 17) 'Reprezentatre timp - 4:35:17 PM

I-49
I.7.7. Funcţii: structuri de control
I.7.7.1. IIf(condiţie, TruePart, FalsePart)
Funcţia IIf 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, în 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.
 Toţi cei trei parametri ai funcţiei sunt obligatorii.
 TruePart sau FalsePart pot la rândul lor să conţină o altă funcţie, deci şi un alt IIF, ceea ce permite
realizarea unor structuri complexe de teste.
Exemplu.
Function TestIF(TestMe As Integer) as String
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.7.7.2. Choose(index, caz-1[,caz-2,... [,caz-n]])
Funcţia Choose întoarce unul din argumentele listei (caz-1 sau caz-2, sau … caz_n) în funcţie de
valoarea pe care o are argumentul index, şi anume:
− dacă index = 1 atunci se întoarce caz-1;
− dacă index = 2 atunci se întoarce caz-2;
− dacă index = n atunci se întoarce caz-n.
 Dacă index < 1, sau index > n, atunci Choose întoarce valoarea Null.
Exemplu.
Function GetChoice(Ind As Integer) as String
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.7.7.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 î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_?. Deci:
− 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.
 Dacă nici una din expresiile evaluate nu este True, Switch întoarce Null.
Exemplu.
Function MatchUp(CityName As String) 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-50
I.7.8. Funcţii de inspecţie
I.7.8.1. 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;
 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.
 Valoarea Null, îndică faptul că un Variant nu conţine date valide. Mai există încă două valori
speciale, Empty şi String vid (gol) care pot fi uşor confundate cu Null, ceea ce constituie o eroare. Deci
reamintim că:
• 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 Valoare, Situatie ' variabile variant
Situatie = IsNull(Valoare) ' Întoarce False, deoarece este Empty
Valoare = ""
Situatie = IsNull(Valoare) ' Întoarce False, deoarece este string vid _ (de lungime 0).
Valoare = Null
Situatie = IsNull(Valoare) ' Întoarce True.
I.7.8.2. IsEmpty(NumeVariabila)
Întoarce o valoare de tip Boolean care indică dacă o variabilă, transmisă ca parametru de intrare,
este sau nu EMPTY, adică 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ţializată (chiar cu Null sau un string vid).
Exemplu.
Dim Valoare, Situatie ' variabile variant
Situatie = IsEmpty(Valoare) ' Întoarce True.
Valoare = Null ' Assign Null.
Situatie = IsEmpty(Valoare) ' Întoarce False.
Valoare = Empty ' Assign Empty.
Situatie = IsEmpty(Valoare) ' Întoarce True.
I.7.8.3. 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.
Aceste (NumeParametru) reprezintă parametrul formal optional care se testează dacă a fost
introdus sau nu în lista parametrilor actuali la apelul funcţiei.
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. Apelarea funcţiei ReturnTwice, definită cu un parametru opţional.
Dim ReturnValue
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
I-51
ReturnTwice = A * 2
End If
End Function
 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.7.8.4. VarType(NumeVariabilă)
Întoarce un Integer, care precizează tipul de date ce se găseşte în variabila de tip variant:
NumeVariabilă (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. Rezultatul întors de funcţia VarType:
Constanta Val Descriere Constanta Val Descriere

vbEmpty 0 Empty (neiniţializat) vbObject 9 Object


vbNull 1 Null (lipsa datelor valide) vbError 10 Error
vbInteger 2 Integer vbBoolean 11 Boolean – valoare
vbLong 3 Long integer vbVariant 12 Variant (în tablouri)
vbSingle 4 Single-precision vbDataObject 13 Obiect de acces la date
vbDouble 5 Double-precision vbDecimal 14 Decimal – valoare
vbCurrency 6 Currency – valoare vbByte 17 Byte – valoare
vbDate 7 Date – val. de tip Date/Text vbArray 8192 Array – Tablou
vbString 8 String

 Constantele fiind definite în VBA, ele pot fi utilizate oriunde în loc de valorile specificate.
Exemplu.
' Variabile declarate variant, deoarece lipseşte tipul de data
Dim IntVar, StrVar, DateVar, MyCheck
' Iniţializarea variabilelor
IntVar = 459: StrVar = "Hello World": DateVar = #2/12/69#
' !!! Aşa se pot scrie mai multe instrucţiuni pe un rând, separându-le, _ aşa cum se vede, cu două
puncte.
MyCheck = VarType(IntVar) ' Întoarce 2.
MyCheck = VarType(StrVar) ' Întoarce 8.
MyCheck = VarType(DateVar) ' Întoarce 7.
I.7.9. 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ţiile agregate SQL se
calculează pe tabela (cererea) legată la acesta.
Funcţiile agregate SQL au ca argument numele câmpului pe care sunt definite. Totuşi, în cazul
cererilor cu clauză total, în care introducerea funcţiei agregate SQL se face într-o coloană ataşată
câmpului de definiţie, ele se folosesc fără argument.
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 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).

I-52
 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.7.10. Funcţiile agregate de domeniu
Funcţiile 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. Domeniul de definiţie este stabilit de valorile ce se găsesc în parametrii (argumentele)
funcţiei.
Funcţiile 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;
− DMax, 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âmp, NumeTabela – sunt stringuri care stabilesc care este câmpul şi 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 parametri. Dacă nu este prezent acest parametru, se vor lua în calcul
datele din câmpul respectiv din toate înregistrările tabelei specificate.
 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 din tabela Studenti cu CodStudent _ având valoarea <100
– întoarce dintre acestea valoarea Nume cea mai mare în ordinea de _ sortare.
– CodStudent (care e folosit în criteriu) este de tip numeric şi a fost _ comparat cu un LITERAL
varX = DMax ("[Nume]", "Studenti", "[CodStudent]<100")
' cazul 2 – selecţia înregistrărilor cu Nume având valoarea 'Doru' _
– întoarce dintre acestea valoarea Anul cea mai mică
– Nume (care e folosit în criteriu) este de tip text şi a fost comparat cu un _ LITERAL
varX = DMin ("[Anul]", "Studenti", "[Nume]='Doru' ")
' 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.
– CodStudent (care e folosit în criteriu) este de tip numeric şi a fost _ comparat cu o dată care se
găseşte într-o variabilă
iNr = 100
varX = DMax ("[Nume]", "Studenti", "[CodStudent]<" & Nr)
' 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ă
– Nume (care e folosit în criteriu) este de tip text şi a fost comparat cu o dată care se găseşte într-o
variabilă
sSir = "Doru"
varX = DMin ("[Anul]", "Studenti", "[Nume]='" & sSir & "'")
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

I-53
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ă în funcţie de natura câmpului folosit de criteriu, număr sau text.
 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-54