¿Cómo puedo invertir el orden de las líneas en un archivo?

Me gustaría invertir el orden de las líneas en un archivo de texto (o stdin), preservando el contenido de cada línea.

Entonces, es decir, comenzando con:

foo
bar
baz

Me gustaría terminar con

baz
bar
foo

¿Existe una utilidad de línea de comandos UNIX estándar para esto?

Cola BSD:

tail -r myfile.txt

Referencia: páginas de manual de FreeBSD , NetBSD , OpenBSD y OS X.

También vale la pena mencionar: tac(el, ejem, reverso de cat). Parte de coreutils .

Voltear un archivo a otro

tac a.txt > b.txt

Existen los conocidos trucos 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

(Explicación: anteponer una línea no inicial para retener el búfer, intercambiar la línea y retener el búfer, imprimir la línea al final)

Alternativamente (con una ejecución más rápida) de los awk one-liners :

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

Si no puedes recordar eso,

perl -e 'print reverse <>'

En un sistema con utilidades GNU, las otras respuestas son más simples, pero no todo el mundo es GNU / Linux ...

al final de su comando ponga: | tac

tac hace exactamente lo que está pidiendo: "Escribir cada ARCHIVO en la salida estándar, la última línea primero".

tac es lo opuesto a cat :-).

Si estás en vimuso

:g/^/m0

tac <file_name>

ejemplo:

$ cat file1.txt
1
2
3
4
5

$ tac file1.txt
5
4
3
2
1

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

Pruebe tac, que funciona en Linux, y si eso no funciona tail -r, use , que funciona en BSD y OSX.

Pruebe el siguiente comando:

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

Solo 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

El método más simple es usar el taccomando. taces catinverso. Ejemplo:

$ 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 

Realmente me gusta la respuesta " tail -r ", pero mi respuesta favorita es ...

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

EDITAR lo siguiente genera una lista ordenada aleatoriamente de números del 1 al 10:

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

donde los puntos se reemplazan con un comando real que invierte la lista

tac

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

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

Para la solución de sistema operativo cruzado (es decir, OSX, Linux) que puede usar tacdentro de un script de shell, use homebrew como otros han mencionado anteriormente, luego solo alias tac de esta manera:

Instalar lib

Para MacOS

brew install coreutils

Para linux debian

sudo apt-get update
sudo apt-get install coreutils 

Luego agrega alias

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

Esto funcionará tanto en BSD como en GNU.

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

Si desea modificar el archivo en su lugar, puede ejecutar

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

Esto elimina la necesidad de crear un archivo temporal y luego eliminar o cambiar el nombre del original y tiene el mismo resultado. Por ejemplo:

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

Basado en la respuesta por ephemient , que hizo casi, pero no del todo, lo que quería.

Me sucede que quiero obtener las últimas nlíneas de un archivo de texto muy grande de manera eficiente .

Lo primero que probé es tail -n 10000000 file.txt > ans.txt, pero lo encontré muy lento, ya que tailtiene que buscar la ubicación y luego retroceder para imprimir los resultados.

Cuando me di cuenta, me cambio a otra solución: tac file.txt | head -n 10000000 > ans.txt. ¡Esta vez, la posición de búsqueda solo necesita moverse desde el final hasta la ubicación deseada y ahorra un 50% de tiempo !

Llevar el mensaje a casa:

Úselo tac file.txt | head -n nsi su tailno tiene la -ropción.

Mejor solución:

tail -n20 file.txt | tac

Para usuarios de Emacs: C-x h(seleccione el archivo completo) y luego M-x reverse-region. También funciona solo para seleccionar partes o líneas y revertirlas.

Veo muchas ideas interesantes. Pero prueba mi idea. Canaliza tu texto en esto:

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

que supone que el carácter '~' no está en el archivo. Esto debería funcionar en cada shell de UNIX desde 1961. O algo así.

Tenía la misma pregunta, pero también quería que la primera línea (encabezado) permaneciera en la parte superior. Entonces necesitaba usar el poder de 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 también funciona en cygwin o gitbash

Puedes hacerlo con vim stdiny stdout. También puede usar expara cumplir con POSIX . vimes solo el modo visual para ex. De hecho, puede usar excon vim -eo vim -E( exmodo mejorado ). vimes útil porque, a diferencia de herramientas como sedesta, almacena el archivo para editarlo, mientras que sedse usa para transmisiones. Es posible que pueda usar awk, pero tendría que almacenar manualmente todo en una variable.

La idea es hacer lo siguiente:

1. Leer de stdin
2. Para cada línea muévala a la línea 1 (para invertir). Comando es g/^/m0. Esto significa globalmente, para cada línea g; coincide con el inicio de la línea, que coincide con cualquier cosa ^; muévalo después de la dirección 0, que es la línea 1 m0.
3. Imprime todo. Comando es %p. Esto significa para el rango de todas las líneas %; imprime la línea p.
4. Salga con fuerza sin guardar el archivo. Comando es q!. Esto significa dejar de fumar q; enérgicamente !.

# 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

Cómo hacer que esto sea reutilizable

Uso un script que llamo ved(editor de vim sed) para usar vim para editar stdin. Agregue esto a un archivo llamado veden su ruta:

#!/usr/bin/env sh

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

Estoy usando un +comando en lugar de +'%p' +'q!', porque vim te limita a 10 comandos. Por lo tanto, fusionarlos le permite "$@"tener 9 +comandos en lugar de 8.

Entonces puedes hacer:

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

Si no tienes vim 8, pon esto en su vedlugar:

#!/usr/bin/env sh

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

rev
text here

o

rev <file>

o

rev texthere

tail -r funciona en la mayoría de los sistemas Linux y MacOS

seq 1 20 | cola -r

sort -r < filename

o

rev < filename