Tutorial

JMESPath is a query language for JSON. You can extract and transform elements from a JSON document. The examples below are interactive. You can change the JMESPath expressions and see the results update automatically.

For each of these examples, the JMESPath expression is applied to the input JSON on the left, and the result of evaluating the JMESPath expression is shown in the JSON document on the right-hand side.

Basic Expressions

The simplest JMESPath expression is an identifier, which selects a key in an JSON object:

Try changing the expression above to b, and c and note the updated result. Also note that if you refer to a key that does not exist, a value of null (or the language equivalent of null) is returned.

You can use a subexpression to return to nested values in a JSON object:

If you refer to a key that does not exist, a value of null is returned. Attempting to subsequently access identifiers will continue to return a value of null. Try changing the expression to b.c.d.e above.

Index Expressions allow you to select a specific element in a list. It should look similar to array access in common programming languages. Indexing is 0 based.

If you specify an index that’s larger than the list, a value of null is returned. You can also use negative indexing to index from the end of the list. [-1] refers to the last element in the list, [-2] refers to the penultimate element. Try it out in the example above.

You can combine identifiers, sub expressions, and index expressions to access JSON elements.

Slicing

Slices allow you to select a contiguous subset of an array. If you’ve ever used slicing in python, then you already know how to use JMESPath slices. In its simplest form, you can specify the starting index and the ending index. The ending index is the first index which you do not want included in the slice. Let’s take a look at some examples. First, given an array of integers from 0 to 9, let’s select the first half of the array:

This slice result contains the elements 0, 1, 2, 3, and 4. The element at index 5 is not included. If we want to select the second half of the array, we can use this expression:

The two example above can be shortened. If the start or stop value is omitted it is assumed to be the start or the end of the array. For example:

Try modifying the example above to only include the last half of the array elements without specifying the end value of 10.

The general form of a slice is [start:stop:step]. So far we’ve looked at the [start:stop] form. By default, the step value is 1, which means to include every element in the range specified by the start and stop value. However, we can use the step value to skip over elements. For example, to select only the even elements from the array.

Also note in this example we’re omitting the start as well as the stop value, which means to use 0 for the start value, and 10 for the stop value. In this example, the expression [::2] is equivalent to [0:10:2].

The last thing to know about slices is that just like indexing a single value, all the values can be negative. If the step value is negative, then the slice is created in reverse order. For example:

The above expression creates a slice but in reverse order.

If you want all the details about how slices work, check out the slices in the specification.

Projections

Projections are one of the key features of JMESPath. It allows you to apply an expression to a collection of elements. There are five kinds of projections:

• List Projections
• Slice Projections
• Object Projections
• Flatten Projections
• Filter Projections

List and Slice Projections

A wildcard expression creates a list projection, which is a projection over a JSON array. This is best illustrated with an example. Let’s say we have a JSON document describing a people, and each array element is a JSON object that has a first, last, and age key. Suppose we wanted a list of all the first names in our list.

In the example above, the first expression, which is just an identifier, is applied to each element in the people array. The results are collected into a JSON array and returned as the result of the expression. The expression can be more complex than a basic identifier. For example, the expression foo[*].bar.baz[0] would project the bar.baz[0] expression to each element in the foo array.

There’s a few things to keep in mind when working with projections. These are discussed in more detail in the [wildcards] section of the spec, but the main points are:

• Projections are evaluated as two steps. The left-hand side (LHS) creates a JSON array of initial values. The right-hand side (RHS) of a projection is the expression to project for each element in the JSON array created by the left-hand side. Each projection type has slightly different semantics when evaluating either the left-hand side and/or the right-hand side.
• If the result of the expression projected onto an individual array element is null, then that value is omitted from the collected set of results.
• You can stop a projection with a Pipe Expression (discussed later).
• A list projection is only valid for a JSON array. If the value is not a list, then the result of the expression is null.

You can try this out in the demo above. Notice how people[*].first only included three elements, even though the people array has four elements. This is because the last element, {"missing": "different"} evaluates to null when the expression first is applied, and null values are not added to the collected result array. If you try the expression foo[*].bar you’ll see a result of null, because the value associated with the foo key is a JSON object, not an array, and a list projection is only defined for JSON arrays.

Slice projections are almost identical to a list projection, with the exception that the left-hand side is the result of evaluating the slice, which may not include all the elements in the original list:

Object Projections

Whereas a list projection is defined for a JSON array, an object projection is defined for a JSON object. You can create an object projection using the * syntax. This will create a list of the values of the JSON object, and project the right-hand side of the projection onto the list of values.

In the example above the * creates a JSON array of the values associated with the ops JSON object. The RHS of the projection, numArgs, is then applied to the JSON array, resulting in the final array of [2, 3]. Below is a sample walk-through of how an implementation could potentially implement evaluating an object projection. First, the object projection can be broken down into its two components, the left-hand side (LHS) and its right-hand side (RHS):

• LHS: ops
• RHS: numArgs

First, the LHS is evaluated to create the initial array to be projected:

evaluate(ops, inputData) -> [{"numArgs": 2}, {"numArgs": 3},
                             {"variadic": True}]

Then the RHS is applied to each element in the array:

evaluate(numArgs, {numArgs: 2}) -> 2
evaluate(numArgs, {numArgs: 3}) -> 3
evaluate(numArgs, {variadic: true}) -> null

Any null values are not included in the final result, so the result of the entire expression is therefore [2, 3].

Flatten Projections

More than one projection can be used in a JMESPath expression. In the case of a List/Object projection, the structure of the original document is preserved when creating projection within a projection. For example, let’s take the expression reservations[*].instances[*].state. This expression is saying that the top level key reservations has an array as a value. For each of those array elements, project the instances[*].state expression. Within each list element, there’s an instances key which itself is a value, and we create a sub projection for each each list element in the list. Here’s an example of that:

The result of this expression is [["running", "stopped"], ["terminated", "running"]], which is a list of lists. The outer list is from the projection of reservations[*], and the inner list is a projection of state created from instances[*]:

1st       r0                         r1
2nd i0          i1             i0            i1
[["running", "stopped"], ["terminated", "running"]]

What if we just want a list of all the states of our instances? We’d ideally like a result ["running", "stopped", "terminated", "running"]. In this situation, we don’t care which reservation the instance belonged to, we just want a list of states.

This is the problem that a Flatten Projection solves. To get the desired result, you can use [] instead of [*] to flatten a list: reservations[].instances[].state. Try changing [*] to [] in the expression above and see how the result changes.

While the flatten spec goes into more detail, a simple rule of thumb to use for the flatten operator, [], is that:

• It flattens sublists into the parent list (not recursively, just one level).
• It creates a projection, so anything on the RHS of the flatten projection is projected onto the newly created flattened list.

You can also just use [] on its own to flatten a list:

If you flattened the result of the expression again, [][], you’d then get a result of [0, 1, 2, 3, 4, 5, 6, 7]. Try it out in the example above.

Filter Projections

Up to this point we’ve looked at:

• List/Slice projections
• Object projections
• Flatten projections

Evaluating the RHS of a projection is a basic type of filter. If the result of the expression evaluated against an individual element results in null, then the element is excluded from the final result.

A filter projection allows you to filter the LHS of the projection before evaluating the RHS of a projection.

For example, let’s say we have a list of machines, each has a name and a state. We’d like the name of all machines that are running. In pseudocode, this would be:

result = []
foreach machine in inputData['machines']
  if machine['state'] == 'running'
    result.insert_at_end(machine['name'])
return result

A filter projection can be used to accomplish this:

Try changing running to stopped in the example above. You can also remove the .name at the end of the expression if you just want the entire JSON object of each machine that has the specified state.

A filter expression is defined for an array and has the general form LHS [? <expression> <comparator> <expression>] RHS. The filter expression <filterexpressions>{.interpreted-text role=“ref”} spec details exactly what comparators are available and how they work, but the standard comparators are supported, i.e ==, !=, <, <=, >, >=.

Pipe Expressions

Projections are an important concept in JMESPath. However, there are times when projection semantics are not what you want. A common scenario is when you want to operate of the result of a projection rather than projecting an expression onto each element in the array. For example, the expression people[*].first will give you an array containing the first names of everyone in the people array. What if you wanted the first element in that list? If you tried people[*].first[0] that you just evaluate first[0] for each element in the people array, and because indexing is not defined for strings, the final result would be an empty array, []. To accomplish the desired result, you can use a pipe expression, <expression> | <expression>, to indicate that a projection must stop. This is shown in the example below:

In the example above, the RHS of the list projection is first. When a pipe is encountered, the result up to that point is passed to the RHS of the pipe expression. The pipe expression is evaluated as:

evaluate(people[*].first, inputData) -> ["James", "Jacob", "Jayden"]
evaluate([0], ["James", "Jacob", "Jayden"]) -> "James"

MultiSelect

Up to this point, we’ve looked at JMESPath expressions that help to pare down a JSON document into just the elements you’re interested in. This next concept, multiselect lists and multiselect hashes allow you to create JSON elements. This allows you to create elements that don’t exist in a JSON document. A multiselect list creates a list and a multiselect hash creates a JSON object.

This is an example of a multiselect list:

In the expression above, the [name, state.name] portion is a multiselect list. It says to create a list of two element, the first element is the result of evaluating the name expression against the list element, and the second element is the result of evaluating state.name. Each list element will therefore create a two element list, and the final result of the entire expression is a list of two element lists.

Unlike a projection, the result of the expression in always included, even if the result is a null. If you change the above expression to people[].[foo, bar] each two element list will be [null, null].

A multiselect hash has the same basic idea as a multiselect list, except it instead creates a hash instead of an array. Using the same example above, if we instead wanted to create a two element hash that had two keys, Name and State, we could use this:

Functions

JMESPath supports function expressions, for example:

Functions can be used to transform and filter data in powerful ways.

Below are a few examples of functions.

This example prints the name of the oldest person in the people array:

Functions can also be combined with filter expressions. In the example below, the JMESPath expressions finds all elements in myarray that contains the string foo.

The @ character in the example above refers to the current element being evaluated in myarray. The expression contains(@, `foo`) will return true if the current element in the myarray array contains the string foo.

While the function expression spec has all the details, there are a few things to keep in mind when working with functions:

• Function arguments have types. If an argument for a function has the wrong type, an invalid-type error will occur. There are functions that can do type conversions (to_string, to_number) to help get arguments converted to their proper type.
• If a function is called with the wrong number of arguments, an invalid-arity will occur.

Next Steps

We’ve now seen an overview of the JMESPath language. The next things to do are:

• See the examples . You’ll see common JMESPath expressions that go beyond the tutorial. You’ll also see you how to combine multiple features together in order to best leverage JMESPath expressions.
• To actually start using JMESPath, pick the language of your choice, and check out the libraries page for more information on using JMESPath in the language of your choice.
• Read the JMESPath Spec , which has the official ABNF grammar and full details of the semantics of the language.

Examples

Filters and Multiselect Lists

One of the most common usage scenarios for JMESPath is being able to take a complex JSON document and simplify it down. The main features at work here are filters and multiselects. In this example below, we’re taking the array of people and, for any element with an age key whose value is greater than 20, we’re creating a sub list of the name and age values.

Filters and Multiselect Hashes

In the previous example we were taking an array of hashes, and simplifying down to an array of two element arrays containing a name and an age. We’re also only including list elements where the age key is greater than 20. If instead we want to create the same hash structure but only include the age and name key, we can instead say:

The last half of the above expression contains key value pairs which have the general form keyname: <expression>. In the above expression we’re just using a field as an expression, but they can be more advanced expressions. For example:

Notice in the above example instead of applying a filter expression ([? <expr> ]), we’re selecting all array elements via [*].

Working with Nested Data

The above example combines several JMESPath features including the flatten operator, multiselect lists, filters, and pipes.

The input data contains a top level key, “reservations”, which is a list. Within each list, there is an “instances” key, which is also a list.

The first thing we’re doing here is creating a single list from multiple lists of instances. By using the flatten we can take the two instances from the first list and the two instances from the second list, and combine them into a single list. Try changing the above expression to just reservations[].instances[] to see what this flattened list looks like. Everything to the right of the reservations[].instances[] is about taking the flattened list and paring it down to contain only the data that we want. This expression is taking each element in the original list and transforming it into a three element sublist. The three elements are:

• In the tags list, select the first element in the flattened Values list whose Key has a value of Name.
• The type
• The state.name of each instance.

The most interesting of those three expressions is the tags[?Key=='Name'].Values[] | [0] part. Let’s examine that further.

The first thing to notice is that we’re filtering down the list associated with the tags key. The tags[?Key==`Name`] tells us to only include list elements that contain a Key whose value is Name. From those filtered list elements we’re going to take the Values key and flatten the list. Finally, the | [0] will take the entire list and extract the 0th element.

Filtering and Selecting Nested Data

In this example, we’re going to look at how you can filter nested hashes.

In this example we’re searching through the people array. Each element in this array contains a hash of two elements, and each value in the hash is itself a hash. We’re trying to retrieve the value of the general key that contains an id key with a value of 100.

If we just had the expression people[?general.id==`100`], we’d have a result of:

[{
  "general": {
    "id": 100,
    "age": 20,
    "other": "foo",
    "name": "Bob"
  },
  "history": {
    "first_login": "2014-01-01",
    "last_login": "2014-01-02"
  }
}]

Let’s walk through how we arrived at this result. In words, the people[?general.id==`100`] expression is saying “for each element in the people array, select the elements where the general.id equals 100”. If we trace the execution of this filtering process we have:

# First element:
    {
      "general": {
        "id": 100,
        "age": 20,
        "other": "foo",
        "name": "Bob"
      },
      "history": {
        "first_login": "2014-01-01",
        "last_login": "2014-01-02"
      }
    },
# Applying the expression ``general.id`` to this hash::
    100
# Does 100==100?
    true
# Add this first element (in its entirety) to the result list.

# Second element:
    {
      "general": {
        "id": 101,
        "age": 30,
        "other": "bar",
        "name": "Bill"
      },
      "history": {
        "first_login": "2014-05-01",
        "last_login": "2014-05-02"
      }
    }

# Applying the expression ``general.id`` to this element::
    101
# Does 101==100?
    false
# Do not add this element to the results list.
# Result of this expression is a list containing the first element.

However, this still isn’t the final value we want which is:

{
  "id": 100,
  "age": 20,
  "other": "foo",
  "name": "Bob"
}

In order to get to this value from our filtered results we need to first select the general key. This gives us a list of just the values of the general hash:

[{
  "id": 100,
  "age": 20,
  "other": "foo",
  "name": "Bob"
}]

From there, we then uses a pipe (|) to stop projections so that we can finally select the first element ([0]). Note that we are making the assumption that there’s only one hash that contains an id of 100. Given the way the data is structured, it’s entirely possible to have data such as:

{
  "people": [
    {
      "general": {
        "id": 100,
        "age": 20
      },
      "history": {
      }
    },
    {
      "general": {
        "id": 101,
        "age": 30
      },
      "history": {
      }
    },
    {
      "general": {
        "id": 100,
        "age": 30
      },
      "history": {
      }
    }
  ]
}

Note here that the first and last elements in the people array both have an id of 100. Our expression would then select the first element that matched.

Finally, it’s worth mentioning there is more than one way to write this expression. In this example we’ve decided that after we filter the list we’re going to select the value of the general key and then select the first element in that list. We could also reverse the order of those operations, we could have taken the filtered list, selected the first element, and then extracted the value associated with the general key. That expression would be:

people[?general.id==`100`] | [0].general

Both versions are equally valid.

Using Functions

JMESPath functions give you a lot of power and flexibility when working with JMESPath expressions. Below are some common expressions and functions used in JMESPath.

sort_by

The first interesting thing here if the use of the function sort_by. In this example we are sorting the Contents array by the value of each Date key in each element in the Contents array. The sort_by function takes two arguments. The first argument is an array, and the second argument describes the key that should be used to sort the array.

The second interesting thing in this expression is that the second argument starts with &, which creates an expression type. Think of this conceptually as a reference to an expression that can be evaluated later. If you are familiar with lambda and anonymous functions, expression types are similar. The reason we use &Date instead of Date is because if the expression is Date, it would be evaluated before calling the function, and given there’s no Date key in the outer hash, the second argument would evaluate to null. Check out function-evaluation{.interpreted-text role=“ref”} in the specification for more information on how functions are evaluated in JMESPath. Also, note that we’re taking advantage of the fact that the dates are in ISO 8601 format, which can be sorted lexicographically.

And finally, the last interesting thing in this expression is the [*] immediately after the sort_by function call. The reason for this is that we want to apply the multiselect hash, the second half of the expression, to each element in the sorted array. In order to do this we need a projection. The [*] does exactly that, it takes the input array and creates a projection such that the multiselect hash {Key: Key, Size: Size} will be applied to each element in the list.

There are other functions that take expression types that are similar to sort_by including min_by and max_by .

Pipes

Pipe expression are useful for stopping projections. They can also be used to group expressions.

Main Page

Let’s look at a modified version of the expression on the JMESPath front page .

We can think of this JMESPath expression as having three components, each separated by the pipe character |. The first expression is familiar to us, it’s similar to the first example on this page. The second part of the expression, sort(@), is similar to the sort_by function we saw in the previous section. The @ token is used to refer to the current element. The sort function takes a single parameter which is an array. If the input JSON document was a hash, and we wanted to sort the foo key, which was an array, we could just use sort(foo). In this scenario, the input JSON document is the array we want to sort. To refer to this value, we use the current element, @, to indicate this. We’re also only taking a subset of the sorted array. We’re using a slice ([-2:]) to indicate that we only want the last two elements in the sorted array to be passed through to the final third of this expression.

And finally, the third part of the expression, {WashingtonCities: join(', ', @)}, creates a multiselect hash. It takes as input, the list of sorted city names, and produces a hash with a single key, WashingtonCities, whose values are the input list (denoted by @) as a string separated by a comma.

Preview Features

Lexical Scopes

JMESPath Community introduces the let-expression function to supports nested lexical scopes.

let $foo = bar in {a: myvar, b: $foo}

The first argument is a JSON object that introduces a new lexical scope.

The second argument is an expression-type that is evaluated against the current context – i.e the current result of JMESPath evaluation context, that can be referred to by the @ node. The expression-type also has access to the stack of nested scopes.

Consider the following example:

When evaluating the states identifier, JMESPath no longer has access to the root scope, where first_choice is defined. Therefore, under normal circumstances, the filter-expression [?name === first_choice] would evaluate the first_choice identifier and return an empty array.

Instead, let() defined the identifier first_choice has taking the value of the property with the same name in the input JSON document. It effectively created a scope that can be represented as the following JSON object:

{ "first_choice": "WA" }

Therefore, when evaluating the filter-expression, the first_choice identifier is indeed defined, and produces the correct result.

Arithmetic Expressions

JMESPath Community now supports arithmetic-expression syntax with the usual operators.

Object Manipulation Functions

As a JSON query language, JMESPath Community now supports functions to manipulate JSON objects .

The items() function allows you to deconstruct a JSON object to its key and values, whereas the from_items() function will combine two arrays into a single JSON object.

The zip() function comes the Python language. It combines two or more arrays into a set of arrays, each of which contains the _i_th indexed item from each indivual array.

For better understanding, consider the following example:

Think of the three fruits, people and country arrays as being rows in a table. Each array has a number of items that you can think of as being the columns in the table.

The zip() function will create as many arrays as there are full columns, each of which will contain the items found in each row of the table.

So, the first array – corresponding to the first column of the table – will contain one item from the people row, one item from the country row and finally one item from the fruits row, resulting in ["John", "Germany", "Orange"].

The second array – corresponding to the second column of the table – contains ["Marc", "France", "Apple"].

String Slices

Using slice-expression to slice strings is popular in modern programming languages. JMESPath Community supports slicing strings using the same syntax:

Note: slice-expression applied to JSON arrays result in a projection. Applying a slice-expression to a JSON string, however, produces a JSON string.

Groups

Using the group_by() function , you can group collection of objects with specific criteria:

Libraries

The JMESPath specification is implemented in various languages. Each list below shows JMESPath libraries as well as the compliance level. The compliance level is based on which compliance tests the library can pass and as reported by their respective authors.

• Fully compliant: means compliant with respect to the original version of JMESPath.
• JMESPath Community: means compliant with respect to the new JMESPath Community specifications.

Language	Name	Compliance Level
C++	jmespath.cpp	Fully compliant
.NET	jmespath.net
Elixir	ex-jmes	Fully compliant
Go	go-jmespath
Java	jmespath-java	Fully compliant
Lua	jmespath.lua	Fully compliant
Javascript	jmespath.js	Fully compliant
PHP	jmespath.php	Fully compliant
Python	python-jmespath
Ruby	jmespath.rb	Fully compliant
Rust	jmespath.rs	Fully compliant
TypeScript	typescript-jmespath

In addition to the JMESPath libraries above, there are a number of miscellaneous JMESPath tools.

Syntax

search(<jmespath expr>, <JSON document>) -> <return value>

search(foo, {"foo": "bar"}) -> "bar"

expression        = sub-expression / index-expression  / comparator-expression
expression        =/ or-expression / identifier
expression        =/ and-expression / not-expression / paren-expression
expression        =/ multi-select-list / multi-select-hash / literal
expression        =/ function-expression / pipe-expression / raw-string
expression        =/ root-node / current-node
expression        =/ arithmetic-expression
expression        =/ let-expression / variable-ref

sub-expression    = expression "." ( identifier / multi-select-list / multi-select-hash / function-expression / "*" ) 

pipe-expression   = expression "|" expression 

or-expression     = expression "||" expression 

and-expression    = expression "&&" expression 

not-expression    = "!" expression 

arithmetic-expression =/ "+" expression ; + %x43 
arithmetic-expression =/ ( "-" / "–" ) expression ; - %x45 – %x2212 \
arithmetic-expression = expression "%" expression ; % %x37 \
arithmetic-expression =/ expression ( "*" / "×" ) expression ; * %x42 ×  %xD7 \
arithmetic-expression =/ expression "+" expression ; + %x43 \
arithmetic-expression =/ expression ( "-" / "–" ) expression ; - %x45 – %x2212 \
arithmetic-expression =/ expression ( "/" / "÷" ) expression ; / %x47 ÷ %F7 \
arithmetic-expression = expression "//" expression ; // %47 %47

paren-expression  = "(" expression ")" 

index-expression  = expression bracket-specifier / bracket-specifier 
bracket-specifier = "[" (number / slice-expression) "]"

bracket-specifier =/ "[]" 

slice-expression  = [number] ":" [number] [ ":" [number] ] 

multi-select-list = "[" ( expression *( "," expression ) ) "]" 

multi-select-hash = "{" ( keyval-expr *( "," keyval-expr ) ) "}" 
keyval-expr       = identifier ":" expression

expression        =/ "*" 
bracket-specifier =/ "[" "*" "]"

filter-expression = "[?" expression "]" 
bracket-specifier =/ filter-expression 
comparator-expression = expression comparator expression 
comparator        = "<" / "<=" / "==" / ">=" / ">" / "!="

function-expression = unquoted-string  ( no-args  / one-or-more-args ) 
no-args             = "(" ")" 
one-or-more-args    = "(" ( function-arg *( "," function-arg ) ) ")" 
function-arg        = expression / expression-type 
current-node        = "@" 
root-node           = "$" 
expression-type     = "&" expression
let-expression = "let" bindings "in" expression 
bindings = variable-binding *( "," variable-binding ) \
variable-binding = variable-ref "=" expression \
variable-ref = "$" unquoted-string


raw-string        = "'" *raw-string-char "'" 
raw-string-char   = (%x00-26 / %x28-5B / %x5D-10FFFF) / preserved-escape / raw-string-escape 
preserved-escape  = escape (%x00-26 / %x28-5B / %x5D-10FFFF) 
raw-string-escape = escape ("'" / escape)

literal           = "`" json-text "`" 

number            = ["-"] 1*digit
digit             = %x30-39 ; 0-9
identifier        = unquoted-string / quoted-string 

unquoted-string   = (%x41-5A / %x61-7A / %x5F) *(  ; A-Za-z_
                        %x30-39  /  ; 0-9
                        %x41-5A /  ; A-Z
                        %x5F    /  ; _
                        %x61-7A)   ; a-z
quoted-string     = quotation-mark *(unescaped-char / escaped-char) quotation-mark
unescaped-char    = %x20-21 / %x23-5B / %x5D-10FFFF
escape            = %x5C   ; \
quotation-mark    = %x22   ; "
escaped-char      = escape (
                        %x22 /          ; "    quotation mark  U+0022
                        %x5C /          ; \    reverse solidus U+005C
                        %x2F /          ; /    solidus         U+002F
                        %x62 /          ; b    backspace       U+0008
                        %x66 /          ; f    form feed       U+000C
                        %x6E /          ; n    line feed       U+000A
                        %x72 /          ; r    carriage return U+000D
                        %x74 /          ; t    tab             U+0009
                        %x75 4HEXDIG )  ; uXXXX                U+XXXX

json-text  = ws json-value ws
ws         = *(
                %x20 /              ; Space
                %x09 /              ; Horizontal tab
                %x0A /              ; Line feed or New line
                %x0D )              ; Carriage return
; `json-value` is any valid JSON value with the one exception that each
; U+0060 GRAVE ACCENT '`' must be escaped with a preceding backslash.
; While implementations are encouraged to use any existing JSON parser for this
; section of the grammar (after handling the escaped characters), a complete
; set of rules derived from RFC 8259 is included below:
json-value = false / null / true / json-object / json-array /
             json-number / json-string
; JSON literals
false = %x66.61.6c.73.65   ; false
null  = %x6e.75.6c.6c      ; null
true  = %x74.72.75.65      ; true
; JSON strings
json-string    = quotation-mark *( json-unescaped / json-escaped ) quotation-mark
json-unescaped = %x20-21     / ; space or '!' (precedes U+0022 '"')
                 %x23-5B     / ; '#' through '[' (precedes U+005C '\')
                 %x5D-5F     / ; ']' through '_' (precedes U+0060 '`')
                 %x61-10FFFF   ; 'a' and all following code points
json-escaped   = escaped-char / (escape "`")
; JSON arrays
json-array      = begin-array [ json-value *( value-separator json-value ) ] end-array
begin-array     = ws %x5B ws  ; [ left square bracket
end-array       = ws %x5D ws  ; ] right square bracket
value-separator = ws %x2C ws  ; , comma
; JSON objects
json-object    = begin-object [ member *( value-separator member ) ] end-object
begin-object   = ws %x7B ws  ; { left curly bracket
end-object     = ws %x7D ws  ; } right curly bracket
member         = json-string name-separator json-value
name-separator = ws %x3A ws  ; : colon
; JSON numbers
json-number   = [ minus ] int [ frac ] [ exp ]
decimal-point = %x2E                 ; .
digit1-9      = %x31-39              ; 1-9
e             = %x65 / %x45          ; e E
exp           = e [ minus / plus ] 1*digit
frac          = decimal-point 1*digit
int           = zero / ( digit1-9 *digit )
minus         = %x2D                 ; -
plus          = %x2B                 ; +
zero          = %x30                 ; 0

expression        = sub-expression / index-expression  / comparator-expression
expression        =/ or-expression / identifier
expression        =/ and-expression / not-expression / paren-expression
expression        =/ multi-select-list / multi-select-hash / literal
expression        =/ function-expression / pipe-expression / raw-string
expression        =/ root-node / current-node
expression        =/ arithmetic-expression
expression        =/ let-expression / variable-ref
  

sub-expression    = expression "." ( identifier / multi-select-list / multi-select-hash / function-expression / "*" )
  

left-evaluation = search(left-expression, original-json-document)
if left-evaluation is `null` then result = `null`
else result = search(right-expression, left-evaluation)

left-evaluation = search("foo", {"foo": {"bar": "baz"}}) -> {"bar": "baz"}
result = search("bar": {"bar": "baz"}) -> "baz"

search(foo.bar, {"foo": {"bar": "value"}}) -> "value"
search(foo."bar", {"foo": {"bar": "value"}}) -> "value"
search(foo.bar, {"foo": {"baz": "value"}}) -> null
search(foo.bar.baz, {"foo": {"bar": {"baz": "value"}}}) -> "value"

pipe-expression   = expression "|" expression
  

left-evaluation = search(left-expression, original-json-document)
result = search(right-expression, left-evaluation)

{"foo": [{"bar": ["first1", "second1"]}, {"bar": ["first2", "second2"]}]}

[
    [
        "first1",
        "second1"
    ],
    [
        "first2",
        "second2"
    ]
]

["first1", "first2"]

foo[*].bar[0] -> ["first1", "first2"]
foo[*].bar | [0] -> ["first1", "second1"]

search(foo | bar, {"foo": {"bar": "baz"}}) -> "baz"
search(foo[*].bar | [0], {
    "foo": [{"bar": ["first1", "second1"]},
            {"bar": ["first2", "second2"]}]}) -> ["first1", "second1"]
search(foo | [0], {"foo": [0, 1, 2]}) -> [0]

or-expression     = expression "||" expression
  

search(foo || bar, {"foo": "foo-value"}) -> "foo-value"
search(foo || bar, {"bar": "bar-value"}) -> "bar-value"
search(foo || bar, {"foo": "foo-value", "bar": "bar-value"}) -> "foo-value"
search(foo || bar, {"baz": "baz-value"}) -> null
search(foo || bar || baz, {"baz": "baz-value"}) -> "baz-value"
search(override || mylist[-1], {"mylist": ["one", "two"]}) -> "two"
search(override || mylist[-1], {"mylist": ["one", "two"], "override": "yes"}) -> "yes"

and-expression    = expression "&&" expression
  

search(True && False, {"True": true, "False": false}) -> false
search(Number && EmptyList, {"Number": 5, EmptyList: []}) -> []
search(foo[?a == `1` && b == `2`],
       {"foo": [{"a": 1, "b": 2}, {"a": 1, "b": 3}]}) -> [{"a": 1, "b": 2}]

not-expression    = "!" expression
  

search(!True, {"True": true}) -> false
search(!False, {"False": false}) -> true
search(!Number, {"Number": 5}) -> false
search(!EmptyList, {"EmptyList": []}) -> true

arithmetic-expression =/ "+" expression ; + %x43
arithmetic-expression =/ ( "-" / "–" ) expression ; - %x45 – %x2212 \
arithmetic-expression = expression "%" expression ; % %x37 \
arithmetic-expression =/ expression ( "*" / "×" ) expression ; * %x42 ×  %xD7 \
arithmetic-expression =/ expression "+" expression ; + %x43 \
arithmetic-expression =/ expression ( "-" / "–" ) expression ; - %x45 – %x2212 \
arithmetic-expression =/ expression ( "/" / "÷" ) expression ; / %x47 ÷ %F7 \
arithmetic-expression = expression "//" expression ; // %47 %47
  

search(a + b, {"a": 1, "b": 2}) -> 3
search(a - b, {"a": 1, "b": 2}) -> -1
search(a * b, {"a": 2, "b": 4}) -> 8
search(a / b, {"a": 2, "b": 3}) -> 0.666666666666667
search(a % b, {"a": 10, "b": 3} -> 1
search(a // b, {"a": 10, "b": 3} -> -3
search(a.b + cd, {"a": {"b": 1}, "c": {"d": 2}}) -> 3

search({ab: a.b, cd: c.d} | ab + cd, {"a": {"b": 1}, "c": {"d": 2}}) -> 3

paren-expression  = "(" expression ")"
  

search(foo[?(a == `1` || b ==`2`) && c == `5`],
       {"foo": [{"a": 1, "b": 2, "c": 3}, {"a": 3, "b": 4}]}) -> []

index-expression  = expression bracket-specifier / bracket-specifier
bracket-specifier = "[" (number / slice-expression) "]"
  

negative-index == (length of array) + negative-index

bracket-specifier =/ "[]"
  

search([0], ["first", "second", "third"]) -> "first"
search([-1], ["first", "second", "third"]) -> "third"
search([100], ["first", "second", "third"]) -> null
search(foo[0], {"foo": ["first", "second", "third"]) -> "first"
search(foo[100], {"foo": ["first", "second", "third"]) -> null
search(foo[0][0], {"foo": [[0, 1], [1, 2]]}) -> 0

slice-expression  = [number] ":" [number] [ ":" [number] ]
  

search([0:4:1], [0, 1, 2, 3]) -> [0, 1, 2, 3]
search([0:4], [0, 1, 2, 3]) -> [0, 1, 2, 3]
search([0:3], [0, 1, 2, 3]) -> [0, 1, 2]
search([:2], [0, 1, 2, 3]) -> [0, 1]
search([::2], [0, 1, 2, 3]) -> [0, 2]
search([::-1], [0, 1, 2, 3]) -> [3, 2, 1, 0]
search([-2:], [0, 1, 2, 3]) -> [2, 3]

search(foo[0:4], {"foo": "hello, world!"}) -> "hell"
search([::], 'raw-string') -> "raw-string"
search([::2], 'raw-string') -> "rwsrn"
search([::-1], 'raw-string') -> "gnirts-war"

multi-select-list = "[" ( expression *( "," expression ) ) "]"
  

search([foo,bar], {"foo": "a", "bar": "b", "baz": "c"}) -> ["a", "b"]
search([foo,bar[0]], {"foo": "a", "bar": ["b"], "baz": "c"}) -> ["a", "b"]
search([foo,bar.baz], {"foo": "a", "bar": {"baz": "b"}}) -> ["a", "b"]
search([foo,baz], {"foo": "a", "bar": "b"}) -> ["a", null]

multi-select-hash = "{" ( keyval-expr *( "," keyval-expr ) ) "}"
keyval-expr       = identifier ":" expression
  

keyval-expr       = identifier ":" expression

search({foo: foo, bar: bar}, {"foo": "a", "bar": "b", "baz": "c"})
              -> {"foo": "a", "bar": "b"}
search({foo: foo, firstbar: bar[0]}, {"foo": "a", "bar": ["b"]})
              -> {"foo": "a", "firstbar": "b"}
search({foo: foo, "bar.baz": bar.baz}, {"foo": "a", "bar": {"baz": "b"}})
              -> {"foo": "a", "bar.baz": "b"}
search({foo: foo, baz: baz}, {"foo": "a", "bar": "b"})
              -> {"foo": "a", "baz": null}

expression        =/ "*"
bracket-specifier =/ "[" "*" "]"
  

search([*].foo, [{"foo": 1}, {"foo": 2}, {"foo": 3}]) -> [1, 2, 3]
search([*].foo, [{"foo": 1}, {"foo": 2}, {"bar": 3}]) -> [1, 2]
search('*.foo', {"a": {"foo": 1}, "b": {"foo": 2}, "c": {"bar": 1}}) -> [1, 2]

filter-expression = "[?" expression "]"
bracket-specifier =/ filter-expression
comparator-expression = expression comparator expression
comparator        = "<" / "<=" / "==" / ">=" / ">" / "!="
  

search('foo[?a<b]', {"foo": [{"a": "char", "b": "char"},
                             {"a": 2, "b": 1},
                             {"a": 1, "b": 2}]})

search(foo[?bar==`10`], {"foo": [{"bar": 1}, {"bar": 10}]}) -> [{"bar": 10}]
search([?bar==`10`], [{"bar": 1}, {"bar": 10}]}) -> [{"bar": 10}]
search(foo[?a==b], {"foo": [{"a": 1, "b": 2}, {"a": 2, "b": 2}]}) -> [{"a": 2, "b": 2}]

function-expression = unquoted-string  ( no-args  / one-or-more-args )
no-args             = "(" ")"
one-or-more-args    = "(" ( function-arg *( "," function-arg ) ) ")"
function-arg        = expression / expression-type
current-node        = "@"
root-node           = "$"
expression-type     = "&" expression
  

foo[].[count(@), bar]

{
  "first_choice": "WA",
  "states": [
     {"name": "WA", "cities": ["Seattle", "Bellevue", "Olympia"]},
     {"name": "CA", "cities": ["Los Angeles", "San Francisco"]},
     {"name": "NY", "cities": ["New York City", "Albany"]}
 ]
}

let-expression = "let" bindings "in" expression
bindings = variable-binding *( "," variable-binding ) \
variable-binding = variable-ref "=" expression \
variable-ref = "$" unquoted-string
  

search([].to_number(@), ``["1", "2", "3", "notanumber", true]``) -> [1, 2, 3]

raw-string        = "'" *raw-string-char "'"
raw-string-char   = (%x00-26 / %x28-5B / %x5D-10FFFF) / preserved-escape / raw-string-escape
preserved-escape  = escape (%x00-26 / %x28-5B / %x5D-10FFFF)
raw-string-escape = escape ("'" / escape)
  

search(`"foo"`, "") -> "foo"
search('foo', "") -> "foo"

search('foo', "") -> "foo"
search(' bar ', "") -> " bar "
search('[baz]', "") -> "[baz]"
search('\u03bB', "") -> "\\u03bB"
search('foo␊bar', "") -> "foo\nbar"
search('foo\␊bar', "") -> "foo\\\nbar"
search('\\', "") -> "\\"

literal           = "`" json-text "`"
  

search(`"foo"`, "anything") -> "foo"
search(`"foo\`bar"`, "anything") -> "foo`bar"
search(`[1, 2]`, "anything") -> [1, 2]
search(`true`, "anything") -> true
search(`{"a": "b"}`.a, "anything") -> "b"
search({first: a, type: `"mytype"`}, {"a": "b", "c": "d"}) -> {"first": "b", "type": "mytype"}

identifier        = unquoted-string / quoted-string
  

search(foo, {"foo": "value"}) -> "value"
search(bar, {"foo": "value"}) -> null
search(foo, {"foo": [0, 1, 2]}) -> [0, 1, 2]
search("with space", {"with space": "value"}) -> "value"
search("special chars: !@#", {"special chars: !@#": "value"}) -> "value"
search("quote\"char", {"quote\"char": "value"}) -> "value"
search("\u2713", {"\u2713": "value"}) -> "value"

Built-in Functions

abs

number abs number $value

Arguments

Name	Presence	Type	Description
$value	required	number	positive or negative number
Returns		number	positive magnitude of input value

Returns the absolute value of the provided argument. The signature indicates that a number is returned, and that the input argument $value must resolve to a number, otherwise an invalid-type error is triggered.

Below is a worked example. Given:

{"foo": -1, "bar": "2"}

Evaluating abs(foo) works as follows:

1. Evaluate the input argument against the current data:

search(foo, {"foo": -1, "bar": "2"}) -> -1

2. Validate the type of the resolved argument. In this case -1 is of type number so it passes the type check.

3. Call the function with the resolved argument:

abs(-1) -> 1

4. The value of 1 is the resolved value of the function expression abs(foo).

Below is the same steps for evaluating abs(bar):

1. Evaluate the input argument against the current data:

search(bar, {"foo": -1, "bar": "2"}) -> "2"

2. Validate the type of the resolved argument. In this case "2" is of type string so we immediately indicate that an invalid-type error occurred.

As a final example, here is the steps for evaluating abs(to_number(bar)):

1. Evaluate the input argument against the current data:

search(to_number(bar), {"foo": -1, "bar": "2"})

2. In order to evaluate the above expression, we need to evaluate to_number(bar):

search(bar, {"foo": -1, "bar": "2"}) -> "2"
# Validate "2" passes the type check for to_number, which it does.
to_number("2") -> 2

Note that to_number is defined below.

3. Now we can evaluate the original expression:

search(to_number(bar), {"foo": -1, "bar": "2"}) -> 2

4. Call the function with the final resolved value:

abs(2) -> 2

5. The value of 2 is the resolved value of the function expression abs(to_number(bar)).

Examples

Given	Expression	Result
null	abs(1)	1
null	abs(abc)	null
null	abs(-1)	1
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	abs(str)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	abs(array[1])	3
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	abs()	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	abs(foo)	1
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	abs(-24)	24
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	abs(false)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	abs(1, 2)	null

avg

number|null avg array[number] $elements

Arguments

Name	Presence	Type	Description
$elements	required	array[number]	array of numbers to calculate average from
Returns		number|null	average value of passed elements

Returns the average of the elements in the provided array.

An empty array will produce a return value of null.

Examples

Given	Expression	Result
false	avg(@)	null
[false]	avg(@)	null
[10,15,20]	avg(@)	15
[10,false,20]	avg(@)	null
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	avg(@)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	avg(empty_list)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	avg(array)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	avg(abc)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	avg(foo)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	avg(numbers)	2.75
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	avg(strings)	null

ceil

number ceil number $value

Arguments

Name	Presence	Type	Description
$value	required	number
Returns		number

Returns the next highest integer value by rounding up if necessary.

Examples

Given	Expression	Result
null	ceil(1.9)	2
null	ceil(1)	1
null	ceil(abc)	null
null	ceil(1.001)	2
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	ceil(decimals[2])	-1
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	ceil(1.2)	2
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	ceil(decimals[0])	2
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	ceil('string')	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	ceil(decimals[1])	2

contains

boolean contains array|string $subjectany $search

Arguments

Name	Presence	Type	Description
$subject	required	array|string
$search	required	any
Returns		boolean

Returns true if the given $subject contains the provided $search value.

If $subject is an array, this function returns true if one of the elements in the array is equal to the provided $search value.

If the provided $subject is a string, this function returns true if there exists within the $subject string at least one occurrence of an equal $search string. If the $search value is not a string, the function MUST return false.

Examples

Given	Expression	Result
null	contains(false, 'bar')	null
null	contains('foobar', 'foo')	true
null	contains('foobar', 'bar')	true
null	contains('foobar', 'not')	false
null	contains('foobar', '123')	false
["a"]	contains(@, 'a')	true
["a"]	contains(@, 'b')	false
["foo","bar"]	contains(@, 'b')	false
["foo","bar"]	contains(@, 'foo')	true
["a","b"]	contains(@, 'a')	true
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	contains('abc', 'a')	true
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	contains('abc', 'd')	false
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	contains(decimals, false)	false
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	contains(decimals, 1.2)	true
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	contains(strings, 'a')	true
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	contains(false, 'd')	null

ends_with

boolean ends_with string $subjectstring $prefix

Arguments

Name	Presence	Type	Description
$subject	required	string
$prefix	required	string
Returns		boolean

Returns true if the $subject ends with the $prefix, otherwise this function returns false.

Examples

Given	Expression	Result
"foobarbaz"	ends_with(@, 'z')	true
"foobarbaz"	ends_with(@, 'baz')	true
"foobarbaz"	ends_with(@, 'foo')	false
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	ends_with(str, 'tr')	true
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	ends_with(str, 'Str')	true
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	ends_with(str, 0)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	ends_with(str, 'r')	true
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	ends_with(str, 'foo')	false
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	ends_with(str, 'SStr')	false

find_first

number find_first string $subjectstring $subnumber $start number $end

Arguments

Name	Presence	Type	Description
$subject	required	string	Subject string
$sub	required	string	Substring
$start	optional	number	Position in the subject string where searching should start.
$end	optional	number	Position in the subject string where searching should end.
Returns		number

Given the subject string, find_first() returns the zero-based index of the first occurence where the sub substring appears in subject or null if it does not appear. If either the $subject or the $sub argument is an empty string, find_first() return null.

The start and end parameters are optional and allow restricting the range within subject in which sub must be found.

• If start is omitted, it defaults to 0 (which is the start of the subject string).
• If end is omitted, it defaults to length(subject) - 1 (which is is the end of the subject string).

If not omitted, the $start and $end arguments are expected to be integers. Othewise, an error MUST be raised.

Contrary to similar functions found in most popular programming languages, the find_first() function does not return -1 if no occurrence of the substring can be found. Instead, it returns null for consistency reasons with how JMESPath behaves.

Examples

Given	Expression	Result
"subject string"	find_first(@, string, `0`)	8
"subject string"	find_first(@, s, `0`)	0
"subject string"	find_first(@, s, `1`)	8
"subject string"	find_first(@, string)	8
"subject string"	find_first(@, string, `0`, `14`)	8
"subject string"	find_first(@, string, `0`, `13`)	null
"subject string"	find_first(@, string, `9`)	null
"subject string"	find_first(@, string, `-99`, `100`)	8
"subject string"	find_first(@, string, `8`)	8

find_last

number find_last string $subjectstring $subnumber $start number $end

Arguments

Name	Presence	Type	Description
$subject	required	string	Subject string
$sub	required	string	Substring
$start	optional	number	Position in the subject string where searching should start.
$end	optional	number	Position in the subject string where searching should end.
Returns		number

Given the $subject string, find_last() returns the zero-based index of the last occurence where the $sub substring appears in $subject or null if it does not appear. If either the $subject or the $sub argument is an empty string, find_last() returns null.

The $start and $end parameters are optional and allow restricting to the slice [$start:$end] the range within $subject in which $sub must be found.

• If $start is omitted, it defaults to 0 (which is the start of the $subject string).
• If $end is omitted, it defaults to length(subject) (which is past the end of the $subject string).

If not omitted, the $start or $end arguments are expected to be integers. Otherwise, an error MUST be raised.

Contrary to similar functions found in most popular programming languages, the find_last() function does not return -1 if no occurrence of the substring can be found. Instead, it returns null for consistency reasons with how JMESPath behaves.

Examples

Given	Expression	Result
"subject string"	find_last(@, string)	8
"subject string"	find_last(@, string, `8`)	8
"subject string"	find_last(@, string, `8`, `9`)	null
"subject string"	find_last(@, string, `9`)	null
"subject string"	find_last(@, s, `1`)	8
"subject string"	find_last(@, s, `0`, `7`)	0

floor

number floor number $value

Arguments

Name	Presence	Type	Description
$value	required	number
Returns		number

Returns the next lowest integer value by rounding down if necessary.

Examples

Given	Expression	Result
null	floor(1.001)	1
null	floor(1.9)	1
null	floor(1)	1
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	floor(foo)	-1
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	floor(str)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	floor(1.2)	1
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	floor(string)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	floor(decimals[0])	1

from_items

object from_items array[any] $arg

Arguments

Name	Presence	Type	Description
$arg	required	array[any]
Returns		object

Returns an object from the provided array of key value pairs. This function is the inversed of the items() function.

Examples

Given	Expression	Result
[["one",1],["two",2]]	from_items(@)	{"one":1,"two":2}
[["one",1],["two",2],["one",3]]	from_items(@)	{"one":3,"two":2}

group_by

object group_by array[object] $elementsexpression->string $expr

Arguments

Name	Presence	Type	Description
$elements	required	array[object]
$expr	required	expression->string
Returns		object

Groups an array of objects $elements using an expression $expr as the group key. The $expr expression is applied to each element in the array $elements and the resulting value is used as a group key.

The result is an object whose keys are the unique set of string keys and whose respective values are an array of objects array matching the group criteria.

Objects that do not match the group criteria are discarded from the output. This includes objects for which applying the $expr expression evaluates to null.

If the result of applying the $expr expression against the current array element results in type other than string or null, an invalid-type error MUST be raised.

Examples

Given	Expression	Result
Show more..
{"items":[{"spec":{"nodeName":"node_01","other":"values_01"}},{"spec":{"nodeName":"node_02","other":"values_02"}},{"spec":{"nodeName":"node_03","other":"values_03"}},{"spec":{"nodeName":"node_01","other":"values_04"}}]}	group_by(items, &nodeName)	{"nodeName":{"node_01":[{"spec":{"nodeName":"node_01","other":"values_01"}},{"spec":{"nodeName":"node_01","other":"values_04"}}],"node_02":[{"spec":{"nodeName":"node_02","other":"values_02"}}],"node_03":[{"spec":{"nodeName":"node_03","other":"values_03"}}]}}
{"array":[{"b":true,"name":"one"},{"b":false,"name":"two"},{"b":false}]}	group_by(array, &name)	[{"age":10,"age_str":"10","bool":true,"name":3},{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":50,"age_str":"50","bool":false,"name":"d"}]
{"array":[{"b":true,"name":"one"},{"b":false,"name":"two"},{"b":false}]}	group_by(array, &b)	null

items

array[any] items object $obj

Arguments

Name	Presence	Type	Description
$obj	required	object
Returns		array[any]

Returns an array of key-value pairs for the provided input object. Each pair is a 2-item array with the first item being the key and the second item being the value. This function is the inversed of the from_items() function.

Note that because JSON hashes are inheritently unordered, the key value pairs of the provided object $obj are inheritently unordered. Implementations are not required to return values in any specific order.

Examples

Given	Expression	Result
{"a":"first","b":"second"}	items(@)	[["a","first"],["b","second"]]

join

string join string $gluearray[string] $stringsarray

Arguments

Name	Presence	Type	Description
$glue	required	string
$stringsarray	required	array[string]
Returns		string

Returns all of the elements from the provided $stringsarray array joined together using the $glue argument as a separator between each.

Examples

Given	Expression	Result
[false]	join(', ', @)	null
["a","b"]	join(', ', @)	"a, b"
["a","b"]	join('', @)	"ab"
["a",false,"b"]	join(', ', @)	null
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	join('|', decimals[].to_string(@))	"1.01|1.2|-1.5"
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	join(', ', )	"a, b"
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	join('|', strings)	"a|b|c"
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	join(', ', str)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	join('|', decimals)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	join(', ', strings)	"a, b, c"
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	join('|', empty_list)	""
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	join(', ', )	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	join(2, strings)	null

keys

array keys object $obj

Arguments

Name	Presence	Type	Description
$obj	required	object
Returns		array

Returns an array containing the keys of the provided object. Note that because JSON hashes are inheritently unordered, the keys associated with the provided object obj are inheritently unordered. Implementations are not required to return keys in any specific order.

Examples

Given	Expression	Result
{}	keys(@)	[]
false	keys(@)	null
{"bar":"bam","foo":"baz"}	keys(@)	["foo","bar"]
["b","a","c"]	keys(@)	null
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	keys(foo)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	keys(strings)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	keys(false)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	keys(empty_hash)	[]

length

number length string|array|object $subject

Arguments

Name	Presence	Type	Description
$subject	required	string|array|object
Returns		number

Returns the length of the given argument using the following types rules:

1. string: returns the number of code points in the string

2. array: returns the number of elements in the array

3. object: returns the number of key-value pairs in the object

Examples

Given	Expression	Result
null	length(not_there)	null
[]	length(@)	0
null	length('abc')	3
{}	length(@)	0
{"baz":"bam","foo":"bar"}	length(@)	2
["a","b","c"]	length(@)	3
[1,2,3,4,5,6,7]	length(@)	7
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	length('abc')	3
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	length('')	0
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	length(str)	3
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	length(strings[0])	1
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	length(objects)	2
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	length(false)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	length(@)	12
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	length('✓foo')	4
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	length(foo)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	length(array)	6

lower

string lower string $subject

Arguments

Name	Presence	Type	Description
$subject	required	string	Subject string
Returns		string

Returns the lowercase subject string.

Examples

Given	Expression	Result
"STRING"	lower(@)	"string"

map

array[any] map expression $exprarray[any] $elements

Arguments

Name	Presence	Type	Description
$expr	required	expression
$elements	required	array[any]
Returns		array[any]

Apply the expr to every element in the elements array and return the array of results. An elements of length N will produce a return array of length N.

Unlike a projection, ([\*].bar), map() will include the result of applying the expr for every element in the elements array, even if the result if null.

Examples

Given	Expression	Result
Show more..
{"array":[{"foo":{"bar":"yes1"}},{"foo":{"bar":"yes2"}},{"foo1":{"bar":false}}]}	map(&foo.bar.baz, array)	[null,null,null]
{"array":[[1,2,3,[4]],[5,6,7,[8,9]]]}	map(&[], array)	[[1,2,3,4],[5,6,7,8,9]]
{"array":[{"foo":{"bar":"yes1"}},{"foo":{"bar":"yes2"}},{"foo1":{"bar":false}}]}	map(&foo.bar, array)	["yes1","yes2",null]
{"array":[{"foo":{"bar":"yes1"}},{"foo":{"bar":"yes2"}},{"foo1":{"bar":false}}]}	map(&foo1.bar, array)	[null,null,false]
{"array":[{"foo":"a"},{"foo":"b"},{},[],{"foo":"f"}]}	map(&foo, array)	["a","b",null,null,"f"]
{"empty":[],"people":[{"a":10,"b":1,"c":"z"},{"a":10,"b":2,"c":null},{"a":10,"b":3},{"a":10,"b":4,"c":"z"},{"a":10,"b":5,"c":null},{"a":10,"b":6},{"a":10,"b":7,"c":"z"},{"a":10,"b":8,"c":null},{"a":10,"b":9}]}	map(&a, badkey)	null
[[1,2,3,[4]],[5,6,7,[8,9]]]	map(&[], @)	[[1,2,3,4],[5,6,7,8,9]]
{"empty":[],"people":[{"a":10,"b":1,"c":"z"},{"a":10,"b":2,"c":null},{"a":10,"b":3},{"a":10,"b":4,"c":"z"},{"a":10,"b":5,"c":null},{"a":10,"b":6},{"a":10,"b":7,"c":"z"},{"a":10,"b":8,"c":null},{"a":10,"b":9}]}	map(&a, people)	[10,10,10,10,10,10,10,10,10]
{"empty":[],"people":[{"a":10,"b":1,"c":"z"},{"a":10,"b":2,"c":null},{"a":10,"b":3},{"a":10,"b":4,"c":"z"},{"a":10,"b":5,"c":null},{"a":10,"b":6},{"a":10,"b":7,"c":"z"},{"a":10,"b":8,"c":null},{"a":10,"b":9}]}	map(&foo, empty)	[]
{"empty":[],"people":[{"a":10,"b":1,"c":"z"},{"a":10,"b":2,"c":null},{"a":10,"b":3},{"a":10,"b":4,"c":"z"},{"a":10,"b":5,"c":null},{"a":10,"b":6},{"a":10,"b":7,"c":"z"},{"a":10,"b":8,"c":null},{"a":10,"b":9}]}	map(&c, people)	["z",null,null,"z",null,null,"z",null,null]

max

number max array[number]|array[string] $collection

Arguments

Name	Presence	Type	Description
$collection	required	array[number]|array[string]
Returns		number

Returns the highest found number in the provided array argument.

An empty array will produce a return value of null.

Examples

Given	Expression	Result
[10,15]	max(@)	15
["a","b"]	max(@)	"b"
["a",2,"b"]	max(@)	null
[10,false,20]	max(@)	null
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	max(strings)	"c"
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	max(empty_list)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	max(decimals)	1.2
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	max(numbers)	5
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	max(abc)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	max(array)	null

max_by

any max_by array $elementsexpression->number|expression->string $expr

Arguments

Name	Presence	Type	Description
$elements	required	array
$expr	required	expression->number|expression->string
Returns		any

Return the maximum element in an array using the expression expr as the comparison key. The entire maximum element is returned. Below are several examples using the people array (defined above) as the given input.

Examples

Given	Expression	Result
Show more..
{"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	max_by(people, &to_number(age_str))	{"age":50,"age_str":"50","bool":false,"name":"d"}
{"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	max_by(people, &age_str)	null
{"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	max_by(people, age)	null
{"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	max_by(people, &age)	{"age":50,"age_str":"50","bool":false,"name":"d"}
{"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	max_by(people, &age_str)	{"age":50,"age_str":"50","bool":false,"name":"d"}
{"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	max_by(people, &bool)	null
{"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	max_by(people, &extra)	null

merge

object merge object $argumentobject $..

Arguments

Name	Presence	Type	Description
$argument	required	object
$..	optional	object
Returns		object

Accepts 0 or more objects as arguments, and returns a single object with subsequent objects merged. Each subsequent object’s key/value pairs are added to the preceding object. This function is used to combine multiple objects into one. You can think of this as the first object being the base object, and each subsequent argument being overrides that are applied to the base object.

Examples

Given	Expression	Result
null	merge()	{"a":"b","c":"d"}
null	merge()	{"a":"override"}
null	merge()	{"a":"x","b":"override","c":"z"}
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	merge()	{"a":1,"b":2}
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	merge()	{"a":2}
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	merge()	{"a":2,"b":2,"c":3,"d":4}
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	merge(empty_hash)	{}
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	merge(empty_hash, empty_hash)	{}

min

number min array[number]|array[string] $collection

Arguments

Name	Presence	Type	Description
$collection	required	array[number]|array[string]
Returns		number

Returns the lowest found number in the provided $collection argument.

Examples

Given	Expression	Result
["a","b"]	min(@)	"a"
[10,15]	min(@)	10
["a",2,"b"]	min(@)	null
[10,false,20]	min(@)	null
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	min(decimals)	-1.5
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	min(abc)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	min(empty_list)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	min(strings)	"a"
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	min(numbers)	-1
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	min(array)	null

min_by

any min_by array $elementsexpression->number|expression->string $expr

Arguments

Name	Presence	Type	Description
$elements	required	array
$expr	required	expression->number|expression->string
Returns		any

Return the minimum element in an array using the expression expr as the comparison key. The entire maximum element is returned. Below are several examples using the people array (defined above) as the given input.

Examples

Given	Expression	Result
Show more..
{"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	min_by(people, &to_number(age_str))	{"age":10,"age_str":"10","bool":true,"name":3}
{"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	min_by(people, &age_str)	null
{"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	min_by(people, age)	null
{"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	min_by(people, &age)	{"age":10,"age_str":"10","bool":true,"name":3}
{"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	min_by(people, &age_str)	{"age":10,"age_str":"10","bool":true,"name":3}
{"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	min_by(people, &bool)	null
{"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	min_by(people, &extra)	null

not_null

any not_null any $argumentany $..

Arguments

Name	Presence	Type	Description
$argument	required	any
$..	optional	any
Returns		any

Returns the first argument that does not resolve to null. This function accepts one or more arguments, and will evaluate them in order until a non null argument is encounted. If all arguments values resolve to null, then a value of null is returned.

Examples

Given	Expression	Result
{"a":null,"b":null,"c":[],"d":"foo"}	not_null(a, b, , d, c)	"foo"
{"a":null,"b":null,"c":[],"d":"foo"}	not_null(a, b)	null
{"a":null,"b":null,"c":[],"d":"foo"}	not_null(no_exist, a, b, c, d)	[]
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	not_null(unknown_key, str)	"Str"
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	not_null(unknown_key, foo.bar, empty_list, str)	[]
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	not_null(unknown_key, null_key, empty_list, str)	[]
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	not_null(all, expressions, are_null)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	not_null()	null

pad_left

string pad_left string $subjectnumber $widthstring $pad

Arguments

Name	Presence	Type	Description
$subject	required	string	Subject string
$width	required	number	Total width of the resulting string
$pad	optional	string	Pad character
Returns		string

Given the subject string, pad_left() adds characters to the beginning and returns a string of length at least width.

The pad optional string parameter specifies the padding character. If omitted, it defaults to an ASCII space (U+0020). If present, it MUST have length 1, otherwise an error MUST be raised.

If the subject string has length greater than or equal to width, it is returned unmodified.

If $width is not an integer, an error MUST be raised.

Examples

Given	Expression	Result
"string"	pad_left(@, `6`)	"string"
"string"	pad_left(@, `10`)	" string"
"string"	pad_left(@, `10`, -)	"----string"
"string"	pad_left(@, `0`)	"string"

pad_right

string pad_right string $subjectnumber $widthstring $pad

Arguments

Name	Presence	Type	Description
$subject	required	string	Subject string
$width	required	number	Total width of the resulting string
$pad	optional	string	Pad character
Returns		string

Given the subject string, pad_right() adds characters to the end and returns a string of length at least width.

The pad optional string parameter specifies the padding character. If omitted, it defaults to an ASCII space (U+0020). If present, it MUST have length 1, otherwise an error MUST be raised.

If the subject string has length greater than or equal to width, it is returned unmodified.

If $width is not an integer, an error MUST be raised.

Examples

Given	Expression	Result
"string"	pad_right(@, `10`)	"string "
"string"	pad_right(@, `10`, -)	"string----"
"string"	pad_right(@, `0`)	"string"
"string"	pad_right(@, `6`)	"string"

replace

string replace string $subjectstring $oldstring $newnumber $count

Arguments

Name	Presence	Type	Description
$subject	required	string	Subject string
$old	required	string	Text that must be replaced in the subject string
$new	required	string	Text used as a replacement
$count	optional	number	Number of replacements to perform
Returns		string

Given the subject string, replace() replaces ocurrences of the old substring with the new substring.

The count optional parameter specifies how many occurrences of the old substring in subject are to be replaced. If this parameter is omitted, all occurrences are replaced. If count is not an integer or is negative,

The replace() function has no effect if count is 0.

Examples

Given	Expression	Result
"aabaaabaaaab"	replace(@, 'aa', '-', `0`)	"aabaaabaaaab"
"aabaaabaaaab"	replace(@, 'aa', '-', `1`)	"-baaabaaaab"
"aabaaabaaaab"	replace(@, 'aa', '-', `2`)	"-b-abaaaab"
"aabaaabaaaab"	replace(@, 'aa', '-', `3`)	"-b-ab-aab"
"aabaaabaaaab"	replace(@, 'aa', '-')	"-b-ab--b"

reverse

array reverse string|array $argument

Arguments

Name	Presence	Type	Description
$argument	required	string|array
Returns		array

Reverses the order of the $argument.

Examples

Given	Expression	Result
[]	reverse(@)	[]
"abcd"	reverse(@)	"dcba"
[0,1,2,3,4]	reverse(@)	[4,3,2,1,0]
["a","b","c",1,2,3]	reverse(@)	[3,2,1,"c","b","a"]
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	reverse('')	""
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	reverse(empty_list)	[]
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	reverse('hello world')	"dlrow olleh"
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	reverse(array)	["100","a",5,4,3,-1]
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	reverse(numbers)	[5,4,3,-1]

sort

array sort array[number]|array[string] $list

Arguments

Name	Presence	Type	Description
$list	required	array[number]|array[string]
Returns		array

This function accepts an array $list argument and returns the sorted elements of the $list as an array.

The array must be a list of strings or numbers. Sorting strings is based on code points. Locale is not taken into account.

Examples

Given	Expression	Result
false	sort(@)	null
{"a":1,"b":2}	sort(@)	null
[1,"a","c"]	sort(@)	[1,"a","c"]
[[],{},false]	sort(@)	[{},[],false]
["b","a","c"]	sort(@)	["a","b","c"]
[false,[],null]	sort(@)	[[],null,false]
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	sort(values(objects))	["bar","baz"]
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	sort(abc)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	sort(keys(objects))	["bar","foo"]
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	sort(numbers)	[-1,3,4,5]
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	sort(decimals)	[-1.5,1.01,1.2]
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	sort(strings)	["a","b","c"]
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	sort(empty_list)	[]
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	sort(@)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	sort(array)	null

sort_by

array sort_by array $elementsexpression->number|expression->string $expr

Arguments

Name	Presence	Type	Description
$elements	required	array
$expr	required	expression->number|expression->string
Returns		array

Sort an array using an expression expr as the sort key. For each element in the array of elements, the expr expression is applied and the resulting value is used as the key used when sorting the elements.

If the result of evaluating the expr against the current array element results in type other than a number or a string, an invalid-type error will occur.

Below are several examples using the people array (defined above) as the given input. sort_by follows the same sorting logic as the sort function.

Examples

Given	Expression	Result
Show more..
{"people":[{"age":10,"order":"1"},{"age":10,"order":"2"},{"age":10,"order":"3"},{"age":10,"order":"4"},{"age":10,"order":"5"},{"age":10,"order":"6"},{"age":10,"order":"7"},{"age":10,"order":"8"},{"age":10,"order":"9"},{"age":10,"order":"10"},{"age":10,"order":"11"}]}	sort_by(people, &age)	[{"age":10,"order":"1"},{"age":10,"order":"2"},{"age":10,"order":"3"},{"age":10,"order":"4"},{"age":10,"order":"5"},{"age":10,"order":"6"},{"age":10,"order":"7"},{"age":10,"order":"8"},{"age":10,"order":"9"},{"age":10,"order":"10"},{"age":10,"order":"11"}]
{"empty_list":[],"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	sort_by(people, name)	null
{"empty_list":[],"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	sort_by(empty_list, &age)	[]
{"empty_list":[],"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	sort_by(people, &extra)	null
{"empty_list":[],"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	sort_by(people, &age)	[{"age":10,"age_str":"10","bool":true,"name":3},{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":50,"age_str":"50","bool":false,"name":"d"}]
{"empty_list":[],"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	sort_by(people, &bool)	null
{"empty_list":[],"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	sort_by(people, &age_str)	[{"age":10,"age_str":"10","bool":true,"name":3},{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":50,"age_str":"50","bool":false,"name":"d"}]
{"empty_list":[],"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	sort_by(people, &to_number(age_str))	[{"age":10,"age_str":"10","bool":true,"name":3},{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":50,"age_str":"50","bool":false,"name":"d"}]
{"empty_list":[],"people":[{"age":20,"age_str":"20","bool":true,"extra":"foo","name":"a"},{"age":40,"age_str":"40","bool":false,"extra":"bar","name":"b"},{"age":30,"age_str":"30","bool":true,"name":"c"},{"age":50,"age_str":"50","bool":false,"name":"d"},{"age":10,"age_str":"10","bool":true,"name":3}]}	sort_by(people, &name)	null

split

array[string] split string $subjectstring $searchnumber $count

Arguments

Name	Presence	Type	Description
$subject	required	string	Subject string
$search	required	string	Text separator
$count	optional	number	Number of splits to perform
Returns		array[string]

Given the subject string, split() breaks on ocurrences of the string search and returns an array.

The split() function returns an array containing each partial string between occurrences of search. If subject contains no occurrences of the search text, an array containing just the original subject string will be returned.

The count optional parameter specifies the maximum number of split points within the search string. If this parameter is omitted, all occurrences are split. If count is not an integer or is negative, an error MUST be raised.

If count is equal to 0, split() returns an array containing a single element, the subject string.

Otherwise, the split() function breaks on occurrences of the search string up to count times. The last string in the resulting array containing the remaining contents of the subject string unmodified.

Examples

Given	Expression	Result
"average|-|min|-|max|-|mean|-|median"	split(average|-|min|-|max|-|mean|-|median, '|-|', `3`)	["average","min","max","mean|-|median"]
"average|-|min|-|max|-|mean|-|median"	split(average|-|min|-|max|-|mean|-|median, '|-|', `2`)	["average","min","max|-|mean|-|median"]
"average|-|min|-|max|-|mean|-|median"	split(average|-|min|-|max|-|mean|-|median, '|-|', `1`)	["average","min|-|max|-|mean|-|median"]
"average|-|min|-|max|-|mean|-|median"	split(average|-|min|-|max|-|mean|-|median, '|-|', `0`)	["average|-|min|-|max|-|mean|-|median"]
"average|-|min|-|max|-|mean|-|median"	split(average|-|min|-|max|-|mean|-|median, '-')	["average|","|min|","|max|","|mean|","|median"]
null	split(all chars, )	["a","l","l"," ","c","h","a","r","s"]
null	split(/, /)	["",""]
"average|-|min|-|max|-|mean|-|median"	split(average|-|min|-|max|-|mean|-|median, '|-|')	["average","min","max","mean","median"]

starts_with

boolean starts_with string $subjectstring $prefix

Arguments

Name	Presence	Type	Description
$subject	required	string
$prefix	required	string
Returns		boolean

Returns true if the $subject starts with the $prefix, otherwise this function returns false.

Examples

Given	Expression	Result
"foobarbaz"	starts_with(@, 'foo')	true
"foobarbaz"	starts_with(@, 'baz')	false
"foobarbaz"	starts_with(@, 'f')	true
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	starts_with(str, 'Str')	true
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	starts_with(str, 'String')	false
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	starts_with(str, 0)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	starts_with(str, 'S')	true
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	starts_with(str, 'St')	true

sum

number sum array[number] $collection

Arguments

Name	Presence	Type	Description
$collection	required	array[number]
Returns		number

Returns the sum of the provided array argument.

An empty array will produce a return value of 0.

Examples

Given	Expression	Result
[]	sum(@)	0
[10,15]	sum(@)	25
[10,false,20]	sum(@)	null
[10,false,20]	sum([].to_number(@))	30
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	sum(array[].to_number(@))	111
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	sum(array)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	sum(numbers)	11
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	sum(empty_list)	0
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	sum(decimals)	0.71

to_array

array to_array any $arg

Arguments

Name	Presence	Type	Description
$arg	required	any
Returns		array

• array - Returns the passed in value.
• number/string/object/boolean/null - Returns a one element array containing the passed in argument.

Examples

Given	Expression	Result
null	to_array(true)	[true]
null	to_array()	[{"foo":"bar"}]
null	to_array(0)	[0]
null	to_array('string')	["string"]
null	to_array()	[1,2]
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	to_array('foo')	["foo"]
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	to_array(0)	[0]
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	to_array(objects)	[{"bar":"baz","foo":"bar"}]
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	to_array()	[1,2,3]
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	to_array(false)	[false]

to_number

number to_number any $arg

Arguments

Name	Presence	Type	Description
$arg	required	any
Returns		number

• string - Returns the parsed number. Any string that conforms to the json-number production is supported. Note that the floating number support will be implementation specific, but implementations should support at least IEEE 754-2008 binary64 (double precision) numbers, as this is generally available and widely used.

• number - Returns the passed in value.

• array - null

• object - null

• boolean - null

• null - null

Examples

Given	Expression	Result
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	to_number()	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	to_number()	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	to_number()	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	to_number('1.0')	1
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	to_number('1.1')	1.1
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	to_number('4')	4
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	to_number(notanumber)	null
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	to_number(false)	null

to_string

string to_string any $arg

Arguments

Name	Presence	Type	Description
$arg	required	any
Returns		string

• string - Returns the passed in value.

• number/array/object/boolean - The JSON encoded value of the object. The JSON encoder should emit the encoded JSON value without adding any additional new lines.

Examples

Given	Expression	Result
null	to_string(2)	"2"
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	to_string('foo')	"foo"
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	to_string(1.2)	"1.2"
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	to_string()	"[0,1]"

trim

string trim string $subjectstring $chars

Arguments

Name	Presence	Type	Description
$subject	required	string	Subject string
$chars	optional	string	Set of characters to be removed
Returns		string

Given the subject string, trim() removes the leading and trailing characters found in chars.

The chars optional parameter represents a set of characters to be removed from the subject string. If this parameter is not specified, or is an empty string, whitespace characters are removed from the subject string.

Examples

Given	Expression	Result
" subject string "	trim(@, 'gsu ')	"bject strin"
" subject string "	trim(@)	"subject string"
" subject string "	trim(@, '')	"subject string"
" subject string "	trim(@, ' ')	"subject string"
" subject string "	trim(@, 's')	" subject string "
" subject string "	trim(@, 'su')	" subject string "
" subject string "	trim(@, 'su ')	"bject string"

trim_left

string trim_left string $subjectstring $chars

Arguments

Name	Presence	Type	Description
$subject	required	string	Subject string
$chars	optional	string	Set of characters to be removed
Returns		string

Given the subject string, trim_left() removes the leading characters found in chars.

Like the trim() function, the chars optional string parameter represents a set of characters to be removed. trim_left() defaults to removing whitespace characters if chars is not specified or is an empty string.

Examples

Given	Expression	Result
" subject string "	trim_left(@)	"subject string "
" subject string "	trim_left(@, 's')	" subject string "
" subject string "	trim_left(@, 'su')	" subject string "
" subject string "	trim_left(@, 'su ')	"bject string "
" subject string "	trim_left(@, 'gsu ')	"bject string "

trim_right

string trim_right string $subjectstring $chars

Arguments

Name	Presence	Type	Description
$subject	required	string	Subject string
$chars	optional	string	Set of characters to be removed
Returns		string

Given the subject string, trim_right() removes the trailing characters found in chars.

Like the trim() function, the chars optional string parameter represents a set of characters to be removed. trim_right() defaults to removing whitespace characters if chars is not specified or is an empty string.

Examples

Given	Expression	Result
" subject string "	trim_right(@, 'gsu ')	" subject string"
" subject string "	trim_right(@)	"subject string "
" subject string "	trim_right(@, 's')	" subject string "
" subject string "	trim_right(@, 'su')	" subject string "
" subject string "	trim_right(@, 'su ')	" subject string"

type

string type array|object|string|number|boolean|null $subject

Arguments

Name	Presence	Type	Description
$subject	required	array|object|string|number|boolean|null
Returns		string

Returns the JavaScript type of the given $subject argument as a string value.

The return value MUST be one of the following:

• number
• string
• boolean
• array
• object
• null

Examples

Given	Expression	Result
false	type(@)	"boolean"
"foo"	type(@)	"string"
null	type(@)	"null"
["abc"]	type(@)	"array"
true	type(@)	"boolean"
{"abc":"123"}	type(@)	"object"
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	type(false)	"boolean"
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	type(@)	"object"
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	type('abc')	"string"
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	type(1)	"number"
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	type(2)	"number"
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	type()	"null"
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	type()	"object"
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	type(true)	"boolean"
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	type()	"array"
123	type(@)	"number"
123.05	type(@)	"number"

upper

string upper string $subject

Arguments

Name	Presence	Type	Description
$subject	required	string	Subject string
Returns		string

Returns the uppercase subject string.

Examples

Given	Expression	Result
"string"	upper(@)	"STRING"

values

array values object $obj

Arguments

Name	Presence	Type	Description
$obj	required	object
Returns		array

Returns the values of the provided object. Note that because JSON hashes are inheritently unordered, the values associated with the provided object obj are inheritently unordered. Implementations are not required to return values in any specific order. For example, given the input:

{"a": "first", "b": "second", "c": "third"}

The expression values(@) could have any of these return values:

• ["first", "second", "third"]

• ["first", "third", "second"]

• ["second", "first", "third"]

• ["second", "third", "first"]

• ["third", "first", "second"]

• ["third", "second", "first"]

If you would like a specific order, consider using the sort or sort_by functions.

Examples

Given	Expression	Result
false	values(@)	null
{"bar":"bam","foo":"baz"}	values(@)	["baz","bam"]
["a","b"]	values(@)	null
Show more..
{"array":[-1,3,4,5,"a","100"],"decimals":[1.01,1.2,-1.5],"empty_hash":{},"empty_list":[],"false":false,"foo":-1,"null_key":null,"numbers":[-1,3,4,5],"objects":{"bar":"baz","foo":"bar"},"str":"Str","strings":["a","b","c"],"zero":0}	values(foo)	null

zip

array[array[any]] zip array[any] $arg

Arguments

Name	Presence	Type	Description
$arg	required	array[any]
Returns		array[array[any]]

Accepts one or more arrays as arguments and returns an array of arrays in which the i-th array contains the i-th element from each of the argument arrays. The returned array is truncated to the length of the shortest argument array.

Examples

Given	Expression	Result
null	zip()	[["a",1],["b",2]]
null	zip()	[["a",1],["b",2]]