I can do this by calling the external utility sed (for a known non-empty $myvar) like so:

if [ "$(printf %s "$myvar" | sed -n '$=')" -eq 1 ]; then

  echo "Your variable has only one line, proceeding"

else

  echo "Error condition, variable must have only one line"

fi

Is there a way to do this using only bash builtins?

Even better, is there a way to do this in a POSIX-specified manner, without calling external utilities?

(This question is one of curiosity and finding better ways to do things; the above code does function. I'm wondering if there is a cleaner/faster way.)

The POSIX way:

NL='

'

case $myvar in

  *"$NL"*) echo more than one line ;;

        *) echo one line ;;

esac

This also works in pre-POSIX Bourne-like shells, too.

The following snippets works in bash (with and without the -posix option):

#!/bin/bash

#!/bin/bash -posix

version_1 () { [[ "$myvar" = *$'n'* ]]; }

version_2 () {

  local newlines="${myvar//[^$'n']/}"

  [[ "${#newlines}" -eq 1 ]]

}

for test in version_1 version_2; do

  if $test; then echo many lines; else echo one line; fi

done

There are several options (bash first, POSIX is below).

The code inside each function could be easily used outside.

#!/bin/bash



nl=$'n'



aregex   (){ [[ $a =~        $nl     ]]; }

apattern (){ [[ $a ==       *$nl*    ]]; }

acut     (){ [[ $a != "${a%%"$nl"*}" ]]; }

areplace (){ [[ $a != "${a//"$nl"/}" ]]; }

acase    (){ case $a in (*$nl*) true;; (*) false;; esac; }

aifs     ()( IFS="$nl"

             set -f; set -- x${a}x;

             (( $# > 1 ));

           )

aread    (){ IFS="$nl" read -rd '' -a b <<<"x${a}x";

             (( "${#b[@]}" > 1 )); }

Each function is an option. Each function will exit with a return value of 0 if there is only one line and a return value of 1 if the variable $a has more than one new-line (more than one $'n').

After a function is executed, this will print the line required:

out=''; "$function" && out="more than "

printf "%9s   = %sone linen" "$1" "$out"

Executing all options:

a='ab'"$nl"'cd' ; alltests

a='ab  cd'      ; alltests

Gives this output:

   aregex   = more than one line

 apattern   = more than one line

     acut   = more than one line

 areplace   = more than one line

    acase   = more than one line

     aifs   = more than one line

    aread   = more than one line



   aregex   = one line

 apattern   = one line

     acut   = one line

 areplace   = one line

    acase   = one line

     aifs   = one line

    aread   = one line  

POSIX

The following options fail in POSIX for several reasons:

• aregex : There is no regex =~ operators in POSIX.


• apattern : There is no == operator in POSIX.


• areplace : Parameter expansion does not have the ${ / / } option.

Four could safely be translated to POSIX:

• posixcut : Probably the best solution.


• posixcase : A common solution for POSIX shells.


• posixifs : Executed inside a sub-shell to be able to set set -f.


• posixread : read does not have -d or -a but it could be adapted.

#!/bin/dash



nl='

'



posixcut (){ [ "${a}" != "${a%%"$nl"*}" ] ; }

posixcase(){ case $a in (*$nl*) true;; (*) false;; esac; }

posixifs ()( IFS="$nl";

             set -f; set -- x${a}x;

             [ "$#" -gt 1 ];

           )

posixread(){ local b=0;

             while IFS=$nl read -r _; do

                 b=$((b+1));

                 [ $b -gt 1 ] && break;

             done <<-_EOT_

x${a}x

_EOT_

             [ $b -gt 1 ];

           }

Note: Yes, local is not strictly POSIX, but is pretty well supported.

The local for b, could be safely removed (check for global $b usage).

Bourne (1977 shell).

If you need code for the original 1977 Bourne shell, use this:

posixcase() { case $a in *$nl*) true;; *) false;; esac; }

posixifs () ( IFS="$nl"

              set -f; set -- x${a}x;

              [ "$#" -gt 1 ];

            )

bourneread()( b=0                ### A helper function.

              while :; do

                  if IFS=$nl read c && [ $b -le 1 ]; then

                      b=`expr $b + 1`

                  else

                      echo "$b"

                      break

                  fi    

              done <<-_EOT_

x${a}x

_EOT_

             )

posixread   (){ [ `bourneread` -gt 1 ]; }

The expansion ${a%% } used in posixcut will not work in Bourne.
The posixifs needs to be divided in two parts to work in Bourne.

The read option needs mayor changes, but works correctly.

Its function is posixread, the bourneread is a required helper function.

All code for Bourne was tested to be working correctly with heirloom shell.

Here is a way that should work with all Bourne syntax / POSIX shells and uses only builtins :

if (set -f ; IFS=$'n'; set -- x${myvar}x ; [ $# = 1 ]) ; then

  echo "Your variable has only one line, proceeding"

else

  echo "Error condition, variable must have exactly one line"

fi

If your shell doesn't support IFS=$'n' (like dash 0.5.7), you can use instead :

IFS="

"