csc_module1.23

名称：csc_module

导入：compile("csc_module:1.23")

作者：253872195@qq.com

简介：节点拓展,时间,文本操作,快手滑块本地识别,数组,随机数,正则,时间,文件操作,md5加密

#### 插件调用方法:在文件头部加上 compile("csc_module:+");
--------------
#### 范围说明 1左半 2上半 3右半 4下半 5左上 6右上 7左下 8右下 默认0全屏,参数可省略
--------------
#### 友情提示:本插件所有功能在直接拉到底部查看更新记录,然后用ctrl+f即可找到你想要的
--------------
##  友情提示: 从上一版直接转到这一版的方法,vscode的方法为ctrl+h即查找替换,把"csc_",替换为"csc." 点全部替换即可
--------------
##  友情提示: 开这一版的原因是文档中csc_有些地方会识别不出来,而csc.所有地方都能识别出来
--------------
节点常用扩展功能
findOnce()
findOne(时间)
findOnce_range(范围)
findOne_range(范围,时间)
findOnce_target(目标,范围)
boundsInside(坐标x1,坐标y1,坐标x2,坐标y2)

**findOnce()** - -只找一次控件,等同find(r),找到会直接跳出并返回控件
```lua
使用方法1:   R():text("微信"):findOnce()        -- 等同 find(r)  这一部分可写在规则中

使用方法2:   local r = R():text("微信")			-- 这一部分写在自己的逻辑中
            local vx = r:findOnce()
            if vx then
                print(vx)
            else
                print("没有找到")
            end

--以下的同类型的都可以这样使用,这里就不一个个写了
```

**findOne(时间)** - -在一定时间内寻找控件,间隔为1秒,找到会直接跳出并返回控件,参数默认为1秒,可省略
```lua
R():text("微信"):findOne(3000)         --在3秒内,间隔为一秒的时间里查找微信的控件,找到会直接返回控件,时间可省略默认为1秒
```

**findOnce_range(范围)** - -在一个范围里面寻找控件
```lua
R():text("微信"):findOnce_range(1) --在屏幕的左半屏找一次控件,找到会返回控件
```

**findOne_range(范围,时间)** - -在一个范围里面寻找控件_时间毫秒,相当于次数
```lua
R():text("微信"):findOne_range(1,3000) --在3秒内,间隔为一秒的时间在左半屏找一次微信的控件,找到会直接返回控件,时间可省略默认为1秒
```

**findOnce_target(目标,范围))**  - -在一个范围里面寻找target目标控件,让target()不再仅支持click及slid
```lua
R():id("com.miui.home:id/icon_title"):findOnce_target(3,1) --在范围1中寻找target=3的符合规则的控件
```

#### 灵活区域运用

**boundsInside(坐标x1,坐标y1,坐标x2,坐标y2)** - -判断找到的控件是否在这个范围内 只适用于findOnce()和findOne(时间)

```lua
R():text("微信"):boundsInside(100,100,200,200):findOnce() --在100,100,200,200的区域内寻找微信这个控件
R():text("微信"):boundsInside(100,100,200,200):findOne(3000) --同findOnce() 只是多了时间,找到后会立即返回,时间可省略默认为1秒
```

------------

#### 字符串函数 
csc.删除前导文本(待删除的文本, 要删除的文本)
csc.删除后导文本(待删除的文本, 要删除的文本)
csc.同时删除前后文本(待删除的文本, 要删除的文本)
csc.删除指定文本(待删除的文本, 要删除的文本)
csc.取指定文本出现次数(要处理的字符串, 要查找的字串)
csc.从左边开始删除指定数量的文本(待删除的文本, 要删除的数量)
csc.从右边开始删除指定数量的文本(待删除的文本, 要删除的数量)
csc.从路径中取后缀(路径)
csc.从路径中取文件名加后缀(路径) 
csc.取文本长度(取长度的文本)
csc.字母转小写(转小写的字母)
csc.字母转大写(转大写的字母)
csc.取反转文本(待反转的文本)
####文本操作实用功能
csc.分割文本(待分割的文本, 分割符)
csc.文本替换(待替换的文本,被替换的文本,替换成的文本)
csc.文本是否存在(待查找的文本,要查找的文本)

------------

**csc.删除前导文本(待删除的文本, 要删除的文本)**
```lua
print(csc.删除前导文本("aacsc.aaaa","aa"))   --返回csc.aaaa 说明:删除前面的aa
```

**csc.删除后导文本(待删除的文本, 要删除的文本)**
```lua
print(csc.删除后导文本("aacsc.aaaa","aa"))   --返回csc.aaaa 说明:删除前面的aa
```

**csc.同时删除前后文本(待删除的文本, 要删除的文本) **
```lua
print(csc.同时删除前后文本("aacsc.aaaa","aa"))   --返回csc. 说明:其实就是同时调用上面两个
```

**csc.根据位置删除文本(待删除的文本, 开始位置, 结束位置)**
```lua
print(csc.根据位置删除文本("aacsc.aaaa",2,5))   --返回a_aaaa 说明:删除2-5位置的字符
```

**csc.删除指定文本(待删除的文本, 要删除的文本)**
```lua
print(csc.删除指定文本("aacsc.aaaa","csc"))   --返回aa_aaaa 说明:删除指定的"csc"文本
```

**csc.取指定文本出现次数(要处理的字符串, 要查找的字串)**
```lua
print(csc.取指定文本出现次数("aacsc.aaaa","csc"))   --返回1  说明:即出现一次
```

**csc.从左边开始删除指定数量的文本(待删除的文本, 要删除的数量)**
```lua
print(csc.从左边开始删除指定数量的文本("aacsc.aaaa",3))   --返回sc_aaaa 说明: 删除左边的三个文本
```

**csc.从右边开始删除指定数量的文本(待删除的文本, 要删除的数量)**
```lua
print(csc.从右边开始删除指定数量的文本("aacsc.aaaa",3))   --返回aacsc.a 说明: 删除右边的三个文本
```

**csc.从路径中取后缀(路径)**
```lua
print(csc.从路径中取后缀("c:/1.txt"))    --返回txt 说明: 取出后缀
```

**csc.从路径中取文件名加后缀(路径) **
```lua
print(csc.从路径中取文件名加后缀("c:/1.txt"))    --返回1.txt
```

**csc.取文本长度(取长度的文本)**
```lua
print(csc.取文本长度("aacsc.aaaa")) --返回 10
```

**csc.字母转小写(转小写的字母)**
```lua
print(csc.字母转小写("AAcsc.AAAA")) --返回 aacsc.aaaa
```

**csc.字母转大写(转大写的字母)**
```lua
print(csc.字母转大写("aacsc.aaaa")) --返回 AAcsc.AAAA
```

**csc.取反转文本(待反转的文本)**
```lua
print(csc.取反转文本("aacsc.aaaa")) --返回 aaaa_cscaa
```

#### 文本操作实用功能

**csc.分割文本(待分割的文本, 分割符)**
```lua
print(csc.分割文本("aacsc.aaaa","_"))   --返回 ["aacsc","aaaa"]
```

**csc.文本替换(待替换的文本,被替换的文本,替换成的文本)**
```lua
print(csc.文本替换("aacsc.aaaa","a","z")) --返回 zzcsc.zzzz
```

**csc.文本是否存在(待查找的文本,要查找的文本)**
```lua
print(csc.文本是否存在("aacsc.aaaa","d")) --返回 3  说明:找到后返回文本的位置,失败返回nil
```

------------

#### 数组
csc.数组_随机(数组)
csc.过滤数组(数组, 要过滤掉的字符串, 是否过滤)
csc.数组排序(数组, 是否倒序)
csc.删除数组元素(数组, 删除元素的位置)
csc.插入数组元素(数组, 插入位置, 插入的值)
csc.数组去重(数组)
csc.数组元素位置互换(数组, 位置1, 位置2)
####  随机数
csc.取随机数(min,max)
csc.随机布尔值()
csc.随机取数组内容(数组)
csc.数组_随机EX(数组,个数)
csc.table键值按字母排序(需要排序的table)

------------

####  数组

**csc.数组_随机(数组)**
```lua
local obj = {"张三","李四","王五","老六","小七"}
print(csc.数组_随机(obj)) --返回 ["小七","老六","张三","李四","王五"] 说明:放进去一个数组之后,会返回一个随机的乱序不重复的数组
```

**csc.过滤数组(数组, 要过滤掉的字符串, 是否过滤)**
```lua
local obj = {"张三","李四","王五","老六","小七"}
print(csc.过滤数组(obj,"李四",false)) --是否过滤输入true返回 ["李四"] 是否过滤输入false返回["张三","王五","老六","小七"]
```

**csc.数组排序(数组, 是否倒序)**
```lua
local obj = {"a","c","b","d","e"}
print(csc.数组排序(obj,true)) --是否倒序true返回 ["e","d","c","b","a"] 是否倒序false返回["a","b","c","d","e"]
```

**csc.删除数组元素(数组, 删除元素的位置)**
```lua
local obj = {"张三","李四","王五","老六","小七"}
print(csc.删除数组元素(obj,0)) --返回["李四","王五","老六","小七"] 元素的位置从0开始,即删除了第0位的张三
```

**csc.插入数组元素(数组, 插入位置, 插入的值)**
```lua
local obj = {"张三","李四","王五","老六","小七"}
print(csc.插入数组元素(obj,2,"王八")) --返回["张三","李四","王八","王五","老六","小七"] 在第三的位置插入了值王八,索引从0开始
```

**csc.数组去重(数组)**
```lua
local obj = {"张三","李四","王五","张三","小七"}
print(csc.数组去重(obj)) --返回["李四","张三","小七","王五"] 数组中出现重复的元素张三会直接被过滤掉
```

**csc.数组元素位置互换(数组, 位置1, 位置2)**
```lua
local obj = {"张三","李四","王五","老六","小七"}
print(csc.数组元素位置互换(obj,2,3)) --返回["张三","李四","老六","王五","小七"] 索引从0开始,王五和老六交换了位置
```

csc.table键值按字母排序(需要排序的table)
```lua
local params ={['app_id']='123456',['time_stamp']='1493449657',['nonce_str']='20e3408a79',['session']='腾讯AI开放平台',['question']='示例仅供参考',['sign']=''};
print(csc.table键值按字母排序(params)) --返回 ["app_id","nonce_str","question","session","sign","time_stamp"]
```

####  随机数

**csc.取随机数(min,max) **
```lua
print(csc.取随机数(10,100)) --返回 10到100之间的随机数
```

**csc.随机布尔值()**
```lua
print(csc.随机布尔值()) --返回 随机返回true或者false
```

**csc.随机取数组内容(数组) **
```lua
local obj = {"张三","李四","王五","老六","小七"}
print(csc.随机取数组内容(obj)) --返回 数组里面的文本随机出现一个,适合随机喊话使用
```

**csc.数组_随机EX(数组,个数)**
```lua
local obj = {"张三","李四","王五","老六","小七"}
print(csc.数组_随机EX(obj,3)) --返回["王五","李四","老六"],后面的个数可省略,省略之后,同上面的csc.数组_随机(数组)
```

------------
####  快手滑块
csc.计算快手滑块位置()
**重要提示:此功能只适用于1080P的手机**
**友情提示:快手的滑块和快看点的滑块是同一个**
**友情提示:此滑块识别功能是本地的,不接入任何网络,所以不会产生任何费用**
```lua
print(csc.计算快手滑块位置())  --识别成功的话,会直接返回目标左侧的X轴坐标,失败返回nil
--本功能只返回目标左侧的X轴坐标,识别成功率目前经过测试很高,具体请自己测试,并自己组装其它逻辑
```
------------
####  新晴天气滑块
csc.计算新晴天气滑块位置()
**重要提示:此功能只适用于1080P的手机**
**友情提示:快手的滑块和快看点的滑块是同一个**
**友情提示:此滑块识别功能是本地的,不接入任何网络,所以不会产生任何费用**
```lua
print(csc.计算新晴天气滑块位置())  --识别成功的话,会直接返回目标左侧的X轴坐标,失败返回nil
--本功能只返回目标左侧的X轴坐标,识别成功率目前经过测试很高,具体请自己测试,并自己组装其它逻辑
```
------------

csc.正则(字符串,匹配表达式)
csc.日期转时间戳(日期,格式)
csc.秒数转具体时间(秒数)
csc.计算N天后的日期(天数,年,月,日)
csc.取时间差(较大时间,较小时间)
csc.时间戳转标准日期(时间戳)
csc.取时间日期多种格式(格式)

####  LUA正则

csc.正则(字符串,匹配表达式)
```lua
print(csc.正则("aacsc.aaaa","c.c")) --返回["csc"] 说明: .代表任意字符
print(csc.正则("帐号01,密码01,帐号02,密码02,帐号03,密码03","(%d+)")) --返回["01","01","02","02","03","03"] 说明: 全局匹配出来所有数字
```

####  时间函数

csc.日期转时间戳(日期,格式)
```lua
print(csc.日期转时间戳("2020-6-14","(%d+)-(%d+)-(%d+)")) --返回 1592107200
```

csc.秒数转具体时间(秒数)
```lua
print(csc.秒数转具体时间(60)) --返回 0天0小时1分0秒  说明:60秒为一分钟
```

csc.计算N天后的日期(天数,年,月,日)
```lua
print(csc.计算N天后的日期(10,2020,6,14)) --返回 2020-06-24    即2020年6月14后,10天后是24号
```

csc.取时间差(较大时间,较小时间)
```lua
local 较大时间 = os.date(os.time{year=2020,month=6,day=14,hour=16,min=1,sec=2});
local 较小时间 = os.date(os.time{year=2018,month=5,day=11,hour=16,min=0,sec=0});
local t_time = csc.取时间差(较大时间,较小时间);
local time_txt = string.format("%04d", t_time.year).."年"..string.format("%02d", t_time.month).."月"..string.format("%02d", t_time.day).."日   "..string.format("%02d", t_time.hour)..":"..string.format("%02d", t_time.min)..":"..string.format("%02d", t_time.sec);
print(time_txt);  --返回0002年01月03日   00:01:02     说明,较大时间和较小时间判断为 2020年比2018年大,如果只对比分钟什么的,自己看着办
```

csc.时间戳转标准日期(时间戳)
```lua
print(csc.时间戳转标准日期(1534435200)) --返回2018-08-17 如果参数为空,则返回当天日期
```

csc.取时间日期多种格式(格式)
```lua
print(csc.取时间日期多种格式(1)) --返回20200722235402,即当天的年月日时分秒
参数说明:1:即例程中的格式:20200722235402   2:返回 2020-07-22 23:54:20  3:返回年 2020  4:返回月 07   
5:返回日 22     6:返回时 23       7:返回分 54       8:返回秒 20
```

------------
####  文件操作
csc.文件是否存在(文件路径)
csc.读取文件(文件路径, 是否删除文件)
csc.写入文件(文件路径, 写入的文本, 写入模式)
csc.读取文件存为数组(文件路径)
csc.数组写入文件(文件路径, 数组)
csc.读取指定行的内容(文件路径,行号)
csc.在指定行号插入一行内容(文件路径,行号,插入的内容)
csc.替换指定行的内容(文件路径,行号,替换内容)
csc.生成随机文本名的文件(文件目录, 文件前缀, 文件类型, 随机个数)
csc.替换文件内容(文件路径, 原文本, 替换文本)
csc.读取文件大小(文件路径)
csc.移动文件(文件路径1, 文件路径2)
csc.复制文件(文件路径1, 文件路径2)
csc.删除文件(文件路径)

------------

csc.文件是否存在(文件路径)
```lua
print(csc.文件是否存在("/sdcard/测试文件夹/1.png")) --文件存在返回true,不存在返回false
```

csc.读取文件(文件路径, 是否删除文件)
```lua
print(csc.读取文件("/sdcard/测试文件夹/1.txt")) --直接读取出来txt文件里面的全部内容,读取失败,返回空字串
```

csc.写入文件(文件路径, 写入的文本, 写入模式)
```lua
print(csc.写入文件("/sdcard/测试文件夹/1.txt","写入的字符","w")) --这是直接写,相当于一个全新的文件,之前的所有内容将全部清空.
print(csc.写入文件("/sdcard/测试文件夹/1.txt","\n写入的字符","a+")) --在文件尾部做写入
```

csc.读取文件存为数组(文件路径)
```lua
print(csc.读取文件存为数组("/sdcard/测试文件夹/1.txt")) --把一整个文件存内容读取为一个数组,自动以换行分割
```

csc.数组写入文件(文件路径, 数组)
```lua
print(csc.数组写入文件("/sdcard/测试文件夹/1.txt",{"写入的字符1","写入的字符2"})) --把数组直接写入到文件中
```

csc.读取指定行的内容(文件路径,行号)
```lua
print(csc.读取指定行的内容("/sdcard/测试文件夹/1.txt",1)) --读取第一行内容
```

csc.在指定行号插入一行内容(文件路径,行号,插入的内容)
```lua
print(csc.在指定行号插入一行内容("/sdcard/测试文件夹/1.txt",1,"文本1")) --在第一行,插入"文本1"
```

csc.替换指定行的内容(文件路径,行号,替换内容)
```lua
print(csc.替换指定行的内容("/sdcard/测试文件夹/1.txt",1,"文本3")) --替换第一行的文本为"文本3"
```

csc.生成随机文本名的文件(文件目录, 文件前缀, 文件类型, 随机个数)
```lua
print(csc.生成随机文本名的文件("/sdcard/测试文件夹/","csc.",".txt",2)) --在目录下,会生成csc. + 2个随机数字 + .txt的文件 如csc.22.txt
```

csc.替换文件内容(文件路径, 原文本, 替换文本)
```lua
print(csc.替换文件内容("/sdcard/测试文件夹/1.txt","文本","内容")) --把文件的所有"文本",替换成"内容"
```

csc.读取文件大小(文件路径)
```lua
print(csc.读取文件大小("/sdcard/测试文件夹/1.txt")) --返回文件的大小
```

csc.移动文件(文件路径1, 文件路径2)
```lua
print(csc.移动文件("/sdcard/测试文件夹/1.png","/sdcard/测试文件夹/2.png")) --1.png,移动到同目录下2.png
```

csc.复制文件(文件路径1, 文件路径2)
```lua
print(csc.复制文件("/sdcard/测试文件夹/2.png","/sdcard/测试文件夹/1.png")) --2.png,复制个1.png到同目录下
```

csc.删除文件(文件路径)
```lua
print(csc.删除文件("/sdcard/测试文件夹/2.png")) --删除指定目录下的2.png
```
------------
####  颜色操作简易封装
csc.多点找色返回单个_模式1(颜色规则)
csc.多点找色返回单个_模式2(控件,屏幕颜色特征,找色精度,找色方向)
csc.多点找色返回多个(颜色规则)
csc.取指定点rbg颜色(坐标x,坐标y)
csc.rgb比色_模式1(坐标x,坐标y,比较的颜色值,相似度)
csc.rgb比色_模式2(比较的颜色值,被比较的颜色值,相似度)

------------
csc.多点找色返回单个_模式1(颜色规则)
```lua
-- 对节点的例程做中文简单封装
local color = {241,833,422,1005,"292,871,#C7D667|299,919,#FCFCFC|364,927,#FEFEFE",95};
print(csc.多点找色返回单个_模式1(color))
```

csc.多点找色返回单个_模式2(控件,屏幕颜色特征,找色精度,找色方向)
```lua
-- 对节点的例程做中文简单封装,以控件为区域来识别特征点,适合app中有控件的操作,比如说砸蛋等
local r = R():desc("新晴天气"):type("RelativeLayout");
local view = r:findOnce()
print(csc.多点找色返回单个_模式2(view,"292,871,#C7D667|299,919,#FCFCFC|364,927,#FEFEFE",95))
```

csc.多点找色返回多个(颜色规则)    
```lua
-- 对节点的例程做中文简单封装
local color = {0,0,1000,1000,"77,693,#50BCF7|92,649,#50BCF7|91,742,#50BCF7",95} 
local points = csc.多点找色返回多个(color)    
if points then
    print("共找到:"..#points)
    for k,v in pairs(points) do 
        print("X:"..v.x..",Y"..v.y);
    end
end
```

csc.取指定点rbg颜色(坐标x,坐标y)
```lua
print(csc.取指定点rbg颜色(100,100)) -- 直接返回该点的rgb颜色值  #d4d2d9
```

csc.rgb比色_模式1(坐标x,坐标y,比较的颜色值,相似度)
```lua
print(csc.rgb比色_模式1(100,100,"#d4d2d9")) --比色成功返回true 失败返回nil   相似度可忽略,默认为95
```

csc.rgb比色_模式2(比较的颜色值,被比较的颜色值,相似度)
```lua
print(csc.rgb比色_模式2("#d4d2d9","#d4d2d9")) --比色成功返回true 失败返回nil   相似度可忽略,默认为95
```

------------

####  常用范围随机点击
csc.控件范围随机坐标点击(控件,缩进量)
csc.控件范围随机坐标点击_缩减范围(控件,left,top,right,bottom)
csc.范围随机坐标点击(x1,y1,x2,y2)

------------
csc.控件范围随机坐标点击(控件,缩进量)
```lua
local view = R():desc("节点精灵"):findOnce()
if view then --在点击之前,最好先判断控件是否存在
	csc.控件范围随机坐标点击(view)--缩进量是向控件里面内缩进,可空,默认为5,即找到控件后,左上右下各缩进5像素的区域内的随机坐标点击控件
end
```

csc.控件范围随机坐标点击_缩减范围(控件,left,top,right,bottom)
```lua
local view = R():desc("节点精灵"):findOnce()
if view then --在点击之前,最好先判断控件是否存在
	csc.控件范围随机坐标点击(view,10,5,10,5)--参数left,top,right,bottom各代码左上右下的缩进量,解释同上,应用到特殊场景
end
```

csc.范围随机坐标点击(x1,y1,x2,y2) 
```lua
csc.范围随机坐标点击(464,1106,616,1258) --在指定区域464,1106,616,1258内随机坐标点击
```
------------

####  加密相关
csc.md5加密(待加密字符串,返回模式)
```lua
--模式说明 1:16位小写加密 2:16位大写加密 3:32位小写加密 4:32位大写加密
print(csc.md5加密("aa"))   --返回 4124bc0a9335c27f086f24ba207a4912 模式可不填写,默认为3,即不填等同csc.md5加密("aa",3)
```

------------

##更新说明

**2020/7/28
####  加密相关
新增 csc.md5加密()

csc.table键值按字母排序(需要排序的table)

**2020/7/24
####  常用范围随机点击
csc.控件范围随机坐标点击(控件,缩进量)
csc.控件范围随机坐标点击_缩减范围(控件,left,top,right,bottom)
csc.范围随机坐标点击(x1,y1,x2,y2)

**2020/7/23
####  颜色操作简易封装
csc.多点找色返回单个_模式1(颜色规则)
csc.多点找色返回单个_模式2(控件,屏幕颜色特征,找色精度,找色方向)
csc.多点找色返回多个(颜色规则)
csc.取指定点rbg颜色(坐标x,坐标y)
csc.rgb比色_模式1(坐标x,坐标y,比较的颜色值,相似度)
csc.rgb比色_模式2(比较的颜色值,被比较的颜色值,相似度)

**2020/7/23
新增:csc.取时间日期多种格式(格式) --感觉时间函数前面的有点少了,特增加了这个

**2020/7/18
新增:csc.计算新晴天气滑块位置()

####文件操作
**2020/7/3
####文件操作
csc.文件是否存在(文件路径)
csc.读取文件(文件路径, 是否删除文件)
csc.写入文件(文件路径, 写入的文本, 写入模式)
csc.读取文件存为数组(文件路径)
csc.数组写入文件(文件路径, 数组)
csc.读取指定行的内容(文件路径,行号)
csc.在指定行号插入一行内容(文件路径,行号,插入的内容)
csc.替换指定行的内容(文件路径,行号,替换内容)
csc.生成随机文本名的文件(文件目录, 文件前缀, 文件类型, 随机个数)
csc.替换文件内容(文件路径, 原文本, 替换文本)
csc.读取文件大小(文件路径)
csc.移动文件(文件路径1, 文件路径2)
csc.复制文件(文件路径1, 文件路径2)
csc.删除文件(文件路径)

**2020/6/29
findOnce_target(目标,范围))

**2020/6/14
####正则
csc.正则
####日期相关
**csc.日期转时间戳
csc.秒数转具体时间
csc.计算N天后的日期
csc.取时间差
csc.时间戳转标准日期

2020/6/14
去掉了之前设置的关闭系统日志功能
####快手滑块
csc.计算快手滑块位置**

**2020/6/14
####数组及随机数
csc.数组_随机
csc.过滤数组
csc.数组排序
csc.删除数组元素
csc.插入数组元素
csc.数组去重
csc.数组元素位置互换
####随机数
**csc.取随机数
csc.随机布尔值
csc.随机取数组内容
csc.数组_随机EX**

**2020/6/13
####文本
csc.删除前导文本
csc.删除后导字符
csc.同时删除前后文本
csc.删除指定文本
csc.取指定文本出现次数
csc.从左边开始删除指定数量的文本
csc.从右边开始删除指定数量的文本
csc.从路径中取后缀
csc.从路径中取文件名加后缀
csc.取文本长度
csc.字母转小写
csc.字母转大写
csc.取反转文本
csc.取反转文本**
####实用文本
**csc.分割文本
csc.文本替换
csc.文本是否存在**

**2020/6/10
####节点拓展
boundsInside - -把找到后判断,修改为在区域内找

2020/6/10
boundsInside

2020/6/09
findOnce
findOne
findOnce_range
findOne_range******

2020年07月28日

2020年07月28日

2020年07月24日