VAR=$(< file) vs read VAR < file

set variable from file content: little bench

In complement to jhnc's correct answer, here is a litte bench:

First creating a single long line with only ascii characters:

For testing, I want to read only one line. I use pseudo fs in shared memory: /dev/shm in order to minimize fs footprint in bench.

LANG=C man -Len -Pcol\ -b man |
    tr \\n \ |
    sed 's/[[:space:]]\+/ /g' >/dev/shm/file

This produce on my host a file containing one single 28kb line.

wc /dev/shm/file

    0  4749 28670 /dev/shm/file

Creating functions regarding our interest

getvar1() {  var=$(cat /dev/shm/file)       ;}
getvar2() {  var=$(< /dev/shm/file)         ;}
getvar3() {  read -r var < /dev/shm/file    ;}
getvar4() {  mapfile -t var < /dev/shm/file ;}

Tests loops:

times=();for string in long short; do
    times+=($string)
    echo "Doing 4 tests with $string string:"
    for test in {1..4}; do
        started=${EPOCHREALTIME/.}  var=---
        for ((i=1000;i--;)); do
            getvar$test
        done
        elap=00000$(( ${EPOCHREALTIME/.}-started))
        printf -v "times[${#times[@]}]" %.5f  ${elap::-6}.${elap: -6}
        mapfile -t command < <(declare -f getvar$test)
        printf 'Test: %d: %s\n  var is %d len: "%s"\n  time: %ssec.\n' $test \
            "${command[2]}" "${#var}" "${var::4}...${var: -4}" "${times[-1]}"
        done
        echo Lorem Ipsum >/dev/shm/file
 done

Produce on my host:

Doing 4 tests with long string:
Test: 1:     var=$(cat /dev/shm/file)
  var is 28670 len: "MAN(...(1) "
  time: 1.72581sec.
Test: 2:     var=$(< /dev/shm/file)
  var is 28670 len: "MAN(...(1) "
  time: 0.15679sec.
Test: 3:     read -r var < /dev/shm/file
  var is 28669 len: "MAN(...N(1)"
  time: 0.35542sec.
Test: 4:     mapfile -t var < /dev/shm/file
  var is 28670 len: "MAN(...(1) "
  time: 0.10624sec.
Doing 4 tests with short string:
Test: 1:     var=$(cat /dev/shm/file)
  var is 11 len: "Lore...psum"
  time: 1.55918sec.
Test: 2:     var=$(< /dev/shm/file)
  var is 11 len: "Lore...psum"
  time: 0.01891sec.
Test: 3:     read -r var < /dev/shm/file
  var is 11 len: "Lore...psum"
  time: 0.01821sec.
Test: 4:     mapfile -t var < /dev/shm/file
  var is 11 len: "Lore...psum"
  time: 0.01632sec.

Then

printf '%8s: %10s%10s%10s%10s\n' string test{1..4} ${times[@]}

  string:      test1     test2     test3     test4
    long:    1.72581   0.15679   0.35542   0.10624
   short:    1.55918   0.01891   0.01821   0.01632

• using $(cat file) took more than 1,5 seoonds! We see here the higher cost of setting up a subshell environment!
• using read is significantly slower than var=$(<file) or mapfile.
• the read command will drop trailing space(s).
• the quickest seem to be mapfile.

Note about mapfile

Reading binary under bash is possible, but for this, you have to read by byte (see Yes , bash can read and write binary. This make the, job but slowly.

Using mapfile with null separator could be very efficient. For sample, Linux kernel use pseudo fs /proc where you could read environment from all process (depending on your access rights). But all entries are separated by a null byte 0x00.

Reading your own environment is useless, this is a sample only:

mapfile -d '' -t env </proc/$$/environ 

Then now in array $env, you must be able to found all your shell environment:

shopt -s extglob
printf 'Variable USER: real="%s", in $env var="%s"\n' "$USER" ${env[@]/#!(USER=?*)}

Should ouptupt something like:

Variable USER: real="john", in $env var="john"

Further with mapfile...

Little binary test using mapfile:

man man | md5sum

2953aa6314f6c27c4277d1731464f2ea  -

IFS= LANG=C mapfile -t -d '' binary < <(man man|zstd)
printf '%s\0' "${binary[@]}" | zstd -d | md5sum

zstd: /*stdin*\: unknown header 
2953aa6314f6c27c4277d1731464f2ea  -

Where zstd complain about trailing null byte added after last ${binary[-1]} field, but decompress binary correctly!

printf '%s\0' "${binary[@]}"| head -c -1 | zstd -d | md5sum

2953aa6314f6c27c4277d1731464f2ea  -

I [...] have seen extensively the use of read instead for the same, i.e.:

IFS='' read -r -d '' VAR < file

Really? I see plenty of use of read, but I don't think I've ever seen it used in the particular manner you describe, to read an entire file into a variable. Of course, reading an entire file into a variable is itself something I don't see very often (and I would generally consider doing so an anti-pattern), so I guess my sample size is limited.

What is the difference in terms of the side effects (e.g. special characters in file),

cat and < both transfer raw bytes without interpretation, until the input is exhausted. On the other hand, read reads and processes just one line. Setting the line delimiter to the empty string does not prevent that. It instructs read that the line delimiter is the NUL character, not that there isn't any delimiter at all. That might be desirable, undesirable, or irrelevant, depending on the situation.

Also, as another answer already observes, command substitutions remove trailing newlines. Because it does not treat newlines as line delimiters, your read command may store trailing newlines in the value of VAR, but VAR=$(< file) will not do so.

performance or any other aspects between the two

read by default interprets line continuations as the shell itself does, and it performs word splitting on the resulting line. The -r option will moot line continuations, and setting IFS to an empty string will neuter word splitting, but that does not necessarily mean that read's provision for these things does not still have a cost.

and why don't I see the former used extensively in scripts that are otherwise using Bash-only features already?

It's not entirely clear what you mean by "the former", but since you say you do see the read variation, I guess you're asking why you don't see $(< file).

That has a lot to do with what scripts you read, so we're not in a position to answer definitively. As I already observed, I don't, myself, see the read usage you describe, which you can take as a data point supporting

• it's a matter of style and personal preference

You could also consider that

• Although a bit wasteful, $(cat file) is intuitive. And $(< file) not too much worse in that sense. Your read command, however, requires a lot more analysis to decipher. At least for me. Code clarity is important.

And of course,

• there are semantic differences between these alternatives, as already described. It is conceivable that the read uses of this form that you observe yourself intentionally make use of that.

Furthermore, although shell script performance is a relevant consideration, it is rarely a primary consideration. If it's important for your program to run as fast as possible then writing it as a shell script at all is a mistake.