语法
- float/bool/string array[index]
- float/bool/string array[rowIndex, colIndex]
- float[]/bool[]/string[] array[indices]
- float[]/bool[]/string[] array[rowIndex, colIndices]
- float[]/bool[]/string[] array[rowIndices, colIndex]
- float[]/bool[]/string[] array[rowIndices, colIndices]
参数
- array -（float []、string[]、bool[]）请求一个或多个元素的数组。
- index, rowIndex, colIndex - float数组元素从 0 开始的线性/行/列 array。
- indices, rowIndices, colIndices -（float[]、bool[]）包含 array 元素从 0 开始的线性/行/列索引的数组，或表示是否包含特定索引的逻辑值。
返回
新数组的数组元素。
描述
使用索引值进行索引
索引运算符会返回从 0 开始的特定 index 位置处的数组元素：
array = [1,2,3,4]
array[ 0 ] 1
array[ 3 ] 4或位于特定 rowIndex（行索引）和 colIndex（列索引）处的元素：
array2d = [1,2,3;
4,5,6;
7,8,9]
array2d[ 1 , 1 ] 5使用索引数组进行索引
此外，可通过数组 (indices, rowIndices, colIndices) 索引数组元素。 在此情况下，索引运算符会返回新数组。 其维度通过索引数组的维度进行规定。
array[ [0,2] ] [1,3]
array[ [1,1] ] [2,2]
array[ 3:-1:1 ] [4,3,2]
array[ [0,1; [1,2;
2,3] ] 3,4]
array2d[ 1 , [0,2] ] [4,6]
array2d[ [0,0,1] , 2 ] [3;
3;
6]
array2d[ 0:2 , [0,2] ] [1,3;
4,6;
7,9]逻辑索引
也可以通过逻辑值提供索引数组 (indices, rowIndices, colIndices)，这些逻辑值表示是否包括特定索引：
array[ [true,false,true] ] [1,3]
array[ array .> 2 ] [3,4]
array[ array .> 1 .&& array .<= 3 ] [2,3]
array2d[ [false,true,true], 0 ] [4;
7]无效索引
如果索引为负数，或者大于等于元素数、行数或列数，将返回默认值。 对于浮点型数组，默认值为 0；对于布尔数组，默认值为 false；对于字符串数组，默认值为 ""。
array[ -1 ] 0
array[ [false,false,true,true,true] ] [3,4,0]
array2d[ [2,3], -1:1 ] [0,7,8;
0,0,0]线性索引
如果 2d array 在 1d 中进行索引，将使用线性索引。 索引将对行执行，从第一行中的元素开始，并继续对后续行执行。
array2d[ 3 ] 4
array2d[ 0 : size(array2d)-1 ] [0,1,2,3,4,5,6,7,8,9]
array2d[ [0; [1;
3; 4;
6] ] 7]同样，如果 2d 索引数组用于行/列索引，将以行的方式解释 rowIndices 或 colIndices 中的索引。
array2d[ 0 , [0,1; [1,2,3,0]
2,3] ]逻辑索引始终为线性。
array[ [true,false; [1,3]
true,false] ]相关内容
示例
递归元素选择
借助 size 函数和索引运算符，可以递归的方式针对特定元素值解析数组。 在本示例中，最长边的索引将从边长度数组中检索。
indexOfLargest(array) = indexOfLargest(array, 0, 0)
indexOfLargest(array, i, iLargest) =
case i == size(array) : iLargest
else :
case array[i] > array[iLargest] : indexOfLargest(array, i+1, i)
else : indexOfLargest(array, i+1, iLargest)
const edgeLengths = comp(e) { all : scope.sx }
indexOfLongestEdge = indexOfLargest(edgeLengths)
Lot --> comp(e) { indexOfLongestEdge : LongestEdge. }解析文本文件
将解析包含表的文本文件并以线性的方式索引元素。
// table
// a;b;c↵
// d;e;f↵
// g;h;i
const file = readTextFile("table.txt")
const cells = splitString(file, "$;|\n") // [a,b,c,d,e,f,g,h,i]
const columns = 3
const indexes = [0 : columns : size(cells)-1] // [0:3:6]
const firstCol = cells[indexes] // [a,d,g]读取 CSV 表
将读取 CSV 文件并使用 2d 索引运算符索引元素。
const table = readStringTable("table.csv")
const firstCol = table[0 : nRows(table)-1, 0] // [a,d,g]使用 2d 数组进行索引
1d 索引运算符的结果是一个数组，具有与 indices 数组相同的维度。
const a = ["_", "d", "i", "a", "g"]
const b = [1,0,0,0;
0,2,0,0;
0,0,3,0;
0,0,0,4]
const c = a[b]
// (4x4)
// d _ _ _
// _ i _ _
// _ _ a _
// _ _ _ g索引超出范围
空 floatArray 通过索引序列进行索引。 这将创建使用默认值（对于浮点型，为零）填充的新数组。
zeros(elems) = floatArray[1:elems]
ones(rows,cols) = floatArray[1:rows,1:cols] .+ 1
const a = zeros(4) // [0,0,0,0]
const b = ones(2,3) // [1,1,1 ; 1,1,1]素数
爱拉托逊斯筛选法实施，使用通过布尔数组进行索引。
findPrimes(max) =
case max <= 1 : floatArray
else : findPrimes(sqrt(max), [2 : max], floatArray)
findPrimes(limit, a, primes) =
case a[0] <= limit : findPrimes(limit, a[a .% a[0] .!= 0], [primes, a[0]])
else : [primes, a]
Lot --> print(findPrimes(20)) // (8)[2,3,5,7,11,13,17,19]