Comment inverser l'ordre des lignes dans un fichier?

Je voudrais inverser l'ordre des lignes dans un fichier texte (ou stdin), en préservant le contenu de chaque ligne.

Donc, c'est-à-dire en commençant par:

foo
bar
baz

J'aimerais finir avec

baz
bar
foo

Existe-t-il un utilitaire de ligne de commande UNIX standard pour cela?

Queue BSD:

tail -r myfile.txt

Référence: pages de manuel FreeBSD , NetBSD , OpenBSD et OS X.

A noter également: tac(le, ahem, revers de cat). Une partie de coreutils .

Retourner un fichier dans un autre

tac a.txt > b.txt

Il y a les astuces sed bien connues :

# 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

(Explication: ajouter une ligne non initiale pour conserver le tampon, permuter la ligne et conserver le tampon, imprimer la ligne à la fin)

Alternativement (avec une exécution plus rapide) à partir des uniformes awk :

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

Si vous ne vous en souvenez pas,

perl -e 'print reverse <>'

Sur un système avec des utilitaires GNU, les autres réponses sont plus simples, mais tout le monde n'est pas GNU / Linux ...

à la fin de votre commande mettez: | tac

tac fait exactement ce que vous demandez, il "Ecrit chaque FICHIER sur la sortie standard, dernière ligne en premier".

tac est l'opposé de cat :-).

S'il vous arrive d'être en cours d' vimutilisation

:g/^/m0

tac <file_name>

exemple:

$ cat file1.txt
1
2
3
4
5

$ tac file1.txt
5
4
3
2
1

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

Essayez tac, qui fonctionne sous Linux, et si cela ne fonctionne pas, utilisez-le tail -r, qui fonctionne sous BSD et OSX.

Essayez la commande suivante:

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

La méthode la plus simple consiste à utiliser la taccommande. tacest catl'inverse. Exemple:

$ 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 

J'aime vraiment la réponse " tail -r ", mais ma réponse gawk préférée est ....

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

MODIFIER ce qui suit génère une liste de nombres triés au hasard de 1 à 10:

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

où les points sont remplacés par une commande réelle qui inverse la liste

tac

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

python: utilisation de [:: - 1] sur 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]))")

Pour une solution multi-OS (c'est-à-dire OSX, Linux) qui peut utiliser à l' tacintérieur d'un script shell, utilisez l'homebrew comme d'autres l'ont mentionné ci-dessus, alors alias tac comme ceci:

Installer la lib

Pour MacOS

brew install coreutils

Pour Linux Debian

sudo apt-get update
sudo apt-get install coreutils 

Ajoutez ensuite un alias

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

Cela fonctionnera à la fois sur BSD et GNU.

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

Si vous souhaitez modifier le fichier sur place, vous pouvez exécuter

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

Cela supprime la nécessité de créer un fichier temporaire, puis de supprimer ou renommer l'original et a le même résultat. Par exemple:

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

Sur la base de la réponse de l'éphémient , qui a fait presque, mais pas tout à fait, ce que je voulais.

Il m'arrive que je souhaite obtenir efficacement les dernières nlignes d'un très gros fichier texte .

La première chose que j'ai essayée est tail -n 10000000 file.txt > ans.txt, mais je l'ai trouvée très lente, car tailelle doit chercher à l'emplacement puis recule pour imprimer les résultats.

Quand je me rends compte, je passe à une autre solution: tac file.txt | head -n 10000000 > ans.txt. Cette fois, la position de recherche a juste besoin de se déplacer de la fin à l'emplacement souhaité et cela économise 50% de temps !

Message à emporter:

À utiliser tac file.txt | head -n nsi votre tailn'a pas l' -roption.

Meilleure solution:

tail -n20 file.txt | tac

Pour les utilisateurs Emacs: C-x h(sélectionnez l'ensemble du fichier), puis M-x reverse-region. Fonctionne également pour sélectionner uniquement les pièces ou les lignes et les restaurer.

Je vois beaucoup d'idées intéressantes. Mais essayez mon idée. Canalisez votre texte dans ceci:

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

ce qui suppose que le caractère '~' n'est pas dans le fichier. Cela devrait fonctionner sur chaque shell UNIX remontant à 1961. Ou quelque chose comme ça.

J'avais la même question, mais je voulais aussi que la première ligne (en-tête) reste au top. Je devais donc utiliser la puissance 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 fonctionne également dans cygwin ou gitbash

Vous pouvez le faire avec vim stdinet stdout. Vous pouvez également utiliser expour être conforme à POSIX . vimest juste le mode visuel pour ex. En fait, vous pouvez utiliser exavec vim -eou vim -E( exmode amélioré ). vimest utile parce que contrairement à des outils comme sedcelui-ci, le fichier sedest mis en mémoire tampon pour l'édition, tandis que est utilisé pour les flux. Vous pourrez peut-être utiliser awk, mais vous devrez tout mettre manuellement en mémoire tampon dans une variable.

L'idée est de faire ce qui suit:

1. Lire depuis stdin
2. Pour chaque ligne, déplacez-le sur la ligne 1 (pour inverser). Le commandement est g/^/m0. Cela signifie globalement, pour chaque ligne g; correspond au début de la ligne, qui correspond à tout ^; déplacez-le après l'adresse 0, qui est la ligne 1m0 .
3. Imprimez tout. Le commandement est %p. Cela signifie pour la gamme de toutes les lignes %; imprimer la ligne p.
4. Quittez de force sans enregistrer le fichier. Le commandement est q!. Cela signifie quitter q; avec force !.

# 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

Comment rendre cela réutilisable

J'utilise un script que j'appelle ved(comme l'éditeur vim sed) pour utiliser vim pour éditer stdin. Ajoutez ceci à un fichier appelé veddans votre chemin:

#!/usr/bin/env sh

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

J'utilise une +commande au lieu de +'%p' +'q!', car vim vous limite à 10 commandes. Leur fusion permet donc "$@"d'avoir 9+ commandes au lieu de 8.

Ensuite, vous pouvez faire:

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

Si vous n'avez pas vim 8, mettez-le à la vedplace:

#!/usr/bin/env sh

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

rev
text here

ou

rev <file>

ou

rev texthere

queue -r fonctionne dans la plupart des systèmes Linux et MacOS

seq 1 20 | queue -r

sort -r < filename

ou

rev < filename