Förord

Att hitta på knasiga namn på dina variabler, konstanter och procedurer är ett av de absolut bästa sätten att göra koden obegriplig!

Innehåll

  » Namngivning av variabler och konstanter
  » Deklaration av variabler och konstanter
  » Objektvariabler

Namngivning av variabler och konstanter

Namn på procedurer, variabler och konstanter består av högst 255 bokstäver eller siffror. (I Visual Basic 3.0 och äldre versioner gick gränsen vid 40.) Blanksteg och punkt är inte tillåtna i namnet. Understreck ( _ ) tillåts som ersättning för blanksteg, men kamelnotation (StorBokstavInlederVarjeOrd) kan också användas. Vissa andra specialtecken är tillåtna i namnet, men bör undvikas. Det första tecknet i namnet får inte vara en siffra.

Procedurer, variabler och konstanter får inte namnges med reserverade ord som End, If, Else, Sub, Function, Public och Private. Välj namn som upplyser om procedurens, variabelns eller konstantens användning. Om en variabel kommer att innehålla namn på olika företag bör den inte kallas strMyLittleString, utan strCompany eller något liknande. Variabelnamn som intA, intB och intC bör användas sparsamt. De är visserligen korta, men säger ingenting om variabelns användning, vilket gör koden svårare att förstå.

VARNING!
Visual Basic 6.0 finns inte bara i amerikansk version, utan även i tysk, fransk, italiensk och spansk version. Däremot inte i svensk version. Ändå är det tillåtet att använda bokstäver som Å, Ä och Ö, vilket inte är tillåtet i programmeringsspråk som C++ och Java. Undvik Å, Ä och Ö vid namngivning av procedurer, variabler och konstanter! Använd engelska namn. Då blir koden lättare att tolka för människor i andra länder och lättare att arbeta med i utländska språkversioner av Windows.

Deklaration av variabler och konstanter

Explicit variabeldeklaration krävs om man skriver


Option Explicit


överst i modulens huvud. Observera att denna sats måste skrivas överst i varje modul där man vill kräva explicit variabeldeklaration. Explicit variabeldeklaration betyder att det blir obligatoriskt att deklarera alla variabler i modulen, vilket är bra. Alla seriösa programmerare använder explicit variabeldeklaration. Det minskar risken för alla möjliga misstag.

Exempel på variabeldeklaration:


Private Sub cmdMyButton_Click()
Dim strCompany As String
Dim strLastName As String
Dim intNumber As Integer


Uttrycket Dim är en förkortning av det engelska verbet dimension, som betyder dimensionera. Man kan även skriva så här:


Private Sub cmdMyButton_Click()
Dim strCompany As String, strLastName As String, intNumber As Integer


VARNING!
Du som är van vid andra programmeringsspråk, t ex Delphi, kanske får för dig att skriva så här:


Private Sub cmdMyButton_Click()
Dim strCompany, strLastName As String, intNumber As Integer


Så här ska man inte deklarera variabler i Visual Basic. I detta exempel får variabeln strCompany inte datatypen String, utan datatypen Variant, som alla variabler får när man struntar i att ange datatyp eller struntar i att deklarera överhuvudtaget.

Variabler med datatypen String kan deklareras med fast längd:


Private Sub cmdMyButton_Click()
Dim strCompany As String * 8


Detta betyder att variabeln strCompany alltid kommer att innehålla åtta tecken. Om den tilldelas en kortare text kommer kvarstående positioner att fyllas med blanksteg. Om den tilldelas en längre text kommer överskjutande tecken att försvinna.

I hjälptexterna skriver Microsoft att en String med fast längd kan innehålla "ungefär" 65536 tecken. Om man kontrollerar själv verkar den exakta gränsen vara 65526.

Från början fanns det sju datatyper i Visual Basic:

Datatyp	Användningsområde	Startvärde	Prefix	Suffix	Antal byte
Integer	Heltal från -32768 till 32767	0	int	%	2
Long	Heltal från -2147483648 till 2147483647	0	lng	&	4
Single	Decimaltal från -3,402823x1E38 till -1,401298x1E-45 och från 1,401298x1E-45 till 3,402823x1E38, samt 0	0	sng	!	4
Double	Decimaltal från -1,79769313486231x1E308 till -4,94065645841247x1E-324 och från 4,94065645841247x1E-324 till 1,79769313486232x1E308, samt 0	0	dbl	#	8
Currency	Penningbelopp från -922337203685477,5808 till 922337203685477,5807	0	cur	@	8
String	Text som kan bestå av 2147483648 tecken eller "ungefär" 65536 tecken om variabeln deklareras med fast längd	""	str	$	Olika
Variant	Kan innehålla både tal och text	Empty	vnt	Saknas	Olika

I Visual Basic 4.0 kom det fyra nya datatyper:

Datatyp	Användningsområde	Startvärde	Prefix	Suffix	Antal byte
Boolean	Variabler som kan innehålla värdena True eller False	False	bln	Saknas	2
Byte	Heltal från 0 till 255	0	byt	Saknas	1
Date	Datum från 100-01-01 till 9999-12-31	0 (1899-12-30)	dte	Saknas	8
Object	En referens till ett godtyckligt objekt	Saknas	obj	Saknas	4

I Visual Basic 6.0 kom det ytterligare en datatyp:

Datatyp	Användningsområde	Startvärde	Prefix	Suffix	Antal byte
Decimal	Decimaltal inom följande gränser: +/-79228162514264337593543950335 utan decimaler +/-7,9228162514264337593543950335 med 28 decimaler Minsta tal skiljt från 0 är +/-0,0000000000000000000000000001	Empty	dec	Saknas	14

Med startvärde menas variabelns värde när den har deklarerats, men ännu inte tilldelats något värde. Många programmerare tycks tro att variabler då är "tomma" eller på något sätt "opålitliga". Så är inte alls fallet. De är mycket pålitliga. En Boolean har värdet False. En String innehåller en "nollängdssträng", alltså "". En Byte, Integer, Long, Single och Double har alla värdet 0. En Date har också värdet 0, vilket motsvarar 1899-12-30 (se avsnittet Typkonvertering nedan).

Empty är ett speciellt "värde" som en variabel med datatypen Variant har innan den tilldelas något värde. Man kan även tilldela en sådan variabel "värdet" Null för att visa att variabeln avsiktligen är "tom". Av samma orsak kan man tilldela en variabel med datatypen Object "värdet" Nothing.

En Decimal kan inte deklareras på vanligt sätt i Visual Basic 6.0, utan deklareras först som en Variant och omvandlas sedan till en Decimal med typkonverteringsfunktionen CDec. Datatypen Decimal bör inte användas i onödan. Single och Double bör heller inte användas i onödan. Dessa datatyper tar mera plats i datorns arbetsminne. Datatypen Variant bör i möjligaste mån undvikas, eftersom den tar mest plats.

Använd alltid ovannämnda prefix (int, lng, sng, dbl, cur, str, vnt, bln, byt, dte, obj och dec) i början av variabelnamn. Att använda prefix i början av variabelnamn kallas ungersk notation. Det är inte något krav, men gör koden lättare att förstå. Varför? Jo, för det första ser man på variabelnamnet vilken datatyp det är frågan om, vilket minskar risken för olämpliga val av datatyper. För det andra ser man lättare vilka ord som överhuvudtaget är namn på variabler och vilka ord som är andra ord i koden. Dessutom finns det ett tredje skäl, som ofta glöms bort. Om man använder ungersk notation kan man använda samma namn till olika variabler genom att kalla en variabel för strNamn, en annan för intNamn, en tredje för lngNamn osv. Det kan vara mycket praktiskt.

Suffixen % (Integer), & (Long), ! (Single), # (Double), @ (Currency) och $ (String) kan användas för att deklarera variabler på ett snabbare sätt:


Private Sub cmdMyButton_Click()
Dim strCompany$, strLastName$, intNumber%
strCompany = "Kalles Bageri"
strLastName = "Karlsson"
intNumber = 345


I detta exempel får variablerna strCompany och strLastName datatypen String och variabeln intNumber datatypen Integer. Visual Basic tillåter detta skrivsätt när det gäller sex av de sju ursprungliga datatyperna. Många programmerare tycker att detta skrivsätt är svårtolkat och inkonsekvent, eftersom det inte kan tillämpas på alla datatyper.

Även vissa funktioner som ingår i själva programmeringsspråket är försedda med suffix, t ex Format$, Left$, Right$, Mid$, Trim$ osv. Microsoft ville på detta sätt poängtera att dessa funktioner har returvärden med datatypen String. Många programmerare tycks undvika dessa funktioner numera, även om de fortfarande är tillgängliga i Visual Basic 6.0. Istället använder man funktionerna Format, Left, Right, Mid, Trim osv, som har returvärden med datatypen Variant. Det är synd, för Format$, Left$, Right$, Mid$, Trim$ osv kan faktiskt ge programmet en viss prestandaförbättring.

Man kan sätta suffix på sina egna funktioner också. Följande funktion fungerar utmärkt och har ett returvärde med datatypen Long:


Public Function Summa&(A&, B&)
Summa = A + B
End Function


Skriv inte svårtolkad kod i Visual Basic! Skriv istället


Public Function Summa(lngA As Long, lngB As Long) As Long
Summa = lngA + lngB
End Function


Konstanter deklareras med uttrycket Const enligt följande exempel:


Private Sub cmdMyButton_Click()
Dim strCompany As String
Dim strLastName As String
Dim intNumber As Integer
Const intBonus As Integer = 500
Const strEmployer As String = "Microsoft"
Const dteStart As Date = #1981-08-12#


Observera att man använder tecknen " respektive # på ömse sidor när man tilldelar ett värde till en variabel eller konstant med datatypen String respektive Date.

En annan skrivregel som är bra att känna till är prefixet &H, som används framför tal i hexadecimal form, och &O, som används framför tal i oktal form. 15 i decimala talsystemet är samma sak som F i hexadecimala talsystemet, men i Visual Basic går det inte att bara skriva F. Man måste skriva &HF.

I kod från äldre versioner av Visual Basic ser man ofta att programmerare har deklarerat konstanternas namn med stora bokstäver, utan prefix och utan att ange datatyp, vilket numera inte rekommenderas. Att man skrev så berodde delvis på att man inte fick ange datatyp när man deklarerade konstanter i Visual Basic 3.0 och äldre versioner. Stora bokstäver tycker somliga är bra att använda för att man ska se på namnet att det är frågan om en konstant, men det är viktigare att se på namnet vilken datatyp det är frågan om.

Objektvariabler

Objektvariabler deklareras med tidig eller sen bindning. Tidig bindning är alltid att föredra, eftersom det ger bättre prestanda.

Ett exempel på tidig bindning:


Private Sub cmdStartExcel_Click()
Dim xlApp As Excel.Application
Dim xlBook As Excel.Workbook
Set xlApp = New Excel.Application
xlApp.Visible = True
Set xlBook = xlApp.Workbooks.Add
End Sub


Ett exempel på sen bindning:


Private Sub cmdStartExcel_Click()
Dim xlApp As Object
Dim xlBook As Object
Set xlApp = CreateObject("Excel.Application")
xlApp.Visible = True
Set xlBook = xlApp.Workbooks.Add
End Sub


Vid sen bindning deklareras objektvariabler As Object. Det kan vara nödvändigt om man skriver en procedur som använder olika objekt som argument.

För att dessa två exempel ska fungera krävs en referens till Microsoft Excel i dialogrutan References, som man öppnar genom att klicka på References... på menyn Project.

0 Kommentarer

Skriv en kommentar på artikeln

Ditt betyg på artikeln

UtmärktLäsvärdIntressantMindre braDålig

Kommentar: