Array methods

.length()

Return the number of elements contained in the target array.

array.length() => Integer

// example
do val = ["Batman", "Robin", "Superman"]
do val.length() // 3

.push(*)

Add an element at the end of an array.

array.push(val) => void

// example
do val = ["Batman", "Superman"]
do val.push("Robin") // ["Batman", "Superman", "Robin"]

.pop()

Remove the last element of an array.

array.pop() => void

// example
do val = ["Batman", "Robin", "Superman"]
do val.pop() // ["Batman", "Robin"]

.reverse()

Create a new Array with all elements reversed

do vec = [3, 2, 1]

do new_vec = vec.reverse()
say new_vec.to_string() // [1, 2, 3]

.append()

Add the elements of the array to the initial array

 do vec = [1, 2, 3]
 do vec2 = [4, 5, 6]

 do append_vec = vec.append(vec2)
 say append_vec.to_string() // [1, 2, 3, 4, 5, 6]

.insert_at(Integer, *)

Add an element at position n of an array (shifting the position of all the following elements).

array.insert_at(n, val) => void

// example
do val = ["Batman", "Superman"]
do val.insert_at(1, "Robin") // ["Batman", "Robin", "Superman"]

.remove_at(Integer)

Remove the nth element of an array (unshifting the position of all the following elements).

array.remove_at(n) => void

// example
do val = ["Batman", "Robin", "Superman"]
do val.remove_at(1) // ["Batman", "Superman"]

.find(*)

Returns a new array with all the values found in the original array matching the given value.

array.find(x) => Array

// example
do val = ["Batman", "Robin", "Superman", "Batman"]
do val.find("Ironman") // []
do val.find("Robin") // ["Robin"]
do val.find("Batman") // ["Batman", "Batman"]

You can find more info about the particular regex syntax used in the *_regex methods on this link.

.to_uppercase()

Return the same string in all uppercase characters.

string.to_uppercase() => String

// example
do val = "Where is Brian?"
do val.to_uppercase() // "WHERE IS BRIAN?"

.to_lowercase()

Return the same string in all lowercase characters.

string.to_lowercase() => String

// example
do val = "Where is Brian?"
do val.to_lowercase() // "where is brian?"

.length()

Return the length of the target string.

string.length() => Integer

// example
do val = "Where is Brian?"
do val.length() // 15

.contains(String), .contains_regex(String)

Return whether the string contains another string or expression.

haystack.contains(needle) => Boolean
haystack.contains_regex(needle) => Boolean

// example
do val = "Where is Brian?"
// does it contain any "r"?
do val.contains("r") // true
// does it contain the word "where"?
do val.contains("where") // false => no, because it is case sensitive
// does it contain any number?
do val.contains_regex("[0-9]") // true

.starts_with(String), .starts_with_regex(String)

Return whether a string starts with another string or expression.

haystack.starts_with(needle) => Boolean
haystack.starts_with_regex(needle) => Boolean

// example
do val = "Where is Brian?"
// does it start with "r"?
do val.starts_with("r") // false
// does it start with any uppercase letter?
do val.starts_with_regex("[A-Z]") // true

.ends_with(String), .ends_with_regex(String)

Return whether a string ends with another string or expression.

haystack.ends_with(needle) => Boolean
haystack.ends_with_regex(needle) => Boolean

// example
do val = "Where is Brian?"
// does it end with "r"?
do val.ends_with("r") // false
// does it end with any uppercase letter?
do val.ends_with_regex("[A-Z]") // false

.match(String), .match_regex(String)

Return all the matches of the string or expression in the target string, or Null if none are found.

haystack.match(needle) => Array[String]
haystack.match_regex(needle) => Array[String]

// example
do val = "Where is Brian?"
// does it match with "r"?
do val.match("r") // ["r", "r"] => yes, twice!
// does it match with any uppercase letter?
do val.match_regex("[A-Z]") // ["W", "B"] => yes, and these are the letters!

About _regex methods:

The \ (backslash) character has a special meaning. For technical reasons, in all strings, it must be properly escaped, by convention by adding another \ in front of itself, to avoid being interpreted as a special character. For example, if you mean to write the exact string "\n" you must in fact write \\n, otherwise \n will be interpreted as a line break.

This Python documentation explains why it especially matters in Regex syntax to escape backslashes: https://docs.python.org/2/howto/regex.html#the-backslash-plague

We follow this nomenclature for CSML Regex handling, so a single Regex backslash must be written as a "\\" string, and an escaped backslash (that behaves as a literal "\" string character) must in fact be escaped twice, once for being in a string, and once for being in a Regex: you have to write "\\\\" to result in the Regex syntax \\which in turn matches the literal "\" string.

In a future release of CSML we might introduce a "raw string" method to bypass this limitation.

.init(size)

Create a new array of size n

do arr = [].init(3) // [null, null, null]

.slice(start, end)

Return a new array with all items between start and end. Some rules apply:

• If end is not specified, all the items after start are returned.

• When specified, end must be ≥ start.

• If any of the parameters is < 0, the count is made from the end of the array.

do x = ["a", "b", "c", "d", "e"].slice(2, 4)
say "{{x}}" // c, d

do x = ["a", "b", "c", "d", "e"].slice(2)
say "{{x}}" // c, d, e

do x = ["a", "b", "c", "d", "e"].slice(-4)
say "{{x}}" // b, c, d, e

do x = ["a", "b", "c", "d", "e"].slice(-4, 3)
say "{{x}}" // b, c

do x = ["a", "b", "c", "d", "e"].slice(-2, 1)
say "{{x}}" // Error

do x = ["a", "b", "c", "d", "e"].slice(2, 1)
say "{{x}}" // Error

.map(fn), .filter(fn), .reduce(acc, fn)

These methods are useful ways to construct a new arrays from existing arrays. They are inspired from similar methods in other languages and follow the same general syntax.

Here are some examples of what these methods can help you achieve:

// create a new array where each original item is multiplied by 2
do newArray = [1, 2, 3, 4].map((item, index) {
  return x * 2
}) // newArray = [2, 4, 6, 8]

// create a new array containing even numbers from the original array
do newArray = [1, 2, 3, 4].filter((item, index) {
  return x % 2 == 0
}) // newArray = [2, 4]

// create a new value by adding all the elements together
do sum = [1, 2, 3, 4].reduce(0, (acc, val, index) {
  do acc = acc + val
  return acc
}) // sum = 1 + 2 + 3 + 4 = 10

.flatten()

Convert an array of arrays to an array containing all elements of the 1st level arrays.

do [[1, 2], [3, 4]].flatten() // [1, 2, 3, 4]

// if a 1st-level element is not an array, it will be kept as is
do [[1, 2], "something", [3, 4]].flatten() // [1, 2, "something", 3, 4]