How to update two properties of an object?

[reitzig]

Consider this simple file:

in.json

{
  "foo": 12.3456789,
  "bar": 98.7654321
}

I want to updated it by rounding the values to two decimal places. From all over the internet, I learn that

(.foo * 100) | round / 100

is the way to go, and I want to use the update assignment |= apply the new value.

With jq v1.8.0 I run:

jq '. |= (.foo = (.foo * 100 | round / 100))' < in.json

and get the expected result:

{
  "foo": 12.35,
  "bar": 98.7654321
}

❓️ How can I update foo and bar in one go?

ℹ️ Assume there are other properties that should not be touched, and that the point of change may be nested multiple levels deep in the JSON, including arrays; my real query looks something like .some.nesting.[].more.nesting.[].stuff |= with_entries(.value |= ???)

---

• I tried

  jq '. |= ((.foo, .bar) = ((.foo * 100) | round / 100, (.bar * 100) | round / 100))' < repro.json
  

  but that yields

  {
    "foo": 0.12,
    "bar": 0.12
  }

  which is all kinds of weird. I suspect that this line from the docs applies and causes both values to be the same:

  If the right-hand side outputs multiple values, only the first one will be used

  But how the actual number is achieved, I struggle to imagine.

• I also tried

  jq '. + { foo: (.foo * 100) | round / 100, bar: (.bar * 100) | round / 100 }' < repro.json

  While that works with the MWE, it doesn't in my real setting; I get

  jq: error (at <stdin>:498): null (null) and number (100) cannot be multiplied`
  

[wader]

Hi, your close! maybe you want something like this:

(.foo, .bar) |= ((. * 100) | round / 100)

or using a function and a bit simpler assignment:

def f: ((. * 100) | round / 100); .foo |= f | .bar |= f

the docs has a section about assignment that might be useful and also the wiki has a even deeper description how it works and is implemented https://github.com/jqlang/jq/wiki/jq-Language-Description#assignments

[reitzig]

Thanks, both are interesting approaches! TIL how to define functions for code reuse. 👍️

Unfortunately, I can't either to work in my real setting. Apparently my MWE was too small! 😅 I suspect my trouble is with how I unwrap all that nesting - - is with_entries the way to go here? -- but I don't see where/how. 🫣

repro.json

{
  "some" : {
    "nesting" : [
      {
        "more" : {
          "nesting" : {
            "A" : {
              "foo" : 12.3456789,
              "bar" : 98.7654321,
              "and" : "other things"
            },
            "B" : {
              "foo" : 23.4567891,
              "bar" : 87.6543219,
              "and" : "other things"
            }
          }
        }
      },
      {
        "more" : {
          "nesting" : {
            "A" : {
              "foo" : 34.5678912,
              "bar" : 76.5432198,
              "and" : "other things"
            },
            "B" : {
              "foo" : 45.6789123,
              "bar" : 65.4321987,
              "and" : "other things"
            }
          }
        }
      }
    ]
  }
}

repro.sh

#!/usr/bin/env bash


round_foo="$(cat <<'JQ'
  def round_two: ((. * 100) | round / 100);

  .some.nesting.[].more.nesting |=
    with_entries(
      .value |= (.foo = (.foo | round_two))
    )
JQ
)"

round_both="$(cat <<'JQ'
  def round_two: ((. * 100) | round / 100);

  .some.nesting.[].more.nesting |=
    with_entries(
      .value |= (.foo = (.foo | round_two), .bar = (.bar | round_two))
    )
JQ
)"
# This ignores the update for .bar;
# I also tried these as line 19 but all error out:
#  - .value | (.foo, .bar) |= round_two
#  - .value | .foo |= round_two | .bar |= round_two

echo "1️⃣ Round only foo:"
jq "${round_foo}" < repro.json

echo -e "\n2️⃣ Round both:"
jq "${round_both}" < repro.json

[wader]

Close again! :) you probably want:

def round_two: ((. * 100) | round / 100);
.some.nesting.[].more.nesting |=
  with_entries(
    # notice the "|" instead of "," so that you keep massaging the same value instead of outputting two values
    # you could also use |= and skip to repeat .key
    .value |= (.foo = (.foo | round_two) | .bar = (.bar | round_two))
  )

another way without with_entries could be

def round_two: ((. * 100) | round / 100);
(.some.nesting[].more.nesting | .A, .B | .foo, .bar) |= round_two    

so how assignment like LHS = RHS and LHS |= RHS etc works is that LHS is an expression that somehow indexes the input and outputs zero or more "paths", then for each such output the RHS is evaluated.

[reitzig]

That does it, thanks a bunch! 🫶 I also learned something from your explanations, much appreciated!