Forem: Julien Gonzalez

jq, reduce, inputs & null input

Julien Gonzalez — Fri, 13 Oct 2023 16:22:44 +0000

Say you have a file (e.g. numbers.txt) with one number per line and you need to sum them all up.

1
2
3

First off, for such a simple task and such a small file you can always do:

# jq -s 'add' numbers.txt
6

In case you wonder: -s causes the file to be loaded into an array which is then passed to add. So essentially what's happening is [1,2,3] | add.

However for the purpose of this post, we're going to use reduce & friends:

# jq -n 'reduce inputs as $n (0; . + $n)' numbers.txt
6

The -n option is quite important here and is something that has tripped me up way too many times that I care to admit.

But before I explain what -n means, let's see what running the same command without it yields:

# jq 'reduce inputs as $n (0; . + $n)' numbers.txt
5

Obviously wrong and we can guess that the first input (i.e. the first line of the file) has gone AWOL. (Another thing I wasted way too much time on.)

The clue is in the doc for inputs:

Outputs all remaining inputs, one by one.

So how do I get the first input? With . of course:

# jq 'reduce inputs as $n (.; . + $n)' numbers.txt
6

So . holds the first line of the file whilst inputs holds the remaining ones.

However sometimes the initialisation sequence of a reducer is similar to the iteration sequence e.g.,

# jq 'reduce inputs as $n (. * 10; . + ($n * 10))' numbers.txt
60

Again, this is a simple and contrived example so it's probably ok to repeat yourself here but there's a way to have the entire file emitted by inputs. That's where -n comes in:

Don't read any input at all. Instead, the filter is run once using null as the input.

So -n causes null to be emitted as the first input, which means that 1 and all the remaining numbers are emitted by inputs:

# jq -n 'reduce inputs as $n (0; . + ($n * 10))' numbers.txt
60

The -n is often useful when you just want to try out some stuff quickly e.g.,

# jq -n '[1,2,3] | add'
6

The value of null (ish)

Julien Gonzalez — Sat, 23 Sep 2023 09:02:57 +0000

TL; DR: The absence of a thing is not the same as the thing being empty.

Say we represent a wallet with an array:

[1, 1, 2, 5, 10, 10] // 2 ⨉ £1, 1 ⨉ £2, …

Now we need to decide when to fetch a wallet. I sometimes see this kind of logic:

if (!wallet?.length) {
  // fetch
}

The problem here is that we equate the absence of a wallet with no money, potentially causing an infinite loop.

That is not to say that you can never consider those two things equally.

For instance, it's okay to restrict access to checkout if you either don't have a wallet or no money in it:

can_checkout = wallet?.length > 0

However if you need to explain why a user can't check out (and you probably ought to) then those two things are very different:

checkout_err = ( wallet == null ? ERR_WALLET_NOT_FOUND
               : !wallet.length ? ERR_WALLET_EMPTY
                                : null )

Nested Ternaries Considered Useful

Julien Gonzalez — Thu, 26 Jan 2023 18:45:59 +0000

Consider this function that returns a discount rate for a given age:

const get_discount = age => {
  if (age <  5) return 1;
  if (age < 12) return 0.5;
  if (age < 25) return 0.3;
  if (age < 65) return 0;
                return 0.4;
};

Using nested ternaries we can remove the fluff and focus on the intent:

const get_discount = age =>
    age <  5 ? 1
  : age < 12 ? 0.5
  : age < 25 ? 0.3
  : age < 65 ? 0
             : 0.4;

Unfortunately nested ternaries tend to be frowned upon. When not outrightly banned, formatting rules often cause them to be laid out in a rather unattractive fashion:

const get_discount = age =>
  age < 5
    ? 1
    : age < 12
      ? 0.5
      : age < 25
        ? 0.3
        : age < 65
          ? 0
          : 0.4;

But using nested ternaries over a sequence of if isn't an either-or choice.

Say we wanted to compute the discount rate on the fly. You can't just swap the nested ternaries without creating an intermediate variable first:

const apply_discount = (price, age) =>
  price - (price * ( age <  5 ? 1
                   : age < 12 ? 0.5
                   : age < 25 ? 0.3
                   : age < 65 ? 0
                              : 0.4));