73642788 Programarea in Visual Basic for Application VBA 1

"Limbaje de programare folosite în informatice de gestiune"

P A R T E A -I-

C U P R I N S

Cap I. Programarea în Visual Basic for Application(VBA)...................................5

I.1 Domeniul de folosire al VBA ......................................................................................................5 I.1.1 Modulele de cod în Access.......................................................................................................6

I.2 Elementele generale ale limbajului Visual Basic ....................................................................7 I.2.1 Tipuri de date. ..........................................................................................................................8

I.2.1.1 Date numerice întregi...............................................................................................................8I.2.1.2 Date numerice reale.................................................................................................................8I.2.1.3 Tipul de date BOOLEAN - logic.............................................................................................8I.2.1.4 Tipul de date STRING - şir de caractere...............................................................................8I.2.1.5 Tipul de date DATE - data calendaristică şi timpul..........................................................10I.2.1.6 Tipul de date ARRAY - tablou...............................................................................................10I.2.1.7 TYPE - Crearea tipurilor de date definite de utilizator. ..................................................11I.2.1.8 Tipul de date VARIANT..........................................................................................................11

I.2.1.8.1 Valorile EMPTY, NULL, STRING VID.........................................................................12I.2.1.9 Tipul de date OBJECT............................................................................................................12

I.2.2 Variabile...................................................................................................................................12I.2.2.1 Declararea variabilelor.........................................................................................................12I.2.2.2 Caractere folosite ca Type-declaration...............................................................................13I.2.2.3 Option Explicit (Opţiune de explicitare).............................................................................13I.2.2.4 Variabile Locale şi Globale..................................................................................................13I.2.2.5 Variabile Publice şi Private..................................................................................................14I.2.2.6 Variabila Statice.....................................................................................................................15I.2.2.7 Domeniul şi durata de valabilitate a variabilelor ............................................................15I.2.2.8 Declararea şi folosirea variabilelor ARRAY - TABLOU..................................................16

I.2.2.8.1 Declararea tablourilor cu dimensiuni fixe - statice........................................................16

Observaţia 1. Ca orice declaraţie care nu specifică tipul şi tablourile declarate fără tip sunt de tip Variant. În acest caz fiind Variant, fiecare element va ocupa 16 bytes, dacă este numeric sau 22 bytes, dacă este string. Deci la tablouri mari se poate ajunge la un consum mare de memorie, ceea ce determină o rezervă în folosirea tablourilor de Variant........................................16

I.2.2.8.2 Declararea tablourilor cu dimensiuni variabile - dinamice............................................16I.2.2.8.3 Utilizarea tablourilor.........................................................................................................17I.2.2.8.4 Tablouri de octeţi..............................................................................................................17

I.2.3 Constante..................................................................................................................................19I.2.4 Instrucţiunile executive ale limbajului Visual Basic........................................................19

I.2.4.1 Instrucţiunea de atribuire......................................................................................................20I.2.4.1.1 Formarea expresiilor în Visual Basic..............................................................................20

Observaţia 1. Aşa cum am mai arătat, dacă un termen al unei expresii este NULL, atunci şi rezultatul expresiei este tot NULL. Spunem că NULL-ul se propagă în expresii. Totuşi există o excepţie, şi anume la operatorul de concatenare a şirurilor, &: Dacă un termen este NULL, iar celălalt nu este NULL, atunci rezultatul va fi chiar termenul diferit de NULL...........................22

Observaţia 2. Valoarea EMPTY, în expresii este considerată, funcţie de tipul de date pe care îl reprezintă, chiar valoarea cu care se iniţializează variabilele de tipul respectiv(astfel în expresii dacă un termen numeric este EMPTY

Created by Serban Criscota 19 ianuarie 2001

atunci se va considera =0; dacă este logice =False; dacă este string = şir vid; etc.) 22

I.2.4.2 Structurile de control.............................................................................................................22I.2.4.2.1 Structura secvenţială.........................................................................................................22I.2.4.2.2 Structura alternativă..........................................................................................................22

I.2.4.2.2.1 Structura alternativă simplă. Instrucţiunea: If...Then...Else............................................................22I.2.4.2.2.2 Structura alternativă multiplă. Instrucţiunile: Select Case şi If...Then...ElseIF…Else...................23

Observaţia 1. Dacă mai multe condiţii sunt adevărate, atunci se vor executa toate grupurile corespunzătoare de instrucţiuni. Deci instrucţiunea Select Case nu se opreşte la întâlnirea primei condiţii adevărate, ci va evalua toate condiţiile............................................................................................................................23

Observaţia 2. În ValoareX se pot folosi reuniuni de mulţimi (operator virgula - ex: 1,2,5) intervale (operator TO - ex: 1 To 7), sau submulţimi(operator IS ex: Is > 7)...........................................................................................................................23

I.2.4.2.3 Structura repetitivă............................................................................................................24I.2.4.2.3.1 Structura repetitivă cu test. Instrucţiunea DO.................................................................................24

Observaţia 1. Instrucţiunea Exit Do, provoacă ieşirea forţată din ciclu. De obicei se execută funcţie de evaluarea unei condiţii într-o instrucţiune IF.......25

Observaţia 2. Condiţia este evaluată funcţie de locul unde este plasată în instrucţiune şi anume:....................................................................................................25

Observaţia 3. Ciclul se execută minim de................................................................25I.2.4.2.3.2 Structura repetitivă cu contor. Instrucţiunea FOR...NEXT.............................................................26

Observaţia 1. Instrucţiunea Exit For, provoacă ieşirea forţată din ciclu şi continuarea programului cu instrucţiunile de după NEXT. De obicei se execută funcţie de evaluarea unei condiţii într-o instrucţiune IF.......................................26

Observaţia 2. Sunt admise imbricări ale structurilor For, dacă sunt folosite variabile contor diferite ca în exemplul următor:...................................................26

Observaţia 3. Într-un For, trebuie evitată schimbarea valorii contorului......27

Observaţia 4. Structura For ... Next este folosită atunci când sunt un număr exact de iteraţii de executat..........................................................................................27

I.2.5 Rutine - proceduri şi funcţii.................................................................................................27I.2.5.1 Ce este o rutină? Elementele care definesc o rutină.........................................................27

Observaţia 1. Definirea unei rutine se face prin atribuirea unui nume(obligatoriu) acesteia şi prin stabilirea listei de parametrii(opţional). Parametrii definiţi în rutină se numesc parametrii formali. ...............................27

Observaţia 2. Declararea parametrilor formali se face după regulile aplicate la declararea variabilelor..............................................................................................28

Observaţia 3. Apelarea unei rutine se face prin numele ei.................................28

Observaţia 4. În momentul apelării, trebuie să se realizeze o corespondenţă între nişte date(variabile, constante, literali) ale modulului apelant cu parametrii formali ai rutinei. Aceasta se face prin stabilirea unei liste de parametrii actuali, declaraţi în momentul apelării. Evident parametrii actuali şi formali trebuie să fie de acelaşi tip şi să ocupe acelaşi loc în cele două liste.

28


Observaţia 5. Parametrii de intrare ai rutinei pot fi în lista parametrilor actuali: variabile, constante, literali sau expresii....................................................28

Observaţia 6. Parametrii de ieşire ai rutinei pot fi în lista parametrilor actuali numai variabile, deoarece aceştia prin definiţie îşi pot schimba valoarea în timpul execuţiei rutinei............................................................................28

I.2.5.1.1 Transmiterea datelor prin parametrii...............................................................................28I.2.5.2 Crearea(definirea) unei rutine.............................................................................................29

I.2.5.2.1 Proceduri(Subrutine).........................................................................................................29I.2.5.2.2 Funcţii................................................................................................................................30

Observaţia 1. Se observă că singura deosebire esenţială faţă de proceduri, se datorează faptului că numele funcţiei are două semnificaţii fiind în acelaşi timp şi numele rutinei şi parametru de ieşire al rutinei. Din această cauză acestuia trebuie să i se precizeze tipul de date. Dacă acest lucru nu se face atunci implicit se va considera Boolean tipul funcţiei............................................30

Observaţia 2. În loc de Exit Sub şi End Sub, la funcţii sunt Exit Function şi End Function, evident cu acelaşi rol. ........................................................................30

I.2.5.3 Apelarea unei rutine...............................................................................................................31I.2.5.3.1 Apelarea unei proceduri(subrutine).................................................................................31

Observaţia 1. Diferenţa între cele două apeluri este că la apelarea cu Call, parametrii actuali ai procedurii trebuie scrişi între paranteze, pe când la apelarea directă prin numele procedurii, este obligatoriu să nu se folosească paranteze...........................................................................................................................31

I.2.5.3.2 Apelarea unei funcţii........................................................................................................31

Observaţia 1. O procedură nu poate fi folosită în locul unei funcţii într-o expresie, deoarece nu returează valori (chiar dacă are parametrii de ieşire). .31

Observaţia 2. Funcţiile pot fi apelate şi ca pe o procedură în oricare din cele două modalităţi prezentate...........................................................................................31

I.2.5.4 Domeniul de valabilitate(vizibilitatea) al rutinelor..........................................................32I.2.5.5 Rutine definite de utilizator. Introducerea codului VBA...................................................32I.2.5.6 Procedurile evenimentelor.....................................................................................................32I.2.5.7 Utilizarea combinată a rutinelor utilizator şi a procedurilor eveniment.......................34I.2.5.8 Parametri opţionali................................................................................................................35

I.2.6 Bibliotecile standard de funcţii şi proceduri. ...................................................................36I.2.6.1 Funcţii matematice.................................................................................................................37

I.2.6.1.1 Int(număr); Fix(număr)....................................................................................................37I.2.6.1.2 Abs(număr)........................................................................................................................37I.2.6.1.3 Sgn(număr)........................................................................................................................37I.2.6.1.4 Sqr(număr).........................................................................................................................37I.2.6.1.5 Exp(număr)........................................................................................................................38I.2.6.1.6 Log(număr)........................................................................................................................38I.2.6.1.7 Rnd[(număr)].....................................................................................................................38I.2.6.1.8 Sin(număr).........................................................................................................................39I.2.6.1.9 Cos(număr)........................................................................................................................39I.2.6.1.10 Tan(număr)......................................................................................................................39I.2.6.1.11 Atn(număr)......................................................................................................................39I.2.6.1.12 Expresii pentru calculul funcţiilor matematice derivate..............................................40

I.2.6.2 Funcţii TEXT - pentru stringuri............................................................................................40I.2.6.2.1 Asc(string).........................................................................................................................40I.2.6.2.2 Chr(CodCaracter)..............................................................................................................40I.2.6.2.3 AscB(string); AscW(string); ChrB(CodChar); ChrW(CodChar)..................................41

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


I.2.6.2.4 LCase(string).....................................................................................................................42I.2.6.2.5 UCase(string).....................................................................................................................42I.2.6.2.6 LTrim(string); RTrim(string); Trim(string)....................................................................42I.2.6.2.7 Len(string | NumeVariabila)............................................................................................42I.2.6.2.8 Left(string, lungime).........................................................................................................43I.2.6.2.9 Right(string, lungime)......................................................................................................43I.2.6.2.10 Mid(string, start[,lungime])............................................................................................44I.2.6.2.11 InStr([start, ]string1, string2[, compare])......................................................................44I.2.6.2.12 String(număr, caracter)...................................................................................................45I.2.6.2.13 Space (număr)..................................................................................................................45I.2.6.2.14 Format(expresie[, format])............................................................................................46

I.2.6.3 Funcţii pentru tablouri(array)..............................................................................................47I.2.6.3.1 UBound(arrayname[, dimension])...................................................................................47I.2.6.3.2 LBound(arrayname[, dimension])...................................................................................47

I.2.6.4 Funcţii pentru mesaje.............................................................................................................48I.2.6.4.1 MsgBox(prompt[, buttons] [, title] )................................................................................48

Observaţia 2. Aceste constante sunt specificate de Visual Basic for Applications. În consecinţă, numele acestea pot fi utilizate oriunde în program în locul valorilor respective..........................................................................................49

Observaţia 3. MsgBox poate fi utilizată şi ca procedură. În acest caz parametrii nu se mai scriu între paranteze. În această formă este folosită pentru afişarea unui mesaj...........................................................................................49

I.2.6.4.2 InputBox(prompt[, title] [, default] [, xpos] [, ypos] )...................................................50I.2.6.5 Funcţii cu tipul: Date/Time ..................................................................................................51

I.2.6.5.1 DatePart(interval, date).....................................................................................................51I.2.6.5.2 DateDiff(interval, date1, date2).......................................................................................51I.2.6.5.3 DateAdd(interval, number, date).....................................................................................52I.2.6.5.4 Day(date); Month(date); Year(date)................................................................................52I.2.6.5.5 Second(date); Minute(date); Hour(date).........................................................................52I.2.6.5.6 Now....................................................................................................................................52I.2.6.5.7 Date....................................................................................................................................52I.2.6.5.8 Timp...................................................................................................................................52I.2.6.5.9 DateSerial(year, month, day)...........................................................................................52

I.2.6.6 Funcţii: structuri de control..................................................................................................53I.2.6.6.1 IIf(condiţie, TruePart, FalsePart).....................................................................................53

Observaţia 1. TruePart sau FalsePart, pot la rândul lor să conţină o altă funcţie, deci şi IIF, ceea ce permite realizarea unor structuri complexe de teste. 53

I.2.6.6.2 Choose(index, caz-1[, caz-2, ... [, caz-n]])......................................................................53I.2.6.6.3 Switch(expr-1, value-1[, expr-2, value-2 … [, expr-n,value-n]])..................................54

I.2.6.7 Funcţii de inspecţie................................................................................................................54I.2.6.7.1 VarType(NumeVariabilă).................................................................................................54I.2.6.7.2 IsNull(expresie).................................................................................................................55

Observaţia 1. Valoarea Null, îndică faptul că un Variant nu conţine date valide. Mai există încă două valori Empty şi String vid(gol) care pot fi uşor confundate cu Null, ceea ce constituie o eroare. Deci vom avea:.........................56

I.2.6.7.3 IsEmpty(NumeVariabila).................................................................................................56I.2.6.7.4 IsMissing(NumeParametru)..............................................................................................56

Observaţia 1. Funcţia IsMissing, se aplică numai dacă parametrul opţional este de tip variant. Dacă parametrul opţional nu este de tip variant ea va întoarce întotdeauna(fie că parametrul opţional este sau nu este folosit la apelarea funcţiei) valoarea FALSE. ...........................................................................57

I.2.6.8 Funcţiile agregate SQL..........................................................................................................57I.2.6.9 Funcţiile agregate de domeniu.............................................................................................57I.2.6.10 Funcţii de conversie.............................................................................................................58


I.2.6.10.1 Str(Număr).......................................................................................................................58

Observaţia 1. După conversie, la începutul stringului va fi un spaţiu pentru numerele pozitive / sau semnul (-) pentru numerele negative..............................59

Observaţia 2. Punctul zecimal va fi reprezentat întotdeauna de semnul punct(.), indiferent de cum este setat acesta în Windows(ca punct sau ca virgulă). 59

I.2.6.10.2 Val(string)........................................................................................................................59I.2.7 Mediul de depanare şi dezvoltare VBA..............................................................................60

C a p I . Programarea în V isua l Bas ic for Appl ica t ion (VBA) .

Basic, este unul din cele mai vechi limbaje de programare. El a fost creat în idea de a se realiza un limbaj de programare necesar unui specialist dintr-un anumit domeniu, care nu are cunoştinţe aprofundate despre sistemele de calcul.

Basic a fost implementat iniţial, în sistemele de operare, ca un interpretor, adică ca un sistem care în momentul în care preia o instrucţiune sursă Basic, o transformă imediat în instrucţiuni obiect(cod maşină) şi le execută. Pentru a îl face cât mai accesibil, au existat variante de Basic care au implementat şi comenzi specifice unui sistem de operare, ajungându-se până a se realiza calculatoare dedicate pentru lucrul sub Basic, fără sisteme de operare.

Evident, fiind conceput pe aceste principii, aplicaţiile realizate nu erau performante, ele ne utilizând eficient facilităţile unui sistem de calcul.

Treptat, s-a trecut la realizare unor implementări, tehnic mai performante, prin realizarea de compilatoare pentru Basic sub diferite sisteme de operare, adică a unor module care transformă un fişier cu instrucţiuni sursă Basic într-un fişier care conţine instrucţiuni direct executabile, în cod obiect.

Firma Microsoft, a realizat o versiune de Basic, numită Visual Basic, care pe lângă principiile iniţiale s-a dorit a rezolva următoarea problemă:

• Un limbaj de programare universal, unic, care să poată fi folosit atât în aplicaţiile de sistem(în locul limbajului C) cât şi în cele utilizator, performant atât din punct de vedere a limbajului(implementând conceptele de programare modulară, programare structurată şi programare la nivel de obiect) cât şi din punct de vedere al utilizării tuturor facilităţilor sistemului de operare.

Astfel s-au creat, pe baza aceluiaşi nucleu de programare Basic, trei sisteme:

Microsoft Visual Basic, ca limbaj universal de programare;

Visual Basic for Application(Visual Basic pentru aplicaţii), prescurtat uzual VBA, ca un limbaj complex pentru dezvoltarea aplicaţiilor în cadrul programelor din Microsoft Office. Aceasta înseamnă că nucleul limbajului, componentele sale şi mediul sunt aceleaşi în Access, Word sau Excel. VBA este aproape identic cu limbajul universal de programare Microsoft Visual Basic;

Visual Basic Script(VB Script), utilizat în special pentru aplicaţiile Internet;

I . 1 Domeniul de fo los ire a l VBA

Aplicaţiile mai simple din Access pot fi scrise fără a fi nevoie de vre-o instrucţiune, eventual folosind comenzile macro. Deşi comenzile macro sunt foarte bune pentru rezolvarea rapidă a unor prelucrări necesare pentru dezvoltarea majorităţii aplicaţiilor de bază, realizarea unor aplicaţii complexe, profesioniste în Access se face folosind limbajul VBA. Acest lucru se datorează faptului că, spre deosebire de comenzile macro, Visual Basic for Application oferă posibilităţi de lucru specifice limbajelor de nivel înalt de programare orientată pe obiecte. Câteva dintre aceste posibilităţi sunt:

• Tratarea erorilor prin proceduri speciale create de proiectant. În timpul execuţiei unei aplicaţii pot interveni diverse erori(de exemplu o împărţire la zero sau ieşirea din domeniul de definiţie al unei variabile, etc.) pe care sistemul le tratează în general prin stoparea modulului unde apar sau chiar a întregii aplicaţii. VBA oferă posibilitatea ca la apariţia unei erori, controlul să fie dat unui modul de cod


VBA, realizat de proiectant care să rezolve în funcţie de context situaţia apărută, fără a mai fi necesară stoparea modulului respectiv sau a aplicaţiei.

• crearea unor structuri ciclice pentru parcurgerea seturilor de înregistrări . Datele unei tabele sau cereri de selecţie se pot manipula ca pe un fişier specific, numit set de înregistrări.

• execuţia proceselor tranzacţionale. Acestea reprezintă practic posibilitatea de a efectua actualizările într-un set de înregistrări, global, la un anumit moment. În cazul apariţiei unei erori se pot anula toate actualizările din procesul respectiv, setul de înregistrări rămânând ne modificat.

• apelarea funcţiilor Windows API, prin care se pot folosi module ale sistemului de operare.

• crearea şi manipularea prin program a obiectelor necesare aplicaţiei

• utilizarea constantelor şi a variabilelor

• crearea de clase de obiecte

De asemenea VBA uşurează scrierea bibliotecilor de funcţii reutilizabile, precum şi proiectarea şi depanarea proceselor complexe de către programatori. În concluzie, deşi comenzile macro pot da soluţii rapide problemelor simple, limitările lor determină necesitatea folosirii limbajului VBA pentru dezvoltarea soluţiilor mai complexe.

I . 1 . 1 Mod u le l e d e cod în A cces s

Codul VBA este scris în unităţi numite rutine, care pot fi subrutine(proceduri) sau funcţii. Aceste subrutine şi funcţii sunt păstrate în obiecte numite module de cod, şi anume:

Module specifice unui anumit formular sau raport . Modulele specifice unui formular sau raport sunt în general numite coduri din spatele formularelor (Code Behind Forms – CBF). Rutinele din acest loc pot fi vizibile(cunoscute, apelabile) doar din modulul respectiv de cod. Codul din spatele formularului sau raportului se poate accesa prin acţionarea pictogramei specifice codului VBA (după selecţia obiectului respectiv) sau prin apăsarea celor trei puncte (…) din dreptul unui eveniment al paginii respective a unui obiect aparţinând formularului sau raportului respectiv *.

Notă: * Dacă procedura eveniment nu este creată, atunci automat un Wizard, va crea structura acesteia, adică instrucţiunile de declarare şi sfârşit precum şi completarea listei de parametrii dacă este cazul. Dacă procedura eveniment a fost creată anterior, atunci se va afişa porţiunea din pagina de cod a formularului sau raportului care conţine respectiva procedură.

Modulele globale , se pot afişa prin acţionarea paginii Module, din fereastra Database. Foarte important este faptul că rutinele scrise în această zonă pot fi vizibile (dacă sunt declarate Public) nu numai din toate modulele de cod ale aplicaţiei, dar chiar din obiecte ale aplicaţiei, din formulare, rapoarte, cereri sau tabele.

Exemplu. De exemplu dacă în modulul global se găseşte o funcţie declarată public, cu numele 'Prag', aceasta va putea fi folosită în expresii din orice:

modul general sau din spatele unui formular sau raport;

controale calculate din formulare sau rapoarte;

proprietăţi ale controalelor sau ale tabelelor(de exemplu Validation Rule, Default Value);

criterii din cereri;

câmpuri calculate din cereri;

practic de oriunde este acceptată o expresie.

Orice modul de cod, este format din două părţi:

• În prima parte se introduc declaraţiile generale ale modulului, valabile în întreg modulul. Acestea sunt:

Opţiunile modulului. De exemplu: Option Explicit, care forţează declararea tuturor variabilelor folosite în modul.


Declararea tipurilor, variabilelor şi constantelor, vizibile în tot modulul de cod.

• În a doua parte se introduc rutinele modulului de cod.

O subrutină(procedură) este o rutină care execută o acţiune:

la apariţia unui eveniment al unui obiect al aplicaţiei ori

la apelarea(lansarea) ei dintr-o altă rutină VBA.

O funcţie este un tip special de rutină, datorită faptului că poate întoarce o valoare, chiar în numele ei.

Deci codul VBA poate fi găsit în rapoarte, formulare şi module de cod. În formulare şi rapoarte, codul VBA poate fi plasat în funcţiile definite de utilizator, în subrutine, ca şi în procedurile eveniment, pe când în modulele generale codul VBA este plasat numai în rutine(funcţii sau proceduri) definite de utilizatori.

De fapt, pentru a construi cu succes rutine în cod VBA, sunt foarte importante două lucruri:

• cum se stabileşte domeniul de valabilitate al variabilelor şi rutinelor

• cum se transmit şi se întorc valorile din rutine.

Toate aceste componente vor fi analizate în cadrul prezentului capitol.

În concluzie, putem spune că programarea în VBA nu este procedurală, adică nu avem de a face cu un program clasic, cu început şi sfârşit, care rezolvă paşii unui algoritm. Codul VBA este practic format din rutine, care sunt executate numai atunci când se produc anumite evenimente. Deci codul VBA implică realizarea unui programări discontinue.

I . 2 Elementele generale a le l imbajului Visual Basic

Definirea unui limbaj de programare, se face în general prin configurarea următoarelor elemente de bază:

♦ Tipuri de date,

♦ Variabile;

♦ Constante;

♦ Instrucţiuni

Instrucţiunea de atribuire;

Structuri de control;

♦ Rutine(proceduri şi funcţii)

♦ Biblioteci;

Dacă limbajul de programare este orientat la nivel de obiect, aşa cum este Visual Basic sau VBA, atunci trebuiesc definite şi elemente referitoare la:

♦ Referirea obiectelor;

♦ Crearea claselor de module de obiecte;

♦ Crearea şi manipularea obiectelor (instanţe ale claselor de obiecte);

♦ Crearea şi manipularea colecţiilor de obiecte

Limbajele de programare dezvoltate mai pun la dispoziţie programatorilor:

♦ Proceduri specifice de tratare ale erorilor;

♦ Modalităţi de verificare şi depanare a erorilor de programare;

♦ Proceduri de import/export de obiecte exterioare aplicaţiei;

♦ Interacţiunea cu sistemul de operare.

♦ Manipularea datelor organizate în fişiere sau baze de date.


I . 2 . 1 T ip u r i d e d a te .

Prin dată se înţelege orice entitate asupra căreia poate opera calculatorul. În cod maşină datele se reprezintă sub forma unei secvenţe de cifre binare. În cazul limbajelor de nivel înalt se face abstracţie de detaliile de reprezentare a datelor, dezvoltând conceptul de tip de date. În memoria calculatorului orice dată apare ca o succesiune de biţi. Modul în care pentru o astfel de succesiune se asociază o valoare depinde de interpretarea ce i se dă. La nivelul limbajelor de programare o astfel de interpretare este reprezentată de tipul datelor.

Un tip de date este noţiunea folosită pentru a defini mulţimea valorilor pe care le pot avea datele ce aparţin acestui tip, dimensiunea efectiva pe care o ocupă în memorie datele, precum şi operaţiile ce se pot efectua asupra acestor date.

Orice limbaj de programare pune la dispoziţia programatorului câteva tipuri de date predefinite (standard), cum ar fi tipurile pentru datele întregi, reale, caracter sau booleene(logice). Acestea sunt tipuri simple de date care se referă la valori elementare.

Limbajul VBA oferă mai multe tipuri simple de date predefinite, cele mai folosite fiind prezentate în continuare:

I . 2 . 1 . 1 D a te nu mer i ce în t r eg i

Numele tipului de date

Spaţiul de memorare

Domeniul de valori

Numărul de valori

Valoarea iniţială

Ex. de nume 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 (întreg lung)

4 octeţi- 2,147,283,648 …. 2,147,483,647

2^32 0 lAmount

Currency (valută)

8 octeţi+/- 922,337,203,685,477.5808

15 cifre şi 4 zecimale

0 cValuta

------------------

I . 2 . 1 . 2 D a te nu mer i ce r ea l e

♦ Datele numerice reale se exprimă sub forma: +/-M * 10^+/-ENumele

tipului de dateSpaţiul de memorare

Domeniu Mantisa(M)

Domeniu Exponent(E)

Valoarea iniţială


Single (precizie simplă)

4 octetAproximativ

7 cifre zecimaleE-45…E38 0 sngValue

Double(precizie dublă)

8 octeţiAproximativ

14 cifre zecimaleE-324…E308 0 dValue

------------------

I . 2 . 1 . 3 T ipu l de da t e B OO LE A N - l og i c



Domeniu De valori

Valoarea iniţială


Boolean (logic)

2 octet True(-1); False(0) False(0) bRaspuns

------------------

I . 2 . 1 . 4 T ipu l de da t e S TR IN G - ş i r de car ac t e r e

Există două tipuri de date de tip String şi anume:

• String de lungime variabilă, care poate conţine până la aproximativ 2 milioane caractere (2^31).

• String de lungime fixă, care poate conţine până la aproximativ 64,000 caractere (2^16).


Codul folosit este codul ANSI şi are date în intervalul 0-255,

Primele 128 caractere (0–127) corespund literelor şi simbolurilor de pe o tastatură US, adică codului ASCII.

Dintre acestea primele 32 sunt caractere netipăribile, dar care pot avea efect în afişarea datelor. De exemplu:

caracterul cu codul 13, CR - retur de car, care produce trecerea la început de rând

caracterul cu codul 10, LF - rând nou, care produce trecerea rândul următor

caracterul cu codul 7, Bell - semnal sonor

caracterul cu codul 8, Back Space - înapoi

caracterul cu codul 9, Tab - salt la următorul marcaj

Codul ASCII

0 · 16 · 32 [space] 48 0 64 @ 80 P 96 ` 112 p

1 · 17 · 33 ! 49 1 65 A 81 Q 97 a 113 q

2 · 18 · 34 " 50 2 66 B 82 R 98 b 114 r

3 · 19 · 35 # 51 3 67 C 83 S 99 c 115 s

4 · 20 · 36 $ 52 4 68 D 84 T 100 d 116 t

5 · 21 · 37 % 53 5 69 E 85 U 101 e 117 u

6 · 22 · 38 & 54 6 70 F 86 V 102 f 118 v

7 Bell 23 · 39 ' 55 7 71 G 87 W 103 g 119 w

8 BS 24 · 40 ( 56 8 72 H 88 X 104 h 120 x

9 Tab 25 · 41 ) 57 9 73 I 89 Y 105 i 121 y

10 LF 26 · 42 * 58 : 74 J 90 Z 106 j 122 z

11 · 27 · 43 + 59 ; 75 K 91 [ 107 k 123 {

12 · 28 · 44 , 60 < 76 L 92 \ 108 l 124 |

13 CR 29 · 45 - 61 = 77 M 93 ] 109 m 125 }

14 · 30 · 46 . 62 > 78 N 94 ^ 110 n 126 ~

15 · 31 · 47 / 63 ? 79 O 95 _ 111 o 127 ·

------------------

Următoarele 128 caractere (128–255) corespund caracterelor speciale, diacriticelor, accente, simboluri valutare, litere în alfabete internaţionale etc.

Literalii string se scriu între ghilimele("…."). La iniţializare variabilele de tip string, vor avea valoarea şir vid, adică "".

Operatorul pentru concatenarea datelor este & (se poate folosi şi semnul + )- La formarea numelor variabilelor de tip string, se foloseşte de obicei prefixul s. De exemplu

sNume.

Notă: Deşi ne-am aştepta ca un caracter să ocupe un octet(8 bits) de memorie(fiind 256=2^8 caractere în codul ANSI), totuşi spaţiul ocupat de un caracter în memorie este de 2 octeţi. Aceasta se datorează faptului că în memorie caracterele sunt în codul UNICODE, cod care are 2^16 caractere. De exemplu în memorie caracterele ASCII, vor avea pe primul octet codul ASCII al caracterului iar în al doilea 0, iar caracterele ANSI cu cod mai mare de 127, vor avea în al doilea octet 1. Deci, în limbajul Visual Basic, caracterele se folosesc în codul ANSII(ASCII), deşi în memorie ele sunt în codul UNICODE.

------------------


I . 2 . 1 . 5 T ipu l de da t e D A TE - da ta ca l en dar i s t i că ş i t impu l



Domeniu de valori


Date (data + timpul)

8 octetData: 1/1/100 la 12/31/9999Timp: 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 Windows.

Notă: Un număr poate fi convertit în tip Date, partea din stânga punctului zecimal reprezentând data, iar cea din stânga timpul. Ora 24 este 0.0, ora 12 este 0.5, numerele negative reprezintă date anterioare celei de 30/Decembrie/1899.

La formarea numelor variabilelor de tip string, se foloseşte de obicei prefixul dt. De exemplu dtStop.

------------------

Visual Basic include mecanismele necesare construirii unor tipuri noi, prin restrângeri sau combinări ale tipurilor deja definite.

Aceste mecanisme poartă numele de constructori de tipuri şi joacă un rol esenţial în programare.

I . 2 . 1 . 6 T ipu l de da t e A R R A Y - t ab lou

Un Tablou - Array, defineşte o mulţime de valori care sunt de acelaşi tip de dată. Un Array, deşi reprezintă o singură variabilă poate stoca mai multe date de acelaşi tip în compartimentele(elementele) sale.

Structura unui asemenea tip poate avea o dimensiune sau mai multe.

Un Array, se caracterizează prin 3 elemente dintre care primele două definesc structura:

Numărul de dimensiuni.

Numărul de elemente(celule) al fiecărei dimensiuni. Practic numărul de ordine al primului(implicit 0) şi al ultimului element al fiecărei dimensiuni.

Tipul de date al elementelor tabloului. Poate fi orice tip de date, eventual chiar tot array.

Referirea la un tablou se poate face fie pentru întreaga structură(folosind numele tabloului), fie pentru fiecare element în parte(folosind numele tabloului indexat la elementul respectiv).

Exemplu. Pentru a stoca cheltuielile pe care le facem în fiecare zi al unui an vom declara bineînţeles o singură variabilă de tip Array, cu 365 elemente de tip numeric, decât 365 variabile individuale. Fiecare element din tablou va conţine o singură valoare. Implicit un tablou se indexează de la 0.

Declararea variabilei se va face:

Dim cCheltuieli(364) As Currency

Pentru a introduce în primele 100 de zile valoarea 22 vom folosi următoarea procedură:

Sub ExempluArray()

Dim cCheltuieli (364) As Currency

Dim intI As Integer

For intI = 0 to 99

cCheltuieli (intI) = 22

Next

End Sub

------------------


I . 2 . 1 . 7 TYPE - C r ear ea t i pu r i l o r de da t e de f in i t e de u t i l i z a to r .

Există posibilitatea ca să se creeze structuri noi de date, definite de proiectant, formate din combinări din alte tipuri de date.

------------------

[Public | Private] Type NumeTipNumeElement1 As typeNumeElement2 As type. . .

End Type------------------

Referirea la variabilele de un tip definit de utilizator, se poate face fie pentru întreaga structură (folosind numele variabilei), fie pentru fiecare element în parte(folosind numele elementul respectiv calificat -cu semnul punct - cu numele variabilei).

Notă: Declararea unui tip de date nu se poate face decât la nivelul unui modul de cod. Deci nu se pot declara tipuri de date la nivelul unei rutine.

Exemplu.

Option Compare Database

Option Explicit

Public Type Person 'se declară tipul de date la nivelul modulului

Nume As String

Prenume As String

Virsta As Integer

End Type

Sub TypeTest()

Dim Primul As Person, Doilea As Person 'se declară 2 variabile de tipul de date Person

Primul.Nume = "Ionescu" ' se folosesc elementele tipului de dată Person

Primul.Prenume = "Ion"

Primul.Virsta = 21

Doilea = Primul ' se referă întregul tip de dată Person

MsgBox Doilea.Nume & " " & Doilea.Prenume & ", varsta=" & Doilea.Virsta & " ani"

End Sub

------------------

I . 2 . 1 . 8 T ipu l de da t e V A RI A N T

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.




DomeniuValoarea iniţială


Variant (numere)

16 octetLa fel ca la tipul

numericEmpty (Gol)

vntValue

Variant(string)

22 octeţi La fel ca la tipul stringEmpty (Gol)

vntNume

------------------

I . 2 . 1 . 8 . 1 V a lor i l e E MPT Y , NU L L , S TR I N G V ID .

• EMPTY - reprezintă valoarea pe care o are o variabilă variant care nu a fost încă îniţializată. La prima introducere a unei date într-o variabilă de tip variant, aceasta se va configura în conformitate cu tipul respectiv de date.

• NULL - reprezintă o valoare pe care o ia o variabilă variant în care datele nu sunt valide.

• String de lungime 0 (vid, gol) - string care nu are nimic în el, adică este "".

------------------

I . 2 . 1 . 9 T ipu l de da t e OB JE C T

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

------------------

I . 2 . 2 Var iab i l e .

Variabilele sunt nume de locaţii de memorie care conţin valori de un anumit tip, ce se modifică în timpul execuţiei programului. Variabilele se caracterizează prin:

• Domeniul de valabilitate(vizibilitate) : se referă la momentul când acestea apar şi dispar din 'codul sursă'. Variabilele apar atunci când sunt declarate prima dată, după care apar şi dispar în funcţie de domeniu. În momentul când acestea apar, variabilele devin vizibile, li se pot atribui valori de un anumit tip şi pot fi folosite în cadrul instrucţiunilor. În rest, ele sunt invizibile.

• Durata de viaţă(valabilitate) : se referă la timpul cât variabila ocupă loc în memorie.

Când se creează variabile trebuiesc avute în vedere mai multe lucruri. Modul şi locul în care se declară o variabilă determină domeniul de valabilitate, durata de valabilitate şi alte caracteristici ale acesteia. Următoarele subiecte analizate vă vor să înţelegeţi mai bine declararea variabilelor în limbajul Visual Basic.

I . 2 . 2 . 1 Declararea variabi le lor

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.

Notă: Ne specificarea unui tip de date duce la crearea unor variabile de tip Variant.

• Se pot declara mai multe variabilele pe acelaşi rând, separate prin virgulă, dar este obligatorie folosirea explicită a tipului de dată pentru fiecare variabilă.

Exemplu. Dim intX As Integer, intY As Integer, intZ As Integer

O greşeală obişnuită este declararea mai multor variabile pe aceeaşi linie, fără a se specifica tipul pentru fiecare variabilă declarată ca în exemplul de mai jos


Dim iCounter, iAge, iWeight As Integer

În acest caz, numai ultima variabilă este declarată ca o variabilă de tip Integer (întreg). Celelalte variabile sunt declarate de tipul Variant.(tipul implicit al unei variabile este variant).

Această eroare este foarte periculoasă, deoarece unele limbaje de programare(PASCAL), folosesc o asemenea notare pentru a declara toate variabilele de pe aceiaşi linie de acelaşi tip.

I . 2 . 2 . 2 C ar ac t e r e fo lo s i t e ca Type - dec la r a t ion .

Anumite variabilele mai pot fi create automat de un anumit tip, folosindu-se în loc de specificaţia As, anumite caractere speciale, denumite caractere de tip, la sfârşitul numelui variabilei, în declaraţia Dim. Astfel:

Tipul de date Integer Long Currency Single Double String Variant

Caracterele de tip % & @ ! # $ implicitAcest tip de declaraţii este importat din variantele mai vechi de Basic, dar nu este recomandabil.

Exemplu. Următoarele declaraţii sunt echivalente.

Dim Nume As String - Dim Nume$

Dim Virsta As Integer - Dim Virsta%

Dim Anul As Variant - Dim Anul

------------------

I . 2 . 2 . 3 O p t ion E xp l i c i t ( Op ţ iu n e de exp l i c i t a r e )

Este o instrucţiune declarativă care poate fi inclusă în secţiunea General Declarations a unui modul, formular sau raport. Când Option Explicit este plasat într-un modul de cod, toate variabilele din interiorul obiectului respectiv (modul, formular sau raport) trebuie să fie declarate înainte de folosire, altfel producându-se o eroare de compilare.

Introducerea instrucţiunii Option Explicit în fiecare modul, formular sau raport, se poate face automat Acest lucru se face prin activarea opţiunii Require Variable Declarations (cere declaraţii de variabile) din meniul Tools | Options | Module. Este foarte important ca această comandă (Option Explicit) să fie plasată în toate modulele de cod. Asiguraţi-vă că aţi configurat opţiunea la valoarea True !

Dacă proprietatea specificată mai sus nu este setată(False), atunci practic se poate să nu se declare deloc variabilele. Declararea acestora se face implicit, funcţie de datele cu care se încarcă la prima folosire variabila(ca în limbajul FORTRAN).

De exemplu, instrucţiunea: x=10, ar genera şi declararea unei variabile de tip întreg.

Folosirea acestei metode este foarte periculoasă, deoarece poate cauza multe probleme.

În concluzie, cea mai eficientă şi mai lipsită de erori metodă de declarare a variabilelor este de a folosi în totalitate instrucţiunea declarativă Dim, pentru fiecare declarare de variabilă, ca în exemplul următor:

Dim iCounter As Integer

Dim sName As string

Aşa cum se vede, acest tip de declaraţie conţine atât numele variabilei, cât şi tipul datelor pe care le poate conţine. Acest lucru permite compilatorului să intercepteze erori de genul memorării unui şir într-o variabilă de tip întreg. La o implementare corespunzătoare, prin selectarea celui mai scurt tip de date folosit pentru fiecare variabilă, se pot reduce resursele necesare executării programului.

I . 2 . 2 . 4 V ar iab i l e Loca le ş i G loba le .

• Funcţie de locul de declarare, variabilele pot fi:

Locale - variabile declarate în interiorul rutinei, vizibile(domeniul de valabilitate) numai în interiorul acesteia.


Globale(nivel modul) - variabile declarate în secţia de declaraţii generale de la începutul unui modul de cod. În acest caz variabila va fi vizibilă în interiorul tuturor rutinelor din modulul respectiv de cod.

Exemplu. Fie declararea variabilei:

Dim sName As String

Dacă această declaraţie se face într-o rutină, atunci ea va putea fi folosită numai în aceasta. Dacă declararea ei se face în secţiunea de declaraţii generale ale modulului de cod, atunci ea se va putea folosi în toate rutinele modulului, dar nu şi în alte module de cod. Această caracteristică o au numai variabilele declarate Public.

Exemplu. Variabilele de nivel global(modul) sunt declarate prin plasarea unei comenzi Dim în secţiunea General Declarations a formularului, raportului sau modulului de cod, ca mai jos:

[ General Declarations]

Option Explicit

Dim miCounter As Integer

------------------

Variabilele de nivel modul pot fi vizualizate din orice rutină aparţinând modulului în care au fost declarate..

Valoarea variabilei poate fi schimbată de orice subrutină sau funcţie din modulul respective. De exemplu, următoarea subrutină schimbă valoarea variabilei de nivel modul miCounter la 20. Reţineţi convenţia de numire a variabilei prin folosirea literei m ca prefix al numelui acesteia. Aceasta o face să fie recunoscută ca o variabilă de nivel modul. Ar trebui să folosiţi declaraţii de nivel modul numai pentru variabilele care trebuie să fie văzute de mai multe rutine. Ar trebui să încercaţi să declaraţi majoritatea variabilelor dumneavoastră de tip local. Această metodă face codul dumneavoastră mai modular şi mai uşor de depanat.

Private Sub cmdModule_Click()

miCounter = 20

MsgBox miCounter

End Sub

------------------

I . 2 . 2 . 5 V ar iab i l e Pu b l i ce ş i Pr i va t e .

O variabilă publică poate fi accesată (este vizibilă, are domeniul de valabilitate) de oriunde din aplicaţie. Variabilele publice se folosesc de obicei pentru identificatori de acces, valori de configurare pentru mediul de lucru şi alte variabile care trebuie să fie vizibile pentru întreaga aplicaţie. Declaraţiile variabilelor publice trebuie să fie plasate în secţiunea General Declarations a modulului general de cod .

Pentru declararea variabilelor publice se foloseşte cuvântul cheie PUBLIC, în loc de DIM.

Exemplu. O declaraţie de variabilă publică arată aşa:

Option Explicit

Public piCounter As Integer

Reţineţi folosirea prefixului p, cu care convenţional se poate indica tipul public al variabilei. Secvenţa de cod următoare, plasată în evenimentul Click al butonului de comandă cmdPublic schimbă valoarea variabilei publice piCounter la 50, şi o afişează.

Private Sub cmdPublic_Click ()

piCounter = 50

Msgbox piCounter

End Sub

------------------


Se poate folosi cuvântul cheie PRIVATE, în loc de DIM, pentru a declara variabile private în secţiunea de declaraţii generale a modulul de cod, adică variabile care nu sunt vizibile, decât de rutinele aparţinând modulului respectiv de cod.

Exemplu. Private MyName As String

Notă: Cuvântul cheie DIM, este echivalent cu PRIVATE, atunci când se folosesc la declararea variabilelor în modulele de cod. Este totuşi indicată folosirea expresiei private, pentru a face codul mai lizibil.(mai uşor de citit şi mai rapid de interpretat)

------------------

I . 2 . 2 . 6 V ar iab i la S ta t i c e

Se poate folosi cuvântul cheie STATIC, în loc de cuvântul cheie DIM, pentru a declara variabile statice în rutine, adică variabile care au proprietatea de aşi reţine valoarea între două chemări ale respectivei rutine,

Exemplul următor ilustrează diferenţa dintre variabilele locale şi cele statice. Variabilele locale sunt iniţializate la fiecare apel al codului. De fiecare dată când lansaţi în execuţie această procedură, se va afişa numărul 1.

Private Sub cmdLocal_Click ()


iCounter = iCounter + 1

MsgBox iCounter

End Sub

De fiecare dată când acest cod este executat, instrucţiunea declarativă Dim reiniţializează variabila iCounter. Este puţin diferită faţă de următoarea secvenţă de cod, care ilustrează folosirea variabilelor statice:

Private Sub cmdLocal_Click ()

Static iCounter As Integer

iCounter = iCounter + 1

MsgBox iCounter

End Sub

De fiecare dată când acest cod este executat, variabila cu numele iCounter este incrementată şi reţinută.

------------------

I . 2 . 2 . 7 D omen iu l ş i du r a ta de va lab i l i t a t e a va r iab i l e lo r

Aşa cum am arătat, domeniul de valabilitate sau vizibilitatea variabilelor, este determinată de cuvântul utilizat în declararea variabilei: Dim, Private, Public şi de locul unde acesta e plasat, determinând ca variabila respectivă să fie locală, modulară(globală) sau publică şi să poată fi folosită numai într-o rutină, la nivelul unui modul de cod, sau în toate modulele de cod.

Ar trebui să faceţi tot posibilul ca majoritatea variabilelor din codul dumneavoastră să fie locale, deoarece acestea sunt ferite de o eventuală modificare (accidentală) de către alte rutine.

Durata de viaţă(valabilitate) a variabilelor, reprezintă, aşa cum am mai arătat, timpul cât variabila are alocat spaţiu în memorie. Fără alte instrucţiuni speciale, o variabilă se creează în momentul în care modulul în care este declarată, este apelat, şi dispare în momentul terminării modulului respectiv.

Astfel, o variabilă locală declarată într-o procedură eveniment, va fi alocată numai în timpul execuţiei procedurii respective (bineînţeles dacă nu este statică).

O variabilă globală declarată într-un modul de cod al unui formular, va fi alocată cât timp formularul respectiv va fi în execuţie.

O variabilă publică declarată într-un modul general de cod al va fi alocată în tot timpul execuţiei aplicaţiei.


I . 2 . 2 . 8 D ec la r ar ea ş i f o lo s i r ea var iab i l e lo r A R R A Y - TA B LO U .

Tablourile se declară la fel ca orice altă variabilă folosindu-se instrucţiunile declarative Dim, Static, Private, sau Public. Diferenţa faţă de declararea unei variabile simple, este aceea că la tablouri, între paranteze, trebuie să se specifice pentru fiecare dimensiune - în ordine şi separate prin virgulă dacă sunt mai multe dimensiuni - valoarea minimă şi maximă a indicelui dimensiunii respective.

I . 2 . 2 . 8 . 1 D ec lararea tab lou r i lor cu d imens iu n i f i xe - s ta t i ce .

Dim NumeTablou(N1 [, N2 [, N3….]) As TipDe DatăAşa cum se observă marginea de jos a indicelui a fost omisă. Ea se consideră a avea valoarea 0.

Totuşi poate fi luată şi 1, numai dacă este introdusă în modulul respectiv de cod, instrucţiunea declarativă Option Base 1.

Exemplu. Declaraţia Dim MyArray(9, 10) As Integer va crea un tabel cu 2 dimensiuni cu 10 pe 11 elemente, cu primul indice cu valori între (0 - 9) şi al doilea indice cu valori între (0 - 10), în care toate cele 110 elemente(celule) sunt de tip Integer.

Observaţia 1. Ca orice declaraţie care nu specifică tipul şi tablourile declarate fără tip sunt de tip Variant. În acest caz fiind Variant, fiecare element va ocupa 16 bytes, dacă este numeric sau 22 bytes, dacă este string. Deci la tablouri mari se poate ajunge la un consum mare de memorie, ceea ce determină o rezervă în folosirea tablourilor de Variant.

Exemplu. În continuare se prezintă ce memorie vor ocupa tablourile.

Tablou Variant - cel puţin 176 bytes(11 el. * 16 bytes).

Dim MyIntegerArray(10) As Integer ' Tablou Integer foloseşte 22 bytes (11 elemenste * 2 bytes).

ReDim MyDoubleArray(10) As Double ' Tablou Double-precision .. 88 bytes(11 el. * 8 bytes).

ReDim MyVariantArray(10) ' Tablou Variant .. cel puţin 176 bytes(11 el. * 16 bytes).

ReDim MyIntegerArray (99, 99) As Integer ' Tablou Integer foloseşte 100 * 100 * 2 bytes (20,000 bytes).

ReDim MyDoubleArray (99, 99) As Double ' Tablou Double-precision .. 100 * 100 * 8 bytes (80,000 bytes).

ReDim MyVariantArray(99, 99) ' Tablou Variant .. cel puţin 160,000 bytes (100 * 100 * 16 bytes).

------------------

Se pot declara tablouri specificându-se explicit şi marginea de jos a indicelui.

Dim NumeTablou(J1 To N1 [, J2 To N2 [, J3 To N3….]) As TipDe Dată• Cu J s-a notat marginea de jos a indicelui, iar cu N marginea de sus a indicelui

I . 2 . 2 . 8 . 2 D ec lararea tab lou r i lor cu d imens iu n i var iab i l e - d in amice .

În timp ce tablourile cu dimensiuni fixe vor ocupa din etapa de compilare, o anumită dimensiune de memorie care nu mai poate fi modificată în timpul execuţiei, tablourile dinamice pot să-şi modifice dimensiunile în timpul execuţiei.

Un tablou dinamic se declară la fel, cu Static, Dim, Private sau Public, fără a se specifica însă nimic între paranteze.

Dim NumeTablou() As TipDe Dată

Exemplu. Dim sngArray() As Single


Notă: Cu instrucţiunea executabilă ReDim (cu o structură asemănătoare cu cea a lui Dim), care se poate plasa oriunde în cod după declararea unui tablou dinamic, se va redimensiona în momentul execuţiei acesteia tabloul cu noile dimensiuni, eventual putându-se schimba şi tipul de date.

Exemplu. ReDim sngArray(11) va redimensiona tabloul, însă nu modifică tipul de date al elementelor şi provoacă pierderea datelor din tablou.

Notă: Folosirea lui ReDim, va provoca pierderea datelor din tabloul pe care îl redimensionăm. Pentru a se evita acest lucru se poate folosi clauza Preserve. Folosirea acestei clauze nu permite modificarea numărului de dimensiuni sau a marginii de jos ai indecşilor.

Exemplu. ReDim Preserve sngArray (UBound(sngArray) + 10) - va redimensiona tabloul, mărind cu 10 numărul lui de elemente şi va păstra datele ce erau în tablou înainte de executarea instrucţiunii.

I . 2 . 2 . 8 . 3 U t i l i zarea tab lou r i lor

Un tablou poate fi utilizat ca pe orice variabilă simplă de tipul respectiv. Referirea unui element al tabloului se face prin numele tabloului, urmat între paranteze de indicele(indicii) elementului respectiv.

Exemplu.

Sub FillArrayMulti()

Dim intI As Integer, intJ As Integer

Dim sngMulti(1 To 5, 1 To 10) As Single

For intI = 1 To 5

For intJ = 1 To 10

sngMulti(intI, intJ) = intI * intJ ' indroduce în fiecre element produsul indicilor elementului.

' afişează indicii elementului şi valoarea din acesta.

MegBox " Tablou( " & intI & " , " & intJ & " ) = " & sngMulti(intI, intJ)Next intJ

Next intI

End Sub

I . 2 . 2 . 8 . 4 T ab lou r i d e oc t e ţ i

Un tablou de octeţi este un tablou dinamic de tipul BYTE .

El poate fi utilizate ca orice tablou dar mai are o proprietate care îl face util în lucrul cu stringuri, şi anume:

• Un tablou de octeţi se poate referi şi direct, numai prin numele lui, fără indici. În felul acesta în el se poate muta direct un string. Trebuie remarcat că în această operaţie fiecare caracter este codificat pe 2 octeţi în UNICODE, deci va ocupa 2 elemente din string.

Exemplu. Pentru înţelegerea acestei secvenţe trebuie studiat mai întâi, în capitolul despre funcţiile text, precizările făcute pentru codul UNICODE.

Public Sub TestMatOcteti()

Dim Caracter As String, Sir As String * 3

Dim X() As Byte ' Tablou de octeţi, va avea 6 elemente deoarece pentru

ReDim X(5) ' un caracter din string sunt necesare 2 elemente de 1 octet

Dim k As Integer, j As Integer, i As Integer

Sir = "1AŞ"

X = Sir

For i = 0 To 2


j = i + 1 ' In “J” se va calcula numărul caracterului in string ... 1, 2, 3 - necesar pt. MID

Caracter = Mid(Sir, j, 1) ' in "Caracter" se vor introduce caracterele

k = 2 * (i) ‘ În “K” – poziţia în tablou a caracterelor… 0, 2, 4

Debug.Print "Caracterul = " & Caracter & "; CodUnicode= " & AscW(Caracter) & _

"; CodAnsii= " & Asc(Caracter) & "; Octetul 1= " & X(k) & "; Octetul 2= " & X(k + 1)

' Ceea ce se afişează cu Debug.Print se poate vizualiza prin comanda View | Debug Window

MsgBox "Caracterul = " & Caracter & "; CodUnicode= " & AscW(Caracter) & _

"; CodAnsii= " & aSc(Caracter) & "; Octetul 1= " & X(k) & "; Octetul 2= " & X(k + 1)

Next I

For i = 0 To 5

Debug.Print "Octetul " & i & " = " & X(i)

MsgBox "Octetul " & i & " = " & X(i)

Next i

End Sub

‘--------------------

După execuţie se va găsi afişat în Debug.Print:

Caracterul = 1; CodUnicode= 49; CodAnsii= 49; Octetul 1= 49; Octetul 2= 0

Caracterul = A; CodUnicode= 65; CodAnsii= 65; Octetul 1= 65; Octetul 2= 0

Caracterul = Ş; CodUnicode= 350; CodAnsii= 170; Octetul 1= 94; Octetul 2= 1

Octetul 0 = 49

Octetul 1 = 0

Octetul 2 = 65

Octetul 3 = 0

Octetul 4 = 94

Octetul 5 = 1

------------------

Explicaţie. În memoria internă, dacă o variabilă nestructurată ocupă mai mulţi octeţi(de exemplu o variabilă integer ocupă 2 octeţi), atunci cel mai semnificativ dintre aceştia se găseşte la dreapta.

Deci dacă într-o variabilă integer se găseşte valoarea:

266(zecimal)=0000.0001.0000.1010(binar)=01.0A(hexazecimal) atunci aceasta se va găsi în memorie:

(0000.1010)(0000.0001) - deci cu octetul cel mai semnificativ(0000.0001) aşezat la dreapta.

Din tabelul de mai jos, se observă cum se găseşte în memoria internă, într-o variabilă de tip tablou de octeţi, datele dintr-un string.

Caracterele din string ‘1’ ‘A’ ‘Ş’Cod ANSI(1 octet/caracter) - zecimal 49 65 170Cod UNICODE(2 octeţi/caracter) -zecimal 49 65 350Memorie -Tabloul X (6 octeţi) - binar 0011.0001 0000.0000 0100.0001 0000.0000 0101.1110 0000.0001

Memorie -Tabloul X (6 octeţi) - hexa 31 00 41 00 5E 01Memorie -Tabloul X (6 octeţi) - zecimal 49 0 65 0 94 1


I . 2 . 3 Con s tan te

Prin declararea unei constante, se poate atribui unui nume, o valoare. Aceasta se face prin instrucţiunea declarativă Const . După declarare, o constantă nu îşi mai poate modifica valoarea. Forma acestei instrucţiuni este:

[Public | Private] Const NumeConstantă [As TipulDeDateAlVariabilei] = ValoareO constantă, se comportă practic ca o variabilă, iniţializată cu o anumită valoare, care nu se mai

poate schimba în timpul execuţiei aplicaţiei.

Regulile aplicate variabilelor privind domeniul şi durata de valabilitate, sunt efective şi în cazul constantelor. Deci vom avea:

♦ constante locale sau globale , funcţie de locul de declarare(în rutină sau secţiunea de declaraţii generale a modulului de cod).

♦ constante publice sau private , dacă folosim sau nu în faţa cuvântului cheie Const, cuvintele cheie Private, Public.

Exemplu. Constanta conAge, este o constantă publică, Integer, cu valoarea 34.

Public Const conAge As Integer = 34

------------------

Constantele se pot declara :

Cu tip explicit, şi anume: Boolean, Byte, Integer, Long, Currency, Single, Double, Date, String, sau Variant, ca în exemplul de mai sus sau;

Cu tip implicit, în care clauza As lipseşte iar tipul va fi determinat de tipul datei cu care se încarcă variabila. De exemplu dacă avem declaraţiile:

Const Ziua = "Miercuri"

Const Virsta = 44

atunci prima constantă va fi de tip string, iar a doua integer.

Ca şi la variabile se pot declara mai multe constante pe acelaşi rând, cu specificarea (dacă este explicită) a tipului pentru fiecare constantă în parte,

Const conAge As Integer = 34, conWage As Currency = 35000, conNume="Soare"

În exemplul de mai sus primele două constante sunt declarate explicit Integer respectiv Currency, iar a treia, implicit, string.

I . 2 . 4 In s t ru c ţ iu n i l e execu t ive a l e l imb aju lu i V i s u a l B as i c .

Limbajele de programare au un set de instrucţiuni care constituie lista completă a posibilităţilor de care dispune programatorul pentru a determina rezolvarea unei probleme(aplicaţie) pe un sistem de calcul.

Instrucţiunile unui limbaj de programare sunt de două feluri:

• Instrucţiuni declarative , care practic nu determină executarea unei acţiuni de către sistemul de calcul, ci numai nişte indicaţii care se dau compilatorului. De exemplu instrucţiunile de declarare ale tipurilor de date, variabilelor sau constantelor(Dim, Const, Type etc.), opţiunile de compilare(Option Explicit, Option Compare Database, etc.)

• Instrucţiuni executive , care reprezintă descrierea unei acţiuni pe care o va efectua sistemul de calcul, în special privind datele aplicaţiei(If, For, Do etc.).

Execuţia unei instrucţiuni reprezintă efectuarea operaţiei specificate de codul instrucţiunii, interpretate la un moment dat de unitatea centrală a unui sistem de calcul sau de un procesor. De obicei, execuţia instrucţiunii presupune obţinerea operanzilor din memoria internă sau din registrele unităţii centrale, formarea rezultatului şi depunerea acestuia într-un registru al unităţii centrale sau în memoria internă.

Ca exemplu de operaţii pe care le face unitatea centrală a sistemului de calcul sunt operaţiile de adunare, scădere, citire, scriere, comparaţie, etc.


Limbajele moderne de programare au un set redus de instrucţiuni complexe:

• Declararea structurilor de date.

• Instrucţiunea de atribuire - prin care se calculează expresii.

• Structurile de control - prin care se determină 'traseul' printre instrucţiuni, adică ordinea în care se execută instrucţiunile.

• Declararea şi apelarea rutinelor

• Crearea claselor de module de obiecte

• Crearea şi manipularea obiectelor

Practic, instrucţiunile executive ale limbajelor moderne de programare sunt instrucţiunea de atribuire şi instrucţiunile prin care se realizează structurile de control. Alte operaţii necesare unei aplicaţii(ca de exemplu executarea operaţiilor de Input / Output), sunt realizate prin rutine din bibliotecile de obiecte, funcţii şi proceduri disponibile limbajului respectiv de programare.

I . 2 . 4 . 1 I ns t r u c ţ iu n ea de a t r ibu i r e

Forma acestei instrucţiuni este:

NumeVariabilă = ExpresieAcţiunea acestei instrucţiuni constă în calcularea expresiei (din dreapta semnului =) şi depunerea

rezultatului în variabila (din dreapta semnului =).

Pentru a se executa cu succes instrucţiunea, este necesar ca rezultatul expresei să aparţină unui tip de date compatibil cu cel al variabilei. În caz contrar se va produce o eroare de execuţie(pe care le vom trata în alt modul).

Totuşi compilatorul încearcă trecerea peste anumite incompatibilităţi, a căror rezolvare este evidentă, efectuând automat conversiile între tipuri diferite de date, dacă este posibil.

Exemplu.

Private Sub TestExpresie()

Dim Vstr As String

Dim Vnr As Integer

Vstr = "251"

Vnr = 251 + 40 ' prelucrari normale

Vstr = 251 + 40 ' nu produce eroare de execuţie.Transforma constanta numerică 291 în stringul "291"

Vnr = Vstr ' nu produce o eroare de execuţie. Transforma stringul "291" în constanta numerică 291

Vstr = Vnr + "ABC" ' va produce eroare de execuţie- TYPE MISMATCH. Nu se poate efectua adunarea.

Vstr = Vnr & "ABC" ' nu produce eroare.

Vnr = "ABC" ' va produce eroare de execuţie- TYPE MISMATCH

End Sub

I . 2 . 4 . 1 . 1 Formarea exp res i i l or în V i su a l B as i c .

O expresie este formată din termeni, asupra cărora se efectuează anumite operaţii.

O expresie al cărei evaluare este o valoare logică(True sau False) se mai numeşte condiţie.

• Termenii pot fi : variabile, constante, literali(valori date direct) sau funcţii(proprii sau din biblioteci)

• Operatorii sunt de trei tipuri


♦ Operatorii aritmetici , care acţionând asupra unor termeni scalari(numere, stringuri, date calendaristice, etc.) vor determina tot un rezultat de aceiaşi natură(scalar).

^ * / \ Mod + - &Ridicare la putere

ÎnmulţireÎmpărţire

realăÎmpărţire întreagă

Restul împărţirii

AdunareScăder

eConcatenare

şiruri.5^2=25 5*2=10 5/2=2.5 10\3=3 10 Mod 3=1 5+2=7 5-2=3 "Ab" & 2="Ab2"

------------------

♦ Operatorii relaţionali , care acţionând asupra unor termeni scalari(numere, stringuri, date calendaristice, etc.) vor determina un rezultat logic(boolean)

< <= > >= = <>mai mic mai mic sau egal mai mare mai mare sau egal egal ne 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ţimecompară două stringuri, dar ţine cont de 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] ex. [A-R] Un singur caracter din listă. ("F" Like "[A-Z]") = True

[!Listă caractere] Un singur char care nu este în listă. (("F" Like "[!A-Z]") = False

------------------

♦ Operatorii logici , având valori logice(True , False) ca operanzi, vor determina un rezultat tot logic.

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 logică între două expresii

------------------

Notă: 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.


Op 1 Op 2 XORTrue True False

True False True

False True True

False False False

Op 1Op

2ANDTrueTrueTrueTrueFalseFalseFalseTrueFalseFalseFalseFa

lse

l

Op 1Op

2ORTrueTrueTrueTrueFalseTrueFalseTrueTrueFalseFalse

False

F

Op

O

NOTTrueFalse

F

FalseTrue

T

Observaţia 1. Aşa cum am mai arătat, dacă un termen al unei expresii este NULL , atunci şi rezultatul expresiei este tot NULL . Spunem că NULL-ul se propagă în expresii. Totuşi există o excepţie, şi anume la operatorul de concatenare a şirurilor, &: Dacă un termen este NULL, iar celălalt nu este NULL, atunci rezultatul va fi chiar termenul diferit de NULL.

Observaţia 2. Valoarea EMPTY, în expresii este considerată, funcţie de tipul de date pe care îl reprezintă, chiar valoarea cu care se iniţializează variabilele de tipul respectiv(astfel în expresii dacă un termen numeric este EMPTY atunci se va considera =0; dacă este logice =False; dacă este string = şir vid; etc.)

I . 2 . 4 . 2 S t r u c tu r i l e de con t r o l

Aşa cum am mai arătat, structurile de control stabilesc ordinea în care se execută instrucţiunile. Există trei structuri de control, şi anume: structura secvenţială, structura alternativă(decizională) şi structura repetitivă(în buclă, în ciclu)

I . 2 . 4 . 2 . 1 S t ru c tu ra s ecven ţ ia lă

Reprezintă execuţia secvenţială a instrucţiunilor, în ordinea în care au fost scrise.

------------------

I . 2 . 4 . 2 . 2 S t ru c tu ra a l t ern a t ivă

Reprezintă execuţia unui anumit grup de instrucţiuni sau a altuia, funcţie de evaluarea unor condiţii.

I . 2 . 4 . 2 . 2 . 1 S t ru c tu ra a l t ern a t ivă s imp lă . I ns t ru c ţ iu n ea : If . . .Then. . .Else

If condiţie Then Grup 1 de instrucţiuni

[ElseGrup 2 de instrucţiuni]

End IF ------------------

Structura If ... Then ... Else evaluează dacă condiţia este adevărată sau falsă.

• Dacă condiţia este adevărată, vor fi executate toate instrucţiunile dintre If şi Else (Grup 1 de instrucţiuni).

• Dacă condiţia este falsă, vor fi executate toate instrucţiunile dintre Else şi End If (Grup 2 de instrucţiuni).

Notă: Folosirea comenzii Else este opţională.

Notă: O condiţie cu rezultatul NULL este tratată ca şi cum ar fi FALSE

Exemplu.

Private Sub cmdIf_Click() ' evenimentul click al unui buton de comandă

If IsNull (Me!txtValue) Then ' Condiţia testează dacă în controlul txtValue, este introdusă o valoare.

' Acest lucru se face cu funcţia IsNULL, studiată în alt modul

MsgBox “Trebuie sa introduceti o valoare”

Else

MsgBox “Ati introdus:” & Me!txtValue

End If

End Sub

Notă: Un control, în care nu este introdus nimic va avea valoarea NULL


------------------

I . 2 . 4 . 2 . 2 . 2 S tru c tu ra a l t ern a t ivă mu l t ip lă . In s t ru c ţ iu n i l e : Selec t Case ş i If . . .Then. . . ElseIF… Else

În locul folosirii mai multe instrucţiuni If ... Then ... Else atunci când decizia se ia prin evaluarea mai multor condiţii(Structura alternativă multiplă) este mult mai simplu, fără îndoială, utilizarea instrucţiunii Select Case sau a instrucţiunii If ... Then ... ElseIF…Else

Instrucţiunea Select Case

Select Case NumeVariabilăCase Valoare1

Grup 1 de instrucţiuni[Case Valoare2

Grup 2 de instrucţiuni][Case ValoareX

Grup X de instrucţiuni]………………………[Case Else

Grup else de instrucţiuni]End Select

Această instrucţiune evaluează mai multe condiţii formate prin verificarea egalităţii între valoarea variabilei ataşate instrucţiunii (NumeVariabilă), şi valorile din dreptul cuvintelor cheie CASE (ValoareI). Deci:

Condiţia I va fi: NumeVariabilă= ValoareI

Dacă o condiţie este advărată atunci se va executa grupul corespunzător de instrucţiuni.

Dacă toate condiţiile sunt false atunci se vor executa - dacă există - instrucţiunile dintre Else …. End Select (Grup else de instrucţiuni)

Observaţia 1. Dacă mai multe condiţii sunt adevărate, atunci se vor executa toate grupurile corespunzătoare de instrucţiuni. Deci instrucţiunea Select Case nu se opreşte la întâlnirea primei condiţii adevărate, ci va evalua toate condiţiile.

Observaţia 2. În ValoareX se pot folosi reuniuni de mulţimi (operator virgula - ex: 1,2,5) intervale (operator TO - ex: 1 To 7), sau submulţimi(operator IS ex: Is > 7)

Exemplu.

Private Sub cmdCase_Click ()

Dim IResponse As Integer

if IsNull (Me!txtValue) Then

iResponse = 0

Else

IResponse = Val (Me!txtValue) 'Funcţia VAL transformă într-o valoare numerică un string.

End If

Select Case iResponse

Case 0

MsgBox "Trebuie sa introduceti un numar”

Case 1 To 5

MsgBox "Ati introdus o valoare intre 1 si 5”


Case 7, 11, 21

MsgBox "Ati introdus 7, 11 sau 21”

Case Else

MsgBox "Ati introdus un numar incorect”

End Select

End Sub

------------------

Această procedură utilizează în prima parte o instrucţiune If pentru a evalua dacă txtValue este nul. În acest caz, procedură memorează un zero într-o variabilă numită iResponse. În caz contrar, valoarea conţinută în txtValue este memorată în iResponse. Instrucţiunea Case evaluează conţinutul variabilei iResponse. Dacă valoarea este 0, este afişată o casetă de text cu mesajul „Trebuie să introduceţi un număr”. Dacă valoarea este între 1 şi 5 inclusiv, este afişată o casetă de text conţinând mesajul „Aţi introdus o valoare între 1 şi 5”. Dacă utilizatorul introduce 7, 11 sau 21, este afişat un mesaj corespunzător. În celelalte cazuri, utilizatorul primeşte un mesaj care indică introducerea unui număr incorect.

Instrucţiunea If . . . Then .. . ElseIF …Else

If condiţie-1 Then[grup 1 de instrucţiuni]

[ElseIf condiţie-n Then[grup n de instrucţiuni]

…………….…..[Else

[grup else de instrucţiuni]]End If

------------------

Instrucţiunea funcţionează similar instrucţiunii Select Case, numai că :

o dată găsită o condiţie adevărat, execuţia instrucţiunii este terminată

condiţiile introduse sunt independente, ne mai fiind obligatorie prezenţa ca un termen a unei anumite variabile.

Deci instrucţiunea va evalua pe rând, în ordine, condiţia 1, 2, etc.

• Prima condiţie găsită adevărată va determina execuţia grupului respectiv de instrucţiuni, şi terminarea instrucţiunii.

• Dacă toate condiţiile sunt false, vor fi executate toate instrucţiunile dintre Else şi End If (Grup else de instrucţiuni).

Notă: Folosirea comenzii Else este opţională.


------------------

I . 2 . 4 . 2 . 3 S t ru c tu ra rep e t i t i vă

Reprezintă execuţia repetată a unui anumit grup de instrucţiuni numit ciclu sau buclă până când o condiţie ia o anumită valoare.

I . 2 . 4 . 2 . 3 . 1 S tru c tu ra rep e t i t i vă cu t e s t . I ns t ru c ţ iu n ea DO

Execută în mod repetat un ciclu şi anume

• cât timp(While) o condiţie este TRUE sau


• până când(Until) o condiţie devine TRUE

Există două forme ale instrucţiunii Do:

------------------

Do [{While | Until} conditie] Do[grup instrucţiuni] [grup instrucţiuni][Exit Do] SAU [Exit Do][grup instrucţiuni] [grup instrucţiuni]

Loop Loop [{While | Until} conditie]------------------

Observaţia 1. Instrucţiunea Exit Do, provoacă ieşirea forţată din ciclu. De obicei se execută funcţie de evaluarea unei condiţii într-o instrucţiune IF.

Observaţia 2. Condiţia este evaluată funcţie de locul unde este plasată în instrucţiune şi anume:

la prima formă a instrucţiunii(cea din stânga) - înaintea executării ciclului sau

la a doua formă a instrucţiunii(cea din dreapta) - după executarea ciclului

Observaţia 3. Ciclul se execută minim de

la prima formă a instrucţiunii(cea din stânga) - se poate ca ciclul să nu se execute de loc

la a doua formă a instrucţiunii(cea din dreapta) - ciclul se va executa minim o dată.


Exemplu.

Private Sub cmdLoop1_Click()


iCounter = 1

Do While iCounter < 5

MsgBox iCounter

ICounter = iCounter + 1

Loop

End Sub

------------------

Procedura va afişa 4 mesaje, cu numere de la 1 la 4.

Această structură nu asigură întotdeauna executarea secvenţei de cod din interiorul buclei. Dacă iCounter este iniţializat cu o valoare mai mare sau egală cu 5, codul din interiorul buclei nu va fi executat niciodată. Dacă doriţi ca secvenţa de cod să fie executată necondiţionat cel puţin o dată, va trebui să folosiţi următoarea structură:

Exemplu.

Private Sub cmdLoop2_Click()


iCounter = 5

Do

MsgBox iCounter

ICounter = iCounter + 1

Loop While iCounter < 5

End Sub

------------------

Procedura va afişa 1 mesaj, cu numărul 1.


Acest cod va fi executat cel puţin o dată, chiar dacă iCounter are valoarea 5. Structura Do While ... Loop face evaluarea înainte de executarea codului şi de aceea nu asigură execuţia codului din interiorul buclei. Structura Do ... Loop While face evaluarea la sfârşitul buclei şi de aceea execuţia codului este asigurată.

------------------

I . 2 . 4 . 2 . 3 . 2 S tru c tu ra rep e t i t i vă cu con tor . In s t ru c ţ iu n ea FOR.. .NEXT

Repetă un ciclu de un anumit număr de ori.

Notă: Mai există o structură: FOR EACH...NEXT, care se aplică colecţiilor de obiecte sau tablourilor. Acesta permite parcurgerea automată a tuturor elementelor unei colecţii sau tablou. Se va prezenta ulterior în modulul referitor la programarea orientată pe obiecte.

For contor = start To end [Step pas][grup instrucţiuni][Exit For][grup instrucţiuni]

Next [contor]------------------

• contor - Variabilă numerică folosită pentru stabilirea numărului de execuţii ale ciclului.

• start - Valoarea iniţială a contorului

• end - Valoarea finală a contorului

• pas - Valoarea de incrementare a controlului după execuţia fiecărui ciclu (implicit este 1)

Explicaţie. Se începe prin executarea ciclului. După aceasta va avea loc adunarea pasului la contor. Acum se va evalua următoarea condiţie, funcţie de semnul(+/-) pe care îl are pasul şi anume

Dacă PAS >=0 , condiţia va fi: contor <= end Dacă PAS < 0 , condiţia va fi: contor >= end

Dacă condiţia este TRUE, atunci se va repeta ciclul, iar dacă condiţia este FALSE, se va termina instrucţiunea FOR, programul continuând cu instrucţiunile de după NEXT.

Deci, practic dacă pasul, este :

pozitiv, atunci contorul va parcurge la fiecare ciclu, crescător (prin adăugarea valorii pasului), toate valorile dintre start şi end (start < end) negativ, atunci contorul va parcurge la fiecare ciclu, descrescător (prin scăderea valorii absolute a pasului), toate valorile dintre start şi end (start > end)

Observaţia 1. Instrucţiunea Exit For, provoacă ieşirea forţată din ciclu şi continuarea programului cu instrucţiunile de după NEXT. De obicei se execută funcţie de evaluarea unei condiţii într-o instrucţiune IF.

Observaţia 2. Sunt admise imbricări ale structurilor For, dacă sunt folosite variabile contor diferite ca în exemplul următor:

For I = 1 To 10

For J = 1 To 10

For K = 1 To 10

...

Next K

Next J

Next I

------------------


Observaţia 3. Într-un For, trebuie evitată schimbarea valorii contorului.

Observaţia 4. Structura For ... Next este folosită atunci când sunt un număr exact de iteraţii de executat.

Exemplu.

Private Sub cmdForNext_Click()


For iCounter = 1 To 5

MsgBox iCounter

Next iCounter

End Sub

------------------

Procedura va afişa 5 mesaje, cu numere de la 1 la 5

Observaţi că iCounter se auto-incrementează. Atât valoarea de start, cât şi cea de sfârşit pot fi ambele variabile. Unei structuri For ... Next i se poate da, de asemenea, o valoare de incrementare (pas)

Exemplu.

Private Sub cmdForNext_Click()


For iCounter = 5 To 1 Step -1

MsgBox iCounter

Next iCounter

End Sub

Procedura va afişa 5 mesaje, cu numere de la 5 la 1

------------------

I . 2 . 5 Ru t in e - p roced u r i ş i fu n c ţ i i .

I . 2 . 5 . 1 C e es t e o r u t in ă ? E l emen te l e ca r e de f in es c o ru t in ă .

Rutina este o structură de sine stătătoare, asemănătoare unui program, prin care se execută o anumită acţiune. Ea este executată numai atunci când este lansată, apelată de către un obiect al aplicaţiei. Rutina poate fi apelată de un număr nelimitat de ori din diferite locuri(obiecte).

Toate declaraţiile(variabile, constante) făcute în interiorul rutinei sunt locale, fiind vizibile numai din interiorul acesteia. De asemenea, durata de viaţă a datelor locale, este numai în intervalul de timp cât rutina se află în execuţie, la terminarea rutinei, având loc automat şi eliberarea din memorie a tuturor variabilelor şi constantelor locale ale acesteia.

Notă: În Visual Basic nu sunt permise imbricări de rutine. Deci într-o rutină nu se poate declara o altă rutină.

Diferit faţă de programe, rutina inter-acţionează cu obiectul care a provocat lansarea(apelarea) ei, prin transferarea de date din şi înspre acesta. Acest lucru se realizează în două moduri şi anume:

Prin lista de parametrii. Aceasta reprezintă practic nişte variabile, prin intermediul cărora se face:

♦ în momentul apelării rutinei, un transfer de date de la modulul care apelează - parametrii de intrare.

♦ în momentul terminării rutinei şi preluării controlului de modulul apelant, un transfer de date de la rutină înspre modulul apelant - parametrii de ieşire.

Prin variabile globale. Aceste variabile fiind vizibile şi din modulul apelant şi din rutină, evident că prin ele se pot face transferuri de date în ambele sensuri între cele două obiecte.

Observaţia 1. Definirea unei rutine se face prin atribuirea unui nume(obligatoriu) acesteia şi prin stabilirea listei de parametrii(opţional). Parametrii definiţi în rutină se numesc parametrii formali.


Observaţia 2. Declararea parametrilor formali se face după regulile aplicate la declararea variabilelor.

Observaţia 3. Apelarea unei rutine se face prin numele ei.

Observaţia 4. În momentul apelării, trebuie să se realizeze o corespondenţă între nişte date(variabile, constante, literali) ale modulului apelant cu parametrii formali ai rutinei. Aceasta se face prin stabilirea unei liste de parametrii actuali, declaraţi în momentul apelării. Evident parametrii actuali şi formali trebuie să fie de acelaşi tip şi să ocupe acelaşi loc în cele două liste.

Observaţia 5. Parametrii de intrare ai rutinei pot fi în lista parametrilor actuali: variabile, constante, literali sau expresii.

Observaţia 6. Parametrii de ieşire ai rutinei pot fi în lista parametrilor actuali numai variabile, deoarece aceştia prin definiţie îşi pot schimba valoarea în timpul execuţiei rutinei.

I . 2 . 5 . 1 . 1 T ran s mi terea d a te lor p r in parametr i i

Există două modalităţi de transmitere a datelor prin parametrii şi anume prin valoare sau prin adresă(referinţă).

Apelarea rutinelor şi transmitera parametrilor (prin valoare)

Transmiterea prin valoare . Din figura de mai sus se obsevă că avem perechi de parametrii, actuali şi formali, care reprezintă practic două variabile care se sincronizează la apelarea şi terminarea rutinei.

Astfel observăm că la apelarea rutinei se face practic pentru fiecare pereche de parametrii operaţia de transfer: ParametruFormal=ParametruActual (de ex: A1=X1 sau A2=X2 etc.), iar la terminarea rutinei transferul invers: ParametruActual=ParametruFormal (de ex: T=B1 sau Y=B1 etc.).

Deci avem de a face cu transferarea unei valori între parametrii formali şi cei actuali. Spunem că facem transmiterea prin valoare a parametrilor.


Modul apelant……….Instr N….. X1=….Instr N+1.. X2=….Apelare rutină - Nume: Rtest

Parametri actuali:X1, X2, YInstr. ….= …Y……….. Instr J…… M1=….Instr J+1… M2=….Apelare rutină - Nume: Rtest

Parametri actuali:M1, M2, TInstr. ….= …T………..

Rutina Nume: RtestParametrii formali:

Intrare: A1, A2Ieşire: B1

Instr1………....= A1 + A2 ' folosirea

'parametrilor de intrare………..B1= …… ' folosirea 'parametrilor de ieşire………..Sfârşit rutină

X1,X2

A1,A2

Y

B1

M1,M2

A1,A2

T

B1

Apelarea rutinelor şi transmitera parametrilor (prin adres ă ) Transmiterea prin adresă (referinţă). . În acest caz lucrurile se petrec altfel. Transferul se

face numai la apelarea rutinei, dar nu se vor transfera valori, ci rutina va primi adresele

parametrilor actuali. În acest fel în rutină parametrii formali se vor genera în memorie peste parametrii actuali. Deci rutina va lucra practic cu parametrii actuali, deşi va folosi numele parametrii formali în expresii.

Notă: În Visual Basic, dacă nu se fac precizări suplimentare, transmiterea parametrilor se face prin adresă (referinţă).

------------------

I . 2 . 5 . 2 C r ear ea (de f in i r ea ) un e i ru t in e .

Rutinele sunt de două feluri: proceduri(sau subrutine) şi funcţii. Diferenţa dintre ele constă în faptul că :

• Funcţiile au un parametru implicit de ieşire care este chiar numele funcţiei.

• Procedurile sunt apelate prin instrucţiuni, iar funcţiile sunt apelate prin introducerea numelui acesteia într-o expresie(ca şi cum ar fi o variabilă sau constantă).

Notă: Funcţiile pot fi folosite direct aproape oriunde unde este cerută o expresie, cu condiţia vizibilităţii ei din locul de unde este apelată. Astfel putem folosi funcţii ca: parametrii de intrare pentru rutine, la definirea proprietăţilor din controale, la cereri etc.

I . 2 . 5 . 2 . 1 Proced u r i (S u b ru t in e )

[Private | Public] [Static] Sub NumeProcedura [(ListaParametriiFormali)] [declaraţii locale de: variabile, constante, etc.][instrucţiuni][Exit Sub][instrucţiuni]

End Sub------------------

• Instrucţiunea, Exit Sub, provoacă dacă este întâlnită terminarea procedurii şi redarea controlului modulului apelant, la instrucţiunea care se găseşte imediat după cea de apelare. În mod normal procedurile se termină la instrucţiunea End Sub.


Modul apelant……….Instr N….. X1=….Instr N+1.. X2=….Apelare rutină - Nume: Rtest

Parametri actuali:X1, X2, YInstr. ….= …Y……….. Instr J…… M1=….Instr J+1… M2=….Apelare rutină - Nume: Rtest

Parametri actuali:M1, M2, TInstr. ….= …T………..

Rutina Nume: RtestParametrii formali:

Intrare: A1, A2Ieşire: B1

Instr1………....= A1 + A2 ' folosirea

'parametrilor de intrare………..B1= …… ' folosirea

'parametrilor de ieşire………..Sfârşit rutină

Parametrii actuali

a

X1X2Y

X

a d r e s

e

e

A1A2B1

A

Parametrii formali

ff

Parametrii actuali

a

M1M2T

M

a d r e s

e

e

A1A2B1

A

Parametrii formali

ff

• Opţiunile Private sau Public, au acelaşi rol ca cel prezentat la variabile. Adică, procedurile declarate Public în modulul general de cod vor fi vizibile din toate modulele de cod ale aplicaţiei. Declararea Private a unei proceduri o face locală, adică vizibilă numai din modulul în care este declarată. Dacă nu se foloseşte nici una din cele două opţiuni, procedura va fi considerată publică.

• Opţiunile Static face ca toate variabilele locale declarate în procedură să fie statice.

• Toate instrucţiunile sunt permise. Datele cu care lucrează acestea pot fi :

parametrii formali;

variabilele şi constantele globale;

variabilele şi constantele locale;

Notă: Este indicat ca să se evite pe cât posibil în crearea rutinelor folosirea variabilelor globale, fiind recomandată utilizarea numai a parametrilor formali pentru schimburile de date ale rutinei cu modulul apelant. Aceasta deoarece o rutină care foloseşte variabile globale este de multe ori foarte puţin lizibilă, greu de depanat sau de întreţinut.

• Lista Parametrilor Formali: Reprezintă o listă de variabile, declarate după regulile prezentate la variabile şi separate prin virgulă. Un parametru se declară conform structurii de mai jos:

[ByVal | ByRef] NumeParametru As TipDate Opţiunile ByVal sau ByRef, precizează modalitatea de transmitere a parametrului respectiv şi anume prin valoare sau prin adresă(referinţă). Aceasta din urmă se ia implicit dacă nu se face nici o precizare.

I . 2 . 5 . 2 . 2 Fu n c ţ i i

[Public | Private] [Static] Function NumeFuncţie [(ListaParametriiFormali)] [As TipFuncţie]

[declaraţii locale de: variabile, constante, etc.][instrucţiuni][Exit Function][instrucţiuni]

End Function------------------

Observaţia 1. Se observă că singura deosebire esenţială faţă de proceduri, se datorează faptului că numele funcţiei are două semnificaţii fiind în acelaşi timp şi numele rutinei şi parametru de ieşire al rutinei. Din această cauză acestuia trebuie să i se precizeze tipul de date. Dacă acest lucru nu se face atunci implicit se va considera Boolean tipul funcţiei.

Deci o funcţie, după ce este executată se va comporta practic ca o variabilă - care s-a încărcat cu valoarea parametrului de ieşire - putând fi introdusă direct în partea dreaptă a oricărei expresii.

Observaţia 2. În loc de Exit Sub şi End Sub, la funcţii sunt Exit Function şi End Function, evident cu acelaşi rol.

Exemplu. Următorul exemplu reprezintă o funcţie care va testa două valori primite ca parametrii şi va returna suma sau diferenţa dintre ele.

Function TestF(Numar1 As Integer, Numar2 As Integer) As Integer

If Numar1 > Numar2 then

TestF = Numar1 - Numar2 ' valoarea de retur se introduce în numele funcţiei

Else

TestF = Numar1 + Numar2 ' valoarea de retur se introduce în numele funcţiei

End If

End Function


…….Se va folosi această funcţie astfel….

MsgBox TestF(20, 5) ' afişează 15

MsgBox TestF(2, 5) ' afişează 7

------------------

I . 2 . 5 . 3 A pe la r ea un e i ru t in e .

Notă: Orice funcţie poate fi apelată ca o procedură, dar o procedură nu poate fi folosită ca o funcţie (în partea din dreapta a unei expresii).

I . 2 . 5 . 3 . 1 A p e larea un e i p roced u r i ( s u b ru t in e )

Există două modalităţi de apelare a unei proceduri:

Prin instrucţiunea CallCall NumeProcedură (ListaParametrilorActuali)

Direct folosind numele procedurii.

NumeProcedură ListaParametrilorActualiNotă: Parametrii se separă prin virgulă.

Observaţia 1. Diferenţa între cele două apeluri este că la apelarea cu Call, parametrii actuali ai procedurii trebuie scrişi între paranteze, pe când la apelarea directă prin numele procedurii, este obligatoriu să nu se folosească paranteze.

I . 2 . 5 . 3 . 2 A p e larea un e i fun c ţ i i .

O funcţie se apelează în partea dreapta a unei expresie, folosindu-se numele ei urmat de lista parametrilor actuali incluşi între paranteze. Numele funcţiei, se va comporta în expresie ca o variabilă, încărcată în timpul execuţiei funcţiei cu o valoare, ca şi cum ar fi un parametru de ieşire al unei proceduri. Spunem că funcţia întoarce(returează) o valoare după execuţia ei. Această valoare va participa la evaluarea expresiei respective.

Observaţia 1. O procedură nu poate fi folosită în locul unei funcţii într-o expresie, deoarece nu returează valori (chiar dacă are parametrii de ieşire)

Observaţia 2. Funcţiile pot fi apelate şi ca pe o procedură în oricare din cele două modalităţi prezentate.

Exemplu. Refacem exemplul prezentat înainte folosind o procedura TestS în locul funcţiei TestF

Sub TestS(Numar1 As Integer, Numar2 As Integer, Rezultat As Integer)

If Numar1 > Numar2 then

Rezultat = Numar1 - Numar2 ' valoarea calculată se introduce în parametru de ieşire

Else

Rezultat = Numar1 + Numar2 ' valoarea calculată se introduce în parametru de ieşire

End If

End Sub

…….Se va folosi această procedură astfel….

Dim Rez As Integer

Call TestS(20, 5, Rez) ' calculează în Rez

MsgBox Rez ' afişează 15

TestS 2, 5, Rez ' calculează în Rez

MsgBox Rez ' afişează 7

------------------


I . 2 . 5 . 4 D omen iu l de va lab i l i t a t e ( v i z ib i l i t a t ea ) a l r u t in e lo r .

Regulile prezentate la variabile, privind această problemă sunt valabile şi pentru rutine.

Codul VBA este scris numai în unităţi numite rutine. Aceste rutine sunt păstrate fie în modulul general (global), fie în modulele specifice din spatele formularelor (Code Behind Forms – CBF).

Domeniul de valabilitate sau de vizibilitatea a rutinei, este determinat de cuvântul utilizat în declararea acesteia: Private sau Public şi de locul unde rutina e plasată. Rutina este modulară(globală), numai dacă este declarată Public şi este plasată în modulul global(general), ea fiind vizibilă în toată aplicaţia. Restul rutinelor, sunt locale şi sunt vizibile numai din modulul unde au fost declarate.

I . 2 . 5 . 5 R u t in e de f in i t e de u t i l i z a to r . In t r odu cer ea codu lu i V B A

Explicaţie. Pentru a crea o rutină definită de utilizator într-un modul global de cod, urmaţi paşii de mai jos:

• Executaţi clic pe marcajul de tabulare Modules (Module) din fereastra bazei de date.

• Începeţi un modul nou sau selectaţi un modul existent şi executaţi clic pe opţiunea Design.

• Selectaţi opţiunea Insert Procedure (Inserează procedură) de pe bara cu instrumente sau selectaţi opţiunea Procedure din meniul Insert (Inserează). Va apărea pe ecran caseta de dialog alăturată.

• Introduceţi numele procedurii şi selectaţi tipul acesteia: funcţie, subrutină sau proprietate. Indicaţi dacă doriţi ca procedura dumneavoastră să fie publică (pentru întreaga aplicaţie) sau privată (numai pentru acest modul). În final, specificaţi dacă doriţi ca toate variabilele din rutina dumneavoastră să fie Apoi, executaţi clic pe OK.

Explicaţie. Pentru a crea o rutină definită de utilizator în modulul de cod din spatele unui formular sau raport, se procedează la fel, în afară de afişarea modulului care se face astfel:

• În timp ce vă aflaţi în modul de afişare Design al unui formular sau raport, vizualizaţi codul din spatele formularului sau raportului executând clic pe butonul Code (Cod) de pe bara cu instrumente sau prin selectarea opţiunii Code din meniul View, sau prin pictograma specifică de pe bara cu instrumente.

I . 2 . 5 . 6 P r ocedu r i l e e ven imen te lo r

Procedurile evenimentelor sunt apelate automat când are loc un eveniment pentru un obiect. De exemplu, când un utilizator execută clic pe un buton de comandă, este executat codul evenimentului Click pentru acel buton de comandă.

Procedurile evenimentelor sunt create automat când scrieţi codul evenimentului pentru un control.

De exemplu, rutina: Private Sub cmdOkay_Click este creată atunci când plasaţi instrucţiuni de cod în evenimentul Click al butonului de comandă cu Caption = 'Apasa' şi numele cmdOkay.

Exemplu. Codul evenimentului Click, al butonului cmdOkay.

Private Sub cmdOkay_Click()

If IsNull (Me!txtNume) Or IsNull (Me!txtVirsta) _

Or isNull(Me!txtSex) Then

MsgBox "Trebuie introduse numele, virsta şi sexul”

Exit Sub

Else

MsgBox "Numele d-tra este: " & Me!txtNume & _

Chr(10) & Chr(13) & ”Virsta dv este acum de : " & _


CalculVirsta(Fix(Val(Me!txtVirsta)), Me!txtSex) & " ani"

End If

End Sub

------------------

Function CalculVirsta(V As Integer, S As Variant) As Integer

If V > 35 And S = "F" Then

CalculVirsta = V - 10


ElseIf V > 25 And S = "F" Then


ElseIf V > 20 And S = "F" Then


ElseIf S = "M" Then

CalculVirsta = V + 5

Else

CalculVirsta = V

End If

End Function

------------------

Explicaţie. Pentru a edita codul unui eveniment , executaţi paşii următori:

• Executaţi click pe control(cmdOkay) în modul de afişare Design şi apoi pe butonul Properties din bara cu instrumente sau executaţi click cu butonul drept al mouse-ului pe obiect şi selectaţi opţiunea Properties din meniul contextual.

• Executaţi click pe marcajul de tabulare al proprietăţilor evenimentului (Event).

• Selectaţi proprietatea pentru care doriţi să scrieţi instrucţiuni de cod (de exemplu, evenimentul On Click).

• Selectaţi [Event Procedure] din lista derulantă.

• Executaţi clic pe butonul (…). Cursorul dumneavoastră va fi plasat în codul evenimentului pentru obiectul respectiv. Automat sistemul va crea instrucţiunea de declarare a procedurii, eventual cu lista de parametrii formali . daca este cazul - şi instrucţiunea de sfârşit a procedurii. Proiectantul va introduce acum codul VBA necesar tratării evenimentului.

------------------

I . 2 . 5 . 7 U t i l i z a r ea combin a t ă a ru t in e lo r u t i l i z a to r ş i a pr ocedu r i lo r e ven imen t .

Am arătat că atât subrutinele, cât şi funcţiile pot primi argumente(parametrii), dar numai funcţiile pot returna valori.

Exemplu. Subrutina următoare primeşte doi parametri, txtFirst şi txtLast. Aceasta afişează apoi un mesaj cu primul caracter al fiecăruia dintre cei primiţi.

Private Sub Initialele (sFirst As String, sLast As String)

MsgBox “Initialele dumneavostră sunt: “ & _

Left (sFirst, 1) & Left (sLast, 1) ' Funcţia Left returează caracterele de la inceputul unui string

End Sub

Ea va fi apelată din procedura eveniment On Click a butonului de comandă cmdNume.

Private Sub cmdNume_Click()

Initialele Me !txtFirstName, Me!txtLastName

End Sub

------------------

Explicaţie. Observaţi că textul din controalele txtFirstName şi txtLastName din formularul curent (Me) sunt transmise subrutinei cu numele Initialele. Parametrii sunt recepţionaţi ca sFirst şi sLast. Primul caracter din stânga al fiecărui parametru este afişat în caseta de mesaje.

Codul precedent transmite pur şi simplu valori şi apoi operează cu ele.

Exemplu. În continuare se ilustrează folosirea unei funcţii care întoarce o valoare.


Private Function ReturnInit (sFName As String, sLName As String) As String

ReturnInit = Left (sFName, 1) & Left (sLName, 1)

End Function

Ea va fi apelată din procedura eveniment On Click a butonului de comandă cmdNume.

Private Sub cmdNume_Click()

Dim sInitials As Integer

sInitials = ReturnInit (Me!txtFirstName, Me!txtLastName)

MsgBox "Initialele dumneavostra sunt: " & sInitials

End Sub

Explicaţie. Reţineţi că acest exemplu apelează o funcţie ReturnInit, trimiţând valorile celor două casete de text ca parametri ai funcţiei. Funcţia asociază numelui funcţiei (ReturnInit) o valoare egală cu primele două caractere ale şirurilor. Apoi, funcţia returnează această valoare, rutinei apelante (cmdNume_Click) şi o atribuie variabilei sInitials.

------------------

I . 2 . 5 . 8 Par ame t r i op ţ i on a l i

Visual Basic vă permite să utilizaţi parametri opţionali. Cu alte cuvinte, nu este necesar să ştiţi câţi parametri vor fi transmişi. Funcţia numită ReturnInit din secvenţa de cod următoare primeşte ultimii doi parametri ca opţionali. Apoi evaluează prezenţa sau nu a parametrilor şi acţionează în consecinţă.

Function ReturnInit (sFName As String, Optional sMI, Optional sLName) As String

If IsMissing (sMI) Then ' IsMissing returează True dacă s-a apelat funcţia fara parametrul sMI

SMI = InputBox ("Introduceţi initiala cuvantului din mijloc”)

End If

If IsMissing (sLName) Then ' IsMissing returează True dacă s-a apelat funcţia fara parametrul sLName

SLName = InputBox („Introduceţi ultimul nume”)

End If

ReturnInit = sLName & " " & sMI & " " sFName

End Function

------------------

• Această funcţie poate fi apelată de exemplu în felul următor:

sName = ReturnInit ("Bill” , , "Gates”)Explicaţie. Aşa cum aţi putut vedea, lipseşte al doilea parametru. În loc să rezulte o eroare de

compilare, funcţia ReturnInit va sesiza acest lucru şi prin funcţia InputBox va cere utilizatorului introducerea valorii respective.

• Sau mai poate fi apelată şi:

sName = ReturnInit ("Bill” , "X", "Gates”)Explicaţie. În acest caz funcţia prin folosirea lui IsMissing, va sesiza prezenţa tuturor celor trei

parametrii actuali.

------------------

Notă: Lucrul cu parametrii opţionali, deci care pot să lipsească la apelarea rutinei, necesită:

Declararea ca opţional a parametrului, prin folosirea clauzei Optional, în faţa numelui parametrului. O restricţie a limbajului este faptul că numai ultimii parametrii pot fi declaraţi opţionali.

Testarea prin funcţia IsMissing, dacă a fost sau nu introdus la apelare parametrul respectiv în lista parametrilor actuali. Dacă nu se doreşte introducerea în lista parametrilor


actuali a unui parametru opţional, atunci se va scrie numai separatorul(virgula) parametrului respectiv.

Numai pentru parametrii declaraţi opţional, se poate introduce o valoare implicită, cu care se va iniţializa parametrul dacă acesta lipseşte din lista parametrilor actuali.

Dacă se folosesc parametrii opţionali, declararea acestora în lista parametrilor formali este :

[Optional] NumeParametru As TipDate [ = ValoareImplicita ]

I . 2 . 6 B ib l io t ec i l e s tan d ard d e fu n c ţ i i ş i p roced u r i .

O bibliotecă este un obiect de sine stătător care permite realizarea unei colecţii de funcţii, proceduri, clase de module de obiecte şi obiecte.

Noile tehnologii şi standarde introduse de Microsoft, permit ca modulele unei biblioteci să poată să fie utilizate de toate aplicaţiile client de pe platforma S.O., care respectă standardele de utilizare a unei biblioteci. În Visual Basic, există posibilitatea creării mai multor tipuri de biblioteci.

Microsoft Office, oferă mai multe biblioteci, care pot fi utilizate în Access, Visual Basic sau alte aplicaţii. Pentru aceasta trebuie ca în prealabil aplicaţia client să înregistreze şi să creeze referinţa(adresa) către biblioteca respectivă. Acest lucru se face prin comanda References. Implicit, o aplicaţie are chiar din faza de instalare create referinţele către cele mai utilizate biblioteci specifice.

Aplicaţiile Access au referinţe create către anumite biblioteci, ale căror module pot fi utilizate oriunde acestea sunt permise.

În acest subcapitol, vor fi prezentate în special cele mai utilizate funcţii ale acestor biblioteci.

Un bun programator, trebuie să cunoască şi să folosească cât mai multe din obiectele puse la dispoziţie de biblioteci. De exemplu dacă avem de realizat o aplicaţie care trebuie la un moment dat să calculeze SINUSUL dintr-o valoare, un programator ne experimentat s-ar putea apuca să creeze un modul care să rezolve acest lucru, pe când un bun programator ştiind că există în biblioteci funcţia Sin, care calculează sinusul unei valori, va rezolva instantaneu această problemă, folosind pur şi simplu funcţia din bibliotecă.

Pentru a putea utiliza o funcţie dintr-o bibliotecă, programatorul trebuie să cunoască trei lucruri:

Numele funcţiei;

Parametrii şi ce reprezintă fiecare;

Ce reprezintă valoarea pe care o returnează funcţia (adică ce operaţii efectuează funcţia).

În crearea expresiilor, în Access se poate folosi un constructor de funcţii - Expressions Builder, lansat de obicei din meniul contextual (Build). Acesta este foarte util, prezentând toate funcţiile, parametrii acestora modulul de Help referitor la obiectul respectiv, operaţiile permise, etc.

În concluzie, în codul VBA, în controalele din formulare sau rapoarte, în proprietăţile tabelelor sau cererilor, se pot folosi în crearea expresiilor atât funcţiile definite(create) de utilizator cât şi funcţiile din bibliotecile către care există referinţe. Toate acestea se pot vizualiza prin Expressions Builder ( prin cele două foldere din Functions, aşa cum se vede din figură)

Access are referinţe implicite către o bibliotecă de funcţii foarte bogată şi cuprinzătoare. Câteva dintre cele mai utilizate funcţii sunt prezentate în continuare.


I . 2 . 6 . 1 F u n c ţ i i ma tema t i ce

I . 2 . 6 . 1 . 1 Int ( număr ) ; Fix( număr )

Întoarce partea întreagă a numărului introdus ca parametrul de intrare.

Tipul de dată al rezultatului va fi acelaşi cu tipul de dată al parametrul de intrare.

Ambele funcţii Int şi Fix îndepărtează partea fracţionară a numărului şi întorc valoarea întreagă care rezultă.

Diferenţa între Int şi Fix este că numai dacă numărul este negativ. Astfel:

Int întoarce primul număr negativ de tip întreg mai mic sau egal cu numărul; Int(–8.4) = -9

Fix întoarce primul număr negativ de tip întreg mai mare sau egal cu numărul; Fix (–8.4) = -8

Exemplu.

Dim MyNumber ' variabilele declarate fără specificarea tipului de dată sunt VARIANT.

MyNumber = Int(99.8) ' Întoarce 99.

MyNumber = Fix(99.2) ' Întoarce 99.

MyNumber = Int(-99.8) ' Întoarce -100.

MyNumber = Fix(-99.8) ' Întoarce -99.

------------------

I . 2 . 6 . 1 . 2 Abs ( număr )

Întoarce valoarea absolută a numărului introdus ca parametrul de intrare.

Tipul de dată al rezultatului va fi acelaşi cu tipul de dată al parametrul de intrare.

Exemplu.

Dim MyNumber

MyNumber = Abs(50.3) ' Întoarce 50.3.

MyNumber = Abs(-50.3) ' Întoarce 50.3.

------------------

I . 2 . 6 . 1 . 3 Sgn ( număr )

Întoarce un Variant (Integer) care reprezintă semnul unui număr.

Dacă parametrul este :

<0 >0 =0

Sgn întoarce -1 1 0

Exemplu.

Dim MyVar1, MyVar2, MyVar3, MySign

MyVar1 = 12: MyVar2 = -2.4: MyVar3 = 0

MySign = Sgn(MyVar1) ' Întoarce 1.

MySign = Sgn(MyVar2) ' Întoarce -1.

MySign = Sgn(MyVar3) ' Întoarce 0.

------------------

I . 2 . 6 . 1 . 4 Sqr( număr )

Întoarce o valoare de tip Double(virgulă mobilă dublă precizie) care reprezintă radicalul(square root) unui număr(>=0).

Exemplu.


Dim MySqr

MySqr = Sqr(4) ' Întoarce 2.

MySqr = Sqr(23) ' Întoarce 4.79583152331272.

MySqr = Sqr(0) ' Întoarce 0.

MySqr = Sqr(-4) ' Generează o eroare.

------------------

I . 2 . 6 . 1 . 5 Exp( număr )

Întoarce o valoare de tip Double care reprezintă e (baza logaritmului natural) ridicat la o putere.

Exemplu.

Dim MyAngle, MyHSin

' Defineşte unghiul în radiani.

MyAngle = 1.3

' Calculează sinusul hiperbolic.

MyHSin = (Exp(MyAngle) - Exp(-1 * MyAngle)) / 2

------------------

I . 2 . 6 . 1 . 6 Log( număr )

Întoarce o valoare de tip Double care reprezintă logaritmul natural al unui număr (>0).

Logaritmul natural este logaritmul în baza e. Constanta e este aproximativ 2.718282.

Exemplu.

Dim MyAngle, MyLog

' Defineşte unghiul în radiani.

MyAngle = 1.3

' Calculează inversul sinusului hiperbolic.

MyLog = Log(MyAngle + Sqr(MyAngle * MyAngle + 1))

------------------

I . 2 . 6 . 1 . 7 Rnd[( număr ) ]

Întoarce o valoare de tip Single(virgulă mobilă simplă precizie) care va conţine un număr aleator.

Argumentul(parametrul) este opţional şi poate fi un Single sau o expresie numerică corectă.

Valoarea întoars ă de Rnd

Dacă parametrul este

Rnd generează

<0 Acelaşi număr de fiecare dată, folosind numărul ca valoare de iniţializare.

>0 Următorul număr din secvenţă.

=0 Cel mai recent număr generat.

Fără (de obicei) Următorul număr din secvenţă.

------------------

Funcţia Rnd întoarce o valoare în intervalul [0..1)

Valoarea parametrului determină cum Rnd generează un număr aleator.

Pentru orice valoare iniţială, aceiaşi secvenţă de numere este generată din cauza faptului că fiecare apel succesiv al funcţiei Rnd, foloseşte numărul generat anterior ca valoare pentru calculul următorului număr din secvenţă.


Înainte de prima folosire a funcţiei Rnd, dacă se doreşte generarea unei secvenţe de numere aleatoare, atunci generatorul de numere aleatoare trebuie iniţializat cu o valoare întâmplătoare. Pentru aceasta se va folosi procedura Randomize, fără parametrii, care va folosi pentru iniţializarea generatorului de numere aleatoare, ceasul sistemului de calcul.

Notă: Dacă se doreşte generarea unor numere întregi, în intervalul [a.. b], se foloseşte formula:

Int((b - a + 1) * Rnd + a)

Exemplu.

Dim MyValue

Randomize

MyValue = Int((6 * Rnd) + 1) ' Generează o valoare aleatoare între 1 şi 6.

------------------

I . 2 . 6 . 1 . 8 S in( număr )

Întoarce o valoare de tip Double care reprezintă sinusul unui unghi în radiani

Rezultatul va fi în intervalul [-1..1]

Pentru a transforma gradele în radiani se înmulţesc gradele cu pi/180. Invers se vor înmulţi radianii cu 180/pi.

Exemplu.

Dim MyAngle, MyCosecant

MyAngle = 1.3 ' Defineşte unghiul în radiani.

MyCosecant = 1 / Sin(MyAngle) ' Calculează cosecanta.

------------------

I . 2 . 6 . 1 . 9 Cos( număr )

Întoarce o valoare de tip Double care reprezintă cosinusul unui unghi în radiani

Exemplu.

Dim MyAngle, MySecant

MyAngle = 1.3 ' Defineşte unghiul în radiani.

MySecant = 1 / Cos(MyAngle) ' Calculează secanta.

------------------

I . 2 . 6 . 1 . 10 Tan( număr )

Întoarce o valoare de tip Double care reprezintă tangenta unui unghi în radiani

Pentru a transforma gradele în radiani se înmulţesc gradele cu pi/180. Invers se vor înmulţi radianii cu 180/pi.

Exemplu.

Dim MyAngle, MyCotangent

MyAngle = 1.3 ' Defineşte unghiul în radiani

MyCotangent = 1 / Tan(MyAngle) ' Calculează cotangenta

------------------

I . 2 . 6 . 1 . 11 Atn( număr )

Întoarce o valoare de tip Double care reprezintă arctangenta unui număr.

Exemplu. pi = 4 * Atn(1) ' Calculează valoarea lui pi.

------------------


I . 2 . 6 . 1 . 12 E xp res i i p en tru ca l cu lu l fu n c ţ i i l or matemat i ce d er iva te

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 . 2 . 6 . 2 F u n c ţ i i TE X T - pen t ru s t r in gu r i .

I . 2 . 6 . 2 . 1 Asc( s t r ing )

Întoarce o valoare de tip Integer, în intervalul 0…255, care reprezintă codul în ASCII(ANSI) a primului caracter din şirul de caractere ce se află în argumentul (parametrul de intrare) funcţiei.

Exemplu.

Dim MyNumber

MyNumber = Asc("A") ' Întoarce 65.

MyNumber = Asc("a") ' Întoarce 97.

MyNumber = Asc("Apple") ' Întoarce 65.

------------------

I . 2 . 6 . 2 . 2 Chr( CodCaracter )

Întoarce o valoare de tip string care reprezintă caracterul asociat codului caracterului în ASCII(ANSI), introdus ca argument al funcţiei.

Notă: Numerele între 0-31 au ca corespondent în codul ASCII caractere netipăribile, dar care pot eventual să determine anumite acţiuni în timpul afişării. De exemplu Chr(10) întoarce un linefeed character - LF, care determină trecerea la o linie nouă. Intervalul normal pentru 'CodCaracter' este 0-255.

Exemplu.


Dim MyChar

MyChar = Chr(65) ' Întoarce A.

MyChar = Chr(97) ' Întoarce a.

MyChar = Chr(62) ' Întoarce >.

MyChar = Chr(37) ' Întoarce %.

------------------

I . 2 . 6 . 2 . 3 AscB( s t r ing ) ; AscW( s t r ing ) ; ChrB( CodChar ) ; ChrW( CodChar )

Funcţiile AscB, AscW, ChrB, ChrW ţin seama că în memorie caracterele sunt codificate pe 2 octeţi în standardul UNICODE, ele considerând şirul de caractere ca pe un tablou de octeţi, în care fiecare caracter ocupă doi octeţi(byte)

• Funcţia AscB - În loc să întoarcă codul pentru primul caracter, întoarce primul byte, din codul în UNICODE al primului caracter, .

• Funcţia AscW - Întoarce codul caracterului în UNICODE (pe 2 octeţi, în intervalul 0…2^16)

• Funcţia ChrB . În loc să întoarcă un caracter al cărui cod(aflat în parametrul funcţiei) poate fi pe 1 sau 2 bytes, ea va întoarce întotdeauna caracterul al cărui cod este pe primul byte.

• Funcţia ChrW - Întoarce un string care conţine caracterul al cărui cod este introdus în argument în standardul UNICODE.

Notă: Aceste funcţii au efect numai pe platformele care acceptă codul UNICODE. Dacă acesta nu este acceptat, atunci ele se comportă la fel ca funcţiile Asc respectiv Chr.

Exemplu.

Public Sub TestUnicode()

MsgBox Asc("A") ' Întoarce Cod Ascii = 65

MsgBox AscB("A") ' Întoarce primul byte din Codul Unicode= 65

MsgBox AscW("A") ' Întoarce Codul Unicode= 65

MsgBox Asc("Ş") ' Întoarce Cod Ascii = 170

MsgBox AscB("Ş") ' Întoarce primul byte din Codul Unicode= 94

MsgBox AscW("Ş") ' Întoarce Codul Unicode= 350

'-------------------------------------------------------------------------------------

MsgBox Chr(65) ' Întoarce Caracterul = A

MsgBox ChrB(65) ' Întoarce Caracterul = A

MsgBox ChrW(65) ' Întoarce Caracterul = A

MsgBox Chr(170) ' Î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 350Cod UNICODE(2 octeţi) 65 0 94 1

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


------------------

I . 2 . 6 . 2 . 4 LCase( s t r ing )

Întoarce un string în care literele mari au fost convertite în litere mici. Restul caracterelor rămân nemodificate

Exemplu.

Dim UpperCase, LowerCase

UpperCase = "Hello World 1234" ' String pentru a fi convertit.

LowerCase = LCase(UpperCase) ' Întoarce "hello world 1234".

------------------

I . 2 . 6 . 2 . 5 UCase( s t r ing )

Întoarce un Variant (String) în care literele mici au fost convertite în litere mari. Restul caracterelor rămân nemodificate

Exemplu.

Dim LowerCase, UpperCase

LowerCase = "Hello World 1234" ' String pentru convertit.

UpperCase = UCase(LowerCase) ' Întoarce "HELLO WORLD 1234".

------------------

I . 2 . 6 . 2 . 6 LTrim( s t r ing ) ; RTrim( s t r ing ) ; Trim( s t r ing )

Întoarce o valoare de tip Variant (String) ce cuprinde o copie a unui string specificat fără spaţiile de început la funcţia LTrim, fără spaţiile de sfârşit la funcţia RTrim, sau fără spaţiile din ambele capete la funcţia Trim.

Exemplu.

Dim MyString, TrimString

MyString = " <-Trim-> " ' Iniţializează stringul.

TrimString = LTrim(MyString) ' TrimString = "<-Trim-> ".

TrimString = RTrim(MyString) ' TrimString = " <-Trim->".

TrimString = LTrim(RTrim(MyString)) ' TrimString = "<-Trim->".

' Utilizând funcţia Trim se obţine acelaşi rezultat.

TrimString = Trim(MyString) ' TrimString = "<-Trim->".

------------------

I . 2 . 6 . 2 . 7 Len( s t r ing | NumeVar iabi la )

Întoarce o valoare de tip Long cuprinzând :

• Dacă argumentul este un string câte caractere are.

• Dacă argumentul este o variabilă, câte caractere pot să fie introduse în ea.

Notă: Dacă argumentul este NULL , funcţia va întoarce tot NULL, ca de altfel ca şi la celelalte funcţii.

Unul (şi numai unul) din cele două argumente posibile trebuie specificat.

Notă: Se poate utiliza funcţia LenB, care ţine cont de reprezentarea în memorie în UNICODE a stringului. În loc să întoarcă numărul de caractere dintr-un string , LenB întoarce numărul de bytes utilizaţi pentru a reprezenta acel string.

Exemplu.


Type CustomerRecord ' Defineşte tipul dorit dorit de utilizator.

ID As Integer ' Această definiţie trebuie să fie la nivel de modul de cod

Name As String * 10

Address As String * 30

End Type

Dim Customer As CustomerRecord ' Declararea variabilelor.

Dim MyInt As Integer, MyCur As Currency

Dim MyString, MyLen

MyString = "Hello World" ' Iniţializează variabila.

MyLen = Len(MyInt) ' Întoarce 2.

MyLen = Len(Customer) ' Întoarce 42.

MyLen = Len(MyString) ' Întoarce 11.

MyLen = Len(MyCur) ' Întoarce 8.

------------------

I . 2 . 6 . 2 . 8 Lef t ( s t r ing , lungime )

Întoarce un sub-şir de caractere din partea stângă a stringului al căror număr este stabilit de lungime.

♦ Lungimea este o expresie numerică indicând câte caractere se vor întoarce:

Dacă este 0, un string de lungime 0 ("") va fi întors - şir vid.

Dacă este mai mare sau egal cu numărul de caractere din string, se va întoarce întregul string.

Pentru a determina numărul de caractere dintr-un string se va utiliza funcţia, Len .

Exemplu.

Dim AnyString, MyStr

AnyString = "Hello World" ' Defineşte stringul.

MyStr = Left(AnyString, 1) ' Întoarce "H".

MyStr = Left(AnyString, 7) ' Întoarce "Hello W".

MyStr = Left(AnyString, 20) ' Întoarce "Hello World".

------------------

I . 2 . 6 . 2 . 9 Right ( s t r ing , lungime )

Întoarce un sub-şir de caractere din partea dreapta a stringului al căror număr este stabilit de lungime.

♦ Lungimea este o expresie numerică indicând câte caractere se vor întoarce:

Dacă este 0, un string de lungime 0 ("") va fi întors - şir vid.

Dacă este mai mare sau egal cu numărul de caractere din string, se va întoarce întregul string.

Pentru a determina numărul de caractere dintr-un string se va utiliza funcţia, Len .

Exemplu.

Dim AnyString, MyStr

AnyString = "Hello World" ' Defineşte stringul.

MyStr = Right(AnyString, 1) ' Întoarce "d".

MyStr = Right(AnyString, 6) ' Întoarce " World".

MyStr = Right(AnyString, 20) ' Întoarce "Hello World".


------------------

I . 2 . 6 . 2 . 10 Mid( s t r ing , s tar t [ , lungime ] )

Întoarce o valoare de tip Variant (String) cuprinzând un număr specificat de caractere dintr-un string.

Parametrii reprezintă:

string (obligatoriu). Expresie string din care sunt întoarse caractere. Dacă stringul conţine NULL, atunci NULL se va întoarce.

start (obligatoriu); Este de tip Long. Reprezintă poziţia caracterului din string de la care începe partea ce va fi preluată. Dacă poziţia este mai mare decât numărul de caractere din string, Mid va întoarce un string vid ("") - de lungime 0. Numerotarea caracterelor începe de la 1.

lungime (opţional); Este de tip Variant (Long). Reprezintă numărul de caractere ce vor fi întoarse. Dacă lipseşte sau dacă este mai mare decât numărul maxim de caractere care mai sunt până la sfârşitul stringului (inclusiv caracterul de început), vor fi întoarse toate caracterele de la poziţia de start până la sfârşit.

Pentru a determina numărul de caractere dintr-un string se va utiliza funcţia Len .

Exemplu.

Dim MyString, FirstWord, LastWord, MidWords

MyString = "Mid Function Demo" ' Crează stringul.

FirstWord = Mid(MyString, 1, 3) ' Întoarce "Mid".

LastWord = Mid(MyString, 14, 4) ' Întoarce "Demo".

MidWords = Mid(MyString, 5) ' Întoarce "Function Demo".

Notă: Mid, poate fi folosit şi în partea stânga a unei instrucţiuni de atribuire, caz în care va înlocui din string, subşirul specificat, cu stringul specificat de expresia din dreapta instrucţiunii, dar fără a modifica lungimea şirului de caractere.

Această facilitate nu este implementată şi la funcţiile Left sau Right

Exemplu.

Public Sub TestMid()

Dim S As String

S = "123456789"

Mid(S, 4, 2) = "A"

MsgBox S ' Afişează 123A56789

Mid(S, 4, 2) = "AB"

MsgBox S ' Afişează 123AB6789

Mid(S, 4, 2) = "ABC"

MsgBox S ' Afişează 123AB6789

End Sub

------------------

I . 2 . 6 . 2 . 11 InStr( [ s tar t , ] s t r ing1 , s t r ing2 [ , compare ] )

Întoarce o valoare de tip Variant (Long) reprezentând poziţia primei apariţii a string2 în string1.

start (opţional). Expresie numerică care stabileşte poziţia de început pentru fiecare căutare. Dacă este omis, căutarea începe de la poziţia primului caracter. Argumentul este obligatoriu dacă se specifică o comparaţie.

string1 (obligatoriu). Şirul de caractere în care se va face căutarea.

string2 (obligatoriu). Şirul de caractere care este căutat


compare (opţional). Prezintă modalitatea în care se poate face compararea a două stringuri. Poate fi 0,1,sau2.

0-implicit - comparare binară

1 - comparare textuală, ne-senzitivă, adică fără să se ţină cont de caracterele mari sau mici.

2 - comparare bazată pe informaţiile din baza de date.

Dacă parametrul compare lipseşte, atunci setarea Option Compare din modulul de cod determină tipul comparaţiei.

Notă: Dacă nu se găseşte şirul specificat se întoarce valoarea 0. Dacă unul din şiruri este NULL, atunci NULL se întoarce.

Exemplu.

Dim SearchString, SearchChar, MyPos

SearchString ="XXpXXpXXPXXP" ' String în care se caută.

SearchChar = "P" ' Se caută "P".

MyPos = Instr(4, SearchString, SearchChar, 1) ' O comparaţie textuală începe de la poziţia 4. Întoarce 6.

MyPos = Instr(1, SearchString, SearchChar, 0) ' O comparaţie binară începe la poziţia 1. Întoarce 9.

MyPos = Instr(1, SearchString, "W") ' Întoarce 0.

' Comparaţia este binară implicit (lipseşte ultimul argument).

MyPos = Instr(SearchString, SearchChar) ' Întoarce 9.

Exemplu.

Private Sub cmdInstr_Click()

Debug. Print InStr("Alison Balter”, "Balter”) ‘Returnează 8

Debug. Print InStr ("Hello”, "1”) ‘Returnează 3

End Sub

------------------

I . 2 . 6 . 2 . 12 S tr ing( număr , carac ter )

Întoarce un şir de caractere, care conţine de număr de ori caracterul specificat.

Notă: Dacă în loc de caracter este un număr N caracterul multiplicat va fi Chr(N). Dacă N>255 se va folosi Chr(N Mod 256).

Notă: Dacă al doilea argument conţine un şir de mai multe caractere se va multiplica primul.

Exemplu.

Dim MyString

MyString = String(5, "*") ' Întoarce "*****".

MyString = String(5, 42) ' Întoarce "*****". - codul Ascii al caracterului * este 42

MyString = String(10, "ABC") ' Întoarce "AAAAAAAAAA".

------------------

I . 2 . 6 . 2 . 13 Space ( număr )

Întoarce un şir de caractere, care conţine de număr de ori caracterul spaţiu.

Exemplu.

Dim MyString

MyString = Space(8) ' întoarce un string cu 8 spaţii


MyString = "Hello" & Space(10) & "World" ' Inserează 10 spaţii între cele două cuvinte.

I . 2 . 6 . 2 . 14 Format( expres ie [ , format ] )

Funcţia Format formatează (transformă) într-un şir de caractere care respectă un şablon(format),o expresie.

• Expresie - este expresia pe care doriţi să o formataţi.

• Format (opţional) reprezintă tipul de format, şablon pe care doriţi să îl aplicaţi El este un nume valid de format[de ex "Long Time" sau "hh:mm:ss AMPM"] sau un format creat(definit) de utilizator.

Exemplu.

Private Sub cmdFormat_Click()

Dim MyTime, MyDate, MyStr

MyTime = #5:04:23 PM#

MyDate = #1/27/93#

' Se vor folosi şi următoarele funcţii care întorc timpul şi data curentă a sistemului de calcul:

' NOW() =întoarce data şi timpul

' TIME() =întoarce timpul

' DATE() =întoarce data

MyStr = Format(Time(), "Long Time")

MsgBox MyStr ' Afişează timpul curent al sistemului de calcul, în formatul definit în Windows pentru 'Long Time'

MyStr = Format(Date, "Long Date")

MsgBox MyStr ' Afişează data curentă a sistemului de calcul, în formatul definit în Windows pentru 'Long Date

MyStr = Format(MyTime, "h:m:s") ' Întoarce "17:4:23".

MsgBox MyStr

MyStr = Format(MyTime, "hh:mm:ss AMPM") ' Întoarce "05:04:23 PM".

MsgBox MyStr

MyStr = Format(MyDate, "dddd, mmm d yyyy") ' Întoarce "Miercuri, Ian 27 1993".

MsgBox MyStr

' Dacă parametrul format lipseşte se va întoarce un string.

MyStr = Format(23) ' Întoarce "23".

MsgBox MyStr

' Formate definite de utilizator. Se folosesc în continuare următoarele caractere pentru format:

' # - Întoarce cifra dacă există. Dacă nu există se întoarce 'blanc'

' 0 - Întoarce cifra dacă există. Dacă nu există se întoarce 0

' , - Întoarce separatorul de grupe de cifre(în sistemul românesc <,> sau american <.>) definit în Windows(System settings)

' . - Întoarce semnul pentru punctul zecimal în sistemul definit în Windows

' % - Întoarce în procente

MyStr = Format(5459.4, "##,##0.00") ' Întoarce "5,459.40".

MsgBox MyStr

MyStr = Format(334.9, "###0.00") ' Întoarce "334.90".

MsgBox MyStr


MyStr = Format(5, "0.00%") ' Întoarce "500.00%".

MsgBox MyStr

' Formate definite de utilizator. Se folosesc în continuare următoarele caractere pentru format:

' < - Întoarce stringul cu litere mici

' > - Întoarce stringul cu litere mari

MyStr = Format("HELLO", "<") ' Întoarce "hello".

MsgBox MyStr

MyStr = Format("This is it", ">") ' Întoarce "THIS IS IT".

MsgBox MyStr

MsgBox Format(50, "Currency") '50.00 LEI - Afişează în sistemul de valută definit în Windows(System settings)

MsgBox Format(Now(), "Short Date") ' 8/5/95 - Afişează în formatul definit pentru 'dată scurtă'

MsgBox Format(Now(), "DDDD") 'Afişează cuvantul pentru zi

MsgBox Format(Now(), "DDD") 'Afişează ziua prescurtat(pe 2,3 caractere)

MsgBox Format(Now(), "YYYY") 'Afişează anul din patru cifre

End Sub

'------------------

I . 2 . 6 . 3 F u n c ţ i i p en t r u t ab lou r i (a r r ay )

I . 2 . 6 . 3 . 1 UBound( ar rayname [ , dimension ] )

I . 2 . 6 . 3 . 2 LBound( ar rayname [ , dimension ] )

Întoarce o valoare de tip Long, care va conţine pentru o anumită dimensiune a unui tablou:

Pentru UBound : valoarea indicelui cel mai mare disponibil (marginea superioară).

Pentru LBound : valoarea indicelui cel mai jos disponibil (marginea inferioară).

Sintaxa funcţiei UBound cuprinde:

arrayname(obligatoriu). Denumirea variabilei care defineşte tabloul.

dimension(opţional). Este de tip Variant (Long). Indică dimensiunea a cărei margine (superioară sau inferioară) este întoarsă. Se utilizează 1 pentru prima dimensiune, 2 pentru a doua etc. Dacă lipseşte , automat va fi 1.

Funcţia UBound se utilizează împreună cu funcţia LBound pentru a determina mărimea unui tablou, şi anume:

LBound - pentru a găsi cea mai joasă valoare a dimensiunii unui tablou.

UBound - pentru a găsi cea mai mare valoare a dimensiunii unui tablou.


Exemplu.

UBound şi LBound întoarce următoarele valori pentru un tablou cu dimensiunile:

Dim A(1 To 100, 0 To 3, -3 To 4)

Funcţia ParametriiValoare

a întoarsă

UBound

(A,1) 100

(A,2) 3

(A,3) 4

LBound

(A,1) 1

(A,2) 0

(A,3) -3

------------------

Marginea cea mai de jos, implicită, pentru orice dimensiune a unui tablou creat prin declaraţie(Dim, Private, Public, ReDim sau Static) , este 0 sau 1. Ea depinde de setarea declaraţiei Option Base.(de obicei 0)

Excepţie. Baza unui tablou creat cu funcţia Array este 0, ea ne fiind afectată de Option Base.

Tablourile, pentru care dimensiunile sunt setate folosind To în declaraţiile Dim, Private, Public, ReDim sau Static pot lua orice valoare întreagă ca fiind marginea cea mai de jos (cel mai mic indice).

I . 2 . 6 . 4 F u n c ţ i i p en t r u mes a j e

I . 2 . 6 . 4 . 1 MsgBox( prompt [ , but tons ] [ , t i t l e ] )

Afişează un mesaj într-o căsuţă de dialog, aşteaptă utilizatorul să apese un buton şi întoarce o valoare de tip Integer care indică ce buton a fost apăsat de utilizator.

Sintaxa funcţiei MsgBox cuprinde următoarele argumente :

Prompt (obligatoriu). Expresie de tip string afişată ca mesaj în caseta de dialog. Lungimea sa maximă este de aproximativ 1024 caractere, depinzând de mărimea caracterelor folosite. Dacă promptul este compus din mai mult de un rând, se pot separa liniile utilizând un caracter CR (carriage return) Chr(13), un caracter LF (line feed) Chr(10), sau o combinaţie (Chr(13) & Chr(10)) după fiecare rând.

Buttons (optional). Expresie numerică care este suma valorilor reprezentând:

Dacă lipseşte, valoarea implicită a acestui parametru este 0.

Setările pentru butoanele argument sunt:

Constanta Valoare Descrierea Ce reprezintă

vbOKOnly 0 Afişează numai butonul OK.

Numărul şi tipul butoanelor afişate în caseta de dialog

VbOKCancel 1 Afişează butoanele OK şi Cancel.

VbAbortRetryIgnore 2 Afişează butoanele Abort, Retry şi Ignore.

VbYesNoCancel 3 Afişează butoanele Yes, No şi Cancel.

VbYesNo 4 Afişează butoanele Yes şi No.

VbRetryCancel 5 Afişează butoanele Retry şi Cancel.

VbCritical 16 Afişează pictograma Critical Message .Felul pictogramei utilizate în partea din stânga sus

VbQuestion 32 Afişează pictograma Warning Query .

VbExclamation 48 Afişează pictograma Warning Message

VbInformation 64 Afişează pictograma Information Message .


VbDefaultButton1 0 Primul buton este implicit

Care este butonul implicit

VbDefaultButton2 256 Al doilea buton este implicit.

VbDefaultButton3 512 Al treilea buton este implicit.

VbDefaultButton4 768 Al patrulea buton este implicit.

VbApplicationModal 0Aplicaţie modală-utilizatorul trebuie să răspundă casetei de mesaj înainte de a continua să lucreze în aplicaţia curentă

Dacă caseta de text este modală la nivelul aplicaţiei curente sau a tuturor taskurilor.VbSystemModal 4096

Sistem modal - toate aplicaţiile sunt blocate până când utilizatorul răspunde casetei de mesaj.

Title (optional). Expresie de tip string afişată pe bara de titlu a casetei de dialog. Dacă titlul lipseşte, se va plasa pe bara de titlu numele aplicaţiei.

Valoarea întoarsă de funcţie este:

Constanta Valoare Butonul pe care s-a apăsat

vbOK 1 OK

vbCancel 2 Cancel

vbAbort 3 Abort

vbRetry 4 Retry

vbIgnore 5 Ignore

vbYes 6 Yes

vbNo 7 No

Observaţia 2. Aceste constante sunt specificate de Visual Basic for Applications. În consecinţă, numele acestea pot fi utilizate oriunde în program în locul valorilor respective.

Observaţia 3. MsgBox poate fi utilizată şi ca procedură. În acest caz parametrii nu se mai scriu între paranteze. În această formă este folosită pentru afişarea unui mesaj.

Exemplu.

Public Sub TestMsgBox()

Dim Rasp As Integer

Dim Nr As Integer

Const LimInf = -100

Const LimSup = 100

' Generează o valoare aleatoare _

întreagă între LimInf şi LimSup

Randomize

Nr = Int((LimSup - LimInf + 1) * Rnd + LimInf)

'MsgBox folosit ca funcţie

' Afişează mesaj, şi introduce în Rasp, butonul apăsat de utilizator _

Se observă folosirea lui at( @ ) ca separator de rânduri!!

Rasp = MsgBox("Doriti modificarea semnului numarului " & Nr & _

" extras ? @ -Yes=Il face pozitiv; @ -No=Il face negativ; ", _

vbYesNoCancel + vbQuestion + vbDefaultButton3 + vbSystemModal, _

"Exemplu parametrii MsgBox")


If Rasp = vbYes Then

Nr = Abs(Nr)

ElseIf Rasp = vbNo Then

Nr = Abs(Nr) * -1

Else ' cazul Cancel

' Lasa numarul neschimbat

End If

MsgBox "Numarul prelucrat este: " & Nr, vbInformation 'MsgBox ca procedura

End Sub

------------------

I . 2 . 6 . 4 . 2 InputBox( prompt [ , t i t l e ] [ , defaul t ] [ , xpos ] [ , ypos ] )

Afişează un mesaj într-o casetă de dialog, aşteaptă ca utilizatorul să introducă un text sau să apese un buton şi întoarce o valoare de tip string ce conţine textul introdus de utilizator într-un Text Box.

Sintaxa funcţiei InputBox cuprinde următoarele argumente:

Prompt (obligatoriu). Expresie de tip string afişată ca mesaj în caseta de dialog. Lungimea sa maximă este de aproximativ 1024 caractere, depinzând de mărimea caracterelor folosite. Dacă promptul este compus din mai mult de un rând, se pot separa liniile utilizând un caracter CR (carriage return) Chr(13), un caracter LF (line feed) Chr(10), sau o combinaţie (Chr(13) & Chr(10)) după fiecare rând.

Title (optional). Expresie de tip string afişată pe bara de titlu a casetei de dialog. Dacă titlul lipseşte, se va plasa pe bara de titlu numele aplicaţiei.

Default (opţional). Expresie de tip string afişată în caseta de text ca răspuns implicit dacă utilizatorul nu introduce nimic. Dacă lipseşte, caseta de text va fi afişată goală.

Xpos (opţional). Expresie numerică care reprezintă, în twips, distanţa pe orizontală de la marginea din stânga a casetei de dialog la marginea din stânga a ecranului. Dacă lipseşte, caseta de dialog este centrată orizontal.

Ypos (opţional). Expresie numerică care reprezintă, în twips, distanţa pe verticală de la marginea de sus a casetei de dialog la marginea de sus a ecranului. Dacă lipseşte, caseta de dialog este poziţionată vertical la aproximativ o treime din distanţa până în subsolul ecranului.

Exemplu.

Următorul exemplu utilizează InputBox pentru a citi o dată introdusă de utilizator şi folosirea lui MsgBox şi ca funcţie şi ca procedură (pentru afişarea unor mesaje). Se observă utilizarea semnului @ pentru a delimita diversele părţi ale şirului de caractere.

Sub CustomMessage()

Dim strMsg As String, strInput As String

' Iniţializează stringul.

strMsg = "Număr în afara intervalului. @ Aţi introdus un număr care este” _

& "mai mic decât 1 şi mai mare ca 10. @ Apăsaţi OK pentru a introduce”_

& "numărul din nou." ' Se observă rolul lui @ de delimitator de rânduri

' Se cere utilizatorului să introducă ceva.

strInput = InputBox("Introduceţi un număr între 1 şi 10.")


' Determină dacă utilizatorul introduce un şir vid <"">, adică nimic.

If strInput <> "" Then ' Testează valoarea intodusă de utilizator

Do While (strInput < 0 Or strInput > 10)

If MsgBox(strMsg, vbOKCancel, "Error!") = vbOK Then

strInput = InputBox("Introduceţi un număr între 1şi 10.")

Else

Exit Sub

End If

Loop

' Afişează data corectă introdusă de utilizator.

MsgBox "Aţi introdus numărul” & strInput & "."

Else ' nu s-a introdus nimic

Exit Sub

End If

End Sub

------------------

I . 2 . 6 . 5 F u n c ţ i i cu t i pu l : Date/Time

I . 2 . 6 . 5 . 1 DatePart ( in terval , date )

Funcţia DatePart întoarce o partea unei date, specificată de argumentul intervalArgumentul interval, de tip string, poate lua următoarele valori:

interval Descriere interval Descriere

yyyy Anul w Ziua din săptămâna

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ă numarul lunii curente

MsgBox DatePart ("Q”, Now) ‘Afişează numarul trimestrului curent

MsgBox DatePart ("Y”, Now) ‘Afişează ziua din anul curent

End Sub

------------------

I . 2 . 6 . 5 . 2 DateDif f( in terval , date1 , date2 )

Funcţia DateDiff întoarce intervalul de timp dintre două date, deci date2-date1. Unitatea de timp este , specificată de argumentul interval

Exemplu.

Private SubcmdDateDiff_Click()

MsgBox DateDiff ("d”, Now, #12/31/02#) ‘Numarul zilelor pana la 12/31/02


MsgBox DateDiff ("m”, Now, #12/31/02#) ‘Numarul lunilor pana la 12/31/02

MsgBox DateDiff ("yyyy”, Now, #12/31/02#) ‘Numarul anilor pana la 12/31/02

MsgBox DateDiff ("q”, Now, #12/31/02#) ‘Numarul trimestrelor pana la 12/31/02

End Sub

------------------

I . 2 . 6 . 5 . 3 DateAdd( in terval , number , date )

Funcţia DateAdd întoarce rezultatul adăugării sau scăderii unei perioade specifice de timp - precizată prin argumentul interval - la o (dintr-o) dată stabilită.

Private Sub cmdDateAdd_Click ()

MsgBox DateAdd (”d”, 3, Now) ‘Ziua de azi plus 3 zile

MsgBox DateAdd (”m”, 3, Now) ‘Ziua de azi plus 3 luni

MsgBox DateAdd (”yyyy”, 3, Now) ‘Ziua de azi plus 3 ani

MsgBox DateAdd ("q”, 3, Now) ‘Ziua de azi plus 3 trimestre

End Sub

------------------

I . 2 . 6 . 5 . 4 Day( date ) ; Month( date ) ; Year( date )

Întoarce un Variant (Integer), care va conţine ziua sau luna sau anul, conţinut în data din argument.

------------------

I . 2 . 6 . 5 . 5 Second( date ) ; Minute( date ) ; Hour( date )

Întoarce un Variant (Integer), care va conţine secunda sau minutul sau ora, conţinut în data din argument.

------------------

I . 2 . 6 . 5 . 6 Now

Întoarce un Variant (Date), care specifică data şi timpul curent, care este în sistemul de calcul.

------------------

I . 2 . 6 . 5 . 7 Date

Întoarce un Variant (Date), care specifică data curentă, care este în sistemul de calcul.

------------------

I . 2 . 6 . 5 . 8 T imp

Întoarce un Variant (Date), care specifică timpul curent, care este în sistemul de calcul.

------------------

I . 2 . 6 . 5 . 9 DateSeria l ( year , month , day )

Întoarce un Variant (Date) care va conţine data specificată în argumentele: year, month, and day.

Descrierea argumentelor:

• year obligatoriu; Integer. Număr între 100 and 9999, inclusiv, sau expresie numerică.

• month obligatoriu; Integer. Orice expresie numerică.

• day obligatoriu; Integer. Orice expresie numerică.

Remarks


Pentru a specifica o dată, de exemplu December 31, 1991, valoarea fiecărui parametru trebuie să fie validă, adică ziua între 1-31 şi luna între 1-12.

Exemplu următor va întoarce o dată, exprimată relativ faţă de altă dată. Se observă că operaţiile se fac specific pentru zile şi luni, ţinându-se cont de numărul de zile şi luni. Astfel ziua (1 - 1) din luna (8 - 2), ar trebui să fie 0/6, dar practic dacă scădem o zi din 1 iunie, avem 31/Mai.Deci, DateSerial(1990 - 10, 8 - 2, 1 - 1) va fi: 31/Mai/1980.

Dacă argumentul pentru an este între 0 şi 99, se vor considera anii din două cifre setaţi în Windows. Pentru ceilalţi ani trebuiesc introduse 4 cifre.

Dacă un argument este dat în afara intervalului acceptat, atunci se va întoarce o dată care este practic mărită cu numărul de zile sau luni care depăşesc valoarea maximă pentru argumentul respectiv. De exemplu MsgBox(DateSerial(1998, 11, 32)) va afişa 2 /12/1998

Exemplu.

Dim MyDate

MyDate = DateSerial(1969, 2, 12) ' Întoarce data February 12, 1969.

------------------

I . 2 . 6 . 6 F u n c ţ i i : s t r u c tu r i d e con t r o l

I . 2 . 6 . 6 . 1 IIf ( condi ţ ie , TruePar t , FalsePar t )

Această funcţie are o acţiune asemănătoare cu a instrucţiunii If…Then…ElseFuncţia IIf întoarce unul din cele două argumente, TruePart sau FalsePart, funcţie de rezultatul

evaluării condiţiei ce se găseşte în primul argument. Astfel, dacă:

• condiţie = true - funcţia întoarce parametrul TruePart• condiţie = false - funcţia întoarce parametrul FalsePartNotă: Toţi cei trei parametrii ai funcţiei sunt obligatorii.

Observaţia 1. TruePart sau FalsePart, pot la rândul lor să conţină o altă funcţie, deci şi IIF, ceea ce permite realizarea unor structuri complexe de teste.

Exemplu.

Function TestIF(TestMe As Integer)

TestIF = IIf(TestMe > 1000, "Large", "Small")

End Function

Dacă va fi folosită în:

MsgBox TestIF(1500) ' afişează Large

MsgBox TestIF(500) ' afişează Small

------------------

I . 2 . 6 . 6 . 2 Choose( index , caz-1 [ , caz-2 , . . . [ , caz-n ] ] )

Funcţia Choose, selecţionează şi întoarce, unul din argumentele listei, şi anume caz-1 sau caz-2 sau ... caz_n, funcţie de valoarea pe care o are argumentul index, şi anume:

Dacă index=1 atunci se întoarce caz-1 Dacă index=2 atunci se întoarce caz-2 Dacă index=n atunci se întoarce caz-n

Notă: Dacă index < 1, sau index > n, atunci Choose întoarce valoarea Null

Exemplu.

Function GetChoice(Ind As Integer)


GetChoice = Choose(Ind, "Speedy", "United", "Federal")

End Function

'La apelul funcţiei vom avea:

MsgBox GetChoice (2) ' afişează United

------------------

Dim X As Variant

X = GetChoice (5) ' X se va face Null

------------------

I . 2 . 6 . 6 . 3 Swi tch( expr-1 , value-1 [ , expr-2 , value-2 … [ , expr- n , va lue-n ] ] )

Această funcţie are o acţiune asemănătoare cu a instrucţiunii If…Then…ElseIf…ElseFuncţia Switch va evalua la în ordine, condiţiile, expr-1, expr-2, expr-n, pînă când va obţine o

valoare true. În acest moment, cercetarea se opreşte, şi funcţia întoarce valoarea pereche care se găseşte în argumentul value_?. Daci:

Dacă expr-1 = True atunci se întoarce value-1, şi gata…

Dacă expr-1 = False atunci trece la evaluarea următoare

Dacă expr-2 = True atunci se întoarce value-2, şi gata…

Dacă expr-2 = False atunci trece la evaluarea următoare

Etc.

Notă: Dacă nici una din expresiile evaluate nu este True, atunci Switch întoarce valoarea Null

Exemplu.

Function MatchUp (CityName As String)

Matchup = Switch(CityName = "London", "English", CityName _

= "Rome", "Italian", CityName = "Paris", "French")

End Function

------------------

'La apelul funcţiei vom avea:

MsgBox MatchUp ("Paris") ' afişează French

------------------

I . 2 . 6 . 7 F u n c ţ i i d e in s pec ţ i e

I . 2 . 6 . 7 . 1 VarType( NumeVar iabi lă )

Întoarce un Integer, care precizează ce tip de date se găseşte în variabila NumeVariabilă , de tip variant, care este argumentul funcţiei.

Reamintim că variabilele de tip variant, se caracterizează prin faptul că în ele se pot introduce valori de diferite tipuri. Funcţia VarType, tocmai acest rol are, să ne indice la un moment dat, ce tip de date se găsesc într-o variabilă de tip variant.


Rezultatul întors de funcţia VarType

Constanta Valoare Descriere

vbEmpty 0 Empty (neiniţializat)

vbNull 1 Null (lipsa datelor valide)

vbInteger 2 Integer

vbLong 3 Long integer

vbSingle 4 Single-precision - număr în virgulă mobilă

vbDouble 5 Double-precision - număr în virgulă mobilă

vbCurrency 6 Currency - valoare

vbDate 7 Date - valoare de tip Date/Text

vbString 8 String

vbObject 9 Object

vbError 10 Error

vbBoolean 11 Boolean - valoare

vbVariant 12 Variant (folosit numai ]n tablouri de Variant)

vbDataObject 13 Obiect de acces la date

vbDecimal 14 Decimal - valoare

vbByte 17 Byte - valoare

vbArray 8192 Array - Tablou

Notă: Constantele fiind definite în Visual Basic for Applications, ele pot fi folosite oriunde în loc de valorile specificate.

Exemplu.

Dim IntVar, StrVar, DateVar, MyCheck 'Variabile declarate variant, deoarece lipseşte tipul de data

' Iniţializarea variabilelor.

IntVar = 459: StrVar = "Hello World": DateVar = #2/12/69# 'Aşa se pot scrie mai multe instrucţiuni pe rând

MyCheck = VarType(IntVar) ' Întoarce 2. Se separă aşa cum se vede cu două puncte.

MyCheck = VarType(DateVar) ' Întoarce 7.

MyCheck = VarType(StrVar) ' Întoarce 8.

------------------

I . 2 . 6 . 7 . 2 IsNul l ( expres ie )

Î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


Notă: Aşa cum am mai arătat dacă un termen al expresiei este Null, atunci expresia va fi tot Null, şi funcţia va întoarce evident True.

Observaţia 1. Valoarea Null, îndică faptul că un Variant nu conţine date valide. Mai există încă două valori Empty şi String vid(gol) care pot fi uşor confundate cu Null, ceea ce constituie o eroare. Deci vom avea:

• NULL - variabilă variant în care datele nu sunt valide.

• EMPTY - variabilă variant care nu a fost îniţializată.

• String de lungime 0 ( vid, gol) - string care nu are nimic în el, adică este "".

Exemplu.

Dim MyVar, MyCheck ' variabile variant

MyCheck = IsNull(MyVar) ' Întoarce False, deoarece este Empty

MyVar = ""

MyCheck = IsNull(MyVar) ' Întoarce False, deoarece este string vid(de lungime 0).

MyVar = Null

MyCheck = IsNull(MyVar) ' Întoarce True.

------------------

I . 2 . 6 . 7 . 3 IsEmpty( NumeVar iabi la )

Întoarce o valoare de tip Boolean care indică dacă o variabilă, transmisă ca parametru de intrare este sau nu iniţializată.

Parametrul este de tip variant şi conţine o dată de tip numeric sau string.

Funcţia IsEmpty întoarce:

• True - dacă variabila NumeVariabila nu este iniţializată, sau a fost introdusă în ea direct Empty.

• False - variabila a fost iniţializata(chiar cu Null sau un string vid)

Exemplu.

Dim MyVar, MyCheck ' variabile variant

MyCheck = IsEmpty(MyVar) ' Întoarce True.

MyVar = Null ' Assign Null.

MyCheck = IsEmpty(MyVar) ' Întoarce False.

MyVar = Empty ' Assign Empty.

MyCheck = IsEmpty(MyVar) ' Întoarce True.

------------------

I . 2 . 6 . 7 . 4 IsMiss ing( NumeParametru )

IsMissing se foloseşte într-o rutină, pentru a testa dacă un parametru opţional al acesteia, a fost sau nu introdus în lista parametrilor actuali de la apelarea acestei rutine.

Parametrul funcţiei IsMissing, <NumeParametru> este de tip variant şi este chiar parametrul optional.

Funcţia IsMissing întoarce o valoare de tip Boolean, care va avea valoarea TRUE, numai dacă parametrul opţional testat, nu a fost introdus în lista parametrilor actuali, deci el practic lipseşte

Exemplu.

Dim ReturnValue

' Se va apela funcţia ReturnTwice definită de utilizator cu un parametru declarat opţional

ReturnValue = ReturnTwice() ' Întoarce Null.


ReturnValue = ReturnTwice(2) ' Întoarce 4.

' Declararea funcţiei.

Function ReturnTwice(Optional A)

If IsMissing(A) Then

' Funcţia a fost apelată fără parametrul A

ReturnTwice = Null

Else

' Funcţia a fost apelată cu parametrul A

ReturnTwice = A * 2

End If

End Function

------------------

Observaţia 1. Funcţia IsMissing, se aplică numai dacă parametrul opţional este de tip variant. Dacă parametrul opţional nu este de tip variant ea va întoarce întotdeauna(fie că parametrul opţional este sau nu este folosit la apelarea funcţiei) valoarea FALSE.

I . 2 . 6 . 8 F u n c ţ i i l e agr ega te S Q L

O funcţie agregată SQL, este specifică prin faptul că datele ei de intrare sunt valorile unui câmp dintr-o tabelă(cerere) - care este legată de obiectul în care se foloseşte, adică cerere, tabel, formular sau raport - , din toate sau o parte din înregistrări.

Ele calculează expresii al căror domeniu de aplicabilitate este un câmp al tabelei(cererii) care se utilizează în obiectul unde sunt folosite. În cazul rapoartelor sau formularelor, funcţii agregate SQL, se calculează pe tabela(cererea) legată la acesta.

Funcţiile agregate SQL se folosesc fără argumente

Funcţiile agregate SQL sunt:

SUM - calculează suma valorilor pe un câmp.

MAX, MIN - întoarce valoarea maximă / minimă a unui câmp.

AVG - calculează media aritmetică a valorilor unui câmp.

COUNT - numărul de înregistrări ale câmpului(diferite de NULL). Dacă se doreşte ca să se ia în calcul şi câmpurile cu valoarea NULL, atunci se va folosi expresia COUNT(*).

VAR, VARP, STDEV, STDEVP - calcule statistice(varianţa şi deviaţia standard)

Notă: Valoarea NULL, în funcţiile agregate (SQL sau de domeniu), nu se ia în considerare. În celelalte funcţii sau operaţii, valoarea NULL a unui termen duce, la rezultatul NULL al expresiei, indiferent de felul în care e constituită aceasta.

------------------

I . 2 . 6 . 9 F u n c ţ i i l e agr ega te de domen iu .

Funcţiilor agregate de domeniu întorc date de calcul agregate, la fel ca şi funcţiile agregate SQL. Diferenţa rezultă din faptul că domeniul de definiţie al acestor funcţii, este reprezentat de un câmp al unei tabele(cereri) - din baza de date curentă - asupra căruia se aplică, eventual, un criteriu de selecţie a înregistrărilor. Domeniului de definiţie este stabilit de valorile ce se găsesc în parametrii(argumentele) funcţiei.

Funcţiilor agregate de domeniu, (au aceiaşi denumire ca a funcţiilor agregate SQL, dar cu litera D în faţă) sunt

DSum - calculează suma valorilor pe un câmp.

D Max, Dmin - întoarce valoarea maximă / minimă a unui câmp.

DAvg - calculează media aritmetică a valorilor unui câmp.


DCount - numărul de înregistrări ale câmpului(diferite de NULL).

DVar, DVarP, DStDev, DStDevP - calcule statistice(varianţa şi deviaţia standard)

DLookUp - întoarce prima valoare întâlnită în domeniul selecţionat. (aceasta nu are echivalent în funcţiile agregate SQL)

Argumentele folosite sunt aceleaşi în toate aceste funcţii, şi stabilesc aşa cum am mai arătat, care este domeniul de definiţie pe care se calculează valoarea agregată.

Dfuncţie((NumeCâmp, NumeTabela[, Criteriu])• Nume Câm, NumeTabela - sunt stringuri care stabilesc care este câmpul din tabela(cererea) asupra

căreia se fac calculele agregate.

• Criteriu - este un string prin care se introduce un criteriu de selecţie a înregistrărilor din domeniul specificat de primii doi parametrii. Dacă nu este prezent acest parametru se vor lua în calcul datele din câmpul respectiv din toate înregistrările tabelei specificate.

Notă: Dacă nu se selecţionează datorită criteriului nici o înregistrare, funcţia întoarce valoarea NULL.

Exemplu.

Dim varX As Variant, iNr As Integer, sSir As String

' cazul 1 - selecţia înregistrărilor cu CodStudent având valoarea <100 - întoarce dintre acestea valoarea Nume cea mai mare în ordinea de sortare.

varX = DMax("[Nume]", "Studenti", "[CodStudent]<1oo") ' CodStudent este de tip numeric

' cazul 2 - selecţia înregistrărilor cu Nume având valoarea 'Doru' - întoarce dintre acestea valoarea Anul cea mai mică

varX = DMin("[Anul]", "Studenti", "[Nume]='Doru' ") ' Nume este de tip text

' cazul 3 - selecţia înregistrărilor cu CodStudent având valoarea < cea din variabila numerică iNr - întoarce dintre acestea valoarea Nume cea mai mare în ordinea de sortare.

iNr = 100

varX = DMax("[Nume]", "Studenti", "[CodStudent]<" & Nr) ' CodStudent este de tip numeric

' cazul 4 - selecţia înregistrărilor cu Nume având valoarea ce se găseşte în variabila string sSir - întoarce dintre acestea valoarea Anul cea mai mică

sSir = "Doru"

varX = DMin("[Anul]", "Studenti", "[Nume]='" & sSir & "'") ' Nume este de tip text

------------------

Se observă că în formarea criteriului este foarte important dacă criteriul se va aplica pe un câmp numeric sau de tip text. În cazul când avem de-a face cu un câmp text valoarea cu care se face compararea trebuie la rândul ei să fie string, deci încadrată din nou între ghilimele (2 ghilimele într-un string delimitat de ghilimele sunt considerate ca un semn ghilimea) sau un apostrof. Deci "[Nume]='Doru' " este echivalent cu "[Nume]=""Doru"" "

Lucrurile se complică în momentul în care criteriul pe care îl introducem va compara un câmp cu o valoare ce se află într-o variabilă, ca în cazurile 3 şi 4. Important este să ştim că forma de scriere a criteriului este diferită funcţie de natura câmpului folosit de criteriu, număr sau text.

Notă: Reamintesc că valoarea NULL, în funcţiile agregate (de domeniu sau SQL), nu se ia în considerare. În celelalte funcţii sau operaţii, valoarea NULL a unui termen duce, la rezultatul NULL al expresiei, indiferent de felul în care e constituită aceasta.

------------------

I . 2 . 6 . 1 0 F u n c ţ i i d e con ver s i e

I . 2 . 6 . 10 .1 S tr( Număr )

Transformă un număr într-un şir de caractere, care vor reprezenta numărul respectiv.


• Număr - argumentul funcţiei, de tip Long, care va conţine o expresie numerică ce va fi convertită într-un şir de caractere.

Observaţia 1. După conversie, la începutul stringului va fi un spaţiu pentru numerele pozitive / sau semnul (-) pentru numerele negative.

Observaţia 2. Punctul zecimal va fi reprezentat întotdeauna de semnul punct(.), indiferent de cum este setat acesta în Windows(ca punct sau ca virgulă).

Notă: Pentru transformările numerelor în stringuri dar care să respecte alte reguli de prezentare, se foloseşte funcţia Format.

Exemplu.

Dim MyString

MyString = Str(459) ' Întoarce " 459".

MyString = Str(-459.65) ' Întoarce "-459.65".

MyString = Str(459.001) ' Întoarce " 459.001".

------------------

I . 2 . 6 . 10 .2 Val ( s t r ing )

Întoarce numărul conţinut în string, ca pe o valoare numerică de tipul cel mai apropiat reprezentării valorii respective.

Notă: Funcţia Val, în momentul în care întâlneşte un caracter care nu poate face parte din reprezentarea unui număr, opreşte inspecţia în continuare, şi face conversia numai până la acest caracter.

• Printre caracterele care nu sunt recunoscute de funcţia Val, sunt şi virgula(,) sau semnul dolar($).

• &O şi &H, sunt considerate ca rădăcina pentru numere în reprezentarea octală, respectiv hexazecimală.

• Spaţiile, tab-ul şi LF, nu se iau în considerare(se sar)

• Punctul zecimal va fi reprezentat întotdeauna de semnul punct. (.)

Exemplu.

Dim MyValue

MyValue = Val("2457") ' Întoarce 2457.

MyValue = Val(" 2 45 7") ' Întoarce 2457.

MyValue = Val("24 and 57") ' Întoarce 24.

MyValue = Val(" 1615 198th Street N.E.") ' Întoarce 1615198

------------------


I . 2 . 7 Med iu l d e d ep an are ş i d ezvo l tare VB A .

Meniul de execuţie şi depanare al VBA, este prezentat mai jos:


Execută instrucţiune cu instrucţiune dar cursorul galben de execuţie se va opri numai pe:g Toate

instr.Nu va mai intra în rutinele apelatei Nu se va mai opri în rutina în care este o

Resetează toate variabilele globale ale aplicaţiei

Afişează fereastra Debug. În aceasta se vor regăsi toate afişările făcute cu instrDebug.Print

Comenzile de compilare

Bara pentru Visual Basic Run

Stop

Punctul de întrerupereVa 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

Cursorul de marcare a instrucţiunii care se va executa

73642788 Programarea in Visual Basic for Application VBA 1

Documents

Transcript of 73642788 Programarea in Visual Basic for Application VBA 1