How can I print lines from file backwards (without using "tac")?

Question

I want to print lines from a file backwards without using tac command. Is there any other solution to do such thing with bash?

Answer 1

Using sed to emulate tac:

sed '1!G;h;$!d' "${inputfile}"

Answer 2

With ed:

ed -s infile <<IN
g/^/m0
,p
q
IN

If you're on BSD/OSX (and hopefully soon on GNU/linux too as it will be POSIX):

tail -r infile

Answer 3

awk '{a[i++]=$0} END {for (j=i-1; j>=0;) print a[j--] }' file.txt

via awk one liners

Answer 4

You can pipe it through:

awk '{print NR" "$0}' | sort -k1 -n -r | sed 's/^[^ ]* //g'

The awk prefixes each line with the line number followed by a space. The sort reverses the order of the lines by sorting on the first field (line number) in reverse order, numeric style. And the sed strips off the line numbers.

The following example shows this in action:

pax$ echo 'a
b
c
d
e
f
g
h
i
j
k
l' | awk '{print NR" "$0}' | sort -k1 -n -r | sed 's/^[^ ]* //g'

It outputs:

l
k
j
i
h
g
f
e
d
c
b
a

Answer 5

As you asked to do it in bash, here is a solution that doesn't make use of awk, sed or perl, just a bash function:

reverse ()
{
    local line
    if IFS= read -r line
    then
        reverse
        printf '%s\n' "$line"
    fi
}

The output of

echo 'a
b
c
d
' | reverse

is

d
c
b
a

As expected.

But beware that lines are stored in memory, one line in each recursively called instance of the function. So careful with big files.

Answer 6

POSIX vi does this, so also ed or ex.

vi:

:g/^/m0

ex:

ex -s infile <<EOS
g/^/move0
x
EOS

ed:

ed -s infile <<EOF
g/^/m0
,p
w
EOF

Answer 7

In perl:

cat <somefile> | perl -e 'while(<>) { push @a, $_; } foreach (reverse(@a)) { print; }'

Answer 8

BASH-only solution

read file into bash array ( one line = one element of array ) and print out array in reverse order:

i=0 

while read line[$i] ; do
    i=$(($i+1))
done < FILE


for (( i=${#line[@]}-1 ; i>=0 ; i-- )) ; do
    echo ${line[$i]}
done

Answer 9

Bash, with mapfile mentioned in comments to fiximan, and actually an possibly better version:

# last [LINES=50]
_last_flush(){ BUF=("${BUF[@]:$(($1-LINES)):$1}"); } # flush the lines, can be slow.
last(){
  local LINES="${1:-10}" BUF
  ((LINES)) || return 2
  mapfile -C _last_flush -c $(( (LINES<5000) ? 5000 : LINES+5 )) BUF
  BUF=("${BUF[@]}") # Make sure the array subscripts make sence, can be slow.
  ((LINES="${#BUF[@]}" > LINES ? LINES : "${#BUF[@]}"))
  for ((i="${#BUF[@]}"; i>"${#BUF[@]}"-LINES; i--)); do echo -n "${BUF[i]}"; done
}

Its performance is basically comparable to the sed solution, and gets faster as the number of requested lines decreases.

Answer 10

Simple do this with your file to sort the data in reverse order, and it should be unique.

sed -n '1h;1d;G;h;$p'

Answer 11

awk -v OFS='\t' '{ print NR,$0 }' | sort -nr | cut -f 2-

This prepends the line number before each line, with a delimiting tab character, sorts the lines in reverse order on these line numbers, and then removes the numbers again with cut.

See also: Schwartzian transform (Wikipedia link)

Answer 12

• Number the lines with nl
• sort in reverse order by number
• remove the numbers with sed

as shown here:

echo 'e
> f
> a
> c
> ' | nl -ba | sort -nr | sed -r 's/^ *[0-9]+\t//'

Result:

c
a
f
e

Note that "nl -ba" for including empty lines in the numbering is an option of GNU-nl and might not work with every nl.