Basic operators

Array operators

Operators used to perform array operations.

$arrayElemAt

Returns the element at the specified index in an array.

{ "$arrayElemAt": ["array", "idx"] }

expry({ $arrayElemAt: [[1, 2, 3], 0] }); // 1
expry({ $arrayElemAt: [[1, 2, 3], 1] }); // 2
expry({ $arrayElemAt: [[1, 2, 3], 3] }); // undefined

$arrayToObject

Converts an array of two-element arrays into an object.

{ "$arrayToObject": "array" }

expry({
  $arrayToObject: [
    ["a", 1],
    ["b", 2],
  ],
}); // { a: 1, b: 2 }
expry({
  $arrayToObject: [
    ["name", "John"],
    ["age", 30],
  ],
}); // { name: "John", age: 30 }
expry({
  $arrayToObject: [
    ["a", 1],
    ["b", 2],
    ["a", 3],
  ],
}); // { a: 3, b: 2 }

$concatArrays

Returns the concatenation of arrays.

{ "$concatArrays": ["array", "array", "..."] }

expry({
  $concatArrays: [
    [1, 2],
    [3, 4],
  ],
}); // [1, 2, 3, 4]
expry({
  $concatArrays: [["hello", " "], ["world"]],
}); // ["hello", " ", "world"]
expry({
  $concatArrays: [["hello", " "], [["world"]]],
}); // ["hello", " ", ["world"]]

$every

Returns true if all elements in an array satisfy the specified condition.

{ "$every": { "input": "array", "as": "string", "cond": "expression" } }

expry({ $every: { input: [1, 2, 3], as: "num", cond: { $gt: ["$$num", 0] } } }); // true
expry({ $every: { input: [1, 2, 3], as: "num", cond: { $gt: ["$$num", 1] } } }); // false

$filter

Returns a subset of an array based on the specified condition.

{ "$filter": { "input": "array", "cond": "boolean", "as": "string" } }

expry({
  $filter: { input: [1, 2, 3, 4], as: "num", cond: { $gt: ["$$num", 2] } },
}); // [3, 4]

$find

Returns the first element in an array that satisfies the specified condition.

{ "$find": { "input": "array", "as": "num", "cond": "expression" } }

expry({ $find: { input: [1, 2, 3], as: "num", cond: { $gt: ["$$num", 1] } } }); // 2
expry({ $find: { input: [1, 2, 3], as: "num", cond: { $gt: ["$$num", 3] } } }); // undefined

$findIndex

Returns the index of the first element in an array that satisfies the specified condition.

{ "$findIndex": { "input": "array", "as": "string", "cond": "expression" } }

expry({
  $findIndex: { input: [1, 2, 3], as: "num", cond: { $gt: ["$$num", 1] } },
}); // 1
expry({
  $findIndex: { input: [1, 2, 3], as: "num", cond: { $gt: ["$$num", 3] } },
}); // -1

$first

Returns the first element of an array.

{ "$first": "array" }

expry({ $first: [1, 2, 3] }); // 1
expry({ $first: ["a,", "b", "c"] }); // "a"
expry({ $first: [] }); // undefined

$firstN

Returns the first N elements of an array.

{ "$firstN": { "n": "number", "input": "array" } }

expry({ $firstN: { n: 2, input: [1, 2, 3] } }); // [1, 2]
expry({ $firstN: { n: 3, input: [1, 2] } }); // [1, 2]
expry({ $firstN: { n: -1, input: [1, 2] } }); // []

$in

Returns a boolean indicating whether a value is in an array.

{ "$in": ["any", "array"] }

expry({ $in: [2, [1, 2, 3]] }); // true
expry({ $in: [4, [1, 2, 3]] }); // false
expry({ $in: ["world", ["hello", "world"]] }); // true

$indexOfArray

Returns the index of the first occurrence of a specified value in an array.

{ "$indexOfArray": ["array", "any"] }

expry({ $indexOfArray: [["a", "abc"], "a"] }); // 0
expry({ $indexOfArray: [[1, 2], 5] }); // -1

$last

Returns the last element of an array.

{ "$last": "array" }

expry({ $last: [1, 2, 3] }); // 3
expry({ $last: ["a,", "b", "c"] }); // "c"
expry({ $last: [] }); // undefined

$lastN

Returns the last N elements of an array.

{ "$lastN": { "n": "number", "input": "array" } }

expry({ $lastN: { n: 2, input: [1, 2, 3] } }); // [2, 3]
expry({ $lastN: { n: 3, input: [1, 2] } }); // [1, 2]
expry({ $lastN: { n: -1, input: [1, 2] } }); // []

$length

Returns the number of elements in an array.

{ "$length": "array" }

expry({ $length: [1, 2, 3] }); // 3
expry({ $length: ["a", "b", "c", "d"] }); // 4
expry({ $length: [] }); // 0

$map

Applies an expression to each element in an array.

{ "$map": { "input": "array", "as": "string", "in": "expression" } }

expry({ $map: { input: [1, 2, 3], as: "num", in: { $add: ["$$num", 1] } } }); // [2, 3, 4]
expry({ $map: { input: ["a", "b"], as: "str", in: { $toUpper: "$$str" } } }); // ["A", "B"]

$max

Returns the largest value in an array.

{ "$max": "array" }

expry({ $max: [3, 7, 2, 4] }); // 7
expry({ $max: ["a", "c", "b"] }); // "c"
expry({ $max: [] }); // undefined

$maxN

Returns the N largest values in an array.

{ "$maxN": { "n": "number", "input": "array" } }

expry({ $maxN: { n: 2, input: [3, 7, 2, 4] } }); // [7, 4]
expry({ $maxN: { n: 3, input: [3, 7, 2, 4] } }); // [7, 4, 3]
expry({ $maxN: { n: 5, input: [3, 7, 2, 4] } }); // [7, 4, 3, 2]

$min

Returns the smallest value in an array.

{ "$min": "array" }

expry({ $min: [3, 7, 2, 4] }); // 2
expry({ $min: ["a", "c", "b"] }); // "a"
expry({ $min: [] }); // undefined

$minN

Returns the N smallest values in an array.

{ "$minN": { "n": "number", "input": "array" } }

expry({ $minN: { n: 2, input: [3, 7, 2, 4] } }); // [2, 3]
expry({ $minN: { n: 3, input: [3, 7, 2, 4] } }); // [2, 3, 4]
expry({ $minN: { n: 5, input: [3, 7, 2, 4] } }); // [2, 3, 4, 7]

$objectToArray

Converts an object to an array of key-value pairs.

{ "$objectToArray": "object" }

expry({ $objectToArray: { a: 1, b: 2 } }); // [["a", 1], ["b", 2]]
expry({ $objectToArray: { name: "John", age: 30 } }); // [["name", "John"], ["age", 30]]

$pop

Removes the last element from an array and returns the array.

{ "$pop": "array" }

expry({ $pop: [1, 2, 3] }); // [1, 2]
expry({ $pop: ["a", "b", "c"] }); // ["a", "b"]
expry({ $pop: [] }); // []

$push

Adds an element to the end of an array and returns the array.

{ "$push": ["array", "any"] }

expry({ $push: [[1, 2], 3] }); // [1, 2, 3]
expry({ $push: [["a", "b"], "c"] }); // ["a", "b", "c"]
expry({ $push: [[], "a"] }); // ["a"]

$reduce

Applies an expression to each element in an array and combines them into a single value.

{ "$reduce": { "input": "array", "initialValue": "any", "in": "expression" } }

expry({
  $reduce: {
    input: ["a", "b", "c"],
    initialValue: "",
    in: { $concat: ["$$value", "$$this"] },
  },
}); // abc
expry({
  $reduce: {
    input: [1, 2, 3],
    initialValue: 0,
    in: { $add: ["$$value", "$$this"] },
  },
}); // 6

$reverseArray

Reverses the elements of an array.

{ "$reverseArray": "array" }

expry({ $reverseArray: [4, 2, 3] }); // [3, 2, 4]
expry({ $reverseArray: ["a", "c", "b"] }); // ["b", "c", "a"]

$shift

Removes the first element from an array and returns the array.

{ "$shift": "array" }

expry({ $shift: [1, 2, 3] }); // [2, 3]
expry({ $shift: ["a", "b", "c"] }); // ["b", "c"]
expry({ $shift: [] }); // []

$slice

Returns a subset of an array.

{ "$slice": ["array", "start", "end"] }

expry({ $slice: [[1, 2, 3], 1, 2] }); // [2]
expry({ $slice: [[1, 2, 3], 1, 3] }); // [2, 3]
expry({ $slice: [[1, 2, 3], 1, 0] }); // []
expry({ $slice: [[1, 2, 3], 0, -1] }); // [1, 2]

$some

Returns true if at least one element in an array satisfies the specified condition.

{ "$some": { "input": "array", "as": "string", "cond": "expression" } }

expry({ $some: { input: [1, 2, 3], as: "num", cond: { $gt: ["$$num", 2] } } }); // true
expry({ $some: { input: [1, 2, 3], as: "num", cond: { $gt: ["$$num", 3] } } }); // false

$sortArray

Sorts the elements of an array.

{ "$sortArray": { "input": "array", "sortBy": "expression" } }

expry({
  $sortArray: { input: [3, 4, 2], sortBy: { $cmp: ["$$first", "$$second"] } },
}); // [2, 3, 4]
expry({
  $sortArray: { input: [3, 4, 2], sortBy: { $cmp: ["$$second", "$$first"] } },
}); // [4, 3, 2]

$splice

Removes elements from an array and inserts new elements in their place.

{
  "$splice": {
    "input": "array",
    "start": "number",
    "deleteCount": "number",
    "items": "array"
  }
}

expry({
  $splice: {
    input: [1, 2, 3],
    start: 1,
    deleteCount: 1,
    items: [4, 5],
  },
}); // [1, 4, 5, 3]
expry({
  $splice: {
    input: ["a", "b", "c"],
    start: 1,
    deleteCount: 2,
    items: ["x", "y", "z"],
  },
}); // ["a", "x", "y", "z"]

$unshift

Adds an element to the beginning of an array and returns the array.

{ "$unshift": ["array", "any"] }

expry({ $unshift: [[1, 2], 3] }); // [3, 1, 2]
expry({ $unshift: [["a", "b"], "c"] }); // ["c", "a", "b"]
expry({ $unshift: [[], "a"] }); // ["a"]
Arithmetic
Boolean