How can I reverse the order of lines in a file?

Question

I'd like to reverse the order of lines in a text file (or stdin), preserving the contents of each line.

So, i.e., starting with:

foo
bar
baz

I'd like to end up with

baz
bar
foo

Is there a standard UNIX commandline utility for this?

Purpure

Important note about reversing the lines: make sure your file has a trailing newline first. Otherwise, the last two lines of an input file will be merged into one line in an output file (at least using the perl -e 'print reverse <>' but it probably applies to other methods too). – Prosecute

possible duplicate of How to reverse lines of a text file? – Detent

Also pretty nearly a duplicate (though older) of unix.stackexchange.com/questions/9356/… . As in that case, migration to unix.stackexchange.com is probably appropriate. – Joly

Answer 1

BSD tail:

tail -r myfile.txt

Reference: FreeBSD, NetBSD, OpenBSD and OS X manual pages.

Nestornestorian

Just remember that the '-r' option isn't POSIX-compliant. The sed and awk solutions below are going to work even in the wonkiest systems. – Katar

(if there is a perl on that wonky system, that is :)) – Lasandralasater

Just tried this on Ubuntu 12.04, and discovered there is no -r option for my version of tail (8.13). Use 'tac' instead (see Mihai's answer below). – Romanic

The checkmark should move below to tac. tail -r fails on Ubuntu 12/13, Fedora 20, Suse 11. – Delatorre

tail -r ~/1 ~ tail: invalid option -- r Try `tail --help' for more information. look like its new option – Unfrequented

The answer should certainly mention that this is BSD-only, particularly since the OP asked for a "standard UNIX" utility. This isn't in GNU tail so it's not even a de facto standard. – Spoilage

@DenTheMan how come when I do this tac text.txt > text.txt it wipes out the files? – Asafetida

On Mac Homebrew and perhaps some other environments this it's going to be gtac, not tac. – Rolling

See gnu.org/software/coreutils/manual/html_node/… for further details of the -r option of tail – Frown

while useful to some, this is not an answer to the question as posed. i.e. it is not a "standard UNIX commandline utility". – Joly

@Asafetida you can't pipe data from a file to itself. You need to use a temporary file. – Fireplace

When I tried piping into tail -r, it seems like the original last line is being concatenated with the original second to last line to form the new first line. Probably because the text stream doesn't have a newline at the end? – Soinski

I disagree that this isn't an answer to the question. BSD isn't as common as GNU these days, but it was once pervasive and is still common. BSD tail is the default on MacOS, at least in El Capitain. – Rally

reverse a file order is not the same as order it in alphabetical descending order – Coronal

Ubuntu 18 doesn't have tail with -r. – Pone

Even on OS/X, tail -r blah > blah empties the file. Unlike tac below. – Cayes

not posix compliant, so not commonly available on *nix systems. – Shon

This doesn't work on Ubuntu 22.04. – Agnesagnese

Answer 2

Also worth mentioning: tac (the, ahem, reverse of cat). Part of coreutils.

Flipping one file into another

tac a.txt > b.txt

Sev

Especially worth mentioning to those using a version of tail with no -r option! (Most Linux folks have GNU tail, which has no -r, so we have GNU tac). – Roseberry

Just a note, because people have mentioned tac before, but tac doesn't appear to be installed on OS X. Not that it'd be difficult to write a substitute in Perl, but I don't have the real one. – Lunar

You can get GNU tac for OS X from Fink. You might wish to get GNU tail as well, as it does some things that BSD tail does not. – Roseberry

If you use OS X with homebrew, you can install tac using brew install coreutils (installs as gtac by default). – Behnken

To be more specific: tac oldfile > newfile – Edmee

Where can I get a complete list of all the coreutils? In the manual :) gnu.org/software/coreutils/manual/coreutils.html – Predator

Is there any way to do this as an overwrite? i.e. tac a.txt > a.txt I don't want a new file, just want the current one flipped. – Rizas

One of the problems is if the file doesn't have a trailing new line, the first 2 lines may be conjoined as 1 line. echo -n "abc\ndee" > test; tac test. – Asafetida

If you use OS X with macports, you can install tac using port install coreutilrs – Passageway

The author does not mention anything about second file. We can conclude that the ideal solution should be to replace the contents in-place. e.g. using ed/sed – Liris

Importantly, you can also pipe in to tac: cat a.txt | tac >b.txt works! – Inlaid

Use tac file | sponge file if you want to change the file and don't want both versions. – Subtile

For what it's worth, in vim you can use tac directly: 1. select all lines (ggVG) and 2. run the command :!tac – Embowed

Answer 3

There's the well-known sed tricks:

# reverse order of lines (emulates "tac")
# bug/feature in HHsed v1.5 causes blank lines to be deleted
sed '1!G;h;$!d'               # method 1
sed -n '1!G;h;$p'             # method 2

(Explanation: prepend non-initial line to hold buffer, swap line and hold buffer, print out line at end)

Alternatively (with faster execution) from the awk one-liners:

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

If you can't remember that,

perl -e 'print reverse <>'

On a system with GNU utilities, the other answers are simpler, but not all the world is GNU/Linux...

Danny

From the same source: awk '{a[i++]=$0} END {for (j=i-1; j>=0;) print a[j--] }' file* Both the sed and awk versions work on my busybox router. 'tac' and 'tail -r' do not. – Katar

I wish this one is the accepted answer. coz sed is always available, but not tail -r and tac. – Zulemazullo

@ryenus: tac is expected to handle arbitrary large files that do not fit in memory (line length is still limited though). It is unclear whether sed solution works for such files. – Marginalia

Only problem though : be prepared to wait :-) – Paul

More precisely: the sed code is in O(n^2), and can be VERY slow for big files. Hence my upvote for the awk alternative, linear. I didn't try the perl option, less piping-friendly. – Paul

Just wanted to point out the Perl version is quite piping friendly. print just prints to STDOUT so you can easily pipe the output or write it to a new file. Of course its worth mentioning that you will be placing the entire file in memory with this version. – Chevy

The advantage of sed is that it can perform the reversal in-place with -i without making a temporary file. – Karaganda

that awk caches the whole file in mem. might not be good for large files. But good for smaller ones. – Jankey

I can't even figure out HOW to run the sed version. At least I can see that for perl and awk (and other answers but I don't want to download something and am not on Linux) – Lashawn

Answer 4

at the end of your command put: | tac

tac does exactly what you're asking for, it "Write each FILE to standard output, last line first."

tac is the opposite of cat :-).

Sworn

Why should he? Please explain the value of the tac command, this is useful for new users who might end up searching the same subject. – Photomural

This really should be the accepted answer. Shame the above has so many votes. – Halberd

BTW: You don't have to pipe to tac if it's coming from a file. You can simply tac filename.ext (reverse of cat filename.ext) – Innocent

Answer 5

If you happen to be in vim use

:g/^/m0

Explanation from @Ronopolis below:

g means "do this globally.
^ means "the beginning of a line".
m means "move the line to a new line number. 0 is which line to move to.
0 means "top of the file, before the current line 1".
So: "Find every line that has a beginning, and move it to line number 0."

You find line 1, and move it to the top. Does nothing. Then find line 2 and move it above line 1, to the top of the file. Now find line 3 and move it to the top. Repeat this for every line. At the end you finish by moving the last line to the top. When you are done, you've reversed all the lines.

Synsepalous

Related: How to reverse the order of lines? at Vim SE – Abominate

I'd vote that up if you briefly explained what it did. – Joly

Yeah, I get that bit, but I meant breaking down what the various bits of the vim command are doing. I've now looked at the answer @Abominate linked, which provides the explanation. – Joly

g means "do this globally. ^ means "the beginning of a line". m means "move the line to a new line number. 0 is which line to move to. 0 means "top of the file, before the current line 1". So: "Find every line that has a beginning, and move it to line number 0." You find line 1, and move it to the top. Does nothing. Then find line 2 and move it above line 1, to the top of the file. Now find line 3 and move it to the top. Repeat this for every line. At the end you finish by moving the last line to the top. When you are done, you've reversed all the lines. – Bennir

It should be noted that the :g global command behaves in a very particular way vs simply using ranges. For example, the command ":%m0" will not reverse the order of the lines, while ":%normal ddggP" will (as will ":g/^/normal ddggP"). Nice trick and explanation... Oh yea, forgot the token "see :help :g for more information"... – Branle

Answer 6

tac <file_name>

example:

$ cat file1.txt
1
2
3
4
5

$ tac file1.txt
5
4
3
2
1

Apiarist

Answer 7

$ (tac 2> /dev/null || tail -r)

Try tac, which works on Linux, and if that doesn't work use tail -r, which works on BSD and OSX.

Lithography

Why not tac myfile.txt - what am I missing? – Ammonium

@sage, to fall back to tail -r in case tac is not available. tac is not POSIX compliant. Neither is tail -r. Still not foolproof, but this improves the odds of things working. – Philae

I see - for instances when you are not able to manually/interactively change the command when it fails. Good enough for me. – Ammonium

You need a proper test to see if tac is available. What happens if tac is available, but runs out of RAM and swap half way through consuming a giant input stream. It fails, and then tail -r succeeds in processing the remainder of the stream giving an incorrect result. – Joly

@PetrPeller See answer above comment by Robert for OSX use homebrew. brew install coreutils and use gtac in place of tac and if your prefer add tac as an alias to gtac if for example you wanted a shell script that used it cross platform (Linux, OSX) – Henghold

Worked for me in Git Bash – Ode

Answer 8

Try the following command:

grep -n "" myfile.txt | sort -r -n | gawk -F : "{ print $2 }"

Thursby

instead of the gawk statement, I'd do something like this: sed 's/^[0-9]*://g' – Disengagement

why not use "nl" instead of grep -n ? – Raskind

@GoodPerson, nl by default will fail to number empty lines. The -ba option is available on some systems, not is not universal (HP/UX comes to mind, though I wish it wouldn't) whereas grep -n will always number every line that matches the (in this case empty) regex. – Portillo

Instead of gawk I use cut -d: -f2- – Infeasible

Answer 9

Just Bash :) (4.0+)

function print_reversed {
    local lines i
    readarray -t lines

    for (( i = ${#lines[@]}; i--; )); do
        printf '%s\n' "${lines[i]}"
    done
}

print_reversed < file

Monsignor

+1 for answer in bash and for O(n) and for not using recursion (+3 if I could) – Corydalis

Try this with a file containing the line -nenenenenenene and witness the reason why people recommend always using printf '%s\n' instead of echo. – Leffen

@Leffen I would agree with that this time since this one's a general function. – Monsignor

Answer 10

For cross OS (i.e. OSX, Linux) solution that may use tac inside a shell script use homebrew as others have mentioned above, then just alias tac like so:

Install lib

For MacOS

brew install coreutils

For linux debian

sudo apt-get update
sudo apt-get install coreutils 

Then add alias

echo "alias tac='gtac'" >> ~/.bash_aliases (or wherever you load aliases)
source ~/.bash_aliases
tac myfile.txt

Henghold

Answer 11

I really like the "tail -r" answer, but my favorite gawk answer is....

gawk '{ L[n++] = $0 } 
  END { while(n--) 
        print L[n] }' file

Andante

Tested with mawk on Ubuntu 14.04 LTS - works, so it is not GNU awk specific. +1 – Zealotry

n++ can be replaced with NR – Stardom

Answer 12

The simplest method is using the tac command. tac is cat's inverse. Example:

$ cat order.txt
roger shah 
armin van buuren
fpga vhdl arduino c++ java gridgain
$ tac order.txt > inverted_file.txt
$ cat inverted_file.txt
fpga vhdl arduino c++ java gridgain
armin van buuren
roger shah 

Moir

not sure why this answer shows up before the one below, but it's a dupe of https://mcmap.net/q/13970/-how-can-i-reverse-the-order-of-lines-in-a-file - which was posted years before. – Amphiprostyle

Answer 13

If you want to modify the file in place, you can run

sed -i '1!G;h;$!d' filename

This removes the need to create a temporary file and then delete or rename the original and has the same result. For example:

$tac file > file2
$sed -i '1!G;h;$!d' file
$diff file file2
$

Based on the answer by ephemient, which did almost, but not quite, what I wanted.

Beanpole

Answer 14

EDIT the following generates a randomly sorted list of numbers from 1 to 10:

seq 1 10 | sort -R | tee /tmp/lst |cat <(cat /tmp/lst) <(echo '-------') **...**

where dots are replaced with actual command which reverses the list

tac

seq 1 10 | sort -R | tee /tmp/lst |cat <(cat /tmp/lst) <(echo '-------') \
<(tac)

python: using [::-1] on sys.stdin

seq 1 10 | sort -R | tee /tmp/lst |cat <(cat /tmp/lst) <(echo '-------') \
<(python -c "import sys; print(''.join(([line for line in sys.stdin])[::-1]))")

Ecclesiasticism

Answer 15

This will work on both BSD and GNU.

awk '{arr[i++]=$0} END {while (i>0) print arr[--i] }' filename

Shrader

Answer 16

I see lots of interesting ideas. But try my idea. Pipe your text into this:

rev | tr '\n' '~' | rev | tr '~' '\n'

which assumes that the character '~' is not in the file. This should work on every UNIX shell going back to 1961. Or something like that.

Retro

Thanks, this worked great on my MacOS. cat foo.txt | rev | tr '\n' '~' | rev | tr '~' '\n' > bar.txt – Pressroom

Answer 17

For Emacs users: C-x h (select the whole file) and then M-x reverse-region. Also works for only selecting parts or the lines and reverting those.

Neff

Answer 18

It happens to me that I want to get the last n lines of a very large text file efficiently.

The first thing I tried is tail -n 10000000 file.txt > ans.txt, but I found it very slow, for tail has to seek to the location and then moves back to print the results.

When I realize it, I switch to another solution: tac file.txt | head -n 10000000 > ans.txt. This time, the seek position just needs to move from the end to the desired location and it saves 50% time!

Take home message:

Use tac file.txt | head -n n if your tail does not have the -r option.

Excurved

Answer 19

You may use Perl on the commandline:

perl -e 'my @b=(); while(<>) {push(@b, $_);}; print join("", reverse(@b));' orig > rev

Trojan

Answer 20

Best solution:

tail -n20 file.txt | tac

Damn

Welcome to Stack Overflow! While this code snippet may solve the question, including an explanation really helps to improve the quality of your post. Remember that you are answering the question for readers in the future, and those people might not know the reasons for your code suggestion. Please also try not to crowd your code with explanatory comments, this reduces the readability of both the code and the explanations! – Ballflower

The tools are documented: people have to man tail, man tac at some point rather than being spoonfed. +1 – Angola

Answer 21

You can do it with vim stdin and stdout. You can also use ex to be POSIX compliant. vim is just the visual mode for ex. In fact, you can use ex with vim -e or vim -E (improved ex mode). vim is useful because unlike tools like sed it buffers the file for editing, while sed is used for streams. You might be able to use awk, but you would have to manually buffer everything in a variable.

The idea is to do the following:

1. Read from stdin
2. For each line move it to line 1 (to reverse). Command is g/^/m0. This means globally, for each line g; match the start of the line, which matches anything ^; move it after address 0, which is line 1 m0.
3. Print everything. Command is %p. This means for the range of all lines %; print the line p.
4. Forcefully quit without saving the file. Command is q!. This means quit q; forcefully !.

# Generate a newline delimited sequence of 1 to 10
$ seq 10
1
2
3
4
5
6
7
8
9
10

# Use - to read from stdin.
# vim has a delay and annoying 'Vim: Reading from stdin...' output
# if you use - to read from stdin. Use --not-a-term to hide output.
# --not-a-term requires vim 8.0.1308 (Nov 2017)
# Use -E for improved ex mode. -e would work here too since I'm not
# using any improved ex mode features.
# each of the commands I explained above are specified with a + sign
# and are run sequentially.
$ seq 10 | vim - --not-a-term -Es +'g/^/m0' +'%p' +'q!'
10
9
8
7
6
5
4
3
2
1
# non improved ex mode works here too, -e.
$ seq 10 | vim - --not-a-term -es +'g/^/m0' +'%p' +'q!'

# If you don't have --not-a-term, use /dev/stdin
seq 10 | vim -E +'g/^/m0' +'%p' +'q!' /dev/stdin

# POSIX compliant (maybe)
# POSIX compliant ex doesn't allow using + sign to specify commands.
# It also might not allow running multiple commands sequentially.
# The docs say "Implementations may support more than a single -c"
# If yours does support multiple -c
$ seq 10 | ex -c "execute -c 'g/^/m0' -c '%p' -c 'q!' /dev/stdin

# If not, you can chain them with the bar, |. This is same as shell
# piping. It's more like shell semi-colon, ;.
# The g command consumes the |, so you can use execute to prevent that.
# Not sure if execute and | is POSIX compliant.
seq 10 | ex -c "execute 'g/^/m0' | %p | q!" /dev/stdin

---

How to make this reusable

I use a script I call ved (vim editor like sed) to use vim to edit stdin. Add this to a file called ved in your path:

#!/usr/bin/env sh

vim - --not-a-term -Es "$@" +'%p | q!'

I am using one + command instead of +'%p' +'q!', because vim limits you to 10 commands. So merging them allows the "$@" to have 9 + commands instead of 8.

Then you can do:

seq 10 | ved +'g/^/m0'

If you don't have vim 8, put this in ved instead:

#!/usr/bin/env sh

vim -E "$@" +'%p | q!' /dev/stdin

Buskined

Answer 22

Not sure if I missed something. How about pipe into sort

i.e. cat file | sort -r

Sorry if I missed the point of this question. I often use this to scan syslogs.

In linux : watch " tail /var/log/syslog | sort -r "

Hope it helps someone Best wishes

Woolridge

That would sort things, which is not the intention. – Insensible