Comment puis-je supprimer la première ligne d'un fichier texte à l'aide du script bash / sed?

J'ai besoin de supprimer à plusieurs reprises la première ligne d'un énorme fichier texte à l'aide d'un script bash.

En ce moment j'utilise sed -i -e "1d" $FILE- mais cela prend environ une minute pour faire la suppression.

Existe-t-il un moyen plus efficace d'y parvenir?

Essayez la queue :

tail -n +2 "$FILE"

-n x: Imprimez simplement les dernières xlignes. tail -n 5vous donnerait les 5 dernières lignes de l'entrée. Le +signe inverse en quelque sorte l'argument et fait tailimprimer tout sauf les premières x-1lignes. tail -n +1imprimerait tout le fichier, tail -n +2tout sauf la première ligne, etc.

GNU tailest beaucoup plus rapide que sed. tailest également disponible sur BSD et l' -n +2indicateur est cohérent entre les deux outils. Consultez les pages de manuel FreeBSD ou OS X pour en savoir plus.

sedCependant, la version BSD peut être beaucoup plus lente . Je me demande comment ils ont géré cela; taildevrait simplement lire un fichier ligne par ligne tout en sedeffectuant des opérations assez complexes impliquant l'interprétation d'un script, l'application d'expressions régulières, etc.

Remarque: vous pourriez être tenté d'utiliser

# THIS WILL GIVE YOU AN EMPTY FILE!
tail -n +2 "$FILE" > "$FILE"

mais cela vous donnera un fichier vide . La raison en est que la redirection ( >) se produit avant d' tailêtre invoquée par le shell:

1. Shell tronque le fichier $FILE
2. Shell crée un nouveau processus pour tail
3. Shell redirige la sortie standard du tailprocessus vers$FILE
4. tail lit à partir de maintenant vide $FILE

Si vous souhaitez supprimer la première ligne à l'intérieur du fichier, vous devez utiliser:

tail -n +2 "$FILE" > "$FILE.tmp" && mv "$FILE.tmp" "$FILE"

Le &&fera en sorte que le fichier ne soit pas écrasé en cas de problème.

Vous pouvez utiliser -i pour mettre à jour le fichier sans utiliser l'opérateur '>'. La commande suivante supprimera la première ligne du fichier et l'enregistrera dans le fichier.

sed -i '1d' filename

Pour ceux qui sont sur SunOS qui n'est pas GNU, le code suivant vous aidera:

sed '1d' test.dat > tmp.dat 

Non, c'est aussi efficace que possible. Vous pouvez écrire un programme C qui pourrait faire le travail un peu plus rapidement (moins de temps de démarrage et d'arguments de traitement) mais il tendra probablement vers la même vitesse que sed lorsque les fichiers deviennent volumineux (et je suppose qu'ils sont volumineux si cela prend une minute ).

Mais votre question souffre du même problème que tant d'autres en ce qu'elle présuppose la solution. Si vous deviez nous dire en détail ce que vous essayez de faire plutôt que comment , nous pourrions peut-être vous proposer une meilleure option.

Par exemple, s'il s'agit d'un fichier A que certains autres programmes B traitent, une solution serait de ne pas supprimer la première ligne, mais de modifier le programme B pour le traiter différemment.

Supposons que tous vos programmes s'ajoutent à ce fichier A et que le programme B lit et traite actuellement la première ligne avant de le supprimer.

Vous pouvez réorganiser le programme B pour qu'il n'essaye pas de supprimer la première ligne mais conserve un décalage persistant (probablement basé sur un fichier) dans le fichier A afin que, la prochaine fois qu'il s'exécute, il puisse rechercher ce décalage, traiter la ligne là-bas et mettre à jour le décalage.

Ensuite, à une heure calme (minuit?), Il pourrait effectuer un traitement spécial du fichier A pour supprimer toutes les lignes actuellement traitées et remettre le décalage à 0.

Il sera certainement plus rapide pour un programme d'ouvrir et de rechercher un fichier plutôt que d'ouvrir et de réécrire. Cette discussion suppose que vous avez le contrôle sur le programme B, bien sûr. Je ne sais pas si c'est le cas mais il peut y avoir d'autres solutions possibles si vous fournissez des informations supplémentaires.

Vous pouvez éditer les fichiers en place: Utilisez simplement le -idrapeau de perl , comme ceci:

perl -ni -e 'print unless $. == 1' filename.txt

Cela fait disparaître la première ligne, comme vous le demandez. Perl devra lire et copier l'intégralité du fichier, mais il organise l'enregistrement de la sortie sous le nom du fichier d'origine.

Vous pouvez facilement le faire avec:

cat filename | sed 1d > filename_without_first_line

sur la ligne de commande; ou pour supprimer définitivement la première ligne d'un fichier, utilisez le mode in-situ de sed avec le -iflag:

sed -i 1d <filename>

Comme l'a dit Pax, vous n'allez probablement pas aller plus vite que cela. La raison en est qu'il n'y a presque aucun système de fichiers qui prend en charge la troncature depuis le début du fichier, donc cela va être une nopération O ( ) où nest la taille du fichier. Ce que vous pouvez faire beaucoup plus rapidement est d'écraser la première ligne avec le même nombre d'octets (peut-être avec des espaces ou un commentaire), ce qui pourrait fonctionner pour vous selon exactement ce que vous essayez de faire (qu'est-ce que c'est d'ailleurs?).

L' spongeutilitaire évite d'avoir à jongler avec un fichier temporaire:

tail -n +2 "$FILE" | sponge "$FILE"

Si vous souhaitez modifier le fichier en place, vous pouvez toujours utiliser l'original edau lieu de son successeur s treaming sed:

ed "$FILE" <<<$'1d\nwq\n'

La edcommande était l'éditeur de texte UNIX d'origine, avant même d'avoir des terminaux plein écran, et encore moins des postes de travail graphiques. Le exrédacteur en chef, mieux connu sous le nom que vous utilisez lors de la saisie à l'invite du côlon dans vi, est une ex la version de tendance ed, tant du même travail de commandes. Bien qu'il edsoit destiné à être utilisé de manière interactive, il peut également être utilisé en mode batch en lui envoyant une chaîne de commandes, ce que fait cette solution.

La séquence <<<$'1d\nwq\n'profite de l'appui de bash pour ici cordes ( <<<) et des citations POSIX ( $'... ') à l' entrée d'alimentation de la edcommande se compose de deux lignes: 1dqui d eletes aligner 1 , et ensuite wq, ce qui w rites au dos du dossier vers disque, puis q uits la session d'édition.

devrait montrer les lignes sauf la première ligne:

cat textfile.txt | tail -n +2

Pourrait utiliser vim pour ce faire:

vim -u NONE +'1d' +'wq!' /tmp/test.txt

Cela devrait être plus rapide, car vim ne lira pas le fichier entier lors du processus.

Que diriez-vous d'utiliser csplit?

man csplit
csplit -k file 1 '{1}'

Comme il semble que je ne puisse pas accélérer la suppression, je pense qu'une bonne approche pourrait être de traiter le fichier par lots comme celui-ci:

While file1 not empty
  file2 = head -n1000 file1
  process file2
  sed -i -e "1000d" file1
end

L'inconvénient est que si le programme est tué au milieu (ou s'il y a un mauvais sql - provoquant la mort ou le blocage de la partie "processus"), il y aura des lignes qui seront soit ignorées, soit traitées deux fois .

(le fichier1 contient des lignes de code sql)

Si ce que vous cherchez à faire est de récupérer après l'échec, vous pouvez simplement créer un fichier contenant ce que vous avez fait jusqu'à présent.

if [[ -f $tmpf ]] ; then
    rm -f $tmpf
fi
cat $srcf |
    while read line ; do
        # process line
        echo "$line" >> $tmpf
    done

Cette doublure fera:

echo "$(tail -n +2 "$FILE")" > "$FILE"

Cela fonctionne, car il tailest exécuté avant echoet ensuite le fichier est déverrouillé, donc pas besoin de fichier temporaire.

Est-ce que l'utilisation de la queue sur les lignes N-1 et de la diriger vers un fichier, puis de supprimer l'ancien fichier et de renommer le nouveau fichier en l'ancien nom ferait le travail?

Si je faisais cela par programme, je lirais le fichier et me souviendrais de l'offset du fichier, après avoir lu chaque ligne, afin que je puisse revenir à cette position pour lire le fichier avec une ligne en moins.