# Builtin - 基础 / 类型转换

## 类型转换

## `dataType(data, n)`

声明：function

根据Data的数据类型返回对应的值。当Data为数组时，N生效，支持对数组中的每个维度或每个单元格进行数据类型的判断。

| 参数   | 类型    | 说明           |
| ------ | ------- | -------------- |
| `data` | any     | 任意类型数据。 |
| `n`    | integer | 整数，可选参数 |

返回：integer|array

### 示例

范例01：当参数为数组型变量时，返回数组类型对应的整数 5

```tsl
a := Array(34, 12); // 定义a为一个数组
result := dataType(a);
return result;
// 输出：5
```

范例02：当参数为整数型变量时，返回整数类型对应的整数 0

```tsl
a := 23; // 定义a为一个整数
result := dataType(a);
return result;
// 输出：0
```

范例03：对数组第一维度数据进行类型判断

```tsl
t := array(1, 3.14, "A", (1, 2, 3), nil);
return dataType(t, -1);
// 输出：array(0,1,2,5,10)
```

范例04：对数组中每一数据进行类型判断

```tsl
t := array(1, 3.14, "A", (1, 2, 3), nil);
return dataType(t, 1);
// 输出：array(0,1,2,(0,0,0),10)
```

## `createBinary(len)`

声明：function

创建一个Binary类型。

| 参数  | 类型    | 说明                     |
| ----- | ------- | ------------------------ |
| `len` | integer | 整数，二进制类型的长度。 |

返回：binary

## `ifNone(data, none_value)`

声明：function

判别是否是None类型，以及判别值是否是指定NoneValue的None类型

| 参数         | 类型    | 说明                                                                                                               |
| ------------ | ------- | ------------------------------------------------------------------------------------------------------------------ |
| `data`       | any     | 任意类型                                                                                                           |
| `none_value` | integer | 整型，可选参数，指定None类型里包含的值，如对象set重载应用中，当包none类型包含值-1时，则表示set出错后重新进入的状态 |

返回：bool

## `createComObject(guid, obj)`

声明：function

创建COM对象。如果创建成功则返回真，否则返回假。

| 参数   | 类型   | 说明             |
| ------ | ------ | ---------------- |
| `guid` | string | 对象的类GUID串。 |
| `obj`  | comobj | 保存创建的对象。 |

返回：bool

## `ifInt(value, n)`

声明：function

判断value是否是一个32位整数类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任何类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

### 示例

范例一：

```tsl
// 判断是否为32位整数类型
r1 := ifInt(1);
r2 := ifInt(3.14);
r3 := ifInt("A");
r4 := ifInt(array(1, 2, 3));
return array(r1, r2, r3, r4);
// 输出：array(1,0,0,0)
```

范例二：

```tsl
// 对数组第一维度数据进行类型判断
t := array(1, 3.14, "A", (1, 2, 3), nil);
return ifInt(t, -1);
// 输出：array(1,0,0,0,0)
```

范例三：

```tsl
// 对数组中每一数据进行类型判断
t := array(1, 3.14, "A", (1, 2.1, 3), nil);
return ifInt(t, 1);
// 输出：array(1,0,0,(1,0,1),0)
```

## `ifInt64(value, n)`

声明：function

判断value是否是一个64位整数类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任何类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

### 示例

范例01：当参数为长整型变量时，返回 1

```tsl
a := 23L; // 定义a为一个64位整数
return ifInt64(a);
// 输出：1
```

范例02：当参数为非长整型变量时，返回 0

```tsl
a := 2.3; // 定义a为一个非64位整数
return ifInt64(a);
// 输出：0
```

范例03：对数组第一维度数据进行类型判断

```tsl
t := array(1, 3L, "A", (1, 2, 3), nil);
return ifInt64(t, -1);
// 输出：array(0,1,0,0,0)
```

范例04：对数组中每一数据进行类型判断

```tsl
t := array(1, 3L, "A", (1, 2L, 3), nil);
return ifInt64(t, 1);
// 输出：array(0,1,0,(0,1,0),0)
```

## `ifReal(value, n)`

声明：function

判断value是否是一个实数类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任何类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

### 示例

范例01：当参数为实数类型变量时，返回 1

```tsl
a := 2.233; // 定义a为一个实数
result := ifReal(a);
return result;
// 输出：1
```

范例02：当参数为非实数类型变量时，返回 0

```tsl
a := array(23, 54, 67); // 定义a为一个非实数
result := ifReal(a);
return result;
// 输出：0
```

范例03：对数组第一维度数据进行类型判断

```tsl
t := array(1, 3.56, "A", (1, 2, 3), nil);
return ifReal(t, -1);
// 输出：array(0,1,0,0,0)
```

范例04：对数组中每一数据进行类型判断

```tsl
t := array(1, 3.56, "A", (1, 2.14, 3), nil);
return ifReal(t, 1);
// 输出：array(0,1,0,(0,1,0),0)
```

## `ifNumber(value, n)`

声明：function

判断value是否是一个数字类型(32位整数、64位整数或者实数)。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任何类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

### 示例

范例01：当参数为数字类型(整数或者实数)变量时，返回 1

```tsl
a := 2.233; // 定义a为一个实数
result := ifNumber(a);
return result;
// 输出：1
```

范例02：当参数为非数字类型变量时，返回 0

```tsl
a := array(23, 54, 67); // 定义a为一个非数字类型
result := ifNumber(a);
return result;
// 输出：0
```

范例03：对数组第一维度数据进行类型判断

```tsl
t := array(1, 3.56, "A", (1, 2, 3), nil);
return ifNumber(t, -1);
// 输出：array(1,1,0,0,0)
```

范例04：对数组中每一数据进行类型判断，nan 也为数字类型

```tsl
t := array(1, 3.56, "A", (nan, 2.14, "C"), nil);
return ifNumber(t, 1);
// 输出：array(1,1,0,(1,1,0),0)
```

## `ifString(value, n)`

声明：function

判断value是否是一个字符串类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任何类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

### 示例

范例01：当参数为字符串类型变量时，返回 1

```tsl
a := 'test'; // 定义a为一个字符串
result := ifString(a);
return result;
// 输出：1
```

范例02：当参数为非字符串类型变量时，返回 0

```tsl
a := array(23, 54, 67); // 定义a为一个非字符串
result := ifString(a);
return result;
// 输出：0
```

范例03：对数组第一维度数据进行类型判断

```tsl
t := array(1, 3.56, "A", (1, 2, 3), nil);
return ifString(t, -1);
// 输出：array(0,0,1,0,0)
```

范例04：对数组中每一数据进行类型判断

```tsl
t := array(1, 3.56, "A", (nan, 2.14, "C"), nil);
return ifString(t, 1);
// 输出：array(0,0,1,(0,0,1),0)
```

## `ifArray(value, n)`

声明：function

判断value是否是一个数组类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任何类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

### 示例

范例01：当参数为数组类型变量时，返回 1

```tsl
a := array(23, 54, 67); // 定义a为一个数组
result := ifArray(a);
return result;
// 输出：1
```

范例02：当参数为非数组类型变量时，返回 0

```tsl
a := 34; // 定义a为一个非数组
result := ifArray(a);
return result;
// 输出：0
```

范例03：对数组第一维度数据进行类型判断

```tsl
t := array(1, 3.56, "A", (1, "C", 3.14), nil);
return ifArray(t, -1);
// 输出：array(0,0,0,1,0)
```

范例04：对数组中每一数据进行类型判断

```tsl
t := array(1, 3.56, "A", (nan, 2.14, "C"), nil);
return ifArray(t, 1);
// 输出：array(0,0,0,(0,0,0),0)
```

## `ifNil(value, n)`

声明：function

判断value是否为空。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任意类型数据。                   |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

### 示例

范例01：当参数为空时，返回 1

```tsl
result := ifNil(nil); // 函数参数为空
return result;
// 输出：1
```

范例02：当参数不为空时，返回 0

```tsl
a := 34; // 函数参数不为空
result := ifNil(a);
return result;
// 输出：0
```

范例03：对数组第一维度数据进行类型判断

```tsl
t := array(1, 3.16, "A", (nil, "C", 3.14), nil);
return ifNil(t, -1);
// 输出：array(0,0,0,0,1)
```

范例04：对数组中每一数据进行类型判断

```tsl
t := array(1, 3.56, "A", (nil, 2.14, "C"), nil);
return ifNil(t, 1);
// 输出：array(0,0,0,(1,0,0),1)
```

## `ifExp(value, n)`

声明：function

判断value是否是一个表达式类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任意类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

### 示例

范例01：当参数是一个表达式类型时，返回 1

```tsl
a := @'dfhdv'+'dbf'; // 函数参数a为一个表达式
result := ifExp(a);
return result;
// 输出：1
```

范例02：当参数不是一个表达式类型时，返回 0

```tsl
a := 'sdhv'+'dbf'; // 函数参数a不为表达式
result := ifExp(a);
return result;
// 输出：0
```

范例03：对数组第一维度数据进行类型判断

```tsl
t := array(1, 3.16, @"A", (nil, @"C", 3.14), nil);
return ifExp(t, -1);
// 输出：array(0,0,1,0,0)
```

范例04：对数组中每一数据进行类型判断

```tsl
t := array(1, 3.56, @"A", (nil, 2.14, @"C"), nil);
return ifExp(t, 1);
// 输出：array(0,0,1,(0,0,1),0)
```

## `ifBinary(value, n)`

声明：function

判断value是否是一个二进制类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任意类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

### 示例

范例01：当参数是一个二进制类型时，返回 1

```tsl
a := binary('111111'); // 函数参数a为二进制类型
result := ifBinary(a);
return result;
// 输出：1
```

范例02：当参数不是一个二进制类型时，返回 0

```tsl
a := 'sdhv'; // 函数参数a不为二进制类型
result := ifBinary(a);
return result;
// 输出：0
```

范例03：对数组第一维度数据进行类型判断

```tsl
b := binary("3.14");
t := array(1, b, "A", (nil, b, 3.14), nil);
return ifBinary(t, -1);
// 输出：array(0,1,0,0,0)
```

范例04：对数组中每一数据进行类型判断

```tsl
b := binary("3.14");
t := array(1, b, "A", (nil, 2.14, b), nil);
return ifBinary(t, 1);
// 输出：array(0,1,0,(0,0,1),0)
```

## `ifFmarray(value)`

声明：function

判断是否为 FMArray 类型。

| 参数    | 类型 | 说明     |
| ------- | ---- | -------- |
| `value` | any  | 输入数据 |

返回：bool

## `ifCache(value)`

声明：function

判断值是否仍是全局缓存引用。

| 参数    | 类型 | 说明       |
| ------- | ---- | ---------- |
| `value` | any  | 待判断的值 |

返回：bool

## 随机函数

## `ifGraph(value, n)`

声明：function

判断value是否是一个图形类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任意类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

### 示例

范例01：当参数是一个图形类型时，返回 1

```tsl
g_data := nDay2('MA5', ma(close(), 5));
g1 := graph(gtLine(), "MA5", g_data, gfColor(), clBlue());
result := ifGraph(g1);
return result;
// 输出：1（该示例依赖行情与图表运行环境，命令行解释器下无法构造图形对象）
```

范例02：当参数不是一个图形类型时，返回 0

```tsl
a := 'sdhv'+'dbf'; // 函数参数a不为图形类型
result := ifGraph(a);
return result;
// 输出：0
```

## `ifGraphgroup(value, n)`

声明：function

判断value是否是一个图形组合类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任意类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

### 示例

范例01：当参数是一个图形组合类型时，返回 1

```tsl
vol_data := nDay2(gfVol(), vol(), gfColor(), ifThen(close() > open(), clRed(), clGreen()));
mavol := nDay2('MA5', ma(vol(), 5));
vol_graph := graph(gtBar(), 'VOLGraph', vol_data);
mavol_graph := graph(gtLine(), 'MA5Graph', mavol, gfColor(), clBlue());
g1 := graphGroup(vol_graph, mavol_graph, gfMinValue(), 0); // 用GraphGroup创建图形组合类型变量g1
result := ifGraphGroup(g1);
return result;
// 输出：1（该示例依赖行情与图表运行环境，命令行解释器下无法构造图形组合对象）
```

范例02：当参数是图形（非图形组合）类型时，返回 0

```tsl
g_data := nDay2('MA5', ma(close(), 5));
g1 := graph(gtLine(), "MA5", g_data, gfColor(), clBlue());
result := ifGraphGroup(g1);
return result;
// 输出：0（该示例依赖行情与图表运行环境，命令行解释器下无法构造图形对象）
```

## `ifMatrix(value, n)`

声明：function

判断value是否是一个Matrix类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任意类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

### 示例

范例01：当参数是一个Matrix类型时，返回 1

```tsl
a := createMatrix(3, 4); // 使用CreateMatrix创建一个Matrix类型变量
result := ifMatrix(a);
return result;
// 输出：1
```

范例02：当参数不是一个Matrix类型时，返回 0

```tsl
a := 'sdhv'; // 函数参数a不为Matrix类型
result := ifMatrix(a);
return result;
// 输出：0
```

## `ifObj(value, n)`

声明：function

判断value是否是一个ComObj对象或者一个TSL的对象类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任意类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

### 示例

范例01：当参数是一个对象类型时，返回 1

```tsl
type function14=class() // 声明类
function SetName(new_name);
begin
name := new_name;
end;
end;
obj := CreateObject('Function14'); // 使用CreateObject函数创建上面类Function14的对象
result := ifObj(obj);
return result;
// 输出：1（该示例依赖对象运行环境，命令行解释器下无法构造类对象）
```

范例02：当参数不是一个对象类型时，返回 0

```tsl
a := 'sdhv'; // 函数参数a不为对象类型
result := ifObj(a);
return result;
// 输出：0
```

## `getOleObject(class_name, method, obj)`

声明：function

获取一个ComObj对象类型。

| 参数         | 类型    | 说明                                                                                                          |
| ------------ | ------- | ------------------------------------------------------------------------------------------------------------- |
| `class_name` | string  | 字符串，对象的类名。                                                                                          |
| `method`     | integer | 整数，产生方法的方法，1:获取一个存在的对象，2:新建一个对象，其他值:如果存在则获取一个存在对象，不存在则创建。 |
| `obj`        | comobj  | 保存返回的对象。                                                                                              |

返回：bool
