'); })();
遥感云计算
GISer
2022-05-14
目录

List

# 简介

列表（List）中的元素是按顺序组织起来的。PIE-Engine Studio提供构建列表算子及列表相关算法，包括但不限于取值、追加、插入、判断是否包含等算法。

# List (opens new window)

构造函数，返回一个由给定参数构建的List对象。

函数 返回值
List(list) List
参数 类型 说明
list List 一个列表或者计算得到的对象
var list1 = pie.List([1,2,3,2]);
var list2 = pie.List(["apple","banana","croup"]);

# add

在列表末尾添加元素。

函数 返回值
add(value) List
参数 类型 说明
value Object 添加的元素
var list1 = pie.List([1,2,3,2]);
var list2 = pie.List(["apple","banana","croup"]);
var addLis1 = list1.add(5);
var addLis2 = list2.add("egg");
print(addLis1);
print(addLis2);

# cat

连接两个列表。

函数 返回值
cat(right) List
参数 类型 说明
right List 被连接的列表
var list1 = pie.List([1,2,3,2]);
var list2 = pie.List([2,5,3]);
var list = list1.cat(list2);
print(list);

# contains

如果列表包含元素，则返回true；否则返回false。

函数 返回值
contains(right) Bool
参数 类型 说明
right Object 元素对象
var list1 = pie.List([1,2,3,2]);
var con = list1.contains(2);
print(con);

# containsAll

不考虑顺序的情况下，如果左边列表包含右边列表中的所有元素，则返回true；否则返回false。

函数 返回值
containsAll(right) Bool
参数 类型 说明
right List 元素对象列表
var list1 = pie.List([1,2,3,4]);
var list2 = pie.List([3,2]);
var list3 = pie.List([1,2,3,4]);
var list4 = pie.List([1,2,3,2,2]);
var list5 = pie.List([1,2,5,2]);
var conAll1 = list1.containsAll(list2);    //true
var conAll2 = list1.containsAll(list3);    //true
var conAll3 = list1.containsAll(list4);    //true
var conAll4 = list1.containsAll(list5);    //false
print(conAll1);
print(conAll2);
print(conAll3);
print(conAll4);

# distinct

返回没有重复元素的列表副本。

函数 返回值
distinct() List
var list1 = pie.List([1,2,4,2]);
var list2 = pie.List(["apple","banana","croup","banana"]);
var get1 = list1.distinct();         
var get2 = list2.distinct();         
print(get1);
print(get2);

# equals

如果两个列表包含的元素及元素顺序相同，则返回true；否则返回false。

函数 返回值
equals(right) Bool
参数 类型 说明
right List 被比较的列表
var list1 = pie.List([1,2,3,2]);
var list2 = pie.List([1,2,3,2]);
var equ = list1.equals(list2);
print(equ);

# get

根据索引获取列表中的元素对象，负索引从列表的末尾开始倒数。

函数 返回值
get(index) Object
参数 类型 说明
index Int 元素在列表中的索引
var list1 = pie.List([1,2,3,2]);
var getvalue = list1.get(2);
print(getvalue);

# getNumber

返回列表中指定位置的数字，负索引从列表的末尾开始倒数。

函数 返回值
getNumber(index) Number
参数 类型 说明
index Int 元素在列表中的索引
var list1 = pie.List([1,2,3,4]);
var list2 = pie.List(["apple","banana","croup"]);
var get1 = list1.getNumber(1);         //异常 
var get2 = list2.getNumber(1);         //正常
print(get1);
print(get2);

# getString

返回列表中指定位置的字符串，负索引从列表的末尾开始倒数。

函数 返回值
getString(index) String
参数 类型 说明
index Int 元素在列表中的索引
var list1 = pie.List([1,2,3,4]);
var list2 = pie.List(["apple","banana","croup"]);
var get1 = list1.getString(1);         //异常 
var get2 = list2.getString(1);         //正常
print(get1);
print(get2);

# indexOf

返回目标元素在列表中第一次出现的位置，如果列表不包含目标元素，则返回-1。

函数 返回值
indexOf(element) Number
参数 类型 说明
element Object 元素对象
var list1 = pie.List([1,2,3,4]);
var inde1 = list1.indexOf(3);    
print(inde1);

# insert

在列表中的指定位置插入元素，负索引从列表的末尾开始倒数。

函数 返回值
insert(index,element) List
参数 类型 说明
index Int 要插入的元素在列表中的索引位置。
element Object 元素对象。
var list1 = pie.List([1,2,3,4]);
var list2 = pie.List(["apple","banana","croup"]);
var str = pie.String("egg");
var inse1 = list1.insert(1,3);   
var inse2 = list2.insert(1,"banana"); 
var inse3 = list2.insert(1,str);  
print(inse1);
print(inse2);
print(inse3);

# lastIndexOfSubList

返回列表中最后一次出现的目标列表的起始位置；如果没有出现，则返回-1。

函数 返回值
lastIndexOfSubList(target) Int
参数 类型 说明
target List 要搜索的目标列表
var list1 = pie.List([1,2,3,4,5,2,7,8,9,10,11,12,3,4,5,2,17,18,19]);
var list2 = pie.List([3,4,5]);
var lastIndex= list1.lastIndexOfSubList(list2);
print(lastIndex);

# length

获取列表中元素的数目。

函数 返回值
length() Number
var list1 = pie.List([1,2,3,2]);
var length = list1.length();
print(length);

# map

针对List中的每个元素进行循环计算。

函数 返回值
map(algorithm,dropNulls) List
参数 类型 说明
algorithm Function 参数是List的方法，需要返回List
dropNulls Boolean 是否允许返回空值
var list1 = pie.List([1,2,3,2]);
var list2 = list1.map(function (value) {
  return pie.Number(value).add(1);
});
print(list2); //[2,3,4,3]

# remove

从列表中删除第一次出现的指定元素（如果存在）。

函数 返回值
remove(element) List
参数 类型 说明
element Object 要删除的指定元素
var list1 = pie.List([1,2,3,2,5,9,7]);
var list2 = pie.List(["apple","banana","croup"]);
var remove1 = list1.remove(2);
var remove2 = list2.remove("croup");
print(remove1 );
print(remove2 );

# removeAll

从列表中删除其他列表中包含的所有元素。

函数 返回值
removeAll(element) List
参数 类型 说明
element Object 要删除的指定元素
var list1 = pie.List([1,2,3,2,5,9,7]);
var list2 = pie.List([3,2,5,9]);
var removeAll = list1.removeAll(list2);
print(removeAll );

# repeat

返回一个包含指定次数的元素值的新列表。

函数 返回值
repeat(value, count) List
参数 类型 说明
value Object 要重复的指定元素
count Int 元素重复的次数
var repeat = pie.List.repeat(3,6);
print(repeat);

# reverse

反转列表中元素的顺序。

函数 返回值
reverse() List
var list1 = pie.List([1,2,3,2]);
var list2 = pie.List(["apple","banana","croup"]);
var reverse1 = list1.reverse();
var reverse2 = list2.reverse();
print(reverse1);
print(reverse2);

# rotate

将列表的元素按指定的距离旋转。

函数 返回值
rotate(distance) List
参数 类型 说明
distance Int 指定旋转的元素长度
var list1 = pie.List([1,2,3,2,5,9,7]);
var list2 = pie.List(["apple","banana","croup"]);
var rotate1 = list1.rotate(2);
var rotate2 = list2.rotate(2);
print(rotate1);
print(rotate2);

# set

用元素替换列表中指定位置的值，负索引从列表的末尾开始倒数。

函数 返回值
set(index,element) List
参数 类型 说明
index Int 列表中的索引
element Object 元素
var list1 = pie.List([1,2,3,2,5,9,7]);
var list2 = pie.List(["apple","banana","croup"]);
var set1 = list1.set(2,10);
var set2 = list2.set(2,"banana");
print(set1);
print(set2);

# slice

返回列表的一部分，介于开始索引（含）和结束索引（互斥）之间。 开始或结束的负值从列表的末尾开始倒数。大于列表大小的值是合法的，但会被截断为列表大小。

函数 返回值
slice(start, end, step) Array
参数 类型 说明
start Int 列表待截取的起始索引
end Int 列表待截取的结束索引。默认为null，截取到列表最后
step Int 截取列表的步长。默认为null，步长为1进行截取
var list1 = pie.List([1,2,3,4,5,2,7,8,9,10,11,12,3,4,5,2,17,18,19]);
var slice1 = list1.slice(1,5);
var slice2 = list1.slice(2,18,3);   
print(slice1 );   //[2,3,4,5]
print(slice2 );   //[3,2,9,12,5,18]

# splice

从起始索引开始，从列表中删除计数元素，然后在该位置插入其他元素的内容。如果start为负，则从列表的末尾开始倒数。

函数 返回值
splice(start, end, step) Array
参数 类型 说明
start Int 要删除的起始索引
end Int 要删除元素的个数
step Int 插入的元素。默认为null，只删除元素，不插入
var list1 = pie.List([1,2,3,4,5,2,7,8,9,10,11,12,3,4,5,2,17,18,19]);
var list2 = pie.List([17,18,19]);
var splice1 = list1.splice(3,3,list2);
var splice2 = list1.splice(3,3);
print(splice1);    //[1,2,3,17,18,19,7,8,9,10,11,12,3,4,5,2,17,18,19]
print(splice2);     //[1,2,3,7,8,9,10,11,12,3,4,5,2,17,18,19]

# swap

交换指定位置元素，负索引从列表的末尾开始倒数。

函数 返回值
swap(pos1,pos2) List
参数 类型 说明
pos1 Int 列表中指定的索引1
pos2 Int 列表中指定的索引2
var list1 = pie.List([1,2,3,2,5,9,7]);
var list2 = pie.List(["apple","banana","croup"]);
var swap1 = list1.swap(2,5);
var swap2 = list2.swap(1,2);
print(swap1 );
print(swap2);

# zip

将两个列表的元素配对以创建两个元素的列表。当输入列表的长度不同时，最终列表的长度与最短列表的长度相同。

函数 返回值
zip(other) List
参数 类型 说明
other List 第二个列表
var list1 = pie.List([1,2,3,2,5,9,7]);
var list2 = pie.List([3,2,5,9]);
var zip = list1.zip(list2);
print(zip);
有问题，我来改改 (opens new window)
上次更新: 2022/05/15, 05:29:22
Kernel
Map

← Map→

最近更新
01
太湖水体浑浊度计算
05-25
02
太湖水域蓝藻密度分析
05-25
03
北京城市建设用地情况分析
05-25
更多文章>
Theme by Vdoing | Copyright © 2021-2022 蜀ICP备2021024989号-3