yq

YQ(1) YQ(1)

NAME

   yq is a portable command-line data file processor

SYNOPSIS

   yq [eval/eval-all] [expression] files..

   eval/e - (default) Apply the expression to each document in each yaml file in sequence

   eval-all/ea - Loads all yaml documents of all yaml files and runs expression once

DESCRIPTION

   a lightweight and portable command-line data file processor.  yq uses jq like syntax but works with yaml, json, xml, csv, properties and TOML files.  It doesn’t yet support everything
   jq does - but it does support the most common operations and functions, and more is being added continuously.

   This documentation is also available at https://mikefarah.gitbook.io/yq/ # QUICK GUIDE

Read a value:

          yq '.a.b[0].c' file.yaml

Pipe from STDIN:

          cat file.yaml | yq '.a.b[0].c'

Update a yaml file, in place

          yq -i '.a.b[0].c = "cool"' file.yaml

Update using environment variables

          NAME=mike yq -i '.a.b[0].c = strenv(NAME)' file.yaml

Merge multiple files

          yq ea '. as $item ireduce ({}; . * $item )' path/to/*.yml

   Note the use of ea to evaluate all files at once (instead of in sequence.)

Multiple updates to a yaml file

          yq -i '
            .a.b[0].c = "cool" |
            .x.y.z = "foobar" |
            .person.name = strenv(NAME)
          ' file.yaml

   See the documentation for more.

KNOWN ISSUES / MISSING FEATURES

   • yq attempts to preserve comment positions and whitespace as much as possible, but it does not handle all scenarios (see https://github.com/go-yaml/yaml/tree/v3 for details)

   • Powershell has its own...opinions: https://mikefarah.gitbook.io/yq/usage/tips-and-tricks#quotes-in-windows-powershell

BUGS / ISSUES / FEATURE REQUESTS

   Please visit the GitHub page https://github.com/mikefarah/yq/.

HOW IT WORKS

   In  yq  expressions are made up of operators and pipes.  A context of nodes is passed through the expression and each operation takes the context as input and returns a new context as
   output.  That output is piped in as input for the next operation in the expression.  To begin with, the context is set to the first yaml document of the first yaml file (if processing
   in sequence using eval).

   Lets look at a couple of examples.

Simple assignment example

   Given a document like:

          a: cat
          b: dog

   with an expression:

          .a = .b

   Like math expressions - operator precedence is important.

   The = operator takes two arguments, a lhs expression, which in this case is .a and rhs expression which is .b.

   It pipes the current, lets call it `root' context through the lhs expression of .a to return the node

          cat

   Side note: this node holds not only its value `cat', but comments and metadata too, including path and parent information.

   The = operator then pipes the `root' context through the rhs expression of .b to return the node

          dog

   Both sides have now been evaluated, so now the operator copies across the value from the RHS (.b) to the LHS (.a), and it returns the now updated context:

          a: dog
          b: dog

Complex assignment, operator precedence rules

   Just like math expressions - yq expressions have an order of precedence.  The pipe | operator has a low order of precedence, so operators with higher  precedence  will  get  evaluated
   first.

   Most of the time, this is intuitively what you’d want, for instance .a = "cat" | .b = "dog" is effectively: (.a = "cat") | (.b = "dog").

   However, this is not always the case, particularly if you have a complex LHS or RHS expression, for instance if you want to select particular nodes to update.

   Lets say you had:

          - name: bob
            fruit: apple
          - name: sally
            fruit: orange

   Lets say you wanted to update the sally entry to have fruit: `mango'.  The incorrect way to do that is: .[] | select(.name == "sally") | .fruit = "mango".

   Because  |  has a low operator precedence, this will be evaluated (incorrectly) as : (.[]) | (select(.name == "sally")) | (.fruit = "mango").  What you’ll see is only the updated seg‐
   ment returned:

          name: sally
          fruit: mango

   To properly update this yaml, you will need to use brackets (think BODMAS from maths) and wrap the entire LHS: (.[] | select(.name == "sally") | .fruit) = "mango"

   Now that entire LHS expression is passed to the `assign' (=) operator, and the yaml is correctly updated and returned:

          - name: bob
            fruit: apple
          - name: sally
            fruit: mango

Relative update (e.g. |=)

   There is another form of the = operator which we call the relative form.  It’s very similar to = but with one key difference when evaluating the RHS expression.

   In the plain form, we pass in the `root' level context to the RHS expression.  In relative form, we pass in each result of the LHS to the RHS expression.  Let’s go through an example.

   Given a document like:

          a: 1
          b: thing

   with an expression:

          .a |= . + 1

   Similar to the = operator, |= takes two operands, the LHS and RHS.

   It pipes the current context (the whole document) through the LHS expression of .a to get the node value:

          1

   Now it pipes that LHS context into the RHS expression . + 1 (whereas in the = plain form it piped the original document context into the RHS) to yield:

          2

   The assignment operator then copies across the value from the RHS to the value on the LHS, and it returns the now updated `root' context:

          a: 2
          b: thing

Add

   Add behaves differently according to the type of the LHS: * arrays: concatenate * number scalars: arithmetic addition * string scalars: concatenate * maps: shallow merge (use the mul‐
   tiply operator (*) to deeply merge)

   Use += as a relative append assign for things like increment.  Note that .a += .x is equivalent to running .a = .a + .x.

Concatenate arrays

   Given a sample.yml file of:

          a:
            - 1
            - 2
          b:
            - 3
            - 4

   then

          yq '.a + .b' sample.yml

   will output

          - 1
          - 2
          - 3
          - 4

Concatenate to existing array

   Note that the styling of a is kept.

   Given a sample.yml file of:

          a: [1,2]
          b:
            - 3
            - 4

   then

          yq '.a += .b' sample.yml

   will output

          a: [1, 2, 3, 4]
          b:
            - 3
            - 4

Concatenate null to array

   Given a sample.yml file of:

          a:
            - 1
            - 2

   then

          yq '.a + null' sample.yml

   will output

          - 1
          - 2

Append to existing array

   Note that the styling is copied from existing array elements

   Given a sample.yml file of:

          a: ['dog']

   then

          yq '.a += "cat"' sample.yml

   will output

          a: ['dog', 'cat']

Prepend to existing array

   Given a sample.yml file of:

          a:
            - dog

   then

          yq '.a = ["cat"] + .a' sample.yml

   will output

          a:
            - cat
            - dog

Add new object to array

   Given a sample.yml file of:

          a:
            - dog: woof

   then

          yq '.a + {"cat": "meow"}' sample.yml

   will output

          - dog: woof
          - cat: meow

Relative append

   Given a sample.yml file of:

          a:
            a1:
              b:
                - cat
            a2:
              b:
                - dog
            a3: {}

   then

          yq '.a[].b += ["mouse"]' sample.yml

   will output

          a:
            a1:
              b:
                - cat
                - mouse
            a2:
              b:
                - dog
                - mouse
            a3:
              b:
                - mouse

String concatenation

   Given a sample.yml file of:

          a: cat
          b: meow

   then

          yq '.a += .b' sample.yml

   will output

          a: catmeow
          b: meow

Number addition - float

   If the lhs or rhs are floats then the expression will be calculated with floats.

   Given a sample.yml file of:

          a: 3
          b: 4.9

   then

          yq '.a = .a + .b' sample.yml

   will output

          a: 7.9
          b: 4.9

Number addition - int

   If both the lhs and rhs are ints then the expression will be calculated with ints.

   Given a sample.yml file of:

          a: 3
          b: 4

   then

          yq '.a = .a + .b' sample.yml

   will output

          a: 7
          b: 4

Increment numbers

   Given a sample.yml file of:

          a: 3
          b: 5

   then

          yq '.[] += 1' sample.yml

   will output

          a: 4
          b: 6

Date addition

   You can add durations to dates.  Assumes RFC3339 date time format, see date-time operators for more information.

   Given a sample.yml file of:

          a: 2021-01-01T00:00:00Z

   then

          yq '.a += "3h10m"' sample.yml

   will output

          a: 2021-01-01T03:10:00Z

Date addition - custom format

   You can add durations to dates.  See date-time operators for more information.

   Given a sample.yml file of:

          a: Saturday, 15-Dec-01 at 2:59AM GMT

   then

          yq 'with_dtf("Monday, 02-Jan-06 at 3:04PM MST", .a += "3h1m")' sample.yml

   will output

          a: Saturday, 15-Dec-01 at 6:00AM GMT

Add to null

   Adding to null simply returns the rhs

   Running

          yq --null-input 'null + "cat"'

   will output

          cat

Add maps to shallow merge

   Adding objects together shallow merges them.  Use * to deeply merge.

   Given a sample.yml file of:

          a:
            thing:
              name: Astuff
              value: x
            a1: cool
          b:
            thing:
              name: Bstuff
              legs: 3
            b1: neat

   then

          yq '.a += .b' sample.yml

   will output

          a:
            thing:
              name: Bstuff
              legs: 3
            a1: cool
            b1: neat
          b:
            thing:
              name: Bstuff
              legs: 3
            b1: neat

Custom types: that are really strings

   When custom tags are encountered, yq will try to decode the underlying type.

   Given a sample.yml file of:

          a: !horse cat
          b: !goat _meow

   then

          yq '.a += .b' sample.yml

   will output

          a: !horse cat_meow
          b: !goat _meow

Custom types: that are really numbers

   When custom tags are encountered, yq will try to decode the underlying type.

   Given a sample.yml file of:

          a: !horse 1.2
          b: !goat 2.3

   then

          yq '.a += .b' sample.yml

   will output

          a: !horse 3.5
          b: !goat 2.3

Alternative (Default value)

   This operator is used to provide alternative (or default) values when a particular expression is either null or false.

LHS is defined

   Given a sample.yml file of:

          a: bridge

   then

          yq '.a // "hello"' sample.yml

   will output

          bridge

LHS is not defined

   Given a sample.yml file of:

          {}

   then

          yq '.a // "hello"' sample.yml

   will output

          hello

LHS is null

   Given a sample.yml file of:

          a: ~

   then

          yq '.a // "hello"' sample.yml

   will output

          hello

LHS is false

   Given a sample.yml file of:

          a: false

   then

          yq '.a // "hello"' sample.yml

   will output

          hello

RHS is an expression

   Given a sample.yml file of:

          a: false
          b: cat

   then

          yq '.a // .b' sample.yml

   will output

          cat

Update or create - entity exists

   This initialises a if it’s not present

   Given a sample.yml file of:

          a: 1

   then

          yq '(.a // (.a = 0)) += 1' sample.yml

   will output

          a: 2

Update or create - entity does not exist

   This initialises a if it’s not present

   Given a sample.yml file of:

          b: camel

   then

          yq '(.a // (.a = 0)) += 1' sample.yml

   will output

          b: camel
          a: 1

Anchor and Alias Operators

   Use the alias and anchor operators to read and write yaml aliases and anchors.  The explode operator normalises a yaml file (dereference (or expands) aliases and remove anchor names).

   yq supports merge aliases (like <<: *blah) however this is no longer in the standard yaml spec (1.2) and so yq will automatically add the !!merge tag to these nodes as  it  is  effec‐
   tively a custom tag.

NOTE –yaml-fix-merge-anchor-to-spec flag

   yq doesn’t merge anchors <<: to spec, in some circumstances it incorrectly overrides existing keys when the spec documents not to do that.

   To  minimise  disruption  while still fixing the issue, a flag has been added to toggle this behaviour.  This will first default to false; and log warnings to users.  Then it will de‐
   fault to true (and still allow users to specify false if needed).

   This flag also enables advanced merging, like inline maps, as well as fixes to ensure when exploding a particular path, neighbours are not affect ed.

   Long story short, you should be setting this flag to true.

   See examples of the flag differences below, where LEGACY is with the flag off; and FIXED is with the flag on.

Merge one map

   see https://yaml.org/type/merge.html

   Given a sample.yml file of:

          - &CENTER
            x: 1
            y: 2
          - &LEFT
            x: 0
            y: 2
          - &BIG
            r: 10
          - &SMALL
            r: 1
          - !!merge <<: *CENTER
            r: 10

   then

          yq '.[4] | explode(.)' sample.yml

   will output

          x: 1
          y: 2
          r: 10

Get anchor

   Given a sample.yml file of:

          a: &billyBob cat

   then

          yq '.a | anchor' sample.yml

   will output

          billyBob

Set anchor

   Given a sample.yml file of:

          a: cat

   then

          yq '.a anchor = "foobar"' sample.yml

   will output

          a: &foobar cat

Set anchor relatively using assign-update

   Given a sample.yml file of:

          a:
            b: cat

   then

          yq '.a anchor |= .b' sample.yml

   will output

          a: &cat
            b: cat

Get alias

   Given a sample.yml file of:

          b: &billyBob meow
          a: *billyBob

   then

          yq '.a | alias' sample.yml

   will output

          billyBob

Set alias

   Given a sample.yml file of:

          b: &meow purr
          a: cat

   then

          yq '.a alias = "meow"' sample.yml

   will output

          b: &meow purr
          a: *meow

Set alias to blank does nothing

   Given a sample.yml file of:

          b: &meow purr
          a: cat

   then

          yq '.a alias = ""' sample.yml

   will output

          b: &meow purr
          a: cat

Set alias relatively using assign-update

   Given a sample.yml file of:

          b: &meow purr
          a:
            f: meow

   then

          yq '.a alias |= .f' sample.yml

   will output

          b: &meow purr
          a: *meow

Explode alias and anchor

   Given a sample.yml file of:

          f:
            a: &a cat
            b: *a

   then

          yq 'explode(.f)' sample.yml

   will output

          f:
            a: cat
            b: cat

Explode with no aliases or anchors

   Given a sample.yml file of:

          a: mike

   then

          yq 'explode(.a)' sample.yml

   will output

          a: mike

Explode with alias keys

   Given a sample.yml file of:

          f:
            a: &a cat
            *a: b

   then

          yq 'explode(.f)' sample.yml

   will output

          f:
            a: cat
            cat: b

Dereference and update a field

   Use explode with multiply to dereference an object

   Given a sample.yml file of:

          item_value: &item_value
            value: true
          thingOne:
            name: item_1
            !!merge <<: *item_value
          thingTwo:
            name: item_2
            !!merge <<: *item_value

   then

          yq '.thingOne |= (explode(.) | sort_keys(.)) * {"value": false}' sample.yml

   will output

          item_value: &item_value
            value: true
          thingOne:
            name: item_1
            value: false
          thingTwo:
            name: item_2
            !!merge <<: *item_value

LEGACY: Explode with merge anchors

   Caution: this is for when –yaml-fix-merge-anchor-to-spec=false; it’s not to YAML spec because the merge anchors incorrectly override the object values (foobarList.b is  set  to  bar_b
   when it should still be foobarList_b).  Flag will default to true in late 2025

   Given a sample.yml file of:

          foo: &foo
            a: foo_a
            thing: foo_thing
            c: foo_c
          bar: &bar
            b: bar_b
            thing: bar_thing
            c: bar_c
          foobarList:
            b: foobarList_b
            !!merge <<:
              - *foo
              - *bar
            c: foobarList_c
          foobar:
            c: foobar_c
            !!merge <<: *foo
            thing: foobar_thing

   then

          yq 'explode(.)' sample.yml

   will output

          foo:
            a: foo_a
            thing: foo_thing
            c: foo_c
          bar:
            b: bar_b
            thing: bar_thing
            c: bar_c
          foobarList:
            b: bar_b
            thing: foo_thing
            c: foobarList_c
            a: foo_a
          foobar:
            c: foo_c
            a: foo_a
            thing: foobar_thing

LEGACY: Merge multiple maps

   see https://yaml.org/type/merge.html.  This has the correct data, but the wrong key order; set –yaml-fix-merge-anchor-to-spec=true to fix the key order.

   Given a sample.yml file of:

          - &CENTER
            x: 1
            y: 2
          - &LEFT
            x: 0
            y: 2
          - &BIG
            r: 10
          - &SMALL
            r: 1
          - !!merge <<:
              - *CENTER
              - *BIG

   then

          yq '.[4] | explode(.)' sample.yml

   will output

          r: 10
          x: 1
          y: 2

LEGACY: Override

   see https://yaml.org/type/merge.html.  This has the correct data, but the wrong key order; set –yaml-fix-merge-anchor-to-spec=true to fix the key order.

   Given a sample.yml file of:

          - &CENTER
            x: 1
            y: 2
          - &LEFT
            x: 0
            y: 2
          - &BIG
            r: 10
          - &SMALL
            r: 1
          - !!merge <<:
              - *BIG
              - *LEFT
              - *SMALL
            x: 1

   then

          yq '.[4] | explode(.)' sample.yml

   will output

          r: 10
          x: 1
          y: 2

FIXED: Explode with merge anchors

   Set --yaml-fix-merge-anchor-to-spec=true to get this correct merge behaviour (flag will default to true in late 2025).  Observe that foobarList.b property is still foobarList_b.

   Given a sample.yml file of:

          foo: &foo
            a: foo_a
            thing: foo_thing
            c: foo_c
          bar: &bar
            b: bar_b
            thing: bar_thing
            c: bar_c
          foobarList:
            b: foobarList_b
            !!merge <<:
              - *foo
              - *bar
            c: foobarList_c
          foobar:
            c: foobar_c
            !!merge <<: *foo
            thing: foobar_thing

   then

          yq 'explode(.)' sample.yml

   will output

          foo:
            a: foo_a
            thing: foo_thing
            c: foo_c
          bar:
            b: bar_b
            thing: bar_thing
            c: bar_c
          foobarList:
            b: foobarList_b
            a: foo_a
            thing: foo_thing
            c: foobarList_c
          foobar:
            c: foobar_c
            a: foo_a
            thing: foobar_thing

FIXED: Merge multiple maps

   Set  --yaml-fix-merge-anchor-to-spec=true  to  get this correct merge behaviour (flag will default to true in late 2025).  Taken from https://yaml.org/type/merge.html.  Same values as
   legacy, but with the correct key order.

   Given a sample.yml file of:

          - &CENTER
            x: 1
            y: 2
          - &LEFT
            x: 0
            y: 2
          - &BIG
            r: 10
          - &SMALL
            r: 1
          - !!merge <<:
              - *CENTER
              - *BIG

   then

          yq '.[4] | explode(.)' sample.yml

   will output

          x: 1
          y: 2
          r: 10

FIXED: Override

   Set --yaml-fix-merge-anchor-to-spec=true to get this correct merge behaviour (flag will default to true in late 2025).  Taken from https://yaml.org/type/merge.html.   Same  values  as
   legacy, but with the correct key order.

   Given a sample.yml file of:

          - &CENTER
            x: 1
            y: 2
          - &LEFT
            x: 0
            y: 2
          - &BIG
            r: 10
          - &SMALL
            r: 1
          - !!merge <<:
              - *BIG
              - *LEFT
              - *SMALL
            x: 1

   then

          yq '.[4] | explode(.)' sample.yml

   will output

          r: 10
          y: 2
          x: 1

Exploding inline merge anchor

   Set --yaml-fix-merge-anchor-to-spec=true to get this correct merge behaviour (flag will default to true in late 2025).

   Given a sample.yml file of:

          a:
            b: &b 42
          !!merge <<:
            c: *b

   then

          yq 'explode(.) | sort_keys(.)' sample.yml

   will output

          a:
            b: 42
          c: 42

Array to Map

   Use this operator to convert an array to..a map.  The indices are used as map keys, null values in the array are skipped over.

   Behind the scenes, this is implemented using reduce:

          (.[] | select(. != null) ) as $i ireduce({}; .[$i | key] = $i)

Simple example

   Given a sample.yml file of:

          cool:
            - null
            - null
            - hello

   then

          yq '.cool |= array_to_map' sample.yml

   will output

          cool:
            2: hello

Assign (Update)

   This operator is used to update node values.  It can be used in either the:

plain form: =

   Which will set the LHS node values equal to the RHS node values.  The RHS expression is run against the matching nodes in the pipeline.

relative form: |=

   This will do a similar thing to the plain form, but the RHS expression is run with each LHS node as context.  This is useful for updating values based on old values, e.g. increment.

Flags

   • c clobber custom tags

Create yaml file

   Running

          yq --null-input '.a.b = "cat" | .x = "frog"'

   will output

          a:
            b: cat
          x: frog

Update node to be the child value

   Given a sample.yml file of:

          a:
            b:
              g: foof

   then

          yq '.a |= .b' sample.yml

   will output

          a:
            g: foof

Double elements in an array

   Given a sample.yml file of:

          - 1
          - 2
          - 3

   then

          yq '.[] |= . * 2' sample.yml

   will output

          - 2
          - 4
          - 6

Update node from another file

   Note this will also work when the second file is a scalar (string/number)

   Given a sample.yml file of:

          a: apples

   And another sample another.yml file of:

          b: bob

   then

          yq eval-all 'select(fileIndex==0).a = select(fileIndex==1) | select(fileIndex==0)' sample.yml another.yml

   will output

          a:
            b: bob

Update node to be the sibling value

   Given a sample.yml file of:

          a:
            b: child
          b: sibling

   then

          yq '.a = .b' sample.yml

   will output

          a: sibling
          b: sibling

Updated multiple paths

   Given a sample.yml file of:

          a: fieldA
          b: fieldB
          c: fieldC

   then

          yq '(.a, .c) = "potato"' sample.yml

   will output

          a: potato
          b: fieldB
          c: potato

Update string value

   Given a sample.yml file of:

          a:
            b: apple

   then

          yq '.a.b = "frog"' sample.yml

   will output

          a:
            b: frog

Update string value via |=

   Note there is no difference between = and |= when the RHS is a scalar

   Given a sample.yml file of:

          a:
            b: apple

   then

          yq '.a.b |= "frog"' sample.yml

   will output

          a:
            b: frog

Update deeply selected results

   Note that the LHS is wrapped in brackets!  This is to ensure we don’t first filter out the yaml and then update the snippet.

   Given a sample.yml file of:

          a:
            b: apple
            c: cactus

   then

          yq '(.a[] | select(. == "apple")) = "frog"' sample.yml

   will output

          a:
            b: frog
            c: cactus

Update array values

   Given a sample.yml file of:

          - candy
          - apple
          - sandy

   then

          yq '(.[] | select(. == "*andy")) = "bogs"' sample.yml

   will output

          - bogs
          - apple
          - bogs

Update empty object

   Given a sample.yml file of:

          {}

   then

          yq '.a.b |= "bogs"' sample.yml

   will output

          a:
            b: bogs

Update node value that has an anchor

   Anchor will remain

   Given a sample.yml file of:

          a: &cool cat

   then

          yq '.a = "dog"' sample.yml

   will output

          a: &cool dog

Update empty object and array

   Given a sample.yml file of:

          {}

   then

          yq '.a.b.[0] |= "bogs"' sample.yml

   will output

          a:
            b:
              - bogs

Custom types are maintained by default

   Given a sample.yml file of:

          a: !cat meow
          b: !dog woof

   then

          yq '.a = .b' sample.yml

   will output

          a: !cat woof
          b: !dog woof

Custom types: clobber

   Use the c option to clobber custom tags

   Given a sample.yml file of:

          a: !cat meow
          b: !dog woof

   then

          yq '.a =c .b' sample.yml

   will output

          a: !dog woof
          b: !dog woof

Boolean Operators

   The or and and operators take two parameters and return a boolean result.

   not flips a boolean from true to false, or vice versa.

   any will return true if there are any true values in an array sequence, and all will return true if all elements in an array are true.

   any_c(condition)  and all_c(condition) are like any and all but they take a condition expression that is used against each element to determine if it’s true.  Note: in jq you can sim‐
   ply pass a condition to any or all and it simply works - yq isn’t that clever..yet

   These are most commonly used with the select operator to filter particular nodes.

Related Operators

   • equals / not equals (==, !=) operators here

   • comparison (>=, < etc) operators here

   • select operator here

or example

   Running

          yq --null-input 'true or false'

   will output

          true

“yes” and “no” are strings

   In the yaml 1.2 standard, support for yes/no as booleans was dropped - they are now considered strings.  See `10.2.1.2.  Boolean' in https://yaml.org/spec/1.2.2/

   Given a sample.yml file of:

          - yes
          - no

   then

          yq '.[] | tag' sample.yml

   will output

          !!str
          !!str

and example

   Running

          yq --null-input 'true and false'

   will output

          false

Matching nodes with select, equals and or

   Given a sample.yml file of:

          - a: bird
            b: dog
          - a: frog
            b: bird
          - a: cat
            b: fly

   then

          yq '[.[] | select(.a == "cat" or .b == "dog")]' sample.yml

   will output

          - a: bird
            b: dog
          - a: cat
            b: fly

any returns true if any boolean in a given array is true

   Given a sample.yml file of:

          - false
          - true

   then

          yq 'any' sample.yml

   will output

          true

any returns false for an empty array

   Given a sample.yml file of:

          []

   then

          yq 'any' sample.yml

   will output

          false

any_c returns true if any element in the array is true for the given condition.

   Given a sample.yml file of:

          a:
            - rad
            - awesome
          b:
            - meh
            - whatever

   then

          yq '.[] |= any_c(. == "awesome")' sample.yml

   will output

          a: true
          b: false

all returns true if all booleans in a given array are true

   Given a sample.yml file of:

          - true
          - true

   then

          yq 'all' sample.yml

   will output

          true

all returns true for an empty array

   Given a sample.yml file of:

          []

   then

          yq 'all' sample.yml

   will output

          true

all_c returns true if all elements in the array are true for the given condition.

   Given a sample.yml file of:

          a:
            - rad
            - awesome
          b:
            - meh
            - 12

   then

          yq '.[] |= all_c(tag == "!!str")' sample.yml

   will output

          a: true
          b: false

Not true is false

   Running

          yq --null-input 'true | not'

   will output

          false

Not false is true

   Running

          yq --null-input 'false | not'

   will output

          true

String values considered to be true

   Running

          yq --null-input '"cat" | not'

   will output

          false

Empty string value considered to be true

   Running

          yq --null-input '"" | not'

   will output

          false

Numbers are considered to be true

   Running

          yq --null-input '1 | not'

   will output

          false

Zero is considered to be true

   Running

          yq --null-input '0 | not'

   will output

          false

Null is considered to be false

   Running

          yq --null-input '~ | not'

   will output

          true

Collect into Array

   This creates an array using the expression between the square brackets.