Number of characters in a shell command's output

Question

I am writing a script which needs to calculate the number of characters in a command's output in a single step.

For example, using the command readlink -f /etc/fstab should return 10 because the output of that command is 10 characters long.

This is already possible with stored variables using the following code:

variable="somestring";
echo ${#variable};
# 10

Unfortunately, using the same formula with a command-generated string does not work:

${#(readlink -f /etc/fstab)};
# bash: ${#(readlink -f /etc/fstab)}: bad substitution

I understand it is possible to do this by first saving the output to a variable:

variable=$(readlink -f /etc/fstab);
echo ${#variable};

But I would like to remove the extra step.

Is this possible? Compatibility with the Almquist shell (sh) using only in-built or standard utilities is preferable.

Answer 1

With GNU expr:

$ expr length + "$(readlink -f /etc/fstab)"
10

The + there is a special feature of GNU expr to make sure the next argument is treated as a string even if it happens to be an expr operator like match, length, +...

The above will strip any trailing newline of output. To work around it:

$ expr length + "$(readlink -f /etc/fstab; printf .)" - 2
10

The result was subtracted to 2 because the final newline of readlink and the character . we added.

With Unicode string, expr does not seem to work, because it returns length of string in bytes instead of characters count (See line 654)

$ LC_ALL=C.UTF-8 expr length ăaa
4

So, you can use:

$ printf "ăaa" | LC_ALL=C.UTF-8 wc -m
3

---

POSIXLY:

$ expr " $(readlink -f /etc/fstab; printf .)" : ".*" - 3
10

The space before command substitution prevent command from being crashed with string start with -, so we need to subtract 3.

Answer 2

Not sure how to do this with shell builtins (Gnouc is though) but the standard tools can help:

1. You can use wc -m which counts characters. Unfortunately, it also counts the final newline so you'd have to get rid of that first:

   readlink -f /etc/fstab | tr -d '\n' | wc -m
   

2. You can of course use awk

   readlink -f /etc/fstab | awk '{print length($0)}'
   

3. Or Perl

   readlink -f /etc/fstab | perl -lne 'print length'
   

Answer 3

I usually do it like this:

$ echo -n "$variable" | wc -m
10

To do commands I'd adapt it like so:

$ echo -n "$(readlink -f /etc/fstab)" | wc -m
10

This approach is similar to what you were doing in your 2 steps, except we're combining them into a single one liner.

Answer 4

You can call external utilities (see other answers), but they will make your script slower, and it's hard to get the plumbing right.

Zsh

In zsh, you can write ${#$(readlink -f /etc/fstab)} to get the length of the command substitution. Note that this isn't the length of the command output, it's the length of the output without any trailing newline.

If you want the exact length of the output, output an extra non-newline character at the end, and subtract one.

$((${#$(readlink -f /etc/fstab; echo .)} - 1))

If what you want is the payload in the command's output, then you need to subtract two here, because the output of readlink -f is the canonical path plus a newline.

$((${#$(readlink -f /etc/fstab; echo .)} - 2))

This differs from ${#$(readlink -f /etc/fstab)} in the rare but possible case where the canonical path itself ends in a newline.

For this specific example, you don't need an external utility at all, because zsh has a built-in construct that's equivalent to readlink -f, through the history modifier A.

echo /etc/fstab(:A)

To get the length, use the history modifier in a parameter expansion:

${#${:-/etc/fstab}:A}

If you have the file name in a variable filename, that would be ${#filename:A}.

Bourne/POSIX-style shells

None of the pure Bourne/POSIX shells (Bourne, ash, mksh, ksh93, bash, yash …) have any similar extension that I know of. If you need to apply a parameter substitution to the output of a command substitution or to nest parameter substitutions, use successive stages.

You can stuff the processing into a function if you like.

command_output_length_sans_trailing_newlines () {
  set -- "$("$@")"
  echo "${#1}"
}

or

command_output_length () {
  set -- "$("$@"; echo .)"
  echo "$((${#1} - 1))"
}

but there's usually no benefit; except with ksh93, that causes an extra fork to be able to use the output of the function, so it makes your script slower, and there's rarely any readability benefit.

Once again, the output of readlink -f is the canonical path plus a newline; if you want the length of the canonical path, subtract 2 instead of 1 in command_output_length. Using command_output_length_sans_trailing_newlines gives the right result only when the canonical path itself doesn't end in a newline.

Bytes vs characters

${#…} is supposed to be the length in characters, not in bytes, which makes a difference in multibyte locales. Reasonably up-to-date versions of ksh93, bash and zsh calculate the length in characters according to the value of LC_CTYPE at the time the ${#…} construct is expanded. Many other common shells don't really support multibyte locales: as of dash 0.5.7, mksh 46 and posh 0.12.3, ${#…} returns the length in bytes. If you want the length in characters in a reliable way, use the wc utility:

$(readlink -f /etc/fstab | wc -m)

As long as $LC_CTYPE designates a valid locale, you can be confident that this will either error out (on an ancient or restricted platform that doesn't support multibyte locales) or return the correct length in characters. (For Unicode, “length in characters” means the number of code points — number of glyphs is yet another story, due to complications such as combining characters.)

If you want the length in bytes, set LC_CTYPE=C temporarily, or use wc -c instead of wc -m.

Counting bytes or characters with wc includes any trailing newlines from the command. If you want the length of the canonical path in bytes, it's

$(($(readlink -f /etc/fstab | wc -c) - 1))

To get it in characters, subtract 2.

Answer 5

This works in dash but it does require that the targeted var is definitely empty or unset. That is why this is actually two commands - I explicitly empty $l in the first:

l=;printf '%.slen is %d and result is %s\n' \
    "${l:=$(readlink -f /etc/fstab)}" "${#l}" "$l"

OUTPUT

len is 10 and result is /etc/fstab

That's all shell builtins - not including the readlink of course - but evaluating it in the current shell that way implies that you must do the assignment before getting the len, which is why I %.silence the first argument in the printf format string and just add it again for the literal value at the tail of printf's arg list.

With eval:

l=$(readlink -f /etc/fstab) eval 'l=${#l}:$l'
printf %s\\n "$l"

OUTPUT

10:/etc/fstab

You can get close to that same thing, but instead of the output in a variable in the first command you get it on stdout:

PS4='${#0}:$0' dash -cx '2>&1' "$(readlink -f /etc/fstab)"

...which writes...

10:/etc/fstab

...to file descriptor 1 without assigning any value to any vars in the current shell.