how to count the number of lines in a variable in a shell script

This little question actually includes the result of three standard shell gotchas (both bash and korn shell):

1. Here-strings (<<<...) have a newline added to them if they don't end with a newline. That makes it impossible to send a completely empty input to a command with a here-string.

2. All trailing newlines are removed from the output of a command used in command substitution (cmd or preferably $(cmd)). So you have no way to know how many blank lines were at the end of the output.

3. (Not really a shell gotcha, but it comes up a lot). wc -l counts the number of newline characters, not the number of lines. So the last "line" is not counted if it is not terminated with a newline. (A non-empty file which does not end with a newline character is not a Posix-conformant text file. So weird results like this are not unexpected.)

So, when you do:

var=$(cmd)
utility <<<"$var"

The command substitution in the first line removes all trailing newlines, and then the here-string expansion in the second line puts exactly one trailing newline back. That converts an empty output to a single blank line, and otherwise removes blank lines from the end of the output.

So utility is wc -l, then you will get the correct count unless the output was empty, in which case it will be 1 instead of 0.

On the other hand, with

var=$(cmd)
printf %s "$cmd" | utility

The trailing newline(s) are removed, as before, by the command substitution, so the printf leaves the last line (if any) unterminated. Now if utility is wc -l, you'll end up with 0 if the output was empty, but for non-empty files, the count will not include the last line of the output.

One possible shell-independent work-around is to use the second option, but with grep '' as a filter:

var=$(cmd)
printf %s "${var}" | grep '' | utility

The empty pattern '' will match every line, and grep always terminates every line of output. (Of course, this still won't count blank lines at the end of the output.)

Having said all that, it is always a bad idea to try to parse the output of ls, even just to count the number of files. (A filename might include a newline character, for example.) So it would be better to use a glob expansion combined with some shell-specific way of counting the number of objects in the glob expansion (and some other shell-specific way of detecting when no file matches the glob).

I was going to suggest this, which is a construct I've used in bash:

f=($(</path/to/file))
echo ${#f[@]}

To handle multiple files, you'd just .. add files.

f=($(</path/to/file))
f=+($(</path/to/otherfile))

or

f=($(</path/to/file) $(</path/to/otherfile))

To handle lots of files, you could loop:

f=()
for file in *.txt; do
    f+=($(<$file))
done

Then I saw chepner's response, which I gather is more korn-y than mine.

NOTE: loops are better than parsing ls.

You can also use like this:

#!/bin/bash

testVar=`ls -1 *.txt`

if [ -z "$testVar" ]; then
        # Empty
        count=0
else
        # Not Empty
        count=`wc -l <<< "$testVar"`
fi

echo "Count : $count"