标准运行库

目录


异常

异常是AngelScript中一个特殊的数据类型,很明显你无法显式操作一个异常

try-catch代码块中,catch部分默认隐式传递了一个异常参数

注意

throwgetExceptionInfo只有程序注册了他们才能使用

函数

void throw(const string &in exception)

显式抛出一个异常,输入的字符串应该位能标识异常类型的身份,用于记录或异常捕获

string getExcetionInfo()

获得上一个抛出的异常的字符串信息

列如

void BadCode()
{
    CApple@ obj = null;
    try
    {
        //obj为空,将会抛出一个异常
        obj.Eat();
    }
    catch
    {
        //默认已经传递了一个隐式的异常信息

        //将会获得 “Null Pointer Access”
        getExcetionInfo();
    }
}

void WeridCode()
{
    try
    {
        throw("人为抛出的异常");
    }
    catch
    {
        //将会获得 “人为抛出的异常”
        getExcetionInfo();
    }
}

异常可能由于各种原因发生,例如,访问空句柄,0作为除数,或应用程序注册函数引发的异常

在某些情况下,脚本故意引发异常以中断某些执行


字符串

注意

只有注册了字符串类型的程序才能在脚本中使用字符串,由于注册方法或注册内容的不同,不同程序使用字符串的方法可能会有所区别

标准库中的字符串(string)是基础类型中的字符串的补充,主要为字符串类型添加了一些列的类方法

关于字符串的定义,请查看数据类型-字符串

运算符

名称 符号 描述 短例
赋值 = 赋值运算符将右侧字符串的内容复制到左侧字符串中, 右值可以是基础数据类型中的任意一种,赋值时将会对其进行隐式转换 string1 = string2 string1 = int2
连接 + += 连接运算符将右侧字符串的内容追加到左侧字符串的末尾,如同赋值,右值可以是任意基础数据类型 string1 = string 2 + string3 string1 += int2
相等 == != 相等运算符用于比较两个字符串是否相等 string1 == string2
比较 < > <= >= 比较运算符用于比较两个字符串内容,注意,比较运算符是对字符串中字符的字节值进行比较,不是对字符串中的字母顺序进行比较 "A" > "B" 等同于 65 > 66
索引 [] 索引运算符允许访问字符串中的单个字符 "Hello World"[2] == ‘l’

方法

方法 描述 短例 结果
uint length() const 返回字符串的长度 Hello World.length() 11
void resize(uint) 重设字符串的长度 "Hello World".resize(5) "Hello"
bool isEmpty() const 返回字符串是否为空 "Hello World".isEmpty() false
string substr(uint start = 0, int count = -1) const 返回起始位置向后指定长度的子字符串 "Hello World".substr(6,4) "World"
void insert(uint pos, const string &in other) 将另外一个字符串插入字符串指定位置 "Hello World".insert(5, "This ") "Hello This World"
void erase(uint pos, int count = -1) 从指定位置删去指定数目的字符 "Hello World".erase(5,4) "Hello"
int findFirst(const string &in str, uint start = 0) const 从指定位置左往右找到第一个和指定字符串对应的子字符串位置, 找不到将返回-1 "Hello World".findFirst("l",0) 2
int findLast(const string &in str, int start = -1) const 从指定位置右往左找到第一个和指定字符串对应的子字符串位置, 找不到将返回-1 "Hello World".findFirst("l",-1) 8
int findFirstOf(const string &in chars, int start = 0) const 从指定位置左往右找到第一个和指定字符串对应的子字符串或字符的位置, 找不到将返回-1 "Hello World".findFirstOf("l",0) 2
int findLastOf(const string &in str, int start = -1) const 从指定位置右往左找到第一个和指定字符串对应的子字符串或字符的位置, 找不到将返回-1 "Hello World".findLastOf("l",-1) 8
int findFirstNotOf(const string &in chars, int start = 0) const 从指定位置左往右找到第一个和指定字符串对应的子字符串或字符的位置, 找不到将返回-1 "Hello World".findFirstNotOf("H",0) 1
int findLastNotOf(const string &in chars, int start = -1) const 从指定位置右往左找到第一个和指定字符串对应的子字符串或字符的位置, 找不到将返回-1 "Hello World".findLastNotOf("d",-1) 9
array@ split(const string &in delimiter) const 根据指定的子字符串将字符串拆分为字符串数组 "Hello World".split(" ") {"Hello", "World"}

函数

函数 描述 短例 结果
string join(const array &in arr, const string &in delimiter) 将数组中的字符串连接成由分隔符分隔的大字符串 join({"Hello", "World"}, " ") "Hello World"
int64 parseInt(const string &in str, uint base = 10, uint &out byteCount = 0) 以基值(10或16)对字符串进行分析获取整数值,最后可将字符串长度输出 parseInt("0x1", 16) 1
uint64 parseUInt(const string &in str, uint base = 10, uint &out byteCount = 0) 以基值(10或16)对字符串进行分析获取整数值,最后可将字符串长度输出 parseUInt("1337", 10) 1337
double parseFloat(const string &in, uint &out byteCount = 0) 对字符串进行分析获取浮点值,最后可将字符串长度输出 parseFloat("13.21F") 13.21f
string formatInt(int64 val, const string &in options = ”, uint width = 0) format函数接受一个字符串,该字符串定义数字的格式 formatInt(1) "1"
string formatUInt(int64 val, const string &in options = ”, uint width = 0) format函数接受一个字符串,该字符串定义数字的格式 formatUInt(1,"0", 4) "1000"
string formatFloat(double val, const string &in options = ”, uint width = 0, uint precision = 0) format函数接受一个字符串,该字符串定义数字的格式 formatFloat(2.2f,"+","4") "+2.2000"

format函数可接受的option

字符 描述 短例 结果
| 左对齐 formatInt(1, ‘l’, 10) " 1"
0 以0填充 formatInt(1, ‘0l’, 10) "0000000001"
+ 正数前添加+号 formatInt(1, ‘+’) "+1"
space 正数添加空格 formatInt(1, ‘space’) "1 "
h 以小写输出为16位数(不支持float) formatInt(10, ‘h’) "0xa"
H 以大写输出位16位数(不支持float) formatInt(10, ‘H’) "0xA"
e 以科学计数法小写输出数字(仅支持float) formatFloat(10.1f, ‘e’) "1.01e1"
E 以科学计数法大写输出数字(仅支持float) formatFloat(10.1f, ‘E’) "1.01E1"

数组

注意

只有注册了数组类型的程序才能在脚本中使用字符串,由于注册方法或注册内容的不同,不同程序使用数组的方法可能会有所区别

声明数组(array)类型可如同普通基础数据类型一样,不同的是尖括号内应该包含数组元素的类型

//声明整数数组
array<int> a, b,c;
//数组元素可为句柄
array<CApple@> d;

除此之外,还有多种方法声明数组

//声明一个元素为0的整数数组
array<int> a;
//声明一个有三个默认初始值的整数数组
//该数组等同于{0, 0, 0}
array<int> b(3);
//声明一个有三个以1为初始值的整数数组
//该数组等同于{1, 1, 1}
array<int> c(3,1);
//声明一个拥有确切元素的数组
array<int> d = {1, 2, 3};

同样的,数组也可以成为数组的元素,可以此来声明交错数组

AngelScript 不存在多维数组,只有交错数组

//一个元素为0的空整数数组的数组
array<array<int>> e;
//一个有两个确切元素的数组数组,元素分别为{1,2}和{3,4}
array<array<int>> f = {{1, 2}, {3, 4}};
//一个有十个数组元素的数组,该数组共包含10 x 10个0
array<array<int>> g(10, array<int>(10));
//一个有十个以整数数组为元素的数组为元素的数组,该数组共包含10 x 10 x 10个0
array<array<array<int>>> h(10, array<array<int>>(10, array<int>(10)));
//你也可以继续套娃下去实现更高维的数组.....

访问数组中的元素可以使用索引运算符,索引的范围为0到数组长度 – 1
以上数组为例

//访问数组元素
b[0] = c[1];
//访问交错数组
f[0][1] == g[1][5];
//访问更高维交错数组
h[1][2][3];

同样的,当数组元素为句柄时,可以通过数组访问对象成员

array<CApple@> apples(1);
//将第一个数组元素指向一个新实例化的对象
@apples[0] = CApple();
//通过数组访问对象
apples[0].Eat();

数组可以通过使用花括号的形式初始化为匿名对象

Function({-1, -2, -3, -4, -5});
//当匿名对象有多种类型可以对应时,你需要显式描述匿名对象的类型
//此时将会抛出错误,因为这个匿名对象可以对应array<uint>和array<int>两种类型
Function({1, 2, 3, 4});
//你需要如此显式描述类型
Function(array<int> = {1, 2, 3, 4});

运算符

名称 符号 描述 短例 结果
赋值 = 将右侧数组值复制给左侧数组 a = {5, 6, 7} {5, 6, 7}
索引 [] 通过索引访问数组元素 a[1] 6
相等 == != 比较两个数组元素是否一致 {1, 2, 3} == {5, 6, 7} false
句柄 @ 获取数组的对象句柄 @a = @{1,2,3} a[1] = 2

方法

方法 描述 短例 结果
uint length() const 返回数组元素数 {1,2,3}.length() 3
void resize(uint) 重设数组长度 {1,2,3}.resize(2) {1,2}
void reverse() 反转数组元素顺序 {1,2,3} {3,2,1}
void insertAt(uint index, const T& in value) 在指定位置插入一个元素 {1,2,3}.insertAt(1,1) {1,2,1,3}
void insertAt(uint index, const array<\T>& arr) 在指定位置插入一个数组 {1,2,3}.insertAt(1,{1,2,3}) {1,2,1,2,3,3}
void insertLast(const T& in) 在数组最后添加一个元素 {1,2,3}.insertLast(4) {1,2,3,4}
void removeAt(uint index) 移除数组指定位置的元素 {1,2,3}.removeAt(0) {2,3}
void removeLast() 移除数组最后一个元素 {1,2,3}.removeLast() {1,2}
void removeRange(uint start, uint count) 移除数组指定范围的元素 {1,2,3}.removeRange(1,2) {1}
void sortAsc() 升序排序数组, 需要数组元素类型拥有opCmp方法 {2,1,3}.sortAsc() {1,2,3}
void sortAsc(uint startAt, uint count) 升序排序范围内的数组, 需要数组元素类型拥有opCmp方法 {2,1,4,3}.sortAsc(1,3) {2,1,3,4}
void sortDesc() 降序排序数组, 需要数组元素类型拥有opCmp方法 {2,1,3}.sortAsc() {3,2,1}
void sortDesc(uint startAt, uint count) 降序排序范围内的数组, 需要数组元素类型拥有opCmp方法 {2,1,4,3}.sortAsc(1,3) {2,4,3,1}
void sort(const less &in compareFunc, uint startAt = 0, uint count = uint(-1)) 此方法接受一个回调函数作为输入,用于在排序数组时比较两个元素 表后附 表后附
int find(const T& in) 获得第一个与传入元素相等的元素索引, 不存在时返回-1, 要求元素类型拥有opEquals或opCmp方法 {1,2,3}.find(2) 1
int find(uint startAt, const T& in) 在指定范围内获得第一个与传入元素相等的元素索引, 不存在时返回-1, 要求元素类型拥有opEquals或opCmp方法 {1,2,3,}.find(1,1) -1
int findByRef(const T& in) 将通过比较地址而不是值来搜索数组中的元素, 不存在时返回-1 {a = 1, b = 2, c = 3}.findByRef(2) -1
int findByRef(uint startAt, const T& in) 将通过比较地址而不是值来搜索数组指定范围中的元素, 不存在时返回-1 {a = 1, b = 2, c = 3}.findByRef(1,b) 1

附 sort方法的使用

回调函数应将同一类型数组元素的两个引用作为参数,并应返回bool。如果第一个参数应放在第二个参数之前,则返回值应为true

array<int> arr = {3,2,1};
arr.sort(function(a,b) { return a < b; });

如要在匿名对象中使用sort

bool lessForInt(const int &in a, const int &in b)
{
    return a < b;
}
bool lessForHandle(const obj @&in a, const obj @&in b)
{
    return a < b;
}
void sortArrayOfInts(array<int> @arr) { arr.sort(lessForInt); }
void sortArrayOfHandles(array<obj@> @arr) { arr.sort(lessForHandle); }

字典

注意

只有注册了字典类型的程序才能在脚本中使用字符串,由于注册方法或注册内容的不同,不同程序使用字典的方法可能会有所区别

字典(dictionary)存储键值对,其中键是字符串,值可以是任何类型

dictionary a = {{"int", 1}, {"boolean", true}, {"float", 2.2f}};

可以动态地添加或删除字典中的键值对

a.set("string", "Hello World");
a.delete("int");

可以通过索引运算符访问字典中的元素

a["boolean"] = false;
//获取字典对象值时需要显式转换
int val = int(a["int"]);
CApple@ apple = cast<CApple>(a["apple"]);

字典可被作为匿名对象

//初始化匿名对象字典时,必须显式说明类型,因为字典的初始化方法和二维交错数组是一样的
//报错报错
foo({{"a",1},{"b",2}});
//正确
foo(dictionary = {{"a", 1}, {"b", 2}});

同样的,可以通过匿名对象初始化一个以字典作为键值对中的值的字典

dictionary d2 = {{'a', dictionary = {{'aa', 1}, {'ab', 2}}}, 
                {'b', dictionary = {{'ba', 1}, {'bb', 2}}}};

方法

方法 描述 短例 结果
void set(const string &in key, ? &in value) 为字典设定一个键值对,如果已存在将覆盖已有的,否则将新建一个键值对 a.set("boolean", true) N/A
bool get(const string &in key, ? &out value) const 从字典中获取一个值到指定变量中,键值不存在时将返回false,并保持指定变量的初始值 a.get("float", b) b = 2.2f
array @getKeys() const 将返回字典中的所有键为一个字符串数组,该数组的顺序不定 a.getKeys() {"int", "boolean", "apple", "float"}
bool exists(const string &in key) const 将返回键值是否存在 a.exists("array") false
bool delete(const string &in key) 删除指定的键值对,键值不存在将返回false a.delete("int") true
void deleteAll() 情况字典所有键值对 a.deleteAll() {}
bool isEmpty() const 返回该字典是否为空 a.isEmpty() false
uint getSize() const 返回字典中键值对的数目 a.getSize() 4

字典值对象

字典值对象(dictionaryValue)是字典储存值的类型,当通过索引访问字典时返回的都是字典值对象

字典值对象类型不可以拥有句柄,但是他可以储存句柄

运算符

名称 符号 描述 短例
赋值 = 将右值复制给左值 dict[0] = dict[1]
句柄赋值 将右值储存对象的句柄复制给左句柄 @apple = @dict[2]
转换 cast<\T> 将字典值对象储存的句柄转换为需要的句柄 cast(dict[2])
转换 ?any() 将字典值对象储存的值转换为需要的类型 int(dict[0])

引用

注意

只有注册了引用类型的程序才能在脚本中使用字符串,由于注册方法或注册内容的不同,不同程序使用引用的方法可能会有所区别

引用类型(ref)被用于处理任何句柄,通常情况下我们储存句柄时必须要知道确切的句柄类型,这让程序编写时增添了非常多的困难,因此有了引用类型来处理所有的句柄引用

例如

//有两个完全不相干的类
class CFood() {};
class CCar() {};

//我想在某个函数中处理这两个类
//传统做法需要为其新建两个不同的重载
//费事费力,浪费空间影响版面
void Cut(CFood@ food) { }
void Cut(CCar@ car) {}
//使用引用类型用一个函数处理两种类
void Cut(ref@ handle)
{
    //首先需显式转换为目标类型
    CFood@ f = cast<CFoold>(handle);
    //当引用不是所需的类型时,将返回空,因此需要空句柄判断
    if(f !is null)
    {
        //?
    }
    else
    {
        CCar c = cast<CCar>(handle);
        if(c !is null)
            //?
        else
            //?
    }
}

声明引用时可以同对象句柄一样声明

ref@ r  = CCar();

运算符

名称 符号 描述 短例
句柄赋值 @= 将右值引用复制给左引用 @ref1 = @ref2
身份判断 is !is 判断两个引用是否指向同一对象 ref1 is ref2
转换 cast<\T> 将引用转换为需要的句柄 cast(ref)

弱引用

注意

只有注册了弱引用类型的程序才能在脚本中使用字符串,由于注册方法或注册内容的不同,不同程序使用弱引用的方法可能会有所区别

弱引用(weakref)是用于那些句柄可能会随时被移除的对象的引用

强引用将会保持对象在堆栈中的存在,而使用弱引用在对象生命周期结束后将自动指向null

弱引用可以使用weakrefconst_weakref来声明

class CApple {}
//声明一个对对象的强引用
CApple @obj1 = CApple();

//保持对对象的弱引用
weakref<CApple> r1(obj1);

//保持对只读对象的弱引用
const_weakref<CApple> r2(obj1);

//只要还有对该对象的强引用,弱引用就能返回该对象
CApple @obj2 = r1.get();

//所有对对象的强引用都被移除,弱引用将会指向null
@obj1 = null;
@obj2 = null;
const CApple @obj3 = r2.get();
//obj3为空

运算符

名称 符号 描述 短例
句柄赋值 @= 将右值引用复制给左引用 @weak1 = @weak2
值赋值 = 将右侧弱引用对象的值赋值给左侧引用对象 weak1 = weak2
身份判断 is !is 判断两个引用是否指向同一对象 weak1 is weak2
转换 cast<\T> 将引用转换为需要的句柄 cast(weak1)

方法

方法 描述
T@ get() const 这与cast运算符的作用完全相同,只是一种更明确的写作方式

日期

注意

只有注册了日期类型的程序才能在脚本中使用字符串,由于注册方法或注册内容的不同,不同程序使用日期的方法可能会有所区别

日期(datetime)类型表示日历日期和时间。它可以用于对日期进行数学运算,例如比较两个日期、确定日期之间的差异以及增加/减去日期以形成新日期。

它还可以用于获取当前系统时间,从而允许测量任务的时间,精度仅为秒

构造函数

//初始化对象为当前系统日期
datetime();
//初始化对象为另一日期对象日期
datetime(const datetime &in other);
//初始化日期对象为指定的日期
datetime(uint y, uint m, uint d, uint h = 0, uint mi = 0, uint s = 0);

方法

方法 描述
uint get_year() const property 返回年
uint get_month() const property 返回月
uint get_day() const property 返回日
uint get_hour() const property 返回时
uint get_minute() const property 返回分
uint get_second() const property 返回秒
bool setDate(uint year, uint month, uint day) 设定日期,输入数字无效时返回false
bool setTime(uint hour, uint minute, uint second) 设定时间,输入数字无效时返回false

运算符

名称 符号 描述
赋值 = 将右值复制给左值
差异 从左值中减去右值,返回秒数
+ +=
– -=
相等 == != 比较两个日期是否相同
比较 < > <= >= 比较两个日期

协程

注意

只有注册了协程类型的程序才能在脚本中使用字符串,由于注册方法或注册内容的不同,不同程序使用协程的方法可能会有所区别

协程用于多线程处理多个任务

函数

funcdef void coroutine(dictionary@)
void createCoRoutine(coroutine @, dictionary @)

此函数用于创建协程。协程将在产生状态下启动,也就是说,它只在当前线程将控制权交给它时才开始执行

可以创建多个协程,它们将轮流以循环方式执行

void yield()

为队列中的下一个协程生成执行控制。

当一个共协程收到控制时,它将从最后一个调用恢复执行,如果这是第一次允许协程执行,则返回入口点


文件

注意

只有注册了文件类型的程序才能在脚本中使用字符串,由于注册方法或注册内容的不同,不同程序使用文件的方法可能会有所区别

文件(file)类型用于处理通过IO的文件读取或保存

例如

file f;
// 以读取模式读取文件
if( f.open("file.txt", "r") >= 0 ) 
{
    //读取整个文件进入一个字符串中
    string str = f.readString(f.getSize()); 
    f.close();
}

方法

方法 描述
int open(const string &in filename, const string &in mode) 打开文件,模式r表示读取,w表示写入,或a表示追加, 如果无法打开文件,则返回负值
int close() 关闭文件,文件未打开则返回-1
int getSize() const 返回文件大小, 文件未打开则返回-1
bool isEndOfFile() const 是否到达文件最尾
string readString(uint length) 从文件中读取指定长度的字符串
string readLine() 以\n分开读取一行字符串
int64 readInt(uint bytes) 从指定长度字节中读取整数
uint64 readUInt(uint bytes) 从指定长度字节中读取整数
float readFloat() 读取4字节长度单精度数
double readDouble() 读取8字节长度的双精度数
int writeString(const string &in str) 写出一个字符串,出错返回-1,否则是字节长度
int writeInt(int64 value, uint bytes) 写出指定长度的整数,出错返回-1,否则是字节长度
int writeUInt(uint64 value, uint bytes) 写出指定长度的整数,出错返回-1,否则是字节长度
int writeFloat(float value) 写出4长度的单精度数,出错返回-1,否则是字节长度
int writeDouble(double value) 写出8长度的双精度数,出错返回-1,否则是字节长度
int getPos() const 获得目前文件指针的位置
int setPos(int pos) 设置目前文件指针的位置
int movePos(int delta) 移动文件指针到指定位置

成员属性

bool mostSignificantByteFirst

如果在读/写数字的方法中首先读取或写入最重要的位,则应将此属性设置为true

它默认设置为false,这是大多数平台上的标准


文件系统

注意

只有注册了文件系统类型的程序才能在脚本中使用字符串,由于注册方法或注册内容的不同,不同程序使用文件系统的方法可能会有所区别

文件系统(filesystem)用于访问系统路径

方法 描述
bool changeCurrentPath(const string &in path) 改变目前的路径,不存在返回false
string getCurrentPath() const 获取目前所在的路径
array @getDirs() 获取目前所在路径的所有文件夹
array @getFiles() 获取目前所在路径的所有文件
bool isDir(const string &in path) 判断路径是否为文件夹
bool isLink(const string &in path) 判断路径是否为链接
int64 getSize(const string &in) const 获得文件的大小
int makeDir(const string &in) 在指定路径创建一个文件夹, 成功返回0
int removeDir(const string &in) 删除一个空文件夹, 成功返回0
int deleteFile(const string &in) 删除一个文件, 成功返回0
int copyFile(const string &in, const string &in) 复制一个文件, 成功返回0
int move(const string &in, const string &in) 移动一个文件, 成功返回0
Categories: 教程合集

Dr.Abc

I ❤ Owl

说点什么

avatar
  订阅  
提醒