# Builtin - 类型转换

## `convertBufToData(buf, convert_type, index)`

声明：function

将字符串或 Binary 缓冲区中的数据按指定基础类型还原为 TSL 数据

<!-- tags: 类型转换 转换 编码 conversion -->

| 参数           | 类型           | 说明                                                            |
| -------------- | -------------- | --------------------------------------------------------------- |
| `buf`          | string\|binary | 存放待转换数据的缓冲区。                                        |
| `convert_type` | string         | 缓冲区中数据的基础类型。                                        |
| `index`        | integer        | 可选。转换起始位置；Binary 下标从 0 开始，字符串下标从 1 开始。 |

支持的 `convert_type`：

| 值                                                             | 数据解释               | 字节数 |
| -------------------------------------------------------------- | ---------------------- | ------ |
| `byte`、`int8`、`shortint`                                     | 单字节整数             | 1      |
| `int16`、`word`、`smallint`                                    | 双字节整数             | 2      |
| `int32`、`integer`、`dword`、`longint`、`longword`、`cardinal` | 双字整数               | 4      |
| `int64`                                                        | 64 位整数              | 8      |
| `single`、`float`                                              | 单精度浮点数           | 4      |
| `double`、`real`                                               | 双精度浮点数           | 8      |
| `comp`                                                         | 类似 `int64` 的实数    | 8      |
| `Currency`                                                     | 保留四位小数的定点实数 | 8      |
| `Extended`                                                     | 扩展精度浮点数         | 10     |

返回：any

### 示例

范例01：还原 Currency 缓冲区中的数值

```tsl
buffer := convertDataToBuf(1.5343, "Currency");
echo convertBufToData(buffer, "Currency"), "\n";
// 输出：1.5343
```

## `convertDataToBuf(data, convert_type)`

声明：function

将数据按指定基础类型编码为内存缓冲区字符串

<!-- tags: 类型转换 转换 编码 conversion -->

| 参数           | 类型   | 说明                 |
| -------------- | ------ | -------------------- |
| `data`         | any    | 要写入缓冲区的数据。 |
| `convert_type` | string | 数据采用的基础类型。 |

支持的 `convert_type`：

| 值                                                             | 数据解释               | 字节数 |
| -------------------------------------------------------------- | ---------------------- | ------ |
| `byte`、`int8`、`shortint`                                     | 单字节整数             | 1      |
| `int16`、`word`、`smallint`                                    | 双字节整数             | 2      |
| `int32`、`integer`、`dword`、`longint`、`longword`、`cardinal` | 双字整数               | 4      |
| `int64`                                                        | 64 位整数              | 8      |
| `single`、`float`                                              | 单精度浮点数           | 4      |
| `double`、`real`                                               | 双精度浮点数           | 8      |
| `comp`                                                         | 类似 `int64` 的实数    | 8      |
| `Currency`                                                     | 保留四位小数的定点实数 | 8      |
| `Extended`                                                     | 扩展精度浮点数         | 10     |

返回：string

### 示例

范例01：将 Currency 数值写入缓冲区并还原

```tsl
buffer := convertDataToBuf(1.5343, "Currency");
echo convertBufToData(buffer, "Currency"), "\n";
// 输出：1.5343
```

## `createBinary(len)`

声明：function

创建一个Binary类型

<!-- tags: 类型转换 创建 生成 转换 conversion -->

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

返回：binary

### 示例

```tsl
value := createBinary(4);
echo trim(toStn(array(ifBinary(value), length(value))));
// 输出：array(1,4)
```

## `createMatrix(cols, rows, cols_value, value1, ..., value_n)`

声明：function

创建 Matrix 数据。Matrix 与 TSL 普通矩阵不同，不支持矩阵运算符，但占用空间较小

<!-- tags: 类型转换 创建 生成 转换 conversion -->

| 参数         | 类型    | 说明                                             |
| ------------ | ------- | ------------------------------------------------ |
| `cols`       | integer | 列数。                                           |
| `rows`       | integer | 行数。                                           |
| `cols_value` | array   | 可选。列名数组；省略时列下标为 0 到 `cols - 1`。 |
| `value1`     | any     | 可选。第一个初始化值。                           |
| `value_n`    | any     | 可选。后续初始化值，按行依次填充。               |

返回：matrix

### 示例

范例01：创建带列名和初始值的 Matrix

```tsl
matrix := createMatrix(2, 3, array("left", "right"), 1, 2, 3, 4, 5, 6);
echo trim(toStn(matrixToArray(matrix))), "\n";
// 输出：array(("left":1,"right":2),("left":3,"right":4),("left":5,"right":6))
```

## `dataType(data, n)`

声明：function

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

<!-- tags: 类型转换 转换 conversion -->

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

返回：integer|array

### 示例

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

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

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

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

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

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

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

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

## `getMatrixFields(matrix)`

声明：function

返回 Matrix 的字段名或列下标数组

<!-- tags: 类型转换 返回 获取 转换 conversion -->

| 参数     | 类型   | 说明                      |
| -------- | ------ | ------------------------- |
| `matrix` | matrix | 要读取字段列表的 Matrix。 |

返回：array

### 示例

范例01：读取 Matrix 的字段名

```tsl
matrix := createMatrix(2, 3, array("left", "right"), 1, 2, 3, 4, 5, 6);
echo trim(toStn(getMatrixFields(matrix))), "\n";
// 输出：array("left","right")
```

## `getNone(data)`

声明：function

读取 None 值携带的整数标记。该值用于对象的多级 `operator[1]` 赋值：初次进入的层级从 0 开始，赋值出错后重新进入时为 -1

<!-- tags: 类型转换 读取 获取 转换 conversion -->

| 参数   | 类型 | 说明                                   |
| ------ | ---- | -------------------------------------- |
| `data` | none | `operator[1]` 赋值过程收到的 None 值。 |

返回：integer

### 示例

范例01：读取多级下标赋值的起始层级

```tsl
obj := new NoneLevelProbe();
obj[0]["value"] := 1;
echo obj.level, "\n";
// 输出：0

type NoneLevelProbe = class
public
    level;
    function operator[1](index, value);
    begin
        if ifNone(value) then
        begin
            level := getNone(value);
            return self;
        end;
    end;
end;
```

## `ifArray(value, n)`

声明：function

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

<!-- tags: 类型转换 判断 检查 转换 conversion -->

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

返回：bool

### 示例

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

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

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

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

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

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

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

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

## `ifBinary(value, n)`

声明：function

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

<!-- tags: 类型转换 判断 检查 转换 conversion -->

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

返回：bool

### 示例

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

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

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

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

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

```tsl
b := binary("3.14");
t := array(1, b, "A", (nil, b, 3.14), nil);
echo trim(toStn(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);
echo trim(toStn(ifBinary(t, 1)));
// 输出：array(0,1,0,(0,0,1),0)
```

## `ifComplex(value, n)`

声明：function

判断 `value` 是否为复数，可通过可选参数 `n` 对数组中的维度或元素进行判断

<!-- tags: 类型转换 类型判断 复数 判断 检查 conversion complex -->

| 参数    | 类型    | 说明                                                                             |
| ------- | ------- | -------------------------------------------------------------------------------- |
| `value` | any     | 任意类型数据                                                                     |
| `n`     | integer | 可选。省略时判断整体；`0` 返回类型编码；正数判断数组元素；负数判断前 `-n` 个维度 |

返回：boolean\|integer\|array

### 示例

```tsl
echo ifComplex(4 + 3j), "\n";
// 输出：1
```

## `ifExp(value, n)`

声明：function

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

<!-- tags: 类型转换 判断 检查 转换 conversion -->

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

返回：bool

### 示例

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

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

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

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

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

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

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

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

## `ifFmarray(value, n)`

声明：function

判断值或数组元素是否为 FMArray

<!-- tags: 类型转换 判断 检查 转换 conversion -->

| 参数    | 类型    | 说明                                                               |
| ------- | ------- | ------------------------------------------------------------------ |
| `value` | any     | 要判断的值                                                         |
| `n`     | integer | 可选。省略时判断整个值，正数检查每个单元格，负数检查前 `-n` 个维度 |

返回：boolean\|integer\|array

### 示例

范例01：判断整个值

```tsl
echo ifFmarray(fmarray[1, 2, 3]);
// 输出：1
```

范例02：判断数组第一维中的每个元素

```tsl
value := array(fmarray[1, 2], 1, fmarray[[1, 2]]);
echo trim(toStn(ifFmarray(value, -1)));
// 输出：array(1,0,1)
```

## `ifGraph(value, n)`

声明：function

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

<!-- tags: 类型转换 判断 检查 转换 conversion -->

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `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);
echo result;
// 输出：1（该示例依赖行情与图表运行环境，命令行解释器下无法构造图形对象）
```

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

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

## `ifGraphgroup(value, n)`

声明：function

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

<!-- tags: 类型转换 判断 检查 转换 conversion -->

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `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);
echo result;
// 输出：1（该示例依赖行情与图表运行环境，命令行解释器下无法构造图形组合对象）
```

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

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

## `ifInt(value, n)`

声明：function

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

<!-- tags: 类型转换 判断 检查 转换 conversion -->

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

返回：bool

### 示例

范例一：

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

范例二：

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

范例三：

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

## `ifInt64(value, n)`

声明：function

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

<!-- tags: 类型转换 判断 检查 转换 conversion -->

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

返回：bool

### 示例

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

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

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

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

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

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

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

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

## `ifMatrix(value, n)`

声明：function

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

<!-- tags: 类型转换 判断 检查 转换 conversion -->

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

返回：bool

### 示例

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

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

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

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

## `ifNil(value, n)`

声明：function

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

<!-- tags: 类型转换 判断 检查 转换 conversion -->

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

返回：bool

### 示例

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

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

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

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

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

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

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

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

## `ifNone(data, none_value)`

声明：function

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

<!-- tags: 类型转换 判断 检查 转换 conversion -->

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

返回：bool

### 示例

```tsl
echo ifNone(1);
// 输出：0
```

## `ifNumber(value, n)`

声明：function

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

<!-- tags: 类型转换 判断 检查 转换 conversion -->

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

返回：bool

### 示例

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

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

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

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

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

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

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

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

## `ifObj(value, n)`

声明：function

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

<!-- tags: 类型转换 判断 检查 转换 conversion -->

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

返回：bool

### 示例

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

```tsl
obj := CreateObject('Function14'); // 使用CreateObject函数创建上面类Function14的对象
result := ifObj(obj);
echo result; // 输出：1

type Function14 = class // 声明类
public
    name;
    function SetName(new_name);
    begin
        name := new_name;
    end;
end;
```

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

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

## `ifReal(value, n)`

声明：function

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

<!-- tags: 类型转换 判断 检查 转换 conversion -->

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

返回：bool

### 示例

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

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

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

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

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

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

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

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

## `ifString(value, n)`

声明：function

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

<!-- tags: 类型转换 判断 检查 转换 conversion -->

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

返回：bool

### 示例

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

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

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

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

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

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

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

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

## `ifwstring(value, n)`

声明：function

判断value是否是一个宽字节字符串类型(Unicode字符集)。与ifString的区别是，ifString判断是否是多字节字符类型。可通过可选参数N对数组中的行或元素进行判断

<!-- tags: 类型转换 判断 检查 转换 conversion -->

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

返回：bool

### 示例

范例一：

```tsl
// 判断是否为宽字节字符串类型
r1 := ifwstring(1);
r2 := ifwstring("A");
r3 := ifwstring(L"C");
r4 := ifwstring(array(1, "A", L"C"));
echo trim(toStn(array(r1, r2, r3, r4)));
// 输出：array(0,0,1,0)
```

范例二：

```tsl
// 对数组第一维度数据进行类型判断
t := array(L"C", 3.56, "A", (1, L"C", 3), nil);
echo trim(toStn(ifwstring(t, -1)));
// 输出：array(1,0,0,0,0)
```

范例三：

```tsl
// 对数组中每一数据进行类型判断
t := array(L"C", 3.56, "A", (nan, 2.14, L"C"), nil);
echo trim(toStn(ifwstring(t, 1)));
// 输出：array(1,0,0,(0,0,1),0)
```

## `matrixToArray(mat)`

声明：function

将 Matrix 或 FMArray 转换为 TSL Array，以便使用普通数组和矩阵操作；反向转换可使用 `mselect`

<!-- tags: 类型转换 转换 conversion -->

| 参数  | 类型            | 说明           |
| ----- | --------------- | -------------- |
| `mat` | matrix\|fmarray | 要转换的数据。 |

返回：array

### 示例

范例01：将 Matrix 转换为 Array

```tsl
matrix := createMatrix(2, 2, array("left", "right"), 1, 2, 3, 4);
echo trim(toStn(matrixToArray(matrix))), "\n";
// 输出：array(("left":1,"right":2),("left":3,"right":4))
```

## `string(value)`

声明：function

将 Binary 或 WideString 转换为普通字符串；字符串输入保持字符串类型

<!-- tags: 类型转换 转换 conversion -->

| 参数    | 类型                       | 说明                         |
| ------- | -------------------------- | ---------------------------- |
| `value` | string\|binary\|widestring | 要转换的字符串或二进制数据。 |

返回：string

### 示例

范例01：将 WideString 转换为普通字符串

```tsl
echo string(L"abcd"), "\n";
// 输出：abcd
```
