跳到主要内容
版本：release

容器类型（array, map）

array表示数组，顺序存储一系列数值，map表示一种映射关系，他们的存储内存也都是动态分配的。

array​

array数组和buffer有点类似，都是可以顺序存储任意mixed数据类型的数据。 我认为buffer和array有以下区别：

提示

buffer是把数据转成十六进制存储，如果根据下标取值的话得到的是数据转成十六进制后的对应下标ASCII值，而在array中可以取出存储的原始数据。

array类型基本语法如下：

array array_name = [ value1, value2, value3, ... ];    // value可以为任意不同类型的数值

array初始化，以及一些简单的符号运算：

array arr = [ 1, 2, nil, "Three", 2, [ "hello", (buffer)1, 3.14 ] ]; // 初始化arr
array arr1 = [1, 2], arr2 = [3, 4];
array add_arr = arr1 + arr2;    // add_arr = [1, 2, 3, 4]
add_arr << ["hello"];           // add_arr = [1, 2, 3, 4, "hello"]
write(add_arr[0]);              // 输出 1

array特殊语法

  • array_instance[&ltn] 获取数组倒数第n个元素

  • array_instance[m..n] 获取第m个元素到第n个元素构成的子数组

  • array_instance[m..&ltn] 获取第m个元素到倒数n个元素构成的子数组

  • array_instance[&ltm..&ltn] 获取倒数第m个元素到倒数n个元素构成的子数组

样例：

array test_arr = [1,2,3,4,5];       // 初始化arr
write(test_arr[<1], "\n");          // 输出 5
write(test_arr[<2], "\n");          // 输出 4
write(test_arr[1..<2], "\n");       // 输出 [2,3,4]
write(test_arr[1..2], "\n");        // 输出 [2,3]
write(test_arr[<3..<1], "\n");      // 输出 [3,4,5]

array常用的外部函数​

下面列出array类型一些常用的外部函数以及用法。

1. 分配空间

函数原型：
array array.allocate(int size, mixed val = nil)
使用方法：
array arr = array.allocate(6); // arr.length() = 6

2. 清除空值

函数原型：
array array_instance.clean_up()
使用方法：
array arr = [1, 2, nil, "Three", 4]; arr.clean_up(); // arr.length() = 4

3. 清除空间

函数原型：
void array_instance.clear()
使用方法：
array arr = [1, 2, nil, "Three", 4]; arr.clear(); // arr.length() = 0

4. 删除一个值

函数原型：
int array_instance.delete(mixed val)
使用方法：
array arr = [1, 2, nil, "Three", 2]; int index = arr.delete(2); // index = 1

5. 删除n个值

函数原型：
void array_instance.delete_at(int pos, int num = 1)
使用方法：
array arr = [1, 2, nil, "Three", 2]; arr.delete_at(2, 2); // arr = [1, 2, 2]

6. 查找，失败-1

函数原型：
int array_instance.find(mixed val)
使用方法：
array arr = [1, 2, nil, "Three", 2]; int index = arr.find(2); // index = 1

7. 取值

函数原型：
mixed array_instance.get(int pos)
使用方法：
array arr = [1, 2, nil, "Three", 2]; mixed val = arr.get(1); // val = 2

8. 取子array

函数原型：
array array_instance.get_range(int pos, int count = -1)
使用方法：
array arr = [1, 2, nil, "Three", 2]; array child = arr.get_range(2,2); // child = [nil, "Three", 2]

9. 插入

函数原型：
void array_instance.insert(int pos, mixed val)
使用方法：
array arr = [1, 2, nil, "Three", 2]; arr.insert(1,"One"); // arr = [1, "one", 2, nil, "Three", 2]

10. 插入数组

函数原型：
void array_instance.insert_n(int pos, array val)
使用方法：
array arr = [1, 2, nil, "Three", 2]; array a = [3, 4]; arr.insert_n(1,a); // arr = [1, 3, 4, 2, nil, "Three", 2]

11. 小于val的元素个数

函数原型：
int array_instance.lower_bound(mixed val)
使用方法：
array arr = [1, 3, 5, 6.5, 7, 9]; int num = arr.lower_bound(6.5); // num = 3 (数组元素需要有序，二分查找)

12. 大等于val的元素个数

函数原型：
int array_instance.upper_bound(mixed val)
使用方法：
array arr = [1, 3, 5, 6.5, 7, 9]; int num = arr.upper_bound(6.5); // num = 4

13. 取值

函数原型：
mixed array_instance.get(int pos)
使用方法：
array arr = [1, 2, nil, "Three", 2]; mixed val = arr.get(1); // val = 2

14. 往后插入

函数原型：
void array_instance.push_back(mixed val)
使用方法：
array arr = [1, 2, nil, "Three", 2];
arr.push_back("!"); // arr = [1, 2, nil, "Three", 2, "!"]

15. 往后插入数组

函数原型：
void array_instance.push_back_n(array val)
使用方法：
array arr = [1, 2, nil, "Three", 2];
array a = [3, 4]; arr.push_back_n(a); // arr = [1, 2, nil, "Three", 2, 3, 4]

16. 赋值

函数原型：
void array_instance.set(int pos, mixed val)
使用方法：
array arr = [1, 2, nil, "Three", 2];
arr.set(2,"2"); // arr = [1, 2, "2", "Three", 2]

17. 复制

函数原型：
void array.copy(array dst, int pos, array src, int start = 0, int copy_len = 2^63 - 1)
使用方法：
array arr = [1, 2, 3];
array arr1 = array.allocate(3);
array.copy(arr1, 0, arr);// arr1 = [1, 2, 3]

18. array转字符串

函数原型：
string array_instance.implode(string delim = "")
使用方法：
array arr = ["hello", "world"];
string str = arr.implode(" "); // str = "hello world"

19. 排序

函数原型：
array array_instance.sort(int order = SortType.ASCENDING)
使用方法：
array arr = [7, 3, (buffer)1, "str"];
arr = arr.sort(SortType.ASCENDING); //arr [3, 7, "str", (buffer)1])

20. 函数排序

函数原型：
array array_instance.sort(function func, int order = ASCENDING)
使用方法：
//

21. 是否为array

函数原型：
bool is_array(mixed val)
使用方法：
array arr = [1, 2, nil, "Three", 2];
bool flag = is_array(arr); // flag = true

22. array映射

函数原型：
array array.map(array arr, function func)
使用方法：
array arr = [111, "222", [1, 2]];
array arrs = arr.map((: lengthof :)); // arrs = [0, 3, 2]

23. 范围数组

函数原型：
array array.range(int start, int end)
使用方法：
array arr = ["hello", "world", 1, 3];
array arr1 = array.range(2, 4); // arr1 = [2, 3, 4]

24. array转string

函数原型：
array array_instance.to_string()
使用方法：
array arr = ["hello", "world", 1, 3];
string str = arr.to_string(); // str = "["hello","world",1,3]"

25. 筛选新array

函数原型：
array array_instance.filter(function fun)
使用方法：
array arr=[4, 6, 8];
array arr1 = arr.filter((mixed val){ return val > 5;}); // arr1 = [6, 8]

26. 筛选第一个满足条件的value

函数原型：
mixed array_instance.select_first(function fun)
使用方法：
用法与filter()类似

27. 从左压缩数组

函数原型：
mixed array_instance.reduce_left(function fun)
使用方法：
array arr = [1, 2, 3];
int val = arr.reduce_left((int val1, int val2){return val1 + val2}); // val = 6;

28. 从右压缩数组

函数原型：
mixed array_instance.reduce_right(function fun)
使用方法：
用法与reduce_left()类似

map​

map可以理解为一种类似于函数的映射（key -> value)，其中key和value都可以是任意mixed类型的数值。

map类型基本语法如下：

map map_name = { key1:value1, key2:value2, key3:value3, ... };    // key和value可以为任意不同类型的数值

map初始化，以及一些简单的符号运算：

map m = {1:2, nil:"Three", "arr":[1, 2]}; // 初始化m
map m1 = {1:2, 3:5}, m2 = {3:4};
map add_map = m1 + m2; // add_map = {1:2, 3:4}， 覆盖m1中相同的key
write(add_map[1]);   // 输出 2

map常用的外部函数​

下面列出map类型一些常用的外部函数以及用法

1. values相加

函数原型：
mixed map.add_values(map m1, map m2)
使用方法：
map m1 = {1:2, 3:5}, m2 = {1:2.3, 3:4};
map m = map.add_values(m1, m2); // m = {1:4.3, 3:9}

2. 分配空间

函数原型：
map map.allocate(int size)
使用方法：
map m = map.allocate(6); // 注意：m.size() = 0

3. 删除无用值

函数原型：
map map_instance.clean_up()
使用方法：
map m = {1:2, nil:4, "hello":nil};
m = m.clean_up(); // m = {1:2, nil:4}

4. 清除map

函数原型：
void map_instance.clear()
使用方法：
map m = {1:2, nil:4, "hello":nil};
m.clear(); // m = {}

5. 删除key对应值（成功true）

函数原型：
int map_instance.delete(mixed key)
使用方法：
map m = {1:2, nil:4, "hello":nil};
int val = m.delete(1); // val = true

6. 删除value对应值

函数原型：
int map_instance.delete_value(mixed val)
使用方法：
map m = {1:2, nil:4, "hello":2};
int val = m.delete_value(2); // val = 2 (val为删除的数量)

7. 取key对应value

函数原型：
mixed map_instance.get(mixed key)
使用方法：
map m = {1:2, nil:4, "hello":nil};
mixed val = m.get(1); // val = 2

8. 取出所有key

函数原型：
array map_instance.keys()
使用方法：
map m = {1:2, nil:4, "hello":nil};
array keys = m.keys(); // keys = [1, nil, "hello"]

9. 设置key-value

函数原型：
void map_instance.set(mixed key, mixed val)
使用方法：
map m = {1:2, nil:4, "hello":nil};
m.set(nil, "hello"); // m = {1:2, nil:"hello", "hello":nil}

10. 取出所有value

函数原型：
array map_instance.values()
使用方法：
map m = {1:2, nil:4, "hello":nil};
array values = m.values(); // values = [2, 4, nil]

11. 是否为map

函数原型：
bool is_mapping(mixed val)
使用方法：
map m = {1:2, nil:4, "hello":nil};
bool flag = is_map(m); // flag = true

12. 是否包含key

函数原型：
bool map_instance.contains_key(mixed key)
使用方法：
map m = {1:2, nil:4, "hello":nil};
bool flag = m.contains_key(1); // flag = true

13. map转string

函数原型：
string map_instance.to_string()
使用方法：
map m = {1:2, nil:4};
string str = m.to_string(); // str = "{1:2,nil:4}"

14. map生成新map

函数原型：
string map_instance.map(function func)
使用方法：
map m = {"a": 2, "b": 3};
map m1 = m.map((int val, string key){ return val + 1;}); // m1 = {"a": 3, "b": 4}

15. 找第一个满足条件的value

函数原型：
mixed map_instance.select_first_key(function func)
使用方法：
map m = {"a": 2, "b": 6, "c": 7};
mixed m1 = m.select_first_key((int val, string key){ return val > 5;}); // m1 = "b"

16. 找第一个满足条件的key

函数原型：
mixed map_instance.select_first_value(function func)
使用方法：
// 用法与select_first_key()类似

17. 设置path-value

函数原型：
mixed map_instance.express_set(string path, mixed val)
使用方法：
map m = { };
m.express_set("a/b", 1); // m = {a: {b: 1}}

18. 增加path对应value

函数原型：
mixed map_instance.express_add(string path, mixed val)
使用方法：
m.express_add("a/b", 2); // m = {a: {b: 3}}

19. 查询path对应value

函数原型：
mixed map_instance.express_query(string path)
使用方法：
int val = m.express_query("a/b"); //val = 3

20. 删除path对应value

函数原型：
mixed map_instance.express_delete(string path)
使用方法：
m.express_delete("a/b"); // m = { }

注意

第14项新map的new_pair = [old_pair.key, (*func)(old_pair.value, old_pair.key)]