jq

https://jqlang.org/
Admin
jq is a lightweight and flexible command-line JSON processor that uses a powerful query language for...
Tokens:81,778
Snippets:635
Trust Score:9.6
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Object construction: example with array expansion

Source: https://jqlang.org/manual

Example from the manual showing the output of `{user, title: .titles[]}` on the given input, producing two objects.

```jq
jq '{user, title: .titles[]}'
```

```json
{"user":"stedolan","titles":["JQ Primer", "More JQ"]}
```

```json
{"user":"stedolan", "title": "JQ Primer"}
```

```json
{"user":"stedolan", "title": "More JQ"}
```

--------------------------------

### Example: destructuring alternative with object/array events

Source: https://jqlang.org/manual

Example command, input, and output for the destructuring alternative operator with both object and array events.

```shell
jq '.[] as {$a, $b, c: {$d, $e}} ?// {$a, $b, c: [{$d, $e}]} | {$a, $b, $d, $e}'
```

```json
[{"a": 1, "b": 2, "c": {"d": 3, "e": 4}}, {"a": 1, "b": 2, "c": [{"d": 3, "e": 4}]}]
```

```json
{"a":1,"b":2,"d":3,"e":4}
{"a":1,"b":2,"d":3,"e":4}
```

--------------------------------

### jq '[.[]|startswith("foo")]'

Source: https://jqlang.org/manual

Outputs true if the input string starts with the given argument. Example shows array of booleans.

```jq
jq '[.[]|startswith("foo")]'
```

```input
["fo", "foo", "barfoo", "foobar", "barfoob"]
```

```output
[false, true, false, true, false]
```

--------------------------------

### Object construction: example with parenthesized key

Source: https://jqlang.org/manual

Example from the manual showing the output of `{(.user): .titles}` on the given input, producing an object with the user's name as key.

```jq
jq '{(.user): .titles}'
```

```json
{"user":"stedolan","titles":["JQ Primer", "More JQ"]}
```

```json
{"stedolan": ["JQ Primer", "More JQ"]}
```

--------------------------------

### Blog post input with realnames mapping

Source: https://jqlang.org/manual

Example input for the blog post example: an object with a posts array and a realnames mapping. Used to demonstrate variable binding for author name lookup.

```json
{"posts": [{"title": "First post", "author": "anon"},
           {"title": "A well-written article", "author": "person1"}],
 "realnames": {"anon": "Anonymous Coward",
               "person1": "Person McPherson"}}
```

--------------------------------

### Example: destructuring alternative with null unmatched variables

Source: https://jqlang.org/manual

Example showing that unmatched variables become null when alternatives define different variables.

```shell
jq '.[] as {$a, $b, c: {$d}} ?// {$a, $b, c: [{$e}]} | {$a, $b, $d, $e}'
```

```json
[{"a": 1, "b": 2, "c": {"d": 3, "e": 4}}, {"a": 1, "b": 2, "c": [{"d": 3, "e": 4}]}]
```

```json
{"a":1,"b":2,"d":3,"e":null}
{"a":1,"b":2,"d":null,"e":4}
```

--------------------------------

### min example

Source: https://jqlang.org/manual

Finds the minimum element of the input array.

```jq
jq 'min'
```

```json
[5,4,2,7]
```

```json
2
```

--------------------------------

### Example: destructuring alternative with error fallback

Source: https://jqlang.org/manual

Example showing error handling with the alternative operator: the first alternative errors, so the second is tried.

```shell
jq '.[] as [$a] ?// [$b] | if $a != null then error("err: \($a)") else {$a,$b} end'
```

```json
[[3]]
```

```json
{"a":null,"b":3}
```

--------------------------------

### foreach expansion for [1,2,3]

Source: https://jqlang.org/manual

Shows the equivalent expansion of the foreach example for input [1,2,3]. Each line produces an intermediate result.

```jq
0 | 1 as $item | . + $item | [$item, . * 2],
    2 as $item | . + $item | [$item, . * 2],
    3 as $item | . + $item | [$item, . * 2]
```

--------------------------------

### Example: function with value argument

Source: https://jqlang.org/manual

Example of a function that captures the filter argument as a value, producing different output than the filter-argument version.

```shell
jq 'def addvalue(f): f as $x | map(. + $x); addvalue(.[0])'
```

```json
[[1,2],[10,20]]
```

```json
[[1,2,1,2], [10,20,1,2]]
```

--------------------------------

### index(1) example

Source: https://jqlang.org/manual

Outputs the index of the first occurrence of 1 in the input array.

```jq
jq 'index(1)'
```

```json
[0,1,2,1,3,1,4]
```

```json
1
```

--------------------------------

### reverse example

Source: https://jqlang.org/manual

Reverses the order of elements in the input array.

```jq
jq 'reverse'
```

```json
[1,2,3,4]
```

```json
[4,3,2,1]
```

--------------------------------

### reduce expansion for [1,2,3]

Source: https://jqlang.org/manual

Shows the equivalent expansion of the reduce example for input [1,2,3]. Each line adds the next item to the running total.

```jq
0 | 1 as $item | . + $item |
    2 as $item | . + $item |
    3 as $item | . + $item
```

--------------------------------

### index(", ") example

Source: https://jqlang.org/manual

Outputs the index of the first occurrence of ", " in the input string.

```jq
jq 'index(", ")'
```

```json
"a,b, cd, efg, hijk"
```

```json
3
```

--------------------------------

### Example: function with filter argument

Source: https://jqlang.org/manual

Example of a function with a filter argument: addvalue(.[0]) adds the first element of the input array to each element.

```shell
jq 'def addvalue(f): . + [f]; map(addvalue(.[0]))'
```

```json
[[1,2],[10,20]]
```

```json
[[1,2,1], [10,20,10]]
```

--------------------------------

### index([1,2]) example

Source: https://jqlang.org/manual

Outputs the index of the first occurrence of the subarray [1,2] in the input array.

```jq
jq 'index([1,2])'
```

```json
[0,1,2,3,1,4,2,5,1,2,6,7]
```

```json
1
```

--------------------------------

### startswith(str)

Source: https://jqlang.org/manual

The `startswith` function outputs `true` if the input string starts with the specified argument.

```APIDOC
## startswith(str)

### Description
Outputs `true` if the input starts with the given string argument.

### Syntax
`startswith(str)`

### Example
- Command: `jq '[.[]|startswith("foo")]'` with input `["fo", "foo", "barfoo", "foobar", "barfoob"]` outputs `[false, true, false, true, false]`
```

--------------------------------

### tostream and fromstream round-trip example

Source: https://jqlang.org/manual

Verifies that tostream and fromstream are inverses. The command converts the input to its streamed form and back, then checks equality with the original, outputting true.

```bash
jq '. as $dot|fromstream($dot|tostream)|.==$dot'
```

```text
[0,[1,{"a":1},{"b":2}]]
```

```text
true
```

--------------------------------

### splits(regex) example

Source: https://jqlang.org/manual

Splits the input string on each regex match of ', *' and emits the substrings as a stream (one per line) instead of an array.

```jq
jq 'splits(", *")'
```

```text
"ab,cd, ef, gh"
```

```text
"ab"
"cd"
"ef"
"gh"
```

--------------------------------

### indices(", ") example

Source: https://jqlang.org/manual

Outputs the indices where the string ", " occurs in the input string.

```jq
jq 'indices(", ")'
```

```json
"a,b, cd, efg, hijk"
```

```json
[3,7,12]
```

--------------------------------

### split(regex; flags) example

Source: https://jqlang.org/manual

Splits the input string on each regex match of ', *' (comma followed by zero or more spaces). The result is an array of substrings.

```jq
jq 'split(", *"; null)'
```

```text
"ab,cd, ef"
```

```text
["ab","cd","ef"]
```

--------------------------------

### jq 'pick(.[2], .[0], .[0])'

Source: https://jqlang.org/manual

Projects the specified indices from an array. Example input: [1,2,3,4] outputs [1,null,3].

```bash
jq 'pick(.[2], .[0], .[0])'
```

--------------------------------

### indices(1) example

Source: https://jqlang.org/manual

Outputs the indices where the value 1 occurs in the input array.

```jq
jq 'indices(1)'
```

```json
[0,1,2,1,3,1,4]
```

```json
[1,3,5]
```

--------------------------------

### jq while generator example

Source: https://jqlang.org/manual

Command-line jq invocation defining a while generator that doubles values until reaching 100, with input 1 and output [1,2,4,8,16,32,64].

```jq
jq 'def while(cond; update): def _while: if cond then ., (update | _while) else empty end; _while; [while(.<100; .*2)]'
```

```json
1
```

```json
[1,2,4,8,16,32,64]
```

--------------------------------

### Blog post output with real author names

Source: https://jqlang.org/manual

Expected output for the blog post example, showing posts with author names replaced by real names from the mapping.

```json
{"title": "First post", "author": "Anonymous Coward"}
{"title": "A well-written article", "author": "Person McPherson"}
```

--------------------------------

### jq '@base64' example

Source: https://jqlang.org/manual

Converts input to base64 as per RFC 4648. For input "This is a message", output is "VGhpcyBpcyBhIG1lc3NhZ2U=".

```jq
jq '@base64'

```

```input
"This is a message"

```

```output
"VGhpcyBpcyBhIG1lc3NhZ2U="

```

--------------------------------

### jq '[.[]|ltrimstr("foo")]'

Source: https://jqlang.org/manual

Outputs its input with the given prefix string removed, if it starts with it.

```jq
jq '[.[]|ltrimstr("foo")]'
```

```input
["fo", "foo", "barfoo", "foobar", "afoo"]
```

```output
["fo","","barfoo","bar","afoo"]
```

--------------------------------

### fromstream with truncate_stream example

Source: https://jqlang.org/manual

Shows fromstream applied to the output of truncate_stream. The command reconstructs the value from the truncated stream, outputting ["b"].

```bash
jq 'fromstream(1|truncate_stream([[0],"a"],[[1,0],"b"],[[1,0]],[[1]]))'
```

```text
null
```

```text
["b"]
```

--------------------------------

### jq 'map(.+1)'

Source: https://jqlang.org/manual

Applies .+1 to each element of an array. Example input: [1,2,3] outputs [2,3,4].

```bash
jq 'map(.+1)'
```

--------------------------------

### group_by(.foo) example

Source: https://jqlang.org/manual

Groups array elements by the .foo field, producing a sorted array of arrays. The input is an array of objects with foo and bar fields.

```jq
jq 'group_by(.foo)'
```

```json
[{"foo":1, "bar":10}, {"foo":3, "bar":100}, {"foo":1, "bar":1}]
```

```json
[[{"foo":1, "bar":10}, {"foo":1, "bar":1}], [{"foo":3, "bar":100}]]
```

--------------------------------

### jq '@base64d' example

Source: https://jqlang.org/manual

Decodes base64 input as per RFC 4648. For input "VGhpcyBpcyBhIG1lc3NhZ2U=", output is "This is a message".

```jq
jq '@base64d'

```

```input
"VGhpcyBpcyBhIG1lc3NhZ2U="

```

```output
"This is a message"

```

--------------------------------

### jq match with global flag example

Source: https://jqlang.org/manual

Finds all matches of '(abc)+' with the 'g' flag. Outputs two match objects for input 'abc abc'.

```bash
jq 'match("(abc)+"; "g")'
```

--------------------------------

### jq match count example

Source: https://jqlang.org/manual

Counts the number of matches of '.' with the 'g' flag by wrapping in an array and taking length. Returns 3 for input 'abc'.

```bash
jq '[ match("."; "g")] | length'
```

--------------------------------

### jq comment continuation with backslashes

Source: https://jqlang.org/manual

Shows how comments are handled in jq filters. A '#' starts a comment that runs to the end of the line, but if the line ends with an odd number of backslashes, the comment continues on the next line. This example outputs [1,3,4,7].

```jq
[
  1,
  # foo \
  2,
  # bar \\
  3,
  4, # baz \\\
  5, \
  6,
  7
  # comment \
    comment \
    comment
]

```

--------------------------------

### Using jq `input` builtin

Source: https://jqlang.org/manual

Demonstrates the `input` builtin, which outputs one new input. Use with the `-n` option to avoid losing the first entity.

```bash
echo 1 2 3 4 | jq '[., input]' # [1,2] [3,4]

```

--------------------------------

### jq 'pick(.a, .b.c, .x)'

Source: https://jqlang.org/manual

Projects the specified paths from an object. Example input: {"a": 1, "b": {"c": 2, "d": 3}, "e": 4} outputs {"a":1,"b":{"c":2},"x":null}.

```bash
jq 'pick(.a, .b.c, .x)'
```

--------------------------------

### GitHub API parents field example

Source: https://jqlang.org/tutorial

Example of the 'parents' field in the GitHub API response for a commit. It contains an array of parent commit objects, each with 'sha', 'url', and 'html_url' fields.

```json
"parents": [
  {
    "sha": "f2ad9517c72f6267ae317639ab56bbfd4a8653d4",
    "url": "https://api.github.com/repos/jqlang/jq/commits/f2ad9517c72f6267ae317639ab56bbfd4a8653d4",
    "html_url": "https://github.com/jqlang/jq/commit/f2ad9517c72f6267ae317639ab56bbfd4a8653d4"
  }
]

```

--------------------------------

### map and map_values examples on array [1]

Source: https://jqlang.org/manual

Clarifies behavior of map and map_values when applied to arrays. Assumes input is [1] in all cases. Shows that map(., .) produces [1,1] while map_values(., .) produces [1] because map_values uses first($x|f).

```jq
map(.+1)          #=>  [2]
map(., .)         #=>  [1,1]
map(empty)        #=>  []

map_values(.+1)   #=>  [2]
map_values(., .)  #=>  [1]
map_values(empty) #=>  []
```

--------------------------------

### unique example

Source: https://jqlang.org/manual

Removes duplicates from the input array and sorts the result.

```jq
jq 'unique'
```

```json
[1,2,5,3,5,3,1,3]
```

```json
[1,2,3,5]
```

--------------------------------

### rindex(1) example

Source: https://jqlang.org/manual

Outputs the index of the last occurrence of 1 in the input array.

```jq
jq 'rindex(1)'
```

```json
[0,1,2,1,3,1,4]
```

```json
5
```

--------------------------------

### pick(pathexps)

Source: https://jqlang.org/manual

Documentation for the jq builtin function `pick`.

```APIDOC
## `pick(pathexps)`

### Description
Emits the projection of the input object or array defined by the specified path expressions. For arrays, negative indices and `.[m:n]` specifications should not be used.

### Method
N/A (jq builtin function)

### Endpoint
N/A

### Parameters
- **pathexps** (path expressions) - Required - A sequence of path expressions defining the projection.

### Request Example
```
jq 'pick(.a, .b.c, .x)'
```

### Response
#### Success Response
- **output** (object or array) - The projected object or array.

#### Response Example
```
{"a":1,"b":{"c":2},"x":null}
```
```

--------------------------------

### $JQ_BUILD_CONFIGURATION

Source: https://jqlang.org/manual

The `$JQ_BUILD_CONFIGURATION` builtin binding shows the jq executable's build configuration. Its value has no particular format, but can be expected to be at least the `./configure` command-line arguments.

```APIDOC
## `$JQ_BUILD_CONFIGURATION`

### Description
Shows the jq executable's build configuration.

### Binding
`$JQ_BUILD_CONFIGURATION`

### Notes
- The value has no particular format, but can be expected to be at least the `./configure` command-line arguments.
- May be enriched in the future to include version strings for build tooling.
- Can be overridden in the command-line with `--arg` and related options.
```

--------------------------------

### indices([1,2]) example

Source: https://jqlang.org/manual

Outputs the indices where the subarray [1,2] occurs in the input array.

```jq
jq 'indices([1,2])'
```

```json
[0,1,2,3,1,4,2,5,1,2,6,7]
```

```json
[1,8]
```

--------------------------------

### max_by(.foo) example

Source: https://jqlang.org/manual

Finds the object with the largest .foo field in the input array.

```jq
jq 'max_by(.foo)'
```

```json
[{"foo":1, "bar":14}, {"foo":2, "bar":3}]
```

```json
{"foo":2, "bar":3}
```

--------------------------------

### jq command: .bar as $x

Source: https://jqlang.org/manual

Command-line example showing variable binding: stores `.bar` in `$x`, then adds it to `.foo`. Input is `{"foo":10, "bar":200}` and output is `210`.

```bash
jq '.bar as $x | .foo | . + $x'
```

```json
{"foo":10, "bar":200}
```

```text
210
```

--------------------------------

### jq 'map(., .)'

Source: https://jqlang.org/manual

Duplicates each element of an array. Example input: [1,2] outputs [1,1,2,2].

```bash
jq 'map(., .)'
```

--------------------------------

### ltrimstr(str)

Source: https://jqlang.org/manual

The `ltrimstr` function removes the given prefix string from the input if it starts with it.

```APIDOC
## ltrimstr(str)

### Description
Outputs its input with the given prefix string removed, if it starts with it.

### Syntax
`ltrimstr(str)`

### Example
- Command: `jq '[.[]|ltrimstr("foo")]'` with input `["fo", "foo", "barfoo", "foobar", "afoo"]` outputs `["fo","","barfoo","bar","afoo"]`
```

--------------------------------

### rindex([1,2]) example

Source: https://jqlang.org/manual

Outputs the index of the last occurrence of the subarray [1,2] in the input array.

```jq
jq 'rindex([1,2])'
```

```json
[0,1,2,3,1,4,2,5,1,2,6,7]
```

```json
8
```

--------------------------------

### trimstr(str)

Source: https://jqlang.org/manual

The `trimstr` function removes the given string from both ends of the input if it starts or ends with it.

```APIDOC
## trimstr(str)

### Description
Outputs its input with the given string removed at both ends, if it starts or ends with it.

### Syntax
`trimstr(str)`

### Example
- Command: `jq '[.[]|trimstr("foo")]'` with input `["fo", "foo", "barfoo", "foobarfoo", "foob"]` outputs `["fo","","bar","bar","b"]`
```

--------------------------------

### Using jq `inputs` builtin

Source: https://jqlang.org/manual

Shows the `inputs` builtin, which outputs all remaining inputs one by one, useful for reductions. Use with `-n` to avoid losing the first entity.

```bash
echo 1 2 3 | jq -n 'reduce inputs as $i (0; . + $i)' # 6

```

--------------------------------

### rindex(", ") example

Source: https://jqlang.org/manual

Outputs the index of the last occurrence of ", " in the input string.

```jq
jq 'rindex(", ")'
```

```json
"a,b, cd, efg, hijk"
```

```json
12
```

--------------------------------

### repeat(exp) example

Source: https://jqlang.org/manual

Applies expression exp repeatedly to . until an error is raised. Recursive calls within repeat will not consume additional memory if exp produces at most one output for each input.

```command
jq '[repeat(.*2, error)?]'
```

```input
1
```

```output
[2]
```

--------------------------------

### jq command: destructuring with as

Source: https://jqlang.org/manual

Command-line example using destructuring in an `as` pattern to bind `$a`, `$b`, and `$c` from the input array, then summing them. Input is `[2, 3, {"c": 4, "d": 5}]` and output is `9`.

```bash
jq '. as [$a, $b, {c: $c}] | $a + $b + $c'
```

```json
[2, 3, {"c": 4, "d": 5}]
```

```json
9
```

--------------------------------

### JOIN($idx; stream; idx_expr)

Source: https://jqlang.org/manual

Same as JOIN($idx; stream; idx_expr; .).

```APIDOC
## JOIN($idx; stream; idx_expr)

### Description
Same as JOIN($idx; stream; idx_expr; .).

### Method
N/A (jq builtin)

### Endpoint
N/A

### Parameters
#### Arguments
- **$idx** (object) - Required - Index object.
- **stream** (stream) - Required - Stream of values.
- **idx_expr** (expression) - Required - Expression to compute index key for each stream value.

### Request Example
```
[1,2,3]
```

### Response
#### Success Response
- **output** (stream) - Results of join expression.

#### Response Example
```
[1,2,3]
```
```

--------------------------------

### import RelativePathString as NAME [<metadata>];

Source: https://jqlang.org/manual

Imports a jq module from a search path, prefixing its symbols with a given name.

```APIDOC
## import RelativePathString as NAME [<metadata>];

### Description
Imports a module found at the given path relative to a directory in a search path. A `.jq` suffix will be added to the relative path string. The module's symbols are prefixed with `NAME::`.

### Syntax
`import RelativePathString as NAME [<metadata>];`

### Parameters
- **RelativePathString** (string) - Required - Path to the module relative to a directory in the search path.
- **NAME** (identifier) - Required - Prefix for the module's symbols.
- **metadata** (object) - Optional - Constant jq expression; should be an object with keys like `homepage`. The `search` key, if present, should be a string or array of strings; it is prefixed to the top-level search path.

### Remarks
- The `.jq` suffix is added to the relative path string.
- The metadata is available via the `modulemeta` builtin.
```

--------------------------------

### jq `debug(msgs)` stderr output

Source: https://jqlang.org/manual

The two lines written to stderr by the preceding `debug(msgs)` example.

```jq
["DEBUG:","Entering function foo with $x == 1"]
["DEBUG:",2]

```

--------------------------------

### unique_by(.foo) example

Source: https://jqlang.org/manual

Keeps only one element for each distinct value of .foo, preserving the first occurrence order.

```jq
jq 'unique_by(.foo)'
```

```json
[{"foo": 1, "bar": 2}, {"foo": 1, "bar": 3}, {"foo": 4, "bar": 5}]
```

```json
[{"foo": 1, "bar": 2}, {"foo": 4, "bar": 5}]
```

--------------------------------

### jq '[.[]|trimstr("foo")]'

Source: https://jqlang.org/manual

Outputs its input with the given string removed at both ends, if it starts or ends with it.

```jq
jq '[.[]|trimstr("foo")]'
```

```input
["fo", "foo", "barfoo", "foobarfoo", "foob"]
```

```output
["fo","","bar","bar","b"]
```

--------------------------------

### setpath([0,"a"]; 1) creates array

Source: https://jqlang.org/manual

setpath creates an array when the path starts with an index.

```bash
jq 'setpath([0,"a"]; 1)'
```

```json
null
```

```json
[{"a":1}]
```

--------------------------------

### unique_by(length) example

Source: https://jqlang.org/manual

Keeps one element per distinct string length, using the length function as the key.

```jq
jq 'unique_by(length)'
```

```json
["chunky", "bacon", "kitten", "cicada", "asparagus"]
```

```json
["bacon", "chunky", "asparagus"]
```

--------------------------------

### in

Source: https://jqlang.org/manual

Documentation for the jq builtin function `in`.

```APIDOC
## `in`

### Description
Returns whether the input key is in the given object, or the input index corresponds to an element in the given array. It is the inverse of `has`.

### Method
N/A (jq builtin function)

### Endpoint
N/A

### Parameters
- **input** (key or index) - Required - The key or index to check.
- **object or array** - Required - The object or array to check against.

### Request Example
```
jq '.[] | in({"foo": 42})'
```

### Response
#### Success Response
- **output** (boolean) - `true` if the key or index exists, `false` otherwise.

#### Response Example
```
true
false
```
```

--------------------------------

### jq '.[:3]' on array of strings

Source: https://jqlang.org/manual

Omitted start index means from the beginning; slice returns first three elements.

```bash
jq '.[:3]'
```

```json
["a","b","c","d","e"]
```

```json
["a", "b", "c"]
```

--------------------------------

### truncate_stream example

Source: https://jqlang.org/manual

Demonstrates the truncate_stream builtin. The command consumes a number (1) as input and truncates that many path elements from the left of the streamed form of ["a",["b"]], producing the streamed form of ["b"].

```bash
jq 'truncate_stream([[0],"a"],[[1,0],"b"],[[1,0]],[[1]])'
```

```text
1
```

```text
[[0],"b"]
[[0]]
```

--------------------------------

### jq variable scope: failing example

Source: https://jqlang.org/manual

Fails because the variable `$names` is scoped only within the parentheses, so it is not visible in the later part of the pipeline.

```jq
(.realnames as $names | .posts[]) | {title, author: $names[.author]}
```

--------------------------------

### jq variable scope: working example

Source: https://jqlang.org/manual

Works because the variable `$names` is scoped over the rest of the expression that defines it, including the parenthesized subexpression.

```jq
.realnames as $names | (.posts[] | {title, author: $names[.author]})
```

--------------------------------

### Invoking jq with shell quoting examples

Source: https://jqlang.org/manual

Shows how to quote jq programs for different shells. Use single quotes on Unix and Powershell, double quotes on Windows command shell, with backslash-escaped double quotes inside the program.

```shell
jq '.["foo"]'
```

```shell
jq '.["foo"]'
```

```shell
jq ".[\"foo\"]"
```

--------------------------------

### jq test('foo') example

Source: https://jqlang.org/manual

Tests if the input string contains 'foo'. Returns true for input "foo".

```bash
jq 'test("foo")'
```

--------------------------------

### jq while(cond; update) example

Source: https://jqlang.org/manual

Applies the update expression .*2 repeatedly to the input 1 while the result is less than 100, producing the array [1,2,4,8,16,32,64]. The command is: jq '[while(.<100; .*2)]'.

```jq
jq '[while(.<100; .*2)]'
```

```input
1
```

```output
[1,2,4,8,16,32,64]
```

--------------------------------

### jq test with flags 'ix' example

Source: https://jqlang.org/manual

Tests each element of an array against the regex 'a b c # spaces are ignored' with flags 'i' (case insensitive) and 'x' (extended format). Returns true for both inputs.

```bash
jq '.[] | test("a b c # spaces are ignored"; "ix")'
```

--------------------------------

### Run jq Docker image

Source: https://jqlang.org/download

Runs the jq Docker image from GitHub Container Registry, executing the jq expression 'range(3)' with the -n flag to produce output without reading input.

```bash
docker run -i --rm ghcr.io/jqlang/jq -n 'range(3)'

```

--------------------------------

### now

Source: https://jqlang.org/manual

Outputs the current time in seconds since Unix epoch.

```APIDOC
## now

### Description
Outputs the current time in seconds since Unix epoch.

### Method
N/A (jq builtin)

### Endpoint
N/A

### Parameters
None

### Request Example
```
.
```

### Response
#### Success Response
- **output** (number) - Current time in seconds since Unix epoch.

#### Response Example
```
1425599507
```
```

--------------------------------

### path(..) to list all paths

Source: https://jqlang.org/manual

Uses path(..) to list all paths in the input object, including nested array indices.

```bash
jq '[path(..)]'
```

```json
{"a":[{"b":1}]}
```

```json
[[],["a"],["a",0],["a",0,"b"]]
```

--------------------------------

### jq match without flags example

Source: https://jqlang.org/manual

Finds the first match of 'foo' in the input. Returns a match object with captures array empty.

```bash
jq 'match("foo")'
```

--------------------------------

### jq '[.[]|endswith("foo")]'

Source: https://jqlang.org/manual

Outputs true if the input string ends with the given argument. Example shows array of booleans.

```jq
jq '[.[]|endswith("foo")]'
```

```input
["foobar", "barfoo"]
```

```output
[false, true]
```

--------------------------------

### Build jq from git clone

Source: https://jqlang.org/download

Build jq from the latest development version. Requires GCC, Make, and Autotools; on macOS, Apple's command line tools (installed from Xcode) may need a newer Bison from Homebrew or MacPorts.

```bash
git clone --recursive https://github.com/jqlang/jq.git
cd jq
autoreconf -i
./configure
make
sudo make install
```
Tokens:
Raw