Description

Use the GetVarType method to determine the data type of the passed parameter.

Declaration

aqObject.GetVarType(VarParam)

VarParam	[in]	Required	Variant
Result	Integer

Applies To

The method is applied to the following object:

aqObject

Parameters

The method has the following parameter:

VarParam

The OLEVariant value whose type you want to determine.

Result Value

An integer number that corresponds to one of the following constants:

Constant Name	Hex Value	Integer Value	Description
`varEmpty`	`0000h`	0	Empty (uninitialized).
`varNull`	`0001h`	1	Null (no valid data).
`varSmallInt`	`0002h`	2	Signed 16-bit integer.
`varInteger`	`0003h`	3	Signed 32-bit integer.
`varSingle`	`0004h`	4	Single-precision floating-point number. Number of significant digits: 7-8.
`varDouble`	`0005h`	5	Double-precision floating-point number. Number of significant digits: 15-16.
`varCurrency`	`0006h`	6	High-precision floating-point number. Number of significant digits: 19-20. Intended to minimize rounding errors in monetary calculations.
`varDate`	`0007h`	7	OLE-compatible TDateTime type.
`varOleStr`	`0008h`	8	String of 16-bit Unicode characters.
`varDispatch`	`0009h`	9	Automation object that implements `IDispatch` interface. Also, this type is used for native JavaScript, JScript, Python, C#Script and C++Script arrays (see below).
`varError`	`000Ah`	10	Code of an OS error.
`varBoolean`	`000Bh`	11	Boolean.
`varVariant`	`000Ch`	12	Variant.
`varUnknown`	`000Dh`	13	Reference to an unknown OLE object.
`varShortInt`	`0010h`	16	Signed 8-bit integer.
`varByte`	`0011h`	17	Unsigned 8-bit integer.
`varWord`	`0012h`	18	Unsigned 16-bit integer.
`varLongWord`	`0013h`	19	Unsigned 32-bit integer.
`varInt64`	`0014h`	20	Signed 64-bit integer.
`varStrArg`	`48h`	72	A COM-compatible string.
`varString`	`100h`	256	A reference to a dynamically allocated string (not COM-compatible).
`varAny`	`101h`	257	A Variant that can contain any value.
`varArray`	`2000h`	8192	Array (but not a native JavaScript, JScript and Python array, see below). Type of array elements is specified by the lower bits. For example, `2003h` is an array of integers.
`varByRef`	`4000h`	16384	Reference to a value of the type given by the lower bits. For example, `4007h` is a reference to a date.

Remarks

For JavaScript, JScript, Python, C#Script and C++Script users: the varArray constant matches the so-called “safe arrays” that are used in VBScript, DelphiScript, Visual Basic 6 and other languages. JavaScript, JScript, Python, C#Script and C++Script use native arrays. For these arrays, GetVarType returns varDispatch, which is also used for objects. To verify that a variable is a native array, you can use the following code:

JavaScript

if (strictEqual(Object.prototype.toString.call(obj), "[object Array]"))
{
// A native JavaScript array
}
else
{
// Not a JavaScript array
}

JScript

if (Object.prototype.toString.call(obj) === "[object Array]")
{
// A native JScript array
}
else
{
// Not a JScript array
}

Python

if isinstance(obj, list):
# A native Python array
else:
# Not a Python array

C++Script, C#Script

if (Object["prototype"]["toString"]["call"](obj) === "[object Array]")
{
// A native JScript array
}
else
{
// Not a JScript array
}

Example

The code snippet below demonstrates how to use the GetVarType method. Besides, it introduces a helper GetTypeName routine that returns human-readable descriptions of data type constants.

JavaScript, JScript

function Main()
{
  var TypeID, TypeDescr, Arr;

  TypeID    = GetVarType(255);
  TypeDescr = GetTypeName(TypeID);
  Log.Message("Type: " + TypeID + " - " + TypeDescr);
  // Prints "Type: 3 - Signed 32-bit integer"

  TypeID    = GetVarType(aqDateTime.Now());
  TypeDescr = GetTypeName(TypeID);
  Log.Message("Type: " + TypeID + " - " + TypeDescr);
  // Prints "Type: 7 - Date/Time"

  Arr       = new Array(1,2,3)
  TypeID    = GetVarType(Arr);
  TypeDescr = GetTypeName(TypeID);
  Log.Message("Type: " + TypeID + " - " + TypeDescr);
  // Prints "Type: 9 - Automation object of IDispatch interface"
}

function GetTypeName(TypeID)
{
  var str = "Unknown";
  switch (TypeID)
  {
     case varEmpty :
       str = "Uninitialized";
       break;
     case varNull :
       str = "Null";
       break;
     case varSmallInt :
       str = "Signed 16-bit integer";
       break;
     case varInteger :
       str = "Signed 32-bit integer";
       break;
     case varSingle :
       str = "Single-precision floating-point number";
       break;
     case varDouble :
       str = "Double-precision floating-point number";
       break;
     case varCurrency :
       str = "Currency. High-precision floating-point number";
       break;
     case varDate :
       str = "Date/Time";
       break;
     case varOleStr :
       str = "String";
       break;
     case varDispatch :
       str = "Automation object of IDispatch interface";
       break;
     case varError :
       str = "Code of an OS error";
       break;
     case varBoolean :
       str = "Boolean";
       break;
     case varVariant :
       str = "Variant";
       break;
     case varShortInt :
       str = "Signed 8-bit integer";
       break;
     case varByte :
       str = "Unsigned 8-bit integer";
       break;
     case varWord :
       str = "Unsigned 16-bit integer";
       break;
     case varLongWord :
       str = "Unsigned 32-bit integer";
       break;
     case varInt64 :
       str = "Signed 64-bit integer";
       break;
  }

  if ((TypeID >= varArray) && (TypeID <= varArray + varInt64))
  {
     str = "Array of " + GetTypeName(TypeID - varArray);
  }
  else if ((TypeID >= varByRef) && (TypeID <= varByRef + varInt64))
  {
     str = "Reference to " + GetTypeName(TypeID - varByRef);
  }

  return str;
}

Python

def Main():
  TypeID = GetVarType(255)
  TypeDescr = GetTypeName(TypeID)
  Log.Message("Type: " + str(TypeID) + " - " + str(TypeDescr))
  # Prints "Type: 3 - Signed 32-bit integer" 
  
  TypeID = GetVarType(aqDateTime.Now())
  TypeDescr = GetTypeName(TypeID)
  Log.Message("Type: " + str(TypeID) + " - " + str(TypeDescr))
  # Prints "Type: 7 - Date/Time"
  
  Arr = [1,2,3]
  TypeID = GetVarType(Arr)
  TypeDescr = GetTypeName(TypeID)
  Log.Message("Type: " + str(TypeID) + " - " + str(TypeDescr));
  # Prints "Type: 9 - Automation object of IDispatch interface"

def GetTypeName(TypeID):
  str = "Unknown"
  if TypeID == varEmpty:
    str = "Uninitialized"
  elif TypeID == varNull:
    str = "Null"
  elif TypeID == varSmallInt:
    str = "Signed 16-bit integer"
  elif TypeID == varInteger:
    str = "Signed 32-bit integer"
  elif TypeID == varSingle:
    str = "Single-precision floating-point number"
  elif TypeID == varDouble:
    str = "Double-precision floating-point number"
  elif TypeID == varCurrency:
    str = "Currency. High-precision floating-point number"
  elif TypeID == varDate:
    str = "Date/Time"
  elif TypeID == varOleStr:
    str = "String"
  elif TypeID == varDispatch:
    str = "Automation object of IDispatch interface"
  elif TypeID == varError:
    str = "Code of an OS error"
  elif TypeID == varBoolean:
    str = "Boolean"
  elif TypeID == varVariant:
    str = "Variant"
  elif TypeID == varShortInt:
    str = "Signed 8-bit integer"
  elif TypeID == varByte:
    str = "Unsigned 8-bit integer"
  elif TypeID == varWord:
    str = "Unsigned 16-bit integer"
  elif TypeID == varLongWord:
    str = "Unsigned 32-bit integer"
  elif TypeID == varInt64:
    str = "Signed 64-bit integer"
  if (TypeID >= varArray) and (TypeID <= varArray + varInt64):
    str = "Array of " + GetTypeName(TypeID - varArray)
  elif (TypeID >= varByRef) and (TypeID <= varByRef + varInt64):
    str = "Reference to " + GetTypeName(TypeID - varByRef)
  return str

VBScript

Sub Main
  Dim TypeID, TypeDescr, Arr

  TypeID    = GetVarType(255)
  TypeDescr = GetTypeName(TypeID)
  Log.Message "Type: " & TypeID & " - " & TypeDescr
  ' Prints "Type: 2 - Signed 16-bit integer"

  TypeID    = GetVarType(aqDateTime.Now)
  TypeDescr = GetTypeName(TypeID)
  Log.Message "Type: " & TypeID & " - " & TypeDescr
  ' Prints "Type: 7 - Date/Time"

  Arr       = Array(10, 20, 30)
  TypeID    = GetVarType(Arr)
  TypeDescr = GetTypeName(TypeID)
  Log.Message "Type: " & TypeID & " - " & TypeDescr
  ' Prints "Type: 8204 - Array of Variant"
End Sub

Function GetTypeName(TypeID)
  GetTypeName = "Unknown"
  Select Case TypeID
     Case varEmpty    : GetTypeName = "Uninitialized"
     Case varNull     : GetTypeName = "Null"
     Case varSmallInt : GetTypeName = "Signed 16-bit integer"
     Case varInteger  : GetTypeName = "Signed 32-bit integer"
     Case varSingle   : GetTypeName = "Single-precision floating-point number"
     Case varDouble   : GetTypeName = "Double-precision floating-point number"
     Case varCurrency : GetTypeName = "Currency. High-precision floating-point number"
     Case varDate     : GetTypeName = "Date/Time"
     Case varOleStr   : GetTypeName = "String"
     Case varDispatch : GetTypeName = "Automation object of IDispatch interface"
     Case varError    : GetTypeName = "Code of an OS error"
     Case varBoolean  : GetTypeName = "Boolean"
     Case varVariant  : GetTypeName = "Variant"
     Case varShortInt : GetTypeName = "Signed 8-bit integer"
     Case varByte     : GetTypeName = "Unsigned 8-bit integer"
     Case varWord     : GetTypeName = "Unsigned 16-bit integer"
     Case varLongWord : GetTypeName = "Unsigned 32-bit integer"
     Case varInt64    : GetTypeName = "Signed 64-bit integer"
  End Select

  If TypeID >= varArray And TypeID <= varArray + varInt64 Then
    GetTypeName = "Array of " & GetTypeName(TypeID - varArray)
  ElseIf TypeID >= varByRef And TypeID <= varByRef + varInt64 Then
    GetTypeName = "Reference to " & GetTypeName(TypeID - varByRef)
  End If
End Function

DelphiScript

function GetTypeName(TypeID); forward;

procedure Main2;
var
  TypeID, TypeDescr;
  Arr : array [0..2];
begin
  TypeID    := GetVarType(255);
  TypeDescr := GetTypeName(TypeID);
  Log.Message('Type: ' + aqConvert.IntToStr(TypeID) + ' - ' + TypeDescr);
  // Prints 'Type: 3 - Signed 32-bit integer'

  TypeID    := GetVarType(aqDateTime.Now());
  TypeDescr := GetTypeName(TypeID);
  Log.Message('Type: ' + aqConvert.IntToStr(TypeID) + ' - ' + TypeDescr);
  // Prints 'Type: 7 - Date/Time'

  Arr       := [1, 2, 3];
  TypeID    := GetVarType(Arr);
  TypeDescr := GetTypeName(TypeID);
  Log.Message('Type: ' + aqConvert.IntToStr(TypeID) + ' - ' + TypeDescr);
  // Prints 'Type: 8204 - Array of Variant'
end;

function GetTypeName(TypeID);
begin
  case TypeID of
     varEmpty    : Result := 'Uninitialized';
     varNull     : Result := 'Null';
     varSmallInt : Result := 'Signed 16-bit integer';
     varInteger  : Result := 'Signed 32-bit integer';
     varSingle   : Result := 'Single-precision floating-point number';
     varDouble   : Result := 'Double-precision floating-point number';
     varCurrency : Result := 'Currency. High-precision floating-point number';
     varDate     : Result := 'Date/Time';
     varOleStr   : Result := 'String';
     varDispatch : Result := 'Automation object of IDispatch interface';
     varError    : Result := 'Code of an OS error';
     varBoolean  : Result := 'Boolean';
     varVariant  : Result := 'Variant';
     varUnknown  : Result := 'Unknown';
     varShortInt : Result := 'Signed 8-bit integer';
     varByte     : Result := 'Unsigned 8-bit integer';
     varWord     : Result := 'Unsigned 16-bit integer';
     varLongWord : Result := 'Unsigned 32-bit integer';
     varInt64    : Result := 'Signed 64-bit integer';
     varArray .. varArray + varInt64 : Result := 'Array of '     + GetTypeName(TypeID - varArray);
     varByRef .. varByRef + varInt64 : Result := 'Reference to ' + GetTypeName(TypeID - varByRef);
     else Result := 'Unknown';
  end;
end;

C++Script, C#Script

function Main()
{
  var TypeID, TypeDescr, Arr;

  TypeID    = GetVarType(255);
  TypeDescr = GetTypeName(TypeID);
  Log["Message"]("Type: " + TypeID + " - " + TypeDescr);
  // Prints "Type: 3 - Signed 32-bit integer"

  TypeID    = GetVarType(aqDateTime["Now"]());
  TypeDescr = GetTypeName(TypeID);
  Log["Message"]("Type: " + TypeID + " - " + TypeDescr);
  // Prints "Type: 7 - Date/Time"

  Arr       = new Array(1,2,3)
  TypeID    = GetVarType(Arr);
  TypeDescr = GetTypeName(TypeID);
  Log["Message"]("Type: " + TypeID + " - " + TypeDescr);
  // Prints "Type: 9 - Automation object of IDispatch interface"
}

function GetTypeName(TypeID)
{
  var str = "Unknown";
  switch (TypeID)
  {
     case varEmpty :
       str = "Uninitialized";
       break;
     case varNull :
       str = "Null";
       break;
     case varSmallInt :
       str = "Signed 16-bit integer";
       break;
     case varInteger :
       str = "Signed 32-bit integer";
       break;
     case varSingle :
       str = "Single-precision floating-point number";
       break;
     case varDouble :
       str = "Double-precision floating-point number";
       break;
     case varCurrency :
       str = "Currency. High-precision floating-point number";
       break;
     case varDate :
       str = "Date/Time";
       break;
     case varOleStr :
       str = "String";
       break;
     case varDispatch :
       str = "Automation object of IDispatch interface";
       break;
     case varError :
       str = "Code of an OS error";
       break;
     case varBoolean :
       str = "Boolean";
       break;
     case varVariant :
       str = "Variant";
       break;
     case varShortInt :
       str = "Signed 8-bit integer";
       break;
     case varByte :
       str = "Unsigned 8-bit integer";
       break;
     case varWord :
       str = "Unsigned 16-bit integer";
       break;
     case varLongWord :
       str = "Unsigned 32-bit integer";
       break;
     case varInt64 :
       str = "Signed 64-bit integer";
       break;
  }

  if ((TypeID >= varArray) && (TypeID <= varArray + varInt64))
  {
     str = "Array of " + GetTypeName(TypeID - varArray);
  }
  else if ((TypeID >= varByRef) && (TypeID <= varByRef + varInt64))
  {
     str = "Reference to " + GetTypeName(TypeID - varByRef);
  }

  return str;
}

aqObject.GetVarType Method

Description

Declaration

Applies To

Parameters

Result Value

Remarks

Example

See Also