unix - tête ET queue de fichier

Disons que vous avez un fichier txt, quelle est la commande pour afficher les 10 premières lignes et les 10 dernières lignes du fichier simultanément?

c'est-à-dire que si le fichier fait 200 lignes, visualisez les lignes 1-10 et 190-200 en une seule fois.

Vous pouvez simplement:

(head; tail) < file.txt

Et si vous avez besoin d'utiliser des tuyaux pour une raison quelconque, alors comme ceci:

cat file.txt | (head; tail)

Remarque: imprimera des lignes dupliquées si le nombre de lignes dans file.txt est inférieur aux lignes de tête par défaut + lignes de queue par défaut.

ed est le standard text editor

$ echo -e '1+10,$-10d\n%p' | ed -s file.txt

Pour un flux pur (par exemple, la sortie d'une commande), vous pouvez utiliser 'tee' pour bifurquer le flux et envoyer un flux à la tête et un à la queue. Cela nécessite l'utilisation de la fonction '> (list)' de bash (+ / dev / fd / N):

( COMMAND | tee /dev/fd/3 | head ) 3> >( tail )

ou en utilisant / dev / fd / N (ou / dev / stderr) plus des sous-shell avec une redirection compliquée:

( ( seq 1 100 | tee /dev/fd/2 | head 1>&3 ) 2>&1 | tail ) 3>&1
( ( seq 1 100 | tee /dev/stderr | head 1>&3 ) 2>&1 | tail ) 3>&1

(Aucun de ceux-ci ne fonctionnera dans csh ou tcsh.)

Pour quelque chose avec un peu meilleur contrôle, vous pouvez utiliser cette commande perl:

COMMAND | perl -e 'my $size = 10; my @buf = (); while (<>) { print if $. <= $size; push(@buf, $_); if ( @buf > $size ) { shift(@buf); } } print "------\n"; print @buf;'

(sed -u 10q; echo ...; tail) < file.txt

Juste une autre variation sur le (head;tail)thème, mais en évitant le problème de remplissage initial du tampon pour les petits fichiers.

head -10 file.txt; tail -10 file.txt

En dehors de cela, vous devrez écrire votre propre programme / script.

Basé sur le commentaire de JF Sebastian :

cat file | { tee >(head >&3; cat >/dev/null) | tail; } 3>&1

De cette façon, vous pouvez traiter la première ligne et le reste différemment dans un même tube, ce qui est utile pour travailler avec des données CSV:

{ echo N; seq 3;} | { tee >(head -n1 | sed 's/$/*2/' >&3; cat >/dev/null) | tail -n+2 | awk '{print $1*2}'; } 3>&1

N * 2
2
4
6

le problème ici est que les programmes orientés flux ne connaissent pas à l'avance la longueur du fichier (car il se peut qu'il n'y en ait pas, s'il s'agit d'un vrai flux).

des outils comme tailtamponner les n dernières lignes vues et attendre la fin du flux, puis imprimer.

si vous voulez le faire en une seule commande (et le faire fonctionner avec n'importe quel décalage, et ne pas répéter les lignes si elles se chevauchent), vous devrez émuler ce comportement que j'ai mentionné.

essayez ce awk:

awk -v offset=10 '{ if (NR <= offset) print; else { a[NR] = $0; delete a[NR-offset] } } END { for (i=NR-offset+1; i<=NR; i++) print a[i] }' yourfile

Il a fallu beaucoup de temps pour aboutir à cette solution qui semble être la seule à couvrir tous les cas d'utilisation (jusqu'à présent):

command | tee full.log | stdbuf -i0 -o0 -e0 awk -v offset=${MAX_LINES:-200} \
          '{
               if (NR <= offset) print;
               else {
                   a[NR] = $0;
                   delete a[NR-offset];
                   printf "." > "/dev/stderr"
                   }
           }
           END {
             print "" > "/dev/stderr";
             for(i=NR-offset+1 > offset ? NR-offset+1: offset+1 ;i<=NR;i++)
             { print a[i]}
           }'

Liste des fonctionnalités:

• sortie live pour la tête (évidemment que pour la queue n'est pas possible)
• pas d'utilisation de fichiers externes
• barre de progression un point pour chaque ligne après MAX_LINES, très utile pour les tâches de longue durée.
• barre de progression sur stderr, assurant que les points de progression sont séparés de la tête + la queue (très pratique si vous voulez pipe stdout)
• évite un ordre de journalisation incorrect en raison de la mise en mémoire tampon (stdbuf)
• évitez de dupliquer la sortie lorsque le nombre total de lignes est inférieur à head + tail.

Je cherchais cette solution depuis un moment. Je l'ai essayé moi-même avec sed, mais le problème de ne pas connaître au préalable la longueur du fichier / flux était insurmontable. De toutes les options disponibles ci-dessus, j'aime la solution awk de Camille Goudeseune. Il a noté que sa solution laissait des lignes vierges supplémentaires dans la sortie avec un ensemble de données suffisamment petit. Ici, je propose une modification de sa solution qui supprime les lignes supplémentaires.

headtail() { awk -v offset="$1" '{ if (NR <= offset) print; else { a[NR] = $0; delete a[NR-offset] } } END { a_count=0; for (i in a) {a_count++}; for (i=NR-a_count+1; i<=NR; i++) print a[i] }' ; }

Eh bien, vous pouvez toujours les enchaîner. Comme tel, head fiename_foo && tail filename_foo. Si cela ne suffit pas, vous pouvez écrire vous-même une fonction bash dans votre fichier .profile ou dans tout fichier de connexion que vous utilisez:

head_and_tail() {
    head $1 && tail $1
}

Et, appelez plus tard à partir de votre invite du shell: head_and_tail filename_foo.

10 premières lignes de file.ext, puis ses 10 dernières lignes:

cat file.ext | head -10 && cat file.ext | tail -10

10 dernières lignes du fichier, puis les 10 premières:

cat file.ext | tail -10 && cat file.ext | head -10

Vous pouvez également diriger la sortie ailleurs:

(cat file.ext | head -10 && cat file.ext | tail -10 ) | your_program

J'ai écrit une application python simple pour ce faire: https://gist.github.com/garyvdm/9970522

Il gère les tubes (flux) ainsi que les fichiers.

s'inspirant des idées ci-dessus (testé bash & zsh)

mais en utilisant un alias `` chapeau '' Head and Tails

alias hat='(head -5 && echo "^^^------vvv" && tail -5) < '


hat large.sql

Pourquoi ne pas l'utiliser sedpour cette tâche?

sed -n -e 1,+9p -e 190,+9p textfile.txt

Pour gérer les tubes (flux) ainsi que les fichiers, ajoutez ceci à votre fichier .bashrc ou .profile:

headtail() { awk -v offset="$1" '{ if (NR <= offset) print; else { a[NR] = $0; delete a[NR-offset] } } END { for (i=NR-offset+1; i<=NR; i++) print a[i] }' ; }

Alors vous pouvez non seulement

headtail 10 < file.txt

mais aussi

a.out | headtail 10

(Cela ajoute toujours de fausses lignes vides lorsque 10 dépasse la longueur de l'entrée, contrairement à l'ancien a.out | (head; tail). Merci, précédents répondants.)

Remarque: headtail 10non headtail -10.

S'appuyant sur ce que @Samus_ a expliqué ici sur le fonctionnement de la commande de @Aleksandra Zalcman, cette variante est pratique lorsque vous ne pouvez pas repérer rapidement où la queue commence sans compter les lignes.

{ head; echo "####################\n...\n####################"; tail; } < file.txt

Ou si vous commencez à travailler avec autre chose que 20 lignes, un nombre de lignes peut même vous aider.

{ head -n 18; tail -n 14; } < file.txt | cat -n

Pour imprimer les 10 premières et les 10 dernières lignes d'un fichier, vous pouvez essayer ceci:

cat <(head -n10 file.txt) <(tail -n10 file.txt) | less

sed -n "1,10p; $(( $(wc -l ${aFile} | grep -oE "^[[:digit:]]+")-9 )),\$p" "${aFile}"

REMARQUE : la variable aFile contient le chemin d'accès complet du fichier .

Je dirais qu'en fonction de la taille du fichier, la lecture active de son contenu peut ne pas être souhaitable. Dans ce cas, je pense qu'un simple script shell devrait suffire.

Voici comment j'ai récemment géré cela pour un certain nombre de très gros fichiers CSV que j'analysais:

$ for file in *.csv; do echo "### ${file}" && head ${file} && echo ... && tail ${file} && echo; done

Cela imprime les 10 premières lignes et les 10 dernières lignes de chaque fichier, tout en imprimant également le nom du fichier et quelques points de suspension avant et après.

Pour un seul gros fichier, vous pouvez simplement exécuter ce qui suit pour le même effet:

$ head somefile.csv && echo ... && tail somefile.csv

Consomme stdin, mais simple et fonctionne pour 99% des cas d'utilisation

head_and_tail

#!/usr/bin/env bash
COUNT=${1:-10}
IT=$(cat /dev/stdin)
echo "$IT" | head -n$COUNT
echo "..."
echo "$IT" | tail -n$COUNT

exemple

$ seq 100 | head_and_tail 4
1
2
3
4
...
97
98
99
100