` and then using their ToString methods.
>
> This property is read-only.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.UInt32Value
**UInt32Value** As `UInt32`
> Returns the value of the Variant as an `UInt32`.
>
> This property is read-only.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.UInt64Value
**UInt64Value** As `UInt64`
> Returns the value of the Variant as an `UInt64`.
>
> This property is read-only.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.WStringValue
**WStringValue** As `WString`
> Returns the value of the Variant as a `WString`.
>
> This property is read-only.
## Method descriptions
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.ArrayElementType
**ArrayElementType** As `Integer`
> Returns an integer that indicates the type of the array. The return value can be tested against the Variant class constants or be compared to the integer values given in the `VarType` description.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Equals
**Equals**(v As Variant) As `Boolean`
> Returns `True` if the Variant has the same value as the Variant passed as a parameter.If the variants are not of the same type a common type is computed & the value is compared for equality.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_Add
**Operator_Add**(v As Variant) As Variant
> Used to define the addition operator for the Variant. See `Operator Add`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_AddRight
**Operator_AddRight**(v As Variant) As Variant
> Used to define the addition operator for the Variant with the implicit `Self` on the right. See `Operator AddRight`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_And
**Operator_And**(v As Variant) As Variant
> Used to define the `And` operator for the Variant. See `Operator And`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_AndRight
**Operator_AndRight**(v As Variant) As Variant
> Used to define the And operator for the Variant with the implicit `Self` on the right. See `Operator AndRight`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_Compare
**Operator_Compare**(v As Variant) As `Integer`
> Used to define all the comparison operators for the Variant.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_Divide
**Operator_Divide**(v As Variant) As Variant
> Used to define the division operator for the Variant. See `Operator Divide`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_DivideRight
**Operator_DivideRight**(v As Variant) As Variant
> Used to define the division operator for the Variant with the implicit `Self` on the right. See `Operator DivideRight`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_IntegerDivide
**Operator_IntegerDivide**(v As Variant) As Variant
> Used to define the integer division operator for the Variant. See `Operator IntegerDivide`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_IntegerDivideRight
**Operator_IntegerDivideRight**(v As Variant) As Variant
> Used to define the integer division operator for the Variant with the implicit `Self` on the right. See `Operator IntegerDivideRight`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_Modulo
**Operator_Modulo**(v As Variant) As Variant
> Used to define the `Mod` operator for the Variant. See `Operator Modulo`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_ModuloRight
**Operator_ModuloRight**(v As Variant) As Variant
> Used to define the `Mod` operator for the Variant with the implicit `Self` on the right.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_Multiply
**Operator_Multiply**(v As Variant) As Variant
> Used to define the multiplication operator for the Variant. See `Operator Multiply`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_MultiplyRight
**Operator_MultiplyRight**(v As Variant) As Variant
> Used to define the multiplication operator for the Variant with the implicit `Self` on the right. `Operator Multiply Right`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_Negate
**Operator_Negate** As Variant
> Use to define the negation operator for the Variant. See `Operator Negate`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_Not
**Operator_Not** As Variant
> Used to define the `Not` operator for the Variant. See `Operator Not`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_Or
**Operator_Or**(v As Variant) As Variant
> Used to define the `Or` operator for the Variant. See `Operator Or`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_OrRight
**Operator_OrRight**(v As Variant) As Variant
> Used to define the `Or` operator for the Variant with the implicit `Self` on the right. See `Operator OrRight`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_Power
**Operator_Power**(v As Variant) As Variant
> Used to define the power (`^`) operator for the Variant. See `Operator Power`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_PowerRight
**Operator_PowerRight**(v As Variant) As Variant
> Used to define the power (`^`) operator for the Variant with the implicit `Self` on the right. See `Operator PowerRight`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_Subtract
**Operator_Subtract**(v As Variant) As Variant
> Used to define the subtraction operator for the Variant. See `Operator Subtract`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_SubtractRight
**Operator_SubtractRight**(v As Variant) As Variant
> Used to define the subtraction operator for the Variant with the implicit `Self` on the right. See `Operator SubtractRight`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_XOr
**Operator_XOr**(v As Variant) As Variant
> Used to define the `XOr` operator for the Variant. See the definitions of the `XOr` operator in the `XOr` description. See `Operator XOr`
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Operator_XOrRight
**Operator_XOrRight**(v As Variant) As Variant
> Used to define the `XOr` operator for the Variant with the implicit `Self` on the right. See the definitions of the `XOr` operator in the `XOr` description. See `Operator XOrRight`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
Variant.Type
**Type** As `Integer`
> Returns an `Integer`, indicating the data type of the Variant. The values of each data type are given in the table in the Notes section of the `VarType` function.
>
> If the Variant is an array, then Type returns TypeArray logically OR'ed with the array element type. You can get the element type by calling ArrayElementType.
>
> An array of Dates will be designated as an array of Objects.
>
> If the Variant is not `Nil`, it provides the same functionality as the `VarType` global function. You can use the Variant class constants instead of the integer values to determine the data type. The names are listed as *Class Constants* on the Variant page.
## Notes
### Particularities of the variant object
The default value of a Variant is `Nil`. However, unlike other objects, you can use the above methods with a `Nil` Variant without raising a `NilObjectException`.
For example, the following is valid for a Variant but not for any other `Object`:
``` xojo
Var v As Variant = Nil
Var vType As Integer ' To store the variant type
vType = v.Type ' It does not raise NilObjectException
```
This peculiarity allows you to use the method `IsNull` instead of *v = Nil*. They both give the same result:
``` xojo
Var v As Variant
If v = Nil Then
...
End If
' OR you can write
If v.IsNull Then
...
End If
```
Variants do not have a specific default value, but will instead get the default value of whatever type they are converted to (see the next section).
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
### Automatic conversion of values
When you assign a Variant to a `string`, numeric, or `DateTime` variable, value of the Variant is converted to the variable's data type. For example,
``` xojo
Var v As Variant
Var n As Integer
Var s As String
v = 25
s = v ' s is "25"
v = "25"
n = v ' n is 25
```
If there is any ambiguity concerning the type conversion of a Variant, you should use one of the properties of the Variant class to force the compiler to convert the Variant to the desired type. In this example, the Product number is supposed to be the string concatenation of the Model number and the Part Number. To do this, use the `StringValue` property to specifically tell the compiler to do what you want:
``` xojo
Var model, partNumber, product As Variant
model = 100
partNumber = 546
product = model + partNumber ' product=646
product = model.StringValue + partNumber.StringValue ' product="100546"
```
Or, you could just type the variables as `String` and do string concatenation directly.
Variants used in an expression convert themselves to the type of the other operand, no matter what kind of data they contain, instead of deferring the type-conversion until runtime. This only affects expressions involving a Variant operand and an operand of some other type, not expressions in which both operands are variants.
Consider the following example:
``` xojo
Var v As Variant = 0.5
```
The comparison:
``` xojo
If v > 0 Then
```
returns `False` since v is being treated as an `Integer` and will round down to 0.
If you instead use:
``` xojo
If v > 0.0 Then
```
the comparison returns `True`.
The comparison:
``` xojo
If v.DoubleValue > 0 Then
```
also returns `True`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
### Conversion from nil
If you assign a Nil Variant to an intrinsic type, then the value will be the default value for the intrinsic type:
``` xojo
Var v As Variant = Nil
Var b As Boolean = v ' False
Var d As Double = v ' 0.0
Var i As Integer = v ' 0
Var s As String = v ' ""
```
## Compatibility
| | |
|-----------------------|-----|
| **Project Types** | All |
| **Operating Systems** | All |
`Object` parent class; `IsNumeric`, `VarType` functions; `Dictionary` classes;