VBA
Parola chiave dell'opzione VBA

Sintassi

• Opzione optionName [valore]
• Opzione esplicita
• Opzione Confronta {Testo | Binario | Banca dati}
• Opzione Modulo privato
• Opzione Base {0 | 1}

Parametri

Osservazioni

Dim myStringsA(0 To 5) As String '// This has 6 elements (0 - 5)
Dim myStringsB(1 To 5) As String '// This has 5 elements (1 - 5)
Dim myStringsC(6 To 9) As String '// This has 3 elements (6 - 9)

Opzione esplicita

È consigliabile utilizzare sempre Option Explicit in VBA in quanto costringe lo sviluppatore a dichiarare tutte le loro variabili prima dell'uso. Questo ha anche altri vantaggi, come l'auto-capitalizzazione per i nomi delle variabili dichiarate e IntelliSense.

Option Explicit

Sub OptionExplicit()
    Dim a As Integer
    a = 5
    b = 10 '// Causes compile error as 'b' is not declared
End Sub

L'impostazione richiede la dichiarazione delle variabili all'interno degli strumenti di VBE ► Opzioni ► Pagina delle proprietà dell'editor inserisce l'istruzione Explicit Option nella parte superiore di ogni foglio di codice appena creato.

Ciò eviterà errori di codifica stupidi come errori di ortografia e influirà sull'uso del tipo di variabile corretto nella dichiarazione delle variabili. (Alcuni altri esempi sono forniti SEMPRE in "Option Explicit" .)

Opzione Confronta {Binario | Testo | Banca dati}

Opzione Confronta binario

Confronto binario rende tutti i controlli per l'uguaglianza di stringa all'interno di un involucro Modulo / classe sensibile. Tecnicamente, con questa opzione, i confronti delle stringhe vengono eseguiti utilizzando l'ordinamento delle rappresentazioni binarie di ciascun carattere.

A <B <E <Z <a <b <e <z

Se in un modulo non è specificata alcuna opzione Confronta, Binary viene utilizzato per impostazione predefinita.

Option Compare Binary

Sub CompareBinary()

    Dim foo As String
    Dim bar As String
    
    '// Case sensitive
    foo = "abc"
    bar = "ABC"
    
    Debug.Print (foo = bar) '// Prints "False"
    
    '// Still differentiates accented characters
    foo = "ábc"
    bar = "abc"
    
    Debug.Print (foo = bar) '// Prints "False"
    
    '// "b" (Chr 98) is greater than "a" (Chr 97)
    foo = "a"
    bar = "b"
    
    Debug.Print (bar > foo) '// Prints "True"
    
    '// "b" (Chr 98) is NOT greater than "á" (Chr 225)
    foo = "á"
    bar = "b"
    
    Debug.Print (bar > foo) '// Prints "False"

End Sub

Opzione Confronta testo

Opzione Confronta testo rende tutti i confronti di stringa all'interno di un modulo / classe utilizzando un confronto senza distinzione tra maiuscole e minuscole .

(A | a) <(B | b) <(Z | z)

Option Compare Text

Sub CompareText()

    Dim foo As String
    Dim bar As String
    
    '// Case insensitivity
    foo = "abc"
    bar = "ABC"
    
    Debug.Print (foo = bar) '// Prints "True"
    
    '// Still differentiates accented characters
    foo = "ábc"
    bar = "abc"
    
    Debug.Print (foo = bar) '// Prints "False"
    
    '// "b" still comes after "a" or "á"
    foo = "á"
    bar = "b"
    
    Debug.Print (bar > foo) '// Prints "True"

End Sub

Opzione Confronta database

Option Compare Database è disponibile solo all'interno di MS Access. Imposta il modulo / classe per utilizzare le impostazioni correnti del database per determinare se utilizzare la modalità Testo o Binario.

Nota: l'uso di questa impostazione è sconsigliato a meno che il modulo non venga utilizzato per la scrittura di UDF di accesso personalizzate (funzioni definite dall'utente) che dovrebbero trattare i confronti del testo nello stesso modo delle query SQL in quel database.

Opzione Base {0 | 1}

Option Base è usato per dichiarare il limite inferiore predefinito degli elementi dell'array . È dichiarato a livello di modulo ed è valido solo per il modulo corrente.

Di default (e quindi se non viene specificata alcuna Option Base), la Base è 0. Ciò significa che il primo elemento di ogni array dichiarato nel modulo ha un indice di 0.

Se viene specificata l' Option Base 1 , il primo elemento dell'array ha l'indice 1

Esempio in base 0:

Option Base 0

Sub BaseZero()

    Dim myStrings As Variant
    
    ' Create an array out of the Variant, having 3 fruits elements
    myStrings = Array("Apple", "Orange", "Peach")
    
    Debug.Print LBound(myStrings) ' This Prints "0"
    Debug.Print UBound(myStrings) ' This print "2", because we have 3 elements beginning at 0 -> 0,1,2
            
    For i = 0 To UBound(myStrings)
    
        Debug.Print myStrings(i) ' This will print "Apple", then "Orange", then "Peach"
    
    Next i

End Sub

Lo stesso esempio con Base 1

Option Base 1

Sub BaseOne()

    Dim myStrings As Variant
    
    ' Create an array out of the Variant, having 3 fruits elements
    myStrings = Array("Apple", "Orange", "Peach")
    
    Debug.Print LBound(myStrings) ' This Prints "1"
    Debug.Print UBound(myStrings) ' This print "3", because we have 3 elements beginning at 1 -> 1,2,3
            
    For i = 0 To UBound(myStrings)
    
        Debug.Print myStrings(i) ' This triggers an error 9 "Subscript out of range"
    
    Next i

End Sub

Il secondo esempio ha generato un Sottoscritto fuori intervallo (Errore 9) al primo stadio del ciclo perché è stato effettuato un tentativo di accedere all'indice 0 dell'array e questo indice non esiste poiché il modulo viene dichiarato con Base 1

Il codice corretto con Base 1 è:

    For i = 1 To UBound(myStrings)
    
        Debug.Print myStrings(i) ' This will print "Apple", then "Orange", then "Peach"
    
    Next i

Va notato che la funzione Dividi crea sempre una matrice con un indice di elemento a base zero indipendentemente da qualsiasi impostazione di Option Base . Gli esempi su come usare la funzione Split possono essere trovati qui

^{Funzione Split}

_{Restituisce un array unidimensionale a base zero contenente un numero specificato di sottostringhe.}

In Excel, le proprietà Range.Value e Range.Formula per un intervallo Range.Formula restituiscono sempre un array Variant 2D basato su 1.

Allo stesso modo, in ADO, il metodo Recordset.GetRows restituisce sempre un array 2D basato su 1.

Una "best practice" consigliata è quella di utilizzare sempre le funzioni LBound e UBound per determinare le estensioni di un array.

'for single dimensioned array
Debug.Print LBound(arr) & ":" & UBound(arr)
Dim i As Long
For i = LBound(arr) To UBound(arr)
    Debug.Print arr(i)
Next i

'for two dimensioned array
Debug.Print LBound(arr, 1) & ":" & UBound(arr, 1)
Debug.Print LBound(arr, 2) & ":" & UBound(arr, 2)
Dim i As long, j As Long
For i = LBound(arr, 1) To UBound(arr, 1)
    For j = LBound(arr, 2) To UBound(arr, 2)
         Debug.Print arr(i, j)
    Next j
Next i

L' Option Base 1 deve trovarsi nella parte superiore di ogni modulo di codice in cui viene creato o ridimensionato un array se gli array devono essere creati in modo coerente con un limite inferiore di 1.