Come posso invertire l'ordine delle linee in un file?

Vorrei invertire l'ordine delle righe in un file di testo (o stdin), preservando il contenuto di ogni riga.

Quindi, cioè iniziando con:

foo
bar
baz

Mi piacerebbe finire con

baz
bar
foo

Esiste un'utilità a riga di comando UNIX standard per questo?

Coda BSD:

tail -r myfile.txt

Riferimento: pagine di manuale di FreeBSD , NetBSD , OpenBSD e OS X.

Vale anche la pena ricordare: tac(the, ahem, reverse of cat). Parte di coreutils .

Lanciare un file in un altro

tac a.txt > b.txt

Ecco i noti trucchi sed :

# 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

(Spiegazione: anteporre la riga non iniziale per contenere il buffer, scambiare la riga e conservare il buffer, stampare la riga alla fine)

In alternativa (con esecuzione più veloce) dai awk one-liners :

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

Se non te lo ricordi,

perl -e 'print reverse <>'

Su un sistema con utility GNU, le altre risposte sono più semplici, ma non tutto il mondo è GNU / Linux ...

alla fine del tuo comando metti: | tac

tac fa esattamente quello che stai chiedendo, "Scrivi ogni FILE sullo standard output, prima l'ultima riga".

tac è l'opposto del gatto :-).

Se ti capita di essere in vimuso

:g/^/m0

tac <file_name>

esempio:

$ cat file1.txt
1
2
3
4
5

$ tac file1.txt
5
4
3
2
1

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

Prova tac, che funziona su Linux e se non funziona tail -r, funziona su BSD e OSX.

Prova il seguente comando:

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

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

Il metodo più semplice sta usando il taccomando. tacè catinverso. Esempio:

$ 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 

Mi piace molto la risposta " tail -r ", ma la mia risposta gawk preferita è ...

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

EDIT quanto segue genera un elenco di numeri in ordine casuale da 1 a 10:

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

dove i punti vengono sostituiti con un comando effettivo che inverte l'elenco

tac

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

python: usando [:: - 1] su 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]))")

Per soluzioni cross OS (ovvero OSX, Linux) che possono essere utilizzate tac all'interno di uno script di shell utilizzare homebrew come altri hanno già detto sopra, quindi basta alias tac in questo modo:

Installa lib

Per MacOS

brew install coreutils

Per debian linux

sudo apt-get update
sudo apt-get install coreutils 

Quindi aggiungi alias

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

Questo funzionerà sia su BSD che su GNU.

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

Se si desidera modificare il file in atto, è possibile eseguire

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

Ciò elimina la necessità di creare un file temporaneo, quindi eliminare o rinominare l'originale e avere lo stesso risultato. Per esempio:

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

Basato sulla risposta di effimero , che ha fatto quasi, ma non del tutto, quello che volevo.

Mi capita di voler ottenere in modo efficiente le ultime nrighe di un file di testo molto grande .

La prima cosa che ho provato è tail -n 10000000 file.txt > ans.txt, ma l'ho trovato molto lento, pertail deve cercare la posizione e poi torna indietro per stampare i risultati.

Quando mi rendo conto che, passo ad un'altra soluzione: tac file.txt | head -n 10000000 > ans.txt. Questa volta, la posizione di ricerca deve solo spostarsi dalla fine alla posizione desiderata e consente di risparmiare il 50% di tempo !

Porta a casa il messaggio:

Utilizzare tac file.txt | head -n nse tailnon si dispone -rdell'opzione.

Soluzione migliore:

tail -n20 file.txt | tac

Per gli utenti Emacs: C-x h(selezionare l'intero file) e quindi M-x reverse-region. Funziona anche per selezionare solo parti o linee e ripristinarle.

Vedo molte idee interessanti. Ma prova la mia idea. Inserisci il tuo testo in questo:

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

il che presuppone che il carattere '~' non sia presente nel file. Questo dovrebbe funzionare su ogni shell UNIX risalente al 1961. O qualcosa del genere.

Avevo la stessa domanda, ma volevo anche che la prima riga (intestazione) rimanesse in cima. Quindi avevo bisogno di usare il potere di awk

cat dax-weekly.csv | awk '1 { last = NR; line[last] = $0; } END { print line[1]; for (i = last; i > 1; i--) { print line[i]; } }'

PS funziona anche in cygwin o gitbash

Puoi farlo con vim stdine stdout. È inoltre possibile utilizzare exper essere conformi a POSIX . vimè solo la modalità visiva per ex. In effetti, è possibile utilizzare excon vim -eo vim -E( exmodalità migliorata ). vimè utile perché a differenza di strumenti come sedquesto buffer il file per la modifica, mentre sedviene utilizzato per i flussi. Potresti essere in grado di utilizzare awk, ma dovresti bufferizzare manualmente tutto in una variabile.

L'idea è di fare quanto segue:

1. Leggi da stdin
2. Per ogni riga spostalo sulla riga 1 (per invertire). Il comando è g/^/m0. Ciò significa globalmente, per ogni linea g; corrisponde all'inizio della riga, che corrisponde a qualsiasi cosa ^; spostalo dopo l'indirizzo 0, che è la riga 1m0 .
3. Stampa tutto. Il comando è %p. Questo significa per la gamma di tutte le linee %; stampa la linea p.
4. Uscita forzata senza salvare il file. Il comando è q!. Questo significa smettere q; con forza !.

# 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

Come renderlo riutilizzabile

Uso uno script che chiamo ved(come vim editor sed) per usare vim per modificarlo stdin. Aggiungi questo a un file chiamato vednel tuo percorso:

#!/usr/bin/env sh

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

Sto usando un +comando invece di +'%p' +'q!', perché vim ti limita a 10 comandi. Quindi unendoli permette "$@"di avere 9+ comandi invece di 8.

Quindi puoi fare:

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

Se non hai vim 8, inseriscilo vedinvece:

#!/usr/bin/env sh

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

rev
text here

o

rev <file>

o

rev texthere

tail -r funziona nella maggior parte dei sistemi Linux e MacOS

seq 1 20 | tail -r

sort -r < filename

o

rev < filename