Fråga: Vad betyder DIM i Visual Basic och BASIC? Vad är en variabel och hur man deklarerar den korrekt

Lämna en kommentar 6,950

Deklarerar en variabel eller matris.

Om variabler listas separerade med kommatecken (till exempel DIM sPar1, sPar2, sPar3 AS STRING), kan endast Variantvariabeln definieras. I allmänhet måste varje variabel definieras på en separat rad.

DIM sPar1 AS STRING

DIM sPar2 AS STRING

DIM sPar3 AS STRING

Dim deklarerar lokala variabler i procedurer. PUBLIC- och PRIVATE-satserna används för att deklarera globala variabler.

Syntax:

Dim variabel [(start till slut)] [, variabel 2 [(start till slut)] [,...]]

Parametrar:

Variabel: Ett godtyckligt namn på en variabel eller array.

Start, End: numeriska värden eller konstanter som anger antalet element (Number_of_elements=(Start-End)+1) och indexintervall.

Start och End kan också vara numeriska uttryck om ReDim tillämpas på procedurnivå.

Typ: Ett nyckelord som deklarerar typen av variabel.

Nyckelord: variabeltyp

Bool: Variabel av typen Boolean (True, False)

Valuta: en variabel av typen Valuta (ett valutavärde med en bråklängd av 4 positioner)

Datum: Variabel av typen Datum

Dubbel: dubbel precision flyttal variabel (1,79769313486232 x 10E308 - 4,94065645841247 x 10E-324)

Heltal: variabel av typen Heltal (-32768 - 32767)

Lång: variabel av typen Långt heltal (-2 147 483 648 - 2 147 483 647)

Objekt: variabel av typen Objekt (Obs: denna variabel kan endast definieras senare med Set-satsen!)

Enkel: Variabel av en typ (3,402823 x 10E38 - 1,401298 x 10E-45)

String: Variabel av typen Sträng med en maximal längd på 64 000 ASCII-tecken.

: variabel av typen Variant (täcker alla typer enligt definition). Om nyckelordet inte anges definieras variablerna automatiskt som variabler av typen Variant, förutom när operatorn från DefBool - DefVar-intervallet används.

I Basic Lotus® Symphony™-språket behöver variabler inte explicit deklareras. Det enda undantaget är arrayer. En variabel kan deklareras med hjälp av Dim-satsen; om det finns flera deklarationsuppgifter separeras de med kommatecken. För att deklarera typen av en variabel anger du ett typdeklarationstecken efter dess namn eller anger lämpligt nyckelord.

I Basic Lotus Symphony kan du definiera endimensionella eller flerdimensionella arrayer genom att ställa in lämplig variabeltyp. Arrayer är användbara för att arbeta med listor och tabeller. Matriselement kan nås med index, som kan specificeras via ett numeriskt uttryck eller en variabel.

Matriser deklareras med Dim-operatorn. Ett indexintervall kan definieras på två sätt:

DIM-text(20) som sträng REM 21-element numrerade 0 till 20

DIM-text(5 till 25) som sträng REM 21-element numrerade 5 till 25

DIM-text (-15 till 5) som sträng REM 21-element (inklusive 0)

REM med nummer -15 till 5

2D-datafält

DIM-text(20,2) som String REM 63-element numrerade 0 till 20 nivå 1, 0 till 20 nivå 2 och 0 till 20 nivå 3

Matristyper kan deklareras dynamiska om ReDim-satsen anger antalet dimensioner i proceduren eller funktionen som innehåller matrisen. I allmänhet definieras dimensionen för en array endast en gång och kan inte ändras. En array kan deklareras i en procedur med hjälp av ReDim-satsen. Dimensioner kan endast definieras med numeriska uttryck. Detta säkerställer att fältlängdsbegränsningarna respekteras.

Exempel:

Dim sVar As String

Dim iVar Som heltal

sVar = "Lotus Symphony"

REM Tvådimensionellt datafält

Dim stext(20,2) som sträng

Const sDim as String = " Dimension:"

stext(i,ii) = str(i) & sDim & str(ii)

Dim stod ursprungligen (i BASIC) för Dimension, eftersom det användes för att bestämma dimensionerna för en array.

(Den ursprungliga implementeringen av BASIC var Dartmouth BASIC, som utvecklades från FORTRAN där DIMENSIONS specificeras.)

Dim används för närvarande för att definiera vilken variabel som helst, inte bara arrayer, så dess betydelse är inte intuitiv.

2018-06-23 16:01

Dim har haft olika betydelser tillskrivna det.

Jag hittade referenser till Dim betydelse "Deklarera i minnet", en mer relevant referens är dokumentet om Dim Statement publicerat av Oracle som en del av Siebel VB-språkreferensen. Naturligtvis kan man argumentera att om man inte deklarerar variabler i minnet, var gör man det? Kanske "Deklarera i en modul"är ett bra alternativ med tanke på hur Dim används.

Enligt min mening är "Declare in Memory" faktiskt det mnemonisk, skapad för att göra det enklare att lära sig hur man använder Dim . Jag ser "deklarera i minnet" som den bästa meningen eftersom det beskriver vad det gör i nuvarande versioner av språket, men det är inte den korrekta betydelsen.

Faktum är att vid ursprunget till Basic Dim användes endast för att deklarera arrayer. Inget nyckelord användes för vanliga variabler, istället härleddes deras typ från deras namn. Till exempel, om ett variabelnamn slutar med $ så är det en sträng (vilket är vad du kan se även i pre-VB6 metodnamn som Mid$). Så du använde Dim bara för att ge dimensionera till arrayer (observera att ReDim ändrar storlek på arrayer).

Verkligen, Det spelar roll? Jag menar att det här nyckelordet är vettigt på ett konstgjort språk. Det får inte vara ett ord på engelska eller något annat naturligt språk. Så det kan bara betyda vad du vill, allt som spelar roll är att det fungerar.

Det är i alla fall inte helt sant. Eftersom BASIC är en del av vår kultur och förstår varför det är som jag hoppas att det kommer att bidra till att förbättra vår syn på världen.

Jag sitter från min dator med en önskan att hjälpa till att bevara denna lilla del av vår kultur som verkar förlorad, ersatt av vårt antagande om vad det var. Så jag grävde fram MSDN både nuvarande och gamla CD-skivor från 1998 års version. Jag letade också upp dokumentationen för den gamla QBasic [borde ha använt DOSBox] och lyckades få fram Dartmouth-manualen för att ta reda på hur de säger Dim . Till min besvikelse säger de inte vad som får Dim att stå för och säger bara hur det används .

Men innan mitt hopp var svagt lyckades jag hitta denna BBC Microcomputer Manual (som påstår sig vara från 1984 och jag vill inte tvivla på det). BBCs mikrodator använde en variant av BASIC som heter BBC BASIC och den beskrivs i dokumentet. Även om han inte säger vad Dims ställning gör, säger han (på sidan 104):

Du kan mäta N$ för att ha så många poster du vill. Till exempel kommer DIM N $ (1000) att skapa en strängarray med plats för 1000 olika namn.

Som sagt, det står inte att Dim betyder Dimension, utan är ett bevis på att associeringen av Dim med Dimension var vanlig när detta skrivs.

Nu fick jag en extra överraskning (på sidan 208), rubriken på avsnittet som beskriver DIM-sökordet (obs: detta finns inte med i innehållet) säger:

DIM-matrisstorlek

Så jag fick inte citatet "Dim worth...", men jag tror att det är uppenbart att varje anständig person som kan läsa detta dokument skulle ta Dim för att betyda dimension.

Med nytt hopp bestämde jag mig för att hitta Dim blev utvald. Återigen, jag hittade inget konto om detta ämne, men jag kunde hitta det definitiva citatet:

Innan du kan använda en array måste du definiera den i en DIM-instruktion (dimension).

Du kan hitta detta som en del av True BASIC Online User Guide på webbsidan för True BASIC inc, ett företag grundat av Thomas Eugene Kurtz, meduppfinnaren av BASIC.

Så Dim är stenografi för DIMENSIONERA, och ja. Detta fanns i FORTRAN tidigare, så det är troligt att det valdes på grund av FORTRAN-inflytande som Patrick McDonald sa i sitt svar.

Dim sum as string = "det här är inte en kinesisk måltid" REM exempel på användning i VB.NET ;)

2017-10-05 01:19

Detta är en förkortning för Dimension, eftersom det ursprungligen användes i BASIC för att ange storleken på arrayer.

DIM - (förkortning för storlek) bestämmer storleken på arrayer

En del av den ursprungliga BASIC-kompilatorns källkod där den hoppar när du letar efter ett DIM-kommando, där du tydligt kan se den ursprungliga avsikten med nyckelordet:

DIM LDA XR01 BACK OFF OBJEKTSPEKARE SUB N3 STA RX01 LDA L 2 FÅ VARIABEL SOM SKA DIMENSIONERAS STA 3 LDA S 3 CAB N36 KONTROLLERA FÖR $ ARRAY BRU *+7 INTE $ ...

Det kom senare att användas för att deklarera alla möjliga variabler när möjligheten att specificera typen av variabler lades till i senare versioner.

2018-06-23 16:02

Mät en variabel, i princip säger du till kompilatorn att du kommer att behöva en variabel av den typen någon gång.

VBA-variabler, variabeldeklaration, Option Explicit, Namnregler, VBA-datatyper, initiala variabelvärden

Variabler- behållare för lagring av föränderlig data. Nästan inget program klarar sig utan dem. För enkelhetens skull kan variabeln jämföras med ett nummer i garderoben - du lämnar över en del data till "garderoben", som svar får du ett nummer. När du behöver dessa uppgifter igen "visar du numret" och får det. Ett exempel på att arbeta med variabler i VBA kan se ut så här:

Dim nMyAge Som heltal

nMyAge = nMyAge + 10

MsgBox nMyAge

Dim nMyAge Som heltal

Så här dekrypterar du den här raden:

Dämpaär omfattningen av variabeln. VBA tillhandahåller fyra nyckelord för omfattningsvariabler:

Dämpa- används i de flesta fall. Om en variabel deklareras som Dim i deklarationsområdet för en modul, kommer den att vara tillgänglig under hela modulen, om den är i en procedur, endast under den tid som proceduren pågår;
Privat- när variabler deklareras i VBA betyder det samma som Dim;
offentlig- En sådan variabel kommer att vara tillgänglig för alla procedurer i alla moduler i detta projekt om du deklarerade den i modulens deklarationsområde. Om du deklarerade det i en procedur, kommer det att bete sig som Dim/Privat;
Statisk- Sådana variabler kan endast användas inom ett förfarande. Dessa variabler är endast synliga inom proceduren där de deklareras, men de behåller sitt värde mellan olika anrop till den proceduren. Används vanligtvis för att samla vissa värden. Till exempel:

Statisk nVar1 Som heltal

nVar1 = nVar1 + 1

MsgBox nVar1

Om det inte finns några speciella krav, är det vettigt att alltid välja Dim-omfattningen.

Det andra ordet i vår deklaration (nMyAge) är identifieraren (med andra ord namnet) för variabeln. Reglerna för att välja namn i VBA är desamma för många element (variabler, konstanter, funktioner och procedurer, etc.). Namn:

måste börja med en bokstav;
får inte innehålla mellanslag och skiljetecken (ett undantag är understrecket);
maximal längd - 255 tecken;
måste vara unik i den aktuella omfattningen (för mer information, se nedan);
reserverade ord (de som är markerade i en annan färg i kodredigeringsfönstret) kan inte användas.

När du skapar VBA-program rekommenderas det starkt att du bestämmer reglerna för vilka namn ska tilldelas objekt - en namnkonvention. Den vanligaste är den så kallade ungerska konventionen (till ära av en av Microsofts programmerare, Charles Simonyi, en etnisk ungrare):

Variabelnamnet måste börja med ett prefix skrivet med små bokstäver. Prefixet anger exakt vad som kommer att lagras i denna variabel:

str (eller s) - Sträng, teckenvärde;
fn (eller f) - funktion;
c (eller versal alla bokstäver) är en konstant;
b - Booleskt, booleskt värde (sant eller falskt);
d - datum;
obj (eller o) - objektreferens;
n är ett numeriskt värde.

namn på funktioner, metoder och varje ord i ett sammansatt ord måste börja med en stor bokstav:

MsgBox objMyDocument.Name

Sub CheckDateSub()

i tidiga versioner av VB fanns det inget ord Const - alla konstanter definierades som variabler, och för att särskilja dem skrevs de med stora bokstäver, understreck sattes mellan orden:

FÖRETAGSNAMN

Många programmerare använder detta tillvägagångssätt för att beteckna konstanter idag (men användningen av nyckelordet Const är nu obligatorisk - detta kommer att diskuteras i nästa avsnitt).

Den tredje delen av vårt tillkännagivande - Som heltalär en indikation på datatypen för vår variabel. Datatypen avgör vilken typ av data som kan lagras i vår variabel.

VBA tillhandahåller följande datatyper:

numerisk(byte - ett heltal från 0 till 255, heltal - ett heltal från -32768 till 32767, långt - ett stort heltal, valuta (ett stort decimaltal med 19 positioner, inklusive 4 decimaler), decimal (ett ännu större decimaltal med 29 positioner), enkel och dubbel - flyttalvärde (dubbel är dubbelt så stor));

Uppmärksamhet! Ett försök att deklarera en variabel av typen Decimal (t.ex. Dim n As Decimal) kommer att resultera i ett syntaxfel. För att kunna arbeta med typen Decimal måste variabeln initialt deklareras som Variant eller deklareras utan typ alls (Dim n), eftersom datatypen Variant används i VBA som standard.

sträng(sträng med variabel längd (upp till cirka 2 miljarder tecken) och fast längd (upp till cirka 65400 tecken);
datum och tid(datum - från 01/01/100 till 12/31/9999);
logisk(boolesk - kan bara lagra sanna och falska värden);
objekt(objekt - lagrar en referens till ett objekt i minnet);
Variant- en speciell datatyp som kan lagra alla andra datatyper.

Du kan också använda anpassade datatyper, men du måste först definiera dem med ett Type-uttryck. Vanligtvis används användardefinierade datatyper som ett ytterligare sätt att validera användarinmatade värden (postnummer är ett klassiskt exempel).

Några punkter relaterade till valet av datatyper för variabler:

den allmänna principen är att välja den minsta datatypen som kan rymma de värden du väljer. Om det finns några tvivel, välj en större datatyp för att undvika fel;
om möjligt är det bättre att inte använda flyttalsdatatyper (enkel och dubbel). Att arbeta med sådana datatyper går långsammare, dessutom kan det uppstå problem med jämförelser på grund av avrundning;
om möjligt är det bättre att inte använda varianttypen. Denna typ gjuts fortfarande av VBA till en av de andra typerna, men den kräver mer minne. Dessutom kan fel uppstå under sådan implicit bildning;
när du definierar variabler kan du använda de så kallade typdefinitionssymbolerna (% - heltal, $ - String, etc.). Till exempel, i vårt exempel måste du kommentera Dim nVar 1 As Integer-raden och skriva på den andra raden:

nVar1% = nVar1% + 1

Detta tillvägagångssätt är föråldrat och rekommenderas inte.

När du deklarerar variabler är det möjligt att inte specificera dess typ. Till exempel kan vår deklaration se ut så här:

Dim nVar1

I det här fallet kommer variabeln automatiskt att deklareras med varianttypen.

I princip kan du arbeta i VBA utan att deklarera variabler. Till exempel den här koden

nVar1 = nVar1 + 1

MsgBox nVar1

kommer att fungera fullt ut. Om vi använder en variabel i ett program utan att deklarera den kommer en ny variabel av typen Variant att skapas automatiskt. Variabler måste dock deklareras! Och samtidigt är det önskvärt att explicit specificera den önskade datatypen. Varför:

antalet fel minskar: programmet från början kommer att vägra acceptera ett värde av fel typ i en variabel (till exempel en sträng istället för en numerisk);
när man arbetar med objekt är tipset om egenskaper och metoder endast giltigt när vi initialt deklarerade en objektvariabel med önskad typ. Till exempel, i Excel kommer de två kodalternativen att fungera på samma sätt:

första alternativet:

Dim oWbk Som arbetsbok

Ange oWbk = Workbooks.Add()

andra alternativet:

Ange oWbk = Workbooks.Add()

Men tipset om egenskaperna och metoderna för oWbk-objektet fungerar bara i det andra fallet.

Alla erfarna utvecklare förbjuder i allmänhet användningen av variabler utan att uttryckligen deklarera dem. För att göra detta kan du använda ett speciellt kompilatorkommando (det placeras endast i deklarationssektionen av modulen)

Alternativ Explicit

eller så kan du infoga detta kommando i alla moduler när de skapas automatiskt - genom att markera kryssrutan i kodredigeringsfönstret Kräv variabeldeklarationer(meny Verktyg -> alternativ, tab Redaktör).

För att illustrera varför de gör detta kan du använda ett enkelt exempel:

n = n + 1

MsgBox n

Till utseendet bör koden inte orsaka några problem och bara visa en i meddelanderutan. Det kommer faktiskt att dyka upp en tom meddelanderuta. Anledningen är mycket smygande gömd: på den tredje raden är n inte alls den engelska bokstaven N, utan den ryska bokstaven P. Det är mycket svårt att särskilja dem i vyn i kodredigeringsfönstret. Samtidigt kommer VBA-kompilatorn, när den stöter på sådan kod, helt enkelt skapa en ny variabel med datatypen Variant, som kommer att ha ett tomt värde. Det kan ta lite tid att upptäcka ett sådant fel.

En bra tumregel är att deklarera variabler i förväg, inte när de behövs. Detta gör programmet mer lättläst och välplanerat.

Du kan deklarera flera variabler på en rad, så här:

Dim n1 Som heltal, s1 Som sträng

Att tilldela värden till variabler ser ut så här:

nvar1 = 30

Om du behöver öka ett redan existerande värde för en variabel kan kommandot se ut så här:

nVar1 = nVar1 + 1

I båda exemplen betyder likhetstecknet inte "lika med", utan tilldela.

När du tilldelar värden till variabler, kom ihåg följande:

strängvärden är alltid omgivna av dubbla citattecken:

sVar1 = "Hej";

datum/tidsvärden är inneslutna i "gitter" - pundsymboler:

dVar1 = #05/06/2004#

Observera att när vi tilldelar ett datum/tidsvärde på detta "explicita sätt" måste vi använda amerikanska standarder: 05 i detta fall är månaden, 06 är dagen. Visningen av detta värde (till exempel i en meddelanderuta) beror på de regionala inställningarna på användarens dator.

Om du behöver skicka ett hexadecimalt värde föregås det av &H-tecken:

nVar1 = &HFF00

Vad finns i variabler innan de tilldelas värden?

I variabler av alla numeriska datatyper - 0.
I strängvariabler med variabel längd - "" (sträng med noll längd).
I strängvariabler med fast längd, en sträng av given längd med ASCII 0-tecken (dessa tecken visas inte).
I Variant, ett tomt värde.
I Objekt - ingenting (det finns ingen referens till något av objekten).

6. Deklarera variabler: Dim-sats för olika datatyper

Oftast försöker folk att inte använda identifierare när de anger typen av en variabel (särskilt för typer som datum/tid). Istället använder de Dim-satsen. En sådan operation kallas för deklaration. Att deklarera variabeltyper när man hanterar händelser innan man använder dem - med kommentarer förstås - är en bra programmeringsstil. Det gör det också möjligt att förbättra "läsbarheten" av programtexter.

Om en variabel deklareras med hjälp av Dim-satsen, kommer användning av en variabel med samma namn och en annan typidentifierare att resultera i ett "dubbeldefinition"-fel när programmet körs. Till exempel, om följande uttryck Dim Count As Integer deklarerar en variabel Count, kan du inte använda variablerna Counts, Count! Count# och Count®. Du bör bara använda namnet Count%, men det är bara en annan form för variabelnamnet Count.

För att tilldela en varianttyp till en variabel, använd Dim-operatorn utan As:

Dim F00 behandlar F00 som en variabel av typvariant.

Du kan också skriva det så här: Dim Foo As Variant - det är lättare att läsa.

Varje information som bör vara tillgänglig för alla händelseprocedurer som är kopplade till formuläret placeras i formulärets (Allmänna) sektion.

Följ dessa steg för att placera Option Explicit i avsnittet (Allmänt).

1. Öppna fönstret Kod.

2. Välj ett objekt (Allmänt) från listan över objekt som erbjuds i objektfönstret.

3. Välj (Deklaration) från Proc-listan.

4. Ange Option Explicit.

Det är ofta nödvändigt att använda deklarationer på formulärnivå i avsnittet (Allmänt) när användaren experimenterar med exempelprogram från hjälpsystemet.

För att kopiera ett exempelprogram från hjälpsystemet, använd knappen Kopiera i Kodexempelfönstret. Du kan sedan använda alternativet Klistra in från menyn Redigera för att klistra in exemplet i kodfönstret. När Visual Basic stöter på ett Option Explicit-kommando slutar det att tillåta odeklarerade variabler. Om du fortfarande försöker använda en sådan variabel kommer ett felmeddelande att visas.

Du kan använda redigeringssidan i dialogrutan Tools|0ptions för att tillämpa en obligatorisk variabeltypsdeklaration. Programmeraren markerar alltid denna ruta. Därefter placeras Option Explicit-satsen automatiskt på de platser i koden där den behövs.

Från boken Låt oss bygga en kompilator! av Crenshaw Jack

Från boken Internet Intelligence [Action Guide] författare Yushchuk Evgeny Leonidovich

Metasökmotorer på Internet med exempel på att söka efter olika typer av information Var och en av de entusiastiska internetanvändarna drömmer om existensen av ett enda informationssystem som skulle kombinera fördelarna med alla sökmotorer

Från boken Server Storage Technologies in Windows® 2000 Windows® Server 2003 av Dilip Naik

Kapitel 10 Lagringsundersystemsfunktioner i olika versioner av Windows NT De föregående kapitlen har tittat på Windows-arkitekturen i termer av specifika lagringsundersystemskapacitet. Det här kapitlet är avsett för proffs som använder lagringsundersystem

Från boken HTML 5, CSS 3 och Web 2.0. Utveckling av moderna webbsidor. författare Dronov Vladimir

Från boken HTML 5, CSS 3 och Web 2.0. Utveckling av moderna webbsidor författare Dronov Vladimir

Deklarera variabler Innan du använder en variabel i din webbskriptkod rekommenderar vi att du deklarerar den. För att göra detta används var-variabeldeklarationsoperatorn, varefter variabelnamnet anges: var x; Nu kan den deklarerade variabeln tilldelas vilken som helst

Från VBA Book for Dummies författaren Cummings Steve

Deklarera variabler Som diskuterats i kapitel 6 är en deklaration en VBA-sats som du använder för att tala om för kompilatorn att du tänker använda ett namngivet objekt och uttryckligen beskriva typen av det objektet. Deklarationsutlåtanden är vanligast att använda

Från boken The C Programming Language for a Personal Computer författaren Bochkov S. O.

Deklarera flera variabler på en rad Du kan deklarera flera variabler på samma kodrad. Nyckelordet Dim skrivs endast ut en gång och variablerna separeras med kommatecken. Men glöm inte att ange datatypen för var och en av variablerna i

Från boken The Art of Shell Scripting Programming av Cooper Mendel

Från boken Linux-programmering genom exempel författare Robbins Arnold

Deklarera anpassade typvariabler Liksom inbyggda datatyper förblir en anpassad typ ett abstrakt begrepp tills du deklarerar en variabel av lämplig typ. Detta kräver inget speciellt - standardsyntaxen är bra

Från boken The End of the Holivar. Pascal vs C författaren Krivtsov M.A.

Deklarera klassvariabler För att deklarera variabler som kommer att behövas i flera egenskaper eller metoder, använd avsnittet Deklarationer i början av klassmodulen. Deklarera alltid dessa variabler som lokala (Privata), eftersom objekt huvudsakligen är avsedda för

Från författarens bok

Variabeldeklarationer Det här avsnittet ger en konsekvent beskrivning av syntaxen och semantiken för variabeldeklarationer. Variabelvarianter listas i följande tabell: Tabell 3.4. Typ av variabel Förklaring Enkel variabel Skalär variabel av ett heltal eller

Från författarens bok

Datadeklaration Om ett nära, långt eller enormt nyckelord omedelbart följs av en identifierare, betyder det att motsvarande dataelement kommer att placeras i ett standarddatasegment (för nära) eller kan placeras i ett annat datasegment (för långt eller enormt) ). Till exempel,

Från författarens bok

9.4. Deklarera variabler: declare och typeset Declare- och typeset-satserna är inbyggda satser (de är absolut identiska med varandra och är synonymer) och är avsedda att införa begränsningar för variabler. Detta är ett mycket svagt försök till typkontroll, vilket

Från författarens bok

8.1.2. En översikt över de olika typerna av filsystem Diskussionen i detta avsnitt är specifik för Linux. Men många moderna Unix-system har också liknande funktioner. Vi rekommenderar att du studerar dokumentationen för ditt system. Historiskt sett stödde V7 Unix endast en typ

Från författarens bok

Standarddatatyper och variabeldeklarationer Värdet som tilldelas en variabel måste matcha dess typ som anges i deklarationsavsnittet. Det finns fyra standardtyper av värden i Pascal (utöver de som kan definieras ytterligare i varje program -

Från författarens bok

Standarddatatyper och variabeldeklarationer int - integerlong - long heltershort - short integerunsigned - unsigned integerfloat - realdouble - long realchar - character Till skillnad från Pfscal finns det inga logiska variabler i C. Exempel på variabeldeklarationer:

En variabel är en slags behållare där VBA lagrar data. Närmare bestämt är det som en låda där du kan lägga något för förvaring, och sedan ta ut det efter behov. Endast i detta fall lagrar vi ett nummer, en sträng eller annan data i en variabel, som vi sedan kan extrahera från den och använda den i koden efter behov.

Vad är variabeln till för? För att lagra värdet och tillämpa det senare när som helst. Till exempel innehåller cell A1 beloppet, och ett tryck på knappen börjar uppdatera rapporten. Efter uppdatering av rapporten kommer beloppet i A1 att ändras. Det är nödvändigt att kontrollera beloppet före uppdateringen med beloppet efter och, beroende på detta, vidta några åtgärder. Variabeln låter dig bara komma ihåg värdet på cellen innan den uppdateras och använda exakt detta värde efter uppdateringen.

Varierande krav:

Bokstäver och siffror kan användas som variabelnamn, men den första bokstaven i ett variabelnamn måste alltid vara en bokstav. Punkter, kommatecken, mellanslag och andra skiljetecken, förutom understreck, är inte tillåtna. Namnets längd får inte överstiga 254 tecken. Du kan inte heller använda reserverade konstanter i VBA-redigeraren som namn på variabler. (t.ex. Sub, Msgbox, ubound, Date, etc.). Bokstäverna är också oviktigt för variabler.

Låt oss nu titta på huvuddatatyperna som deklareras i VBA och som kan lagras i variabler:

Data typ	Upptar en byte i minnet	Värdegränser
bytes	1	Hela nummer från 0 innan 255
Boolean	2	Sann eller Falsk
Heltal	2	Heltal från ( -32768 ) innan 32767
Lång	4	Heltal från ( -2147483648 ) innan 2147483647
Enda	4	Från ( -3,402823Е+38) innan ( –1.401298Е-45) och från 1,401298Е-45 innan 3,402823Е+38
Dubbel	8	Från ±1,79769313486232E+308 innan ±4,94065645841247E-324
Decimal	12	Från ±79228162514264337593543950335 inga decimaler till ±7,9228162514264337593543950335 med 28 decimaler
Valuta	8	Från ( –922337203685477.5808 ) innan 922337203685477.5807
Datum	8	Från 01.01.100 innan 31.12.9999 (inte att förväxla med datum i Excel - 01/01/1900 till 12/31/2078)
Sträng	1	Från 0 innan 65400 tecken för fasta strängar och drygt 2 miljarder för strängar med variabel längd
Objekt	4	Vilket föremål som helst
array	Bestäms av antalet och storleken på element	-
Variant	från 16	Någon av de inbyggda datatyperna

Som du kan se i tabellen tar Variant upp mest minne. Dessutom, om den lagrar numeriska data. Om en sådan variabel lagrar data av en strängtyp (text), så kommer storleken på det upptagna minnet att mätas med start från 22 byte + längden på strängen lagrad i variabeln. Ju mer minne en variabel tar, desto längre tid tar det att initiera i minnet och desto långsammare kommer koden att köras. Det är därför det är viktigt att uttryckligen ställa in vilken typ av data som lagras i en variabel - detta kallas deklarera en variabel.

Datatypen Decimal används inte längre, så att deklarera en variabel av denna typ i VBA kommer inte att fungera - ett sådant försök kommer att leda till ett syntaxfel. För att arbeta med data av typen Decimal måste en variabel initialt deklareras som Variant eller utan typ alls (till exempel Dim a), eftersom Variantdatatypen är standard i VBA och accepterar alla datatyper.

Du kan även tilldela variabler till andra datatyper som inte finns i tabellen ovan - det är typer som stöds av objektmodellen för applikationer som VBA är "ansluten till". Till exempel, om du anger VBA från Excel, är Excel-objektmodelltypbiblioteket anslutet som standard och många typer av denna objektmodell blir tillgängliga för variabler. Många av dem är bekanta för alla: arbetsbok, arbetsblad, intervall, celler, diagram, etc. De där. dessa är böcker, ark, celler, diagram. Det finns många typer, för nästan varje föremål och samling. Det är meningslöst att överväga allt här. Jag kan bara ge ett par rader kod:

"Namn på mitt program"

Deklarationen av variabler beskrivs i detalj nedan.
Du kan läsa mer om att komma åt intervall från VBA i den här artikeln: Så här får du tillgång till ett intervall från VBA

Hur man deklarerar variabler
Faktum är att allt är väldigt enkelt. Detta görs med hjälp av scope-operatorerna: Dim , Public ,Static och typtilldelningsoperatorn As . Den vanligaste operatören är Dim . Låt oss ta det som ett exempel. Deklarationssyntax:

[scope operator] variabelnamn Som [datatyp]

Ett mycket vanligt misstag när man deklarerar variabler, gjort av nybörjare för att lära sig VBA:

Dim MyVar1, MyVar2, MyVar3 Som heltal

Det verkar som om, baserat på logik, alla variabler tilldelas datatypen Integer . Men detta är ett felaktigt antagande. Heltalstypen tilldelas endast den sista variabeln till vilken den är "bunden" av As-operatorn - MyVar3. Alla andra variabler är av datatyp Variant . De där. om du inte uttryckligen anger typen av lagrad data för variabeln (dvs. ange inte en datatyp för det), så tilldelar VBA själv variantdatatypen till en sådan variabel, eftersom den kan lagra vilken typ av data som helst. Och så här ser den korrekta datatypstilldelningen ut:

Dim MyVar1%, MyVar2%, MyVar3%

Det finns sex typer som kan deklareras på detta sätt:
! -Enda
# - Dubbel
$ - Sträng
% - heltal
& - Långt
@-Valuta
Vad du bör vara uppmärksam på när du deklarerar variabler på detta sätt: det ska inte finnas några mellanslag mellan variabelnamnet och typtecknet.
Jag personligen föredrar att använda den första metoden, dvs. fullständig typspecifikation. Det är mer läsbart och tydligare. Men det här är mina preferenser och i dina koder har du rätt att använda den metod som är bekväm för dig - det blir inget fel.

Låt oss nu titta på scope-operatorerna (Dim , Public och Static):

Dim - denna operator används för att deklarera en variabel vars värde endast kommer att lagras i proceduren inom vilken variabeln deklareras. Under starten av proceduren initieras en sådan variabel i minnet, du kan använda dess värde i endast denna procedur, och när proceduren är slutförd laddas variabeln bort från minnet (nollställs) och data på den går förlorad. En variabel som deklareras på detta sätt kallas också lokal variabel. Men med hjälp av detta uttalande kan du deklarera en variabel som kommer att vara tillgänglig i vilken modulprocedur som helst. Det är nödvändigt att deklarera en variabel utanför proceduren - i deklarationsområdet (läs som den första raden i modulen, efter deklarationsraderna av typen - Option Explicit). Då kommer variabelns värde att vara tillgängligt i alla förfaranden endast i modulen där variabeln deklarerades. Sådana variabler kallas variabler på modulnivå.
Statisk - denna sats används för att deklarera en variabel vars värde är tänkt att användas i proceduren, men utan att förlora värdet på denna variabel i slutet av proceduren. Variabler av denna typ används vanligtvis som ackumulerande räknare. En sådan variabel initieras i minnet första gången proceduren där den deklareras körs. I slutet av proceduren laddas inte data om variabeln ur minnet, men de är dock inte tillgängliga i andra procedurer. Så fort du kör proceduren med denna variabel igen, kommer data om en sådan variabel att finnas tillgänglig i den form som den var innan proceduren slutfördes. En sådan variabel laddas ur minnet först efter att projektet stängts. (böcker med kod). Hos vanligt folk kallas sådana variabler ofta global(möjligen på grund av att tidigare sådana variabler deklarerades med hjälp av Global-satsen, som nu är föråldrad och inte används)

Offentlig - detta uttalande används för att deklarera en variabel vars värde kommer att lagras i alla projektförfaranden. En variabel som deklareras på detta sätt ska deklareras utanför förfarandet - i deklarationsområdet. En sådan variabel laddas in i minnet när projektet laddas. (när du öppnar en bok) och lagrar värdet tills projektet avlastas (avslutningsbok). Du kan använda den i vilken modul och vilken projektprocedur som helst. Viktig: att deklarera en variabel på detta sätt måste vara strikt i en standardmodul. Sådana variabler kallas variabler på projektnivå.
För en bättre förståelse för var och hur man deklarerar variabler på projektnivå, två små exempel.
Fel deklaration

Alternativ Explicit Sub main() Public MyVariable As String MyVariable = "Global variabel" "visa det aktuella värdet för variabeln MsgBox MyVariable "försök att ändra värdet på variabeln Call sub_main "visa det ändrade värdet för variabeln MsgBox MyVariable End Sub " ytterligare procedur för att ändra värdet på variabeln Sub ChangeMyVariable() MyVariable = "Ändrade dess värde" End Sub

variabler kommer inte att vara synliga i alla moduler i alla procedurer och funktioner i projektet, eftersom:
1. Den offentliga operatören är inte tillåten i proceduren (mellan Sub och End Sub), så VBA kommer definitivt att ge ett fel när de försöker utföra en sådan procedur - Ogiltigt attribut i Sub eller Funktion.
2. Även om Public ersätts av Dim kommer den redan att vara en variabel på procedurnivå och kommer inte att vara tillgänglig för andra procedurer.
3. Eftersom deklarationen är felaktig - den andra proceduren (ChangeMyVariable) vet inget om MyVariable-variabeln och kan naturligtvis inte ändra den.
Rätt deklaration

"Ovanför globala variabler och konstanter kan det bara finnas deklarationer: Alternativ Explicit "påtvingad deklaration av variabler Alternativ Bas 1 "nedre gränsen för deklarerade arrayer börjar från 1 Alternativ Jämför text "jämför text okänsligt "global variabel - första raden, framför allt procedurer Offentlig MyVariable som sträng "ytterligare procedurer och funktioner Sub main() MyVariable = "Global variabel" "visa det aktuella värdet för variabeln MsgBox MyVariable, vbInformation, "www.site" "försöker ändra värdet på en variabel Ring ChangeMyVariable "visa det ändrade värdet på variabeln MsgBox MyVariable, vbInformation, "www.site" End Sub "ytterligare procedur för att ändra värdet på en variabel SubChangeMyVariable() MyVariable = "Ändrade sin betydelse" slut sub

"ovanför globala variabler och konstanter kan endast deklarationer vara: Alternativ Explicit "tvingad deklaration av variabler Alternativ Bas 1 "nedre gränsen för deklarerade arrayer börjar med 1 Alternativ Jämför text "skiftlägesokänslig textjämförelse "global variabel - första raden, framför allt procedurer Public MyVariable As String "ytterligare procedurer och funktioner Sub main() MyVariable = "Global variabel" "visa det aktuella värdet för variabeln MsgBox MyVariable, vbInformation, "www.site" "försök att ändra värdet på variabeln Call ChangeMyVariable "show det ändrade värdet på variabeln MsgBox MyVariable, vbInformation, "www ..procedur för att ändra värdet på en variabel Sub ChangeMyVariable() MyVariable = "Ändrade dess värde" End Sub

Omfattningsoperatörer kan också tillämpas på procedurer. Det finns en annan scope-operatör tillgänglig för procedurer, Privat . En procedur som deklareras på detta sätt är endast tillgänglig från modulen där den är skriven och en sådan procedur är inte synlig i makroanropsdialogen ( alt+F8)

Hur man namnger en variabel korrekt:

"Vad är det svåraste i programmerarens jobb? - att hitta på namn på variabler." :-) Men att komma på ett variabelnamn är inte heller så lätt. Du kan naturligtvis ge dem namn som: a, d, f, x, y etc. (Jag själv gör detta ibland, men antingen i enkla koder, eller för speciell förvirring av koden). Men det är värt att överväga: hur kommer du att hantera dem i en stor kod? Koden för 10 rader kommer fortfarande att tolerera sådana namn, men för större projekt - jag skulle inte råda dem att arbeta med sådana variabler i dem. Du kommer själv att bli förvirrad över vilken variabel som deklareras och vilken typ av data den kan lagra och vilket värde den är tilldelad. Därför är det bäst att ge betydelsefulla namn till variabler och följa variabelnamnkonventionen. Vad är avtalet? Allt är väldigt enkelt: variabelns huvudnamn föregås av ett prefix som anger vilken typ av data som vi avser att lagra i denna variabel. Jag har redan pratat om de tillgängliga datatyperna ovan. Och nedan är en ungefärlig tabell över överensstämmelse mellan prefix och datatyper:

Prefix	Lagrad datatyp
b	Boolean
bt	bytes
i	Heltal
l	Lång
s	Enda
d	Dubbel
c	Valuta
dt	Datum
str	Sträng
obj	Objekt
v	Variant

Själv gjorde jag om det lite för mig själv, tk. en del av notationen förefaller mig knapphändig. Till exempel Double I betecknar som dbl, och Singel som sgl. Detta verkar mer självklart för mig.

Vad är fördelen med att explicit specificera dataprefixet. VBA tillhandahåller satser som Def, som kan användas för att ange standarddatatypen för variabler vars första bokstav faller inom det intervall som anges i satsen. Till exempel:

DefBool B-C Sub test() Dim bCheck, cCheck End Sub

Men jag tror att det räcker med en bokstav för en typ. Du kan ange flera Def-satser samtidigt.

DefBool B DefStr S Sub test() Dim bCheck, sCheck End Sub

Följande är en komplett lista över typoperatorer och de data som var och en anger:
defbool- Ställer in den booleska typen
DefByte- Anger bytetypen
DefCur- Ställer in valutatyp
DefDate- Anger datumtypen
DefDbl- Specificerar dubbeltypen
DefInt- Anger heltalstypen
Deflng- Anger typen Lång
DefObj- Ställer in objekttypen
DefSng- Anger typen Single
DefStr- Anger strängtypen
DefVar- Anger varianttypen
Som standard använder VBA DefVar-satsen för alla variabler.

Nåväl, en viktig punkt är ett direkt meningsfullt variabelnamn. Namnet på variabeln bör ungefär återspegla vad som kommer att lagras i den. Till exempel, du skapar en rapport och du måste deklarera två variabler: den ena är arknamnet, den andra är bokens namn. Det kunde ha gjorts så här: str1, str2. Kort sagt, jättebra. Men om du tänker efter – och hur kan du förstå vilken av dessa variabler som lagrar vad? Aldrig. Du måste titta på koden och komma ihåg vilken variabel som tilldelades vilket värde. Inte särskilt bekvämt, eller hur? Vad händer om du ställer in namnen så här: strBoknamn, strSheetName, då verkar det vara mer tydligt vad vi kommer att lagra i dem. Detta är praktiskt inte bara för dig när du arbetar med koden, utan även för andra personer som kan komma att använda din kod i framtiden. Det blir lättare för dem att läsa koden om den är välformad och variablerna har ett meningsfullt namn. Och spara inte på längden på namnet - namnet ska vara begripligt. Utan fanatism förstås :-). Även om VBA tillåter oss att skapa variabler upp till 254 tecken långa, är det lika obekvämt att läsa en sådan variabel som att läsa med ett enda tecken. Men här beror allt på dina preferenser och fantasi.
Litet tillägg: det är bättre att vänja sig vid att namnge variabler i det latinska alfabetet (dvs det engelska alfabetet), eftersom för VBA är engelska "native" och det är bättre att använda det.

Ett litet exempel på hur man använder variabler i koder:

sub-main() "deklarera variabler med specifika typer tilldelade"Som sträng - text "As Long är ett heltal Dim sAddress As String , sNewAddress As String , sShName As String Dim lRow As Long Dim rRange as Range "tilldelade variabeln rRange en referens till den för närvarande valda cellen Ställ in rRange = Urval "ändra urval - välj cell D9 Range("D9"). Välj "tilldela adressen för de markerade cellerna till variabeln sAddress = Selection.Address "tilldela variabeln lRow värdet på den första raden i urvalet lRad = Selection.Row "visa meddelande MsgBox "Adress till valt område:"& sAddress, vbInformation, "www.site" MsgBox "Första radens nummer: "& lRow, vbInformation, "www.site" "tilldela en annan variabel värdet på adressen till cell A1 sNewAddress = "A1" "välj den cell som anges av variabeln sNewAddres Range(sNewAddress). Välj MsgBox "Adress till valt område:"& sNewAddress, vbInformation, "www.site" "välj den initialt valda cellen med variabeln rRange rRange.Välj MsgBox "Adress till valt område:"& rRange.Address, vbInformation, "www.site" "ställ in värdet på variabeln sShName="excel-vba" "döp om det aktiva bladet till namnet som ges av variabeln ActiveSheet.Name = sShName End Sub

Sub main() "deklarerar variabler med specifika typtilldelningar "As String - text "As Long - heltal Dim sAddress As String, sNewAddress As String, sShName As String Dim lRow As Long Dim rrange as Range "tilldelade cell/intervalltyp till variabel" tilldelas variabeln rRange en referens till den aktuellt valda cellen Set rRange = Selection "ändra urvalet - välj cellen D9 Range("D9"). Välj "tilldela adressen för de valda cellerna till variabeln sAddress = Selection.Address " tilldela värdet på den första raden i det valda området till variabeln lRow lRow = Selection .Row "visa meddelandet MsgBox "Address of the selection: " & sAddress, vbInformation, "www..site" "tilldela en annan variabel värdet på adressen till cell A1 sNewAddress = "A1" "välj cellen som anges av variabeln sNewAddres Range(sNewAddress). Välj MsgBox "Vald områdesadress: " & sNewAddress, vbInformation, "www.site" "välj den initialt valda cellen med hjälp av rRange variabel rRange.Select MsgBox "Selection area address: " & rRange.Address, vbInformation, "www.site" "ställ in värdet på variabeln sShName = "excel-vba" "byt namn på det aktiva arket till det namn som anges av variabeln ActiveSheet.Name = sShName End Sub

Artikeln hjälper dig att se steg-för-steg-exekveringen av denna kod: Fånga fel och felsöka VBA-kod
Viktig! Om en cellreferens tilldelas en variabel (Set var = Range("A1")), är åtkomst till variabeln identisk med åtkomst till själva cell A1, närhelst det händer. En sådan tilldelning kommer inte ihåg egenskaperna för cellen före eller efter - variabeln lagrar en referens till en specifik cell och åtkomst är endast till cellens egenskaper för närvarande. För att komma ihåg värdet, färgen på en cell eller till och med adressen (liksom andra egenskaper) innan du ändrar cellen och tillämpar dem även efter att du har ändrat/flyttat själva cellen, är det nödvändigt att lagra cellens egenskaper i variabler:

Sub main() Dim val, l_InteriorColor As Long , l_FontColor As Long Dim rRange As Range "tilldelade cell/intervalltyp till variabel "tilldelade variabeln rRange en referens till den aktiva cellen Ställ in rRange = ActiveCell "kom ihåg cellegenskaper val = rRange.Value "(!LANG:value l_InteriorColor = rRange.Interior.Color"цвет заливки l_FontColor = rRange.Font.Color "цвет шрифта !} "kopiera en annan cell och klistra in i stället för den aktiva" ActiveSheet.Range("D1"). Kopiera rRange "kontrollera att rRange nu har helt andra egenskaper - som D1 "Fyllfärgsintervall: " "Omfång teckensnittsfärg: "& rRange.Font.Color & vbNewLine, vbInformation, "www.site" "tilldela egenskaper från lagrade i variabler rRange.Value = val "värde rRange.Interior.Color = l_InteriorColor "fyllningsfärg rRange.Font.Color = l_FontColor "font color "kontrollera att rRange returnerade parametrar innan du kopierar MsgBox "rRange value: " & rRange.Value & vbNewLine & _ "Fyllfärgsintervall: "&rRange.Interior.Color&vbNewLine&_ "Omfång teckensnittsfärg: "& rRange.Font.Color & vbNewLine, vbInformation, "www.site" End Sub

Sub main() Dim val, l_InteriorColor As Long, l_FontColor As Long Dim rRange As Range :l_InteriorColor value = rRange.Interior.Color"цвет заливки l_FontColor = rRange.Font.Color "цвет шрифта "копируем другую ячейку и вставляем на место активной ActiveSheet.Range("D1").Copy rRange "проверяем, что rRange теперь имеет совершенно другие свойста - как у D1 MsgBox "Значение rRange: " & rRange.Value & vbNewLine & _ "Цвет заливки rRange: " & rRange.Interior.Color & vbNewLine & _ "Цвет шрифта rRange: " & rRange.Font.Color & vbNewLine, vbInformation, "www..Value = val "значение rRange.Interior.Color = l_InteriorColor "цвет заливки rRange.Font.Color = l_FontColor "цвет шрифта "проверяем, что rRange возвращены параметры до копирования MsgBox "Значение rRange: " & rRange.Value & vbNewLine & _ "Цвет заливки rRange: " & rRange.Interior.Color & vbNewLine & _ "Цвет шрифта rRange: " & rRange.Font.Color & vbNewLine, vbInformation, "www.сайт" End Sub!}

Detta gäller även alla andra objekt. De där. de variabler vars värden tilldelas genom Set-satsen.

Konstanter
Det finns också en annan sorts "variabler" - konstanter. Detta är bara samma variabel (som namnet antyder) - den kan inte ändras under körningen av koden, eftersom är ett konstant värde och dess värde tilldelas endast en gång - innan koden exekveras.

Const sMyConst As String = "Namn på mitt program"

Konstanter kan tilldelas data av samma typ som variabler. För konstanternas extra omfattning/livslängd används endast Public. Om omfattningen inte är specificerad kommer konstanten endast att vara tillgänglig från modulen där den deklareras. Här uppmärksammar jag att Dim inte längre används, pga. Dim är en identifierare endast för variabler. Ett par viktiga skillnader mellan att deklarera konstanter och att deklarera variabler:

när du deklarerar en konstant är det nödvändigt att uttryckligen ange att det är en konstant med nyckelordet Const
omedelbart vid tidpunkten för deklarationen måste du tilldela värdet till konstanten: = "Namn på mitt program"

I alla andra avseenden är deklarationen och användningen av konstanter identisk med deklarationen av variabler. Låt mig kort ge ett par exempel.
Om konstanten deklareras i en procedur:

Sub TestConst() Const sMyConst As String = "Mitt programnamn är 'MsgBox sMyConst' visa ett meddelande med programnamnet End Sub Sub TestConst2() MsgBox sMyConst "kommer att ge ett fel Variabel ej definierad End Sub

För att använda en konstant i alla procedurer i projektet (boken), är det nödvändigt att deklarera den som offentlig.