How does this return the length of a command output in zsh

I asked GPT3 and got the correct solution for calculating the length of the output of a function in zsh in a single command (doing it in two steps, first FOO="$(some_cmmand)" and then get the length ${#FOO} is easy but I wanted it done in a single step):

$((${#$(some_command)}))

However it could not explain how this works (the explanation didn't include what the outer shell expansion or parenthesis do). I'm hoping a human can give an explanation. Thanks in advance.

Human is online. Let's break it down:

• $(some_command) - command substitution. The command inside the parentheses is run, and the output of the command is substituted in place. So if some_command is echo hey, then $(echo hey) would become hey.

• ${#...} - parameter length expansion. So for example, if var="hey", then ${#var} is 3

• $((...)) - arithmetic expansion, that evaluates the arithmetic expression inside the double parentheses, but in your case, the expression is simply ${#$(some_command)}, just ensuring that the length expansion and the command substitution are done in the correct order.

So $((${#$(some_command)})) runs some_command, gets the output, calculates the length of the output, and then evaluates that length as an arithmetic expression - resulting in the length of the output of some_command

It looks like ChatGPT is trying to give us all a lesson in the differences between scalar contexts and array contexts :).

As you noted, $(...) is a command substitution, and ${#...} returns a length. But when we try nesting the two expansions with some example commands, the results are a bit surprising:

> v=$(print abc def)
> print ${#v}
7
> print ${#$(print abc def)}
2   # what!?!

We're apparently getting the number of elements in the array or argument list produced by the command, instead of the total string length. A few more tests seem to confirm this:

> x=$(print a b c d e f); print ${#x}
11
> print ${#$(print a b c d e f)}
6
> y=$(print abcde); print ${#y}
5
> print ${#$(print abcde)}
1

Another confirmation: if the variable is an array, then the two-step version behaves like the nested variant. These use assignments in the form val=(...) to create an array:

> x=($(print a b c d e f)); print ${#x}
6
> print ${#$(print a b c d e f)}
6
> y=($(print abcde)); print ${#y}
1
> print ${#$(print abcde)}
1

The addition of the $((..)) operator changes the behavior by placing all of the expansions in an arithmetic context. There is no support for arrays in shell arithmetic, so everything operates as scalars. Therefore the array result is changed to a scalar (apparently early in the process) so we get the total length of the output string:

> print $((${#$(print a b c d e f)}))
11
> print $((${#$(print abcde)}))
5

There are other ways to get the total string length instead of the size of the array. One standard way to convert an array to a scalar is to use quotes - then we can get the length of that expression. Another possibility is to use the join expansion flag to create a string:

> print ${#${"$(print abc def)"}}
7
> print ${#${:-"$(print abc def)"}}
7
> print ${#:-"$(print abc def)"}
7
> print ${#${(j: :)$(print abc def)}}
7

Most of the time, the best option is the (c) parameter expansion flag. It's a good choice since it is somewhat self-documenting, and it's probably the most efficient way to do it:

> print ${(c)#$(print ab cd ef)}
8