IDL语法基础（01）

⛄`IDL`简介

交互式数据语言——IDL（Interactive Data Language）是进行应用程序开发、科学数据分析与可视化表达的理想工具。IDL是基于矩阵运算的计算机语言，它语法简单，自带大量的功能函数，用很少的几行代码就能实现其它语言很难实现的功能。利用IDL可以快速地进行科学数据读写、三维数据可视化、数值运算和三维图形建模等。IDL可以应用在地球科学（包括气象、水文、海洋、土壤和地质等），医学影像、图像处理、GIS系统、软件开发、测试、天文、航空航天、信息处理、数学统计与分析以及环境工程等领域。IDL的优势：

数据访问 —— 灵活的数据输入、输出方式。在科学研究中，将会使用大量不同格式的数据。IDL 基本上支持各种数据格式，并提供了大量的数据读写工具，免除数据读写的烦恼，可以将更多的精力投入到数据分析。
数据分析 —— 强大的图像处理、信号处理和数据统计分析能力。IDL 集成了完善的数据分析、数据统计、图像处理和信号处理软件包。项目应用 IDL 可以节省大量时间。使用传统的 C 或者 FORTRAN 语言需要数天或数周的项目，使用 IDL 可以在数小时内完成。
数据可视化 —— 先进的图形技术和强大的可视化能力。从简单的二维绘图、三维绘图、体数据可视化、图像显示、动画显示等，到利用 OpenGL硬件加速功能进行交互式的三维图形浏览，以及支持多处理器快速进行体数据渲染，使用 IDL可以轻松获得丰富的可视化效果。从直接图形法到对象图形法，再到快速可视化函数，IDL 提供了丰富的可视化过程和函数供用户调用，使用少量代码即可实现复杂的可视化结果。
软件开发 —— 跨平台支持、全新且统一的开发环境、有效的数据管理手段。
集成 —— 灵活的外部语言接口。IDL 是一个灵活的、可扩展的用于可视化、分析和开发的工具，能够轻松的与其他的软件工具集成。IDL 能够将其他编程语言的代码和函数导入，也可以将 IDL 实现的功能集成到其他语言编写的应用程序中去。
程序共享 —— 灵活多样的程序发布方式和轻松的成果共享。

IDL的帮助提供了详细的使用说明和函数功能描述，学会使用帮助是快速入门和解决问题的最佳途径。帮助的启动方式有以下三种：

点击主菜单[帮助]下的[选中项目帮助]和[帮助内容]功能菜单；
工作台编辑代码时按 F1 或选择一个函数后按 F1，则启动帮助；
命令行中输入?回车后启动帮助。

注意事项：

（1）IDL不区分大小写；

（2）分号”;”表示注释内容的开始；

（3）符号”$“，续行符；符号”&“，续命令符；

（4）创建IDL变量不需要事先声明，直接赋值，并且变量随时可以进行数据类型和维数的动态改变；

（5）科学计数法：a = 6.63e-34，b = 2.998e8

（6）help命令可以帮助用户跟踪变量类型和大小。对于标量，显示变量的名称、类型和值；对于数组型变量，显示变量名称、类型和大小。

⛄`IDL`语法基础

👀数据类型

IDL中有17种基本数据类型。基本数据类型的名称、类型代码、字节大小、创建方式和范围，以及类型转换等。

数据类型	代码	字节数	范围	创建变量	类型转换
字节型	1	1	`0~255`	`Var=0B`	`byte()`
16位有符号整型	2	2	`-32768~32767`	`Var=0`	`fix()`
32位有符号长整型	3	4	`-2^31~2^31-1`	`Var=0L`	`long()`
64位有符号整型	14	8	`-2^63~2^63-1`	`Var=0LL`	`long64()`
16位无符号整型	12	2	`0~65535`	`Var=0U`	`uint()`
32位无符号长整型	13	4	`0~2^32-1`	`Var=0UL`	`ulong()`
64位无符号整型	15	8	`0~2^64-1`	`Var==0ULL`	`ulong64()`
浮点型	4	4	`-10^38~2^38`	`Var=0.0`	`float()`
双精度浮点型	5	8	`-10^308~2^308`	`Var=0.0D`	`double()`
复数	6	8	`-10^38~2^38`	`Var=Complex(0.0,0.0)`	`complex()`
双精度复数	9	16	`-10^308~2^308`	`Var=Dcomplex(0.0D,0.0D)`	`dcomplex()`
字符串	7	0~32767	`None`	`Var=' '或Var=" "`	`string()`
结构体	8	复合类型	`None`	`St1={}`
指针	10	4	`None`	`Var=Ptr_New()`
对象	11	4	`None`	`Var=Obj_New()`
链表	11	复合类型	`None`	`Ls=List()`
哈希表	11	复合类型	`None`	`Hs=Hash()`

变量的类型代码通过Size(var, /type)来获得，如下：

IDL> a=10
IDL> print,size(a,/type)
           2
IDL> b=10.0
IDL> print,size(b,/type)
           4
IDL> c=10L
IDL> print,size(c,/type)
           3

👀常量和变量

常量。常量是不能修改的固定值，分为整型常量、浮点型常量、复数型常量和字符型常量等类型。

变量。IDL 中的变量分为局部变量和系统变量。在 IDL 程序中，二者的区别在于生命周期不一样，局部变量仅仅在所在的函数或过程中有效，而系统变量则在始终有效或某个程序的周期中有效。

（1）命名规则

变量名称的最大长度不超过 255 个字符，变量的首位只能是字母和下划线，中后部只能是字母、数字、下划线_和连接符$。如下正确：

abc_3$d	ok_24_bit IDL_type variable _day_month_year
如下错误：
abc.cha one%file 4_lists $file

变量相关函数 IDL_VALIDNAME。该函数用来检测字符串是否可以作为 IDL 下的变量，并能够将无效字符转换为“_”并返回变量。调用格式为 IDL_VALIDNAME ( String [, /CONVERT_ALL] [, /CONVERT_SPACES])

IDL> print,IDL_VALIDNAME('idl')
idl
IDL> print,IDL_VALIDNAME('i d l', /CONVERT_SPACES)
i_d_l
IDL> print,IDL_VALIDNAME('16ENVIIDL', /CONVERT_ALL)
_16ENVIIDL

判断变量是否已经被定义，可以使用N_Elements函数，示例代码如下：

IDL> a=1
IDL> ;变量已经定义        
IDL> print,N_Elements(a)
           1
IDL> ;变量没有定义
IDL> print,N_Elements(aa)
           0

（2）变量类型转换

变量可以通过类型转换函数进行强制类型转换。

类型转换	函数名称	操作	结果
字节型	`BYTE`	BYTE(1.2)	1B
整型	`FIX`	FIX(2.5)	2
无符号整型	`UINT`	UINT([5.5,-3])	5 65533
长整型	`LONG`	LONG(65538.5)	65538
无符号长整型	`ULONG`	ULONG([5.5,-3])	5 4294967293
64 位长整型	`LONG64`	LONG64([5.5,-3])	5 -3
无符号 64 位长整型	`ULONG64`	ULONG64([5.5,-3])	5 18446744073709551613
浮点型	`FLOAT`	FLOAT([5.5,-3])	5.50000 -3.00000
双精度类型	`DOUBLE`	DOUBLE([5.5,-3])	5.5000000 -3.0000000
复数类型	`COMPLEX`	COMPLEX(1, 2)	(1.00000, 2.00000)
双精度复数类型	`DCOMPLEX`	DCOMPLEX(1, 2)	(1.0000000, 2.0000000)

在进行数据的转换中需要注意转换后的数据的界限问题。如下面操作：

IDL> ;整型转换为浮点
IDL> print,float(1)
      1.00000

IDL> ;浮点数取整
IDL> print,fix(1.3+1.8)
       3
 
IDL> ;fix还可以指定输出类型
IDL> help,fix(1.3,type=5)
<Expression>    DOUBLE    =        1.3000000

IDL> ;出现这个错误是因为整型变量是16Bit的，最大值为32767，此种情况下用长整型强制转换函数long(a)。
IDL> a=33000
IDL> print,fix(a)
  -32536

IDL> ;注意整型变量的运算，如除法运算
IDL> ;结果是1，原因在于参与运算的两个数字为整数，运算结果依然是整数。
IDL> result = 8/5
IDL> print,result
IDL> ;在运算时需要增加强制类型转换，将整形类型转换为浮点类型。
IDL> result = 8/float(5)
IDL> print,result
      1.60000
IDL> result = 8*1.0/5
IDL> print,result
      1.60000

浮点类型和双精度类型的取整操作函数如下：

函数名称	功能	操作	结果
`floor`	向下取整	floor(2.4) floor(2.5)	2 2
`ceil`	向上取整	floor(2.4) floor(2.5)	3 3
`round`	四舍五入	floor(2.4) floor(2.5)	2 3

（3）变量类型的动态性

在使用的过程中，可以随时修改变量类型，即变量类型具备动态性。该特性使得IDL在数学运算中将低精度类型提升为高精度类型，确保计算结果具备足够的精度。

IDL> num=6
IDL> help,num
NUM             INT       =        6
IDL> num=num*1.1
IDL> help,num
NUM             FLOAT     =       6.60000

（4）系统变量

系统变量分为预定义系统变量和自定义系统变量。预定义系统变量是IDL中预先定义的系统变量，一般情况下不允许修改，包括常数变量、图形变量、系统配置和错误处理；自定义系统变量是用户创建的系统变量。

👀数组

程序设计中，为了处理方便，把具有相同类型的若干变量按有序的形式组织起来。这些按序排列的同类数据元素的集合称为数组。IDL 是面向矩阵的第四代语言，对数组的维数为0～8 维，在数组的处理时非常的灵活、高效。

注意，IDL 中数组下标的顺序先是列标，后是行标。

👁创建数组

（1）赋值创建

通过方括号[]赋值创建数组。

IDL> arr = [1,2,3]
IDL> help,arr
ARR             INT       = Array[3]
IDL> arr = [[1,2,3],[4,5,6]]
IDL> help,arr
ARR             INT       = Array[3, 2]
IDL> arr
       1       2       3
       4       5       6

（2）函数创建

利用数组创建函数可创建不同类型或维数的数组。

通用函数，可以用 IDL 的通用函数进行全零数组或索引数组的创建。

数据类型	创建全0数组	创建索引数组
字节型	`bytArr()`	`bindgen()`
16位有符号整型	`intarr()`	`indgen()`
32位有符号长整型	`lonarr()`	`lindgen()`
64位有符号整型	`lon64arr()`	`l64indgen()`
16位无符号整型	`uintarr()`	`uindgen()`
32位无符号长整型	`ulongarr()`	`ulindgen()`
64位无符号整型	`ulon64arr()`	`ul64indgen()`
浮点型	`fltarr()`	`findgen()`
双精度浮点型	`dblarr()`	`dindgen()`
复数	`complexarr()`	`cindgen()`
双精度复数	`dcomplexarr()`	`dcindgen()`
字符串	`strarr()`	`sindgen()`
指针	`ptrarr()`
对象	`objarr()`

IDL> num = findgen(20)
IDL> num
      0.00000000       1.0000000       2.0000000       3.0000000       4.0000000       		  5.0000000		   6.0000000       7.0000000       8.0000000       9.0000000       		  10.000000       11.000000		   12.000000       13.000000       14.000000               15.000000       16.000000       17.000000		18.000000       19.000000

常规函数，MAKE_ARRAY()函数：是在程序运行过程中创建特定的数组。

调用格式为： Result = MAKE_ARRAY ( [D1 [, ..., D8]] [, /INDEX] [, DIMENSION = vector] [, /NOZERO] [, SIZE=vector] [, TYPE=type_code] [, VALUE=value] )

IDL> a = Make_array(4,5,/Integer,Value=6)
IDL> a
       6       6       6       6
       6       6       6       6
       6       6       6       6
       6       6       6       6
       6       6       6       6

创建特殊数组：RANDOMU()函数返回一个或多个均匀分布的浮点型数组，值在[0,1]之间。RANDOMN()函数返回一个或多个正态分布的浮点型数组，这些数的平均为零，标准偏差为 1 。

👁数组存储

IDL中的矢量和数组均是以先行后列顺序存储的(IDL最初是设计用来处理行扫描的卫星数据)，下标值的起始值是 0。

IDL> array = indgen(4,3)
IDL> array
       0       1       2       3
       4       5       6       7
       8       9      10      11

👁数组访问

（1）下标方式

可以使用下标来存取该数组中的每一个元素。按照“数组名[下标]”或“数组名（下标）”对数组中元素进行存取，数组下标起始值为0。因为函数的调用方式为“函数名（参数）”，为避免混淆，数组下标使用时一般使用[]。其中-1为最后一个元素的下标，可根据下标值依次获取元素。

IDL> arr = indgen(9)
IDL> arr
       0       1       2       3       4       5       6       7       8
IDL> arr(3)
       3
IDL> arr[3]
       3
IDL> arr[-1]
       8
IDL> arr[-5:-1]
       4       5       6       7       8

（2）向量方式

下标可以通过向量方式表示。

IDL> arr = indgen(9)+5
IDL> arr
       5       6       7       8       9      10      11      12      13
IDL> index = [0,2,4,6,8]
IDL> arr[index]
       5       7       9      11      13
;对30行20列的索引数组取出第6~10列中第12~15行的数据，可以通过“:”方式
IDL> arr1 = indgen(20,30)
IDL> select_arr1 = arr1[5:9,11:14]
IDL> select_arr1
     225     226     227     228     229
     245     246     247     248     249
     265     266     267     268     269
     285     286     287     288     289 
;对30行20列的索引数组取出第10行的数据，可以通过“*”方式
IDL> vec_10 = arr1[*,9]
IDL> vec_10
     180     181     182     183     184     185     186     187     188     189     190	 191	 192     193     194     195     196     197     198     199

👁数组运算

（1）求大、求小和求余

数组的求大(<)、求小(>)和求余(mod)操作返回的是同维数组的计算结果。数组求大（<value）是将数组中小于value的元素赋为value；求小（>value）是将数组中大于value的值赋为value；数组求余（mod)是计算数组中各元素的余数。

IDL> a = indgen(8)+3
IDL> a
       3       4       5       6       7       8       9      10
IDL> a>6
       6       6       6       6       7       8       9      10
IDL> a
       3       4       5       6       7       8       9      10
IDL> a<6
       3       4       5       6       6       6       6       6

（2）数组与数运算
数组与数的运算遵循的基本规律是，数组中的每个元素与数进行运算。

IDL> a = indgen(8)
IDL> a
       0       1       2       3       4       5       6       7
IDL> a = indgen(8)+5
IDL> a
       5       6       7       8       9      10      11      12

（3）数组与数组运算
数组与数组的运算，结果的元素个数与运算的最小数组个数一致，多维数组需要转换为一维数组来运算。

IDL> arr = [2,4,6,8]
IDL> arr1  = [4.5]
IDL> arr + arr1
       6.5000000
IDL> arr1  = [5,6]
IDL> arr + arr1
       7      10
IDL> arr2 = [[1,3,5],[2,4,6]]
IDL> arr3 = [[1,2],[3,4]]
IDL> arr2 + arr3
       2       5
       8       6

（4）数组合并

数组与数组的合并需要两个数组的行数或列数相同。

IDL> a = indgen(2,5)
IDL> b = indgen(4,5)
IDL> ;行数相同，可直接使用[]
IDL> c = [a,b]
IDL> c
       0       1       0       1       2       3
       2       3       4       5       6       7
       4       5       8       9      10      11
       6       7      12      13      14      15
       8       9      16      17      18      19
IDL> ;列数相同，需要使用[[],[]]
IDL> d = indgen(2,3)
IDL> e = [[a],[d]]
IDL> e
       0       1
       2       3
       4       5
       6       7
       8       9
       0       1
       2       3
       4       5

👁相关函数

（1）数组信息 Size()

Size()函数能够返回数组的结构信息，调用格式为 Result = SIZE(变量, [/KeyWords])。输入变量可以是常量、数组、字符串、结构体、指针和对象等任何数据类型。不设置关键字时，函数返回变量的基本信息：变量维数、每一维的数值元素个数（维数），变量类型代码、元素总个数。设置关键字N_Dimensions、N_Elements、Dimensions、Tname和Type，则依次返回数组的维数、元素个数、每一维的维数、类型名称和类型代码信息。

IDL> data = indgen(4,5)
IDL> size(data)
           2           4           5           2          20
IDL> size(data,/N_dimensions)
           2
IDL> size(data,/N_elements)
          20
IDL> size(data,/Dimensions)
           4           5
IDL> size(data,/Tname)
INT

（2）条件查找

WHERE()函数返回满足指定条件（即数组表达式）数组元素的下标所组成的一维数组。调用格式为：

Result =WHERE(数组表达式 [, count] [, COMPLEMENT=变量 1] [, /L64] [, NCOMPLEMENT=变量 2])。

关键字：count 返回的是符合指定条件的个数；变量 1 是不满足条件的数组的下标信息；变量 2 是不满足条件的数组的个数；

IDL> a = indgen(10)+3
IDL> a
       3       4       5       6       7       8       9      10      11      12
IDL> B = WHERE(a GT 6, count, COMPLEMENT=B_C, NCOMPLEMENT=count_c)
IDL> count
           6
IDL> B
           4           5           6           7           8           9
IDL> count_c
           4
IDL> B_C
           0           1           2           3

（3）大小调整

Reform()函数可以使数组在元素个数不修改的前提下，改变数组的维数，方便了数组的动态使用。调用格式：

Result = REFORM(Array, D1 [, ..., D8] [, 关键字] )

Rebin()函数可以修改数组的维数大小，将维数调整为 D1 [, ..., D8]指定的维数，且大小必须原数据的大小的整数倍，默认抽样算法是双线性内插。调用格式：

Result = REBIN(数组, D1 [, ..., D8] [, /SAMPLE] )
SAMPLE：设置该关键字则使用最近临值抽样法。

Congrid()函数可以调整数组为同维任意大小的数组，默认在处理一维或二维数组时默认是最近邻重采样方式，处理三维数组时默认是双线性内插值。在数据缩小操作时，Rebin 做了插值处理，而 Congrid 仅仅是重新采样。调用格式为：

Result = Congrid(数组, X,Y,Z [,关键字] )
INTERP：抽样采用线性内插法；
CUBIC：采用卷积内插法。

EXPAND 用来对二维数组进行大小修改，采用双线性内插算法。调用格式：

EXPAND, A, Nx, Ny, Result[, FILLVAL=value] [, MAXVAL=value]

其中 A 为源数组，Nx、Ny 为修改后的维数，Result 为修改后的数组，FILLVAL 是填充数据，默认为-1；MAXVAL 是数据的最大值，大于该值的赋为 FILLVAL。

INTERPOLATE()函数可以调整数组为同维任意大小的数组，并能够任意定位插值点。调用格式：

INTERPOLATE(数组, X[, Y [, Z]] [, 关键字] )

其中，X [, Y [, Z]]为待调整数组下标索引，可以是单个变量或数组，若X为0.5，则表示计算下标[0]和下标[1]中间位置的数值；
GRID 关键字：采用网格插值方式生成插值点，否则按线性方式生成；
Missing 关键字：插值点坐标超出数组自身坐标范围时赋予该值。

（4）数组反转

Reverse()函数可以对数组进行反转。调用格式：

result = Reverse(数组, index[, 关键字] )
index 是反转的数组的维数索引，它不能大于数组的维数。

（5）数组转置 Transpose()
Transpose ()函数可以对数组进行反转。调用格式：

result = Transpose(数组, [P])
关键字：P 是调整后的维数数组列表，如不设置则完全反转。

（6）数组旋转

①Rotate()函数

Rotate()函数可以以 90°整倍数的角度对数组进行旋转操作。调用格式：

result = Rotate (数组, direction )
Direction：该关键字为整数，范围 0-7，分别代表的图像旋转方式。

②Rot()函数

Rot()函数可以以任意的角度对数组进行旋转操作并能进行放大、缩小操作。调用格式：

result = Rot(数组, Angle, [Mag, X0, Y0],[关键字])
Angle：该关键字数组旋转地角度，单位为度(°)。
Mag：为放大的倍数；
X0：为旋转中心的 X 坐标，默认为列中心；
Y0：为旋转中心的 Y 坐标，默认为行中心；
PIVOT：该关键字控制旋转后(X0,Y0)点是否仍然在原图像中的位置，不设置则(X0,Y0)点在图像的中心位置。

（7）数组平移

Shift()函数是按指定的平移量 S1、…、Sn，分别对数组的第 1、…、n 维进行平移后生成新数组。其中 Si 为正表示向前平移；Si 为负表示向后平移。调用格式：

result = Shift(数组，S1、…、Sn)

（8）数组排序
Sort()函数返回排序后的数组索引。调用格式：

result = Sort(数组[, /L64])

（9）数组唯一调整（求不同值）
Uniq()函数返回数组中相邻元素不同值的索引。该函数只能发现相邻值，若不相邻，则会认为是两个值。如果先对数组进行排序，则可求出数组中包含的不同值。调用格式为：

result = UNIQ(数组 [, Index] )

（10）判断数组

Array_Equal()函数进行数组相同的判断。调用格式：

result = Array_Equal(数组, /关键字)
result：返回 0 或 1。
NO_TYPECONV：添加该关键字，用于将两数组转换为同一类型，判断数据类型是否相同；为1时，数组可直接比较，不转换数据类型。

（11）元素个数

N_Elements()函数返回数组元素的个数。调用格式：

result = N_Elements(数组)

（12）求最值

Max()函数返回满足数组元素的最大值。调用格式：

result = Max(数组 [,关键字], min =变量 1)。
result：返回的是数组的最大值；
变量 1：返回的是数组的最小值；

Min()函数返回满足数组元素的最小值。调用格式：

result = Min(数组 [,关键字], max =变量 1)。
result：返回的是数组的最小值；
变量 1：返回的是数组的最大值；

（13）求和

Total()函数返回满足数组元素和，并可以通过关键字进行求和选项的控制。调用格式：

result = Total(数组, Dimension, [,关键字])。
result：返回的是数组元素求和结果；
Dimension：数组求和元素的行列控制；
CUMULATIVE：设置该关键字后，返回结果与原数组一致，第 i 个元素的值为 0-i 值的和；
Double：返回双精度类型结果；
Integer：返回整型数据结果；
PRESERVE_TYPE：返回结果类型与原数组类型一致，设置该关键字的时，/double 等关键字无效。

（14）乘积计算
Product()函数计算数组中所有或部分元素的乘积。调用格式：

result = Product(数组, Dimension, [,关键字])。
关键字控制与 total 函数的关键字基本一致。

（15）其它运算

Factorial()函数计算满足数组元素阶乘。调用格式：

result = Factorial(数组, [,关键字])。
关键字-Stirling：返回结果为Stirling近似值。

Mean()函数计算数组元素的平均值。调用格式为：

result = Mean(数组, [,关键字])。

Variance()函数计算数组元素的方差。调用格式：

result = Variance(数组, [,关键字])。

Stddev()函数计算数组元素的方差。调用格式：

result = Variance(数组, [,关键字])。

Moment()函数计算数组元素的平均值、方差、倾斜度及频率曲线峰态。调用格式：

result = Moment(数组, [,关键字])。

👁矩阵运算

矩阵间的运算，遵循以下两个法则（注意与线性代数矩阵运算的区别和联系）：

A#B 表示 A 的列乘以 B 的行，要求A的行数必须跟B的列数一致。

A##B 表示 A 的行乘以 B 的列，要求A的列数必须跟B的行数一致。

👀字符串

字符串和字符串数组的创建可以通过直接赋值或函数来实现。在IDL中字符串用双引号" "或单引号''括起来表示。但以"为首的字符串的首字符不能为数字，因为以"开头的数字串代表一个8进制。

字符串连接直接用加号"+"。字符串操作在文件读取、命令行输入以及窗口参数输入时经常被用到。字符串操作都是通过字符串处理函数来实现的。

函数名	函数描述
`STRCMP(str1, str2, N, /FOLD_CASE)`	对两个字符串进行比较，如果 N 存在，只对前 N 个进行比较，`/FOLD_CASE` 表示模糊比较
`STRCOMPRESS(str1)`	删除字符串 `str1` 中的空格
`STREGEX()`	正则表达式
`STRJOIN()`	字符串相连接
`STRLEN(）`	返回字符串的长度
`STRLOWCASE(）`	将所有的大写字母改写成小写字母
`STRMATCH(Str1,str2)`	字符串 `Str1` 中是否存在 `Str2`，可以使用通配符
`STRMID(Str1,po1,Len,REVERSE_OFFSET)`	从字符串 `po1` 开始取出 `Len` 个字符。字符串的第一个字符的位置为 0
`STRPOS(Exp_Str1,Sea_Str2,Pos,<br />REVERSE_OFFSET,/REVERSE_SEARCH] )`	从一个字符串中查找与另外一个字符串完全匹配的起始点所在的位置。`Pos`是查找点的起始位置，默认值为0、1（如果指定`/REVERSE_SEARCH]`）；指定时，则表示从开始的Pos起，或者从末尾开始的`Pos` 起（如果指定 `REVERSE_OFFSET` ）
`STRPUT,Des_Var_str,Sou_str,Pos`	将字符串`Sou_str`插入到字符串`Des_Var_str`之中，`POS`插入点的位置，默认值为 0，依次将字符串Sou_str覆盖插入到`Des_Var_str`中。`Sou_str` 不为字符串，则按默认格式自动转化从 `POS` 处开始插入`Des_Var_str`，如果插入值的位置超过了 `Des_Var` 的最大长度，则自然截断
`STRSPLIT(Str1)`	根据特定要求拆分字符串`str1`；
`STRTRIM(str,Flag)`	移去字符串中的空格。`Flag`：0(移去右边空格），1(移去左边空格），2（移去两边的空格）
`STRUPCASE(）`	将所有的小写字母改写成大写字母

👀其它数据类型

结构体：创建结构体时用大括号{}，同时需要赋予结构体名称。

注意：通过"help, struct1, /structure"语句可以查看结构体struct1的基本信息。通过结构体"变量名.成员名"或"变量名.(index)"的方式访问。

指针：指针用指针函数Ptr_New()来创建，通过"*"+指针变量名来访问。

指针赋值与变量赋值不一样，指针赋值是使两个指针指向同一个堆向量，修改任意一个会影响另一个。

对象：对象是数据（属性）和程序（方法）封装在一起的实体。IDL中用Obj_New函数或ObjArr函数来创建对象。ObjArr()函数用来创建对象数组；Obj_New()函数用来创建某一特定类的对象。

调用对象、销毁对象、处理函数

链表：链表（list)是一个复合数据类型，它可以包含变量、数组、结构体、指针、对象、链表和哈希表等数据类型。链表中的元素是有次序的，可以通过索引来进行编辑操作。

链表是由list()函数来创建。链表访问与数组访问一样，通过下标索引来实现。创建链表、访问链表、增加链表、删除链表、链表反转、转为数组、链表连接、链表比较、销毁链表

哈希表：哈希表（Hash)是一个高效的复合数据类型，可以包含变量、数组、结构体、指针、对象、链表和哈希表等数据类型。哈希表的特点是关键字（keys）与值对应，通过链表函数或关键字快速访问处理。

哈希表创建通过创建函数Hash()创建；元素访问是根据关键字；哈希表元素添加与数组元素的添加类似；其他操作：关键字输出、关键字查询、删除哈希表、转换为结构体、哈希表组合、哈希表比较、销毁哈希表。

👀运算符

数学运算符

加（+）、减（-）、增运算（++）、减运算（--）、乘（*）、除（/）、幂（^）、取余（mod）、取小（<）、取大（>）

逻辑运算符

逻辑与（&&）、逻辑或（||）、逻辑非（~）

位运算符

位加符（AND）、位取反符（NOT）、位或符（OR）、位异或符（XOR）

关系运算符

等于（EQ）、不等于（NE）、大于等于（GE）、大于（GT）、小于等于（LE）、小于（LT）。返回值是真（1）假（0）

数组（矩阵）运算符

数组乘（#）是第一个数组的列元素乘以第二个数组的行元素并求和。

矩阵乘（##）与数组乘类似，区别是行乘以列。

其它运算符

圆括号()用来对表达式进行组合或一系列表达式控制优先级。

方括号[]用来数组连接或对数组进行元素调用。

条件运算符是？:，value = expr1 ? expr2 : expr3 如果 expr1 是 true，那么 value 等于 expr2 ，否则 value =等于expr3。

对象方法调用符.或->两种，对象可以通过这两种符号来调用相关的方法。

指针调用符为*，引用格式为*指针变量名。

运算符优先级

优先级	操作符
一级（最高）	`()` (公式表达式) `[]` (数组连接)
二级	`.` (结构体域表达式) `[]` (数组元素调用) `()` (函数引用)
三级	`*` (指针调用) `^` (幂函数) `++` (增函数) `--` (减函数)
四级	`*` (乘) `#` 和 `##` (矩阵乘) `/`(除) `MOD` (取余数)
五级	`+` (加) `-` (减和取反) `<` (求小) `>` (求大) `NOT` (位取反) `~` (逻辑取反)
六级	`EQ` (等于) `NE` (不等于) `LE` (小于等于) `LT` (小于) `GE` (大于等于) `GT` (大于)
七级	`AND` (位与) `OR` (位或) `XOR` (位异或)
八级	`&&` (逻辑与)
九级	`?:` (条件表达式)