Array

Home of the ABS programming language: the joy of shell scripting.


Array

Arrays represent a list of elements of any other type:

[1, 2, "hello", [1, f(x){ x + 1 }]]

They can be looped over:

for x in [1, 2] {
    echo(x)
}

You can access elements of the array with the index notation:

array[3]

Accessing an index that does not exist returns null.

To concatenate arrays, “sum” them:

[1, 2] + [3] # [1, 2, 3]

This is also the suggested way to push a new element into an array:

x = [1, 2]
x += [3]
x # [1, 2, 3]

In a similar way, we can make a shallow copy of an array using the + operator with an empty array. Be careful, the empty array must be on the left side of the + operator.

a = [1, 2, 3]
a   # [1, 2, 3]

# shallow copy an array using the + operator with an empty array
# note well that the empty array must be on the left side of the +
b = [] + a
b   # [1, 2, 3]

# modify the shallow copy without changing the original
b[0] = 99
b   # [99, 2, 3]
a   # [1, 2, 3]

It is also possible to modify an existing array element using array[index] assignment. This also works with compound operators such as += :

a = [1, 2, 3, 4]
a # [1, 2, 3, 4]

# index assignment
a[0] = 99
a # [99, 2, 3, 4]

# compound assignment
a[0] += 1
a # [100, 2, 3, 4]

An array can also be extended by using an index beyond the end of the existing array. Note that intervening array elements will be set to null. This means that they can be set to another value later:

a = [1, 2, 3, 4]
a # [1, 2, 3, 4]

# indexes beyond end of array expand the array
a[4] = 99
a # [1, 2, 3, 4, 99]
a[6] = 66
a # [1, 2, 3, 4, 99, null, 66]

# assign to a null element
a[5] = 55
a # [1, 2, 3, 4, 99, 55, 66]

An array is defined as “homogeneous” when all its elements are of a single type:

[1, 2, 3] # homogeneous
[null, 0, "", {}] # heterogeneous

This is important as some functions are only supported on homogeneous arrays: sum(), for example, can only be called on homogeneous arrays of numbers.

Supported functions

contains(e)

This function is deprecated and might be removed in future versions.

Use the “in” operator instead: 3 in [1, 2, 3]

Checks whether e is present in the array. e can only be a string or number and the array needs to be a homogeneous array of strings or numbers:

[1, 2, 3].contains(3) # true
[1, 2, 3].contains(4) # false

every(f)

Returns true when all elements in the array return true when applied to the function f:

[0, 1, 2].every(f(x){type(x) == "NUMBER"}) # true
[0, 1, 2].every(f(x){x == 0}) # false

filter(f)

Returns a new array with only the elements that returned true when applied to the function f:

["hello", 0, 1, 2].filter(f(x){type(x) == "NUMBER"}) # [0, 1, 2]

find(f)

Returns the first element that returns true when applied to the function f:

["hello", 0, 1, 2].find(f(x){type(x) == "NUMBER"}) # 0

len()

Returns the length of the array:

[1, 2].len() # 2

join(separator)

Joins the elements of the array by separator:

[1, 2, 3].join("_") # "1_2_3"

keys()

Returns an array of the keys in the original array:

(1..2).keys() # [0, 1]

map(f)

Modifies the array by applying the function f to all its elements:

[0, 1, 2].map(f(x){x+1}) # [1, 2, 3]

pop()

Pops the last element from the array, returning it:

a = [1, 2, 3]
a.shift() # 3
a # [1, 2]

push()

Pushes an element at the end of the array:

[1, 2].push(3) # [1, 2, 3]

This is equivalent to summing 2 arrays:

[1, 2] + [3] # [1, 2, 3]

reverse()

Reverses the order of the elements in the array:

[1, 2].reverse() # [2, 1]

shift(start, end)

Removes the first elements from the array, and returns it:

a = [1, 2, 3]
a.shift() # 1
a # [2, 3]

slice(start, end)

Returns a portion of the array, from start to end:

(1..10).slice(0, 3) # [1, 2, 3]"

If start is negative, it slices from the end of the string, back as many characters as the value of start:

(1..10).slice(-3, 0) # [8, 9, 10]"

some(f)

Returns true when at least one of the elements in the array returns true when applied to the function f:

[0, 1, 2].map(f(x){x == 1}) # true
[0, 1, 2].map(f(x){x == 4}) # false

sort()

Sorts the array. Only supported on arrays of only numbers or only strings:

[3, 1, 2].sort() # [1, 2, 3]
["b", "a", "c"].sort() # ["a", "b", "c"]

str()

Returns the string representation of the array:

[1, 2].str() # "[1, 2]"

sum()

Sums the elements of the array. Only supported on arrays of numbers:

[1, 1, 1].sum() # 3

unique()

Returns an array with unique values:

[1, 1, 1, 2].unique() # [1, 2]

Next

That’s about it for this section!

You can now head over to read about hashes.