标准运行库

目录

• 异常
• 字符串
• 数组
• 字典
  • 字典值
• 引用
• 弱引用
• 日期
• 协程
• 文件
• 文件系统

异常

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

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

注意

throw和getExceptionInfo只有程序注册了他们才能使用

函数

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)是基础类型中的字符串的补充，主要为字符串类型添加了一些列的类方法

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

运算符

方法

函数

format函数可接受的option

数组

注意

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

声明数组(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});

运算符

方法

附 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}}}};

方法

字典值对象

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

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

运算符

引用

注意

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

引用类型(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();

运算符

弱引用

注意

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

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

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

弱引用可以使用weakref或const_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为空

运算符

方法

日期

注意

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

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

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

构造函数

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

方法

运算符

协程

注意

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

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

函数

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();
}

方法

成员属性

bool mostSignificantByteFirst

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

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

文件系统

注意

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

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