Comment puis-je supprimer une nouvelle ligne s'il s'agit du dernier caractère d'un fichier?

J'ai quelques fichiers que j'aimerais supprimer le dernier saut de ligne s'il s'agit du dernier caractère d'un fichier. od -cme montre que la commande que j'exécute écrit le fichier avec une nouvelle ligne à la fin:

0013600   n   t  >  \n

J'ai essayé quelques trucs avec sed, mais le mieux auquel je puisse penser ne fait pas l'affaire:

sed -e '$s/\(.*\)\n$/\1/' abc

Des idees pour faire cela?

perl -pe 'chomp if eof' filename >filename2

ou, pour éditer le fichier sur place:

perl -pi -e 'chomp if eof' filename

^{[Note de l'éditeur: -pi -ec'était à l'origine -pie, mais, comme l'ont noté plusieurs commentateurs et expliqué par @hvd, ce dernier ne fonctionne pas.]}

Cela a été décrit comme un «blasphème perl» sur le site awk que j'ai vu.

Mais, dans un test, cela a fonctionné.

Vous pouvez profiter du fait que les substitutions de commandes shell suppriment les caractères de fin de ligne :

Formulaire simple qui fonctionne dans bash, ksh, zsh:

printf %s "$(< in.txt)" > out.txt

Alternative portable (compatible POSIX) (légèrement moins efficace):

printf %s "$(cat in.txt)" > out.txt

Remarque:

• Si in.txtextrémités avec plusieurs caractères de nouvelle ligne, la substitution de commande supprime tous d'entre eux - grâce, @Sparhawk. (Il ne supprime pas les caractères d'espacement autres que les retours à la ligne de fin.)
• Étant donné que cette approche lit le fichier d'entrée entier en mémoire , elle n'est recommandée que pour les fichiers plus petits.
• printf %sgarantit qu'aucune nouvelle ligne n'est ajoutée à la sortie (c'est l'alternative compatible POSIX au non standard echo -n; voir http://pubs.opengroup.org/onlinepubs/009696799/utilities/echo.html et https: //unix.stackexchange. com / a / 65819 )

Un guide des autres réponses :

• Si Perl est disponible, choisissez la réponse acceptée - elle est simple et économe en mémoire (ne lit pas tout le fichier d'entrée à la fois).

• Sinon, considérez la réponse Awk de ghostdog74 - elle est obscure, mais aussi efficace en mémoire ; un équivalent plus lisible (compatible POSIX) est:

  • awk 'NR > 1 { print prev } { prev=$0 } END { ORS=""; print }' in.txt
  • L'impression est retardée d'une ligne afin que la dernière ligne puisse être traitée dans le ENDbloc, où elle est imprimée sans fin en \nraison de la définition du séparateur d'enregistrement de sortie ( OFS) sur une chaîne vide.

• Si vous voulez une solution détaillée, mais rapide et robuste qui modifie réellement sur place (par opposition à la création d'un fichier temporaire qui remplace ensuite l'original), considérez le script Perl de jrockway .

Vous pouvez le faire avec headdepuis GNU coreutils, il prend en charge les arguments relatifs à la fin du fichier. Donc, pour ne pas utiliser le dernier octet:

head -c -1

Pour tester une nouvelle ligne de fin, vous pouvez utiliser tailet wc. L'exemple suivant enregistre le résultat dans un fichier temporaire et remplace par la suite l'original:

if [[ $(tail -c1 file | wc -l) == 1 ]]; then
  head -c -1 file > file.tmp
  mv file.tmp file
fi

Vous pouvez également utiliser spongefrom moreutilspour effectuer des modifications "sur place":

[[ $(tail -c1 file | wc -l) == 1 ]] && head -c -1 file | sponge file

Vous pouvez également créer une fonction réutilisable générale en insérant ceci dans votre .bashrcfichier:

# Example:  remove-last-newline < multiline.txt
function remove-last-newline(){
    local file=$(mktemp)
    cat > $file
    if [[ $(tail -c1 $file | wc -l) == 1 ]]; then
        head -c -1 $file > $file.tmp
        mv $file.tmp $file
    fi
    cat $file
}

Mettre à jour

Comme indiqué par KarlWilbur dans les commentaires et utilisé dans la réponse de Sorentar , truncate --size=-1peut remplacer head -c-1et prend en charge l'édition sur place.

head -n -1 abc > newfile
tail -n 1 abc | tr -d '\n' >> newfile

Modifier 2:

Voici une awkversion (corrigée) qui n'accumule pas un tableau potentiellement énorme:

awk '{if (line) print line; ligne = $ 0} END {printf $ 0} 'abc

rester bouche bée

   awk '{q=p;p=$0}NR>1{print q}END{ORS = ""; print p}' file

Une méthode très simple pour les fichiers sur une seule ligne, nécessitant l'écho GNU de coreutils:

/bin/echo -n $(cat $file)

Si vous voulez bien faire les choses, vous avez besoin de quelque chose comme ceci:

use autodie qw(open sysseek sysread truncate);

my $file = shift;
open my $fh, '+>>', $file;
my $pos = tell $fh;
sysseek $fh, $pos - 1, 0;
sysread $fh, my $buf, 1 or die 'No data to read?';

if($buf eq "\n"){
    truncate $fh, $pos - 1;
}

Nous ouvrons le fichier pour lecture et ajout; l'ouverture pour l'ajout signifie que nous sommes déjà seekà la fin du fichier. On obtient alors la position numérique de la fin du fichier avec tell. Nous utilisons ce nombre pour rechercher un caractère, puis nous lisons ce caractère. S'il s'agit d'une nouvelle ligne, nous tronquons le fichier au caractère avant cette nouvelle ligne, sinon nous ne faisons rien.

Cela fonctionne en temps constant et en espace constant pour n'importe quelle entrée, et ne nécessite pas non plus d'espace disque.

Voici une solution Python sympa et bien rangée. Je n'ai pas essayé d'être laconique ici.

Cela modifie le fichier sur place, plutôt que de faire une copie du fichier et de supprimer la nouvelle ligne de la dernière ligne de la copie. Si le fichier est volumineux, ce sera beaucoup plus rapide que la solution Perl qui a été choisie comme meilleure réponse.

Il tronque un fichier de deux octets si les deux derniers octets sont CR / LF, ou d'un octet si le dernier octet est LF. Il n'essaye pas de modifier le fichier si le ou les derniers octets ne sont pas (CR) LF. Il gère les erreurs. Testé en Python 2.6.

Mettez ceci dans un fichier appelé "striplast" et chmod +x striplast.

#!/usr/bin/python

# strip newline from last line of a file


import sys

def trunc(filename, new_len):
    try:
        # open with mode "append" so we have permission to modify
        # cannot open with mode "write" because that clobbers the file!
        f = open(filename, "ab")
        f.truncate(new_len)
        f.close()
    except IOError:
        print "cannot write to file:", filename
        sys.exit(2)

# get input argument
if len(sys.argv) == 2:
    filename = sys.argv[1]
else:
    filename = "--help"  # wrong number of arguments so print help

if filename == "--help" or filename == "-h" or filename == "/?":
    print "Usage: %s <filename>" % sys.argv[0]
    print "Strips a newline off the last line of a file."
    sys.exit(1)


try:
    # must have mode "b" (binary) to allow f.seek() with negative offset
    f = open(filename, "rb")
except IOError:
    print "file does not exist:", filename
    sys.exit(2)


SEEK_EOF = 2
f.seek(-2, SEEK_EOF)  # seek to two bytes before end of file

end_pos = f.tell()

line = f.read()
f.close()

if line.endswith("\r\n"):
    trunc(filename, end_pos)
elif line.endswith("\n"):
    trunc(filename, end_pos + 1)

PS Dans l'esprit du "Perl golf", voici ma solution Python la plus courte. Il extrait le fichier entier de l'entrée standard dans la mémoire, supprime toutes les nouvelles lignes à la fin et écrit le résultat sur la sortie standard. Pas aussi laconique que le Perl; vous ne pouvez pas battre Perl pour de petits trucs rapides et délicats comme celui-ci.

Supprimez le "\ n" de l'appel à .rstrip()et il supprimera tous les espaces blancs à la fin du fichier, y compris plusieurs lignes vides.

Mettez ceci dans "slurp_and_chomp.py" puis exécutez python slurp_and_chomp.py < inputfile > outputfile.

import sys

sys.stdout.write(sys.stdin.read().rstrip("\n"))

Une solution rapide utilise l'utilitaire gnu truncate:

[ -z $(tail -c1 file) ] && truncate -s-1 file

Le test sera vrai si le fichier a une nouvelle ligne à la fin.

La suppression est très rapide, vraiment en place, aucun nouveau fichier n'est nécessaire et la recherche lit également à la fin un seul octet ( tail -c1).

Encore un autre WTDI perl:

perl -i -p0777we's/\n\z//' filename

$ perl -e 'local $ /; $ _ = <>; s / \ n $ //; print 'a-text-file.txt

Voir aussi Faire correspondre n'importe quel caractère (y compris les sauts de ligne) dans sed .

Utilisation de dd:

file='/path/to/file'
[[ "$(tail -c 1 "${file}" | tr -dc '\n' | wc -c)" -eq 1 ]] && \
    printf "" | dd  of="${file}" seek=$(($(stat -f "%z" "${file}") - 1)) bs=1 count=1
    #printf "" | dd  of="${file}" seek=$(($(wc -c < "${file}") - 1)) bs=1 count=1

perl -pi -e 's/\n$// if(eof)' your_file

En supposant le type de fichier Unix et que vous ne voulez que la dernière nouvelle ligne, cela fonctionne.

sed -e '${/^$/d}'

Cela ne fonctionnera pas sur plusieurs nouvelles lignes ...

* Fonctionne uniquement si la dernière ligne est une ligne vierge.

Encore une autre réponse FTR (et ma préférée!): Echo / cat la chose que vous voulez dépouiller et capturer la sortie par des backticks. La dernière nouvelle ligne sera supprimée. Par exemple:

# Sadly, outputs newline, and we have to feed the newline to sed to be portable
echo thingy | sed -e 's/thing/sill/'

# No newline! Happy.
out=`echo thingy | sed -e 's/thing/sill/'`
printf %s "$out"

# Similarly for files:
file=`cat file_ending_in_newline`
printf %s "$file" > file_no_newline

POSIX SED:

«$ {/ ^ $ / d}»

$ - match last line


{ COMMANDS } - A group of commands may be enclosed between { and } characters. This is particularly useful when you want a group of commands to be triggered by a single address (or address-range) match.

C'est une bonne solution si vous en avez besoin pour travailler avec des tubes / redirection au lieu de lire / sortir depuis ou vers un fichier. Cela fonctionne avec une ou plusieurs lignes. Cela fonctionne qu'il y ait une nouvelle ligne de fin ou non.

# with trailing newline
echo -en 'foo\nbar\n' | sed '$s/$//' | head -c -1

# still works without trailing newline
echo -en 'foo\nbar' | sed '$s/$//' | head -c -1

# read from a file
sed '$s/$//' myfile.txt | head -c -1

Détails:

• head -c -1tronque le dernier caractère de la chaîne, quel que soit le caractère. Donc, si la chaîne ne se termine pas par une nouvelle ligne, vous perdrez un caractère.
• Donc , pour remédier à ce problème, nous ajoutons une autre commande qui ajoutera une nouvelle ligne de fuite s'il n'y a pas un: sed '$s/$//'. Le premier $signifie n'appliquer la commande qu'à la dernière ligne. s/$//signifie remplacer la «fin de la ligne» par «rien», ce qui ne fait essentiellement rien. Mais cela a pour effet secondaire d'ajouter une nouvelle ligne de fin s'il n'y en a pas.

Remarque: la valeur par défaut de Mac headne prend pas en charge l' -coption. Vous pouvez faire brew install coreutilset utiliser à la gheadplace.

La seule fois où j'ai voulu faire cela, c'est pour le code golf, puis j'ai simplement copié mon code hors du fichier et l'ai collé dans une echo -n 'content'>fileinstruction.

sed ':a;/^\n*$/{$d;N;};/\n$/ba' file

J'ai eu un problème similaire, mais je travaillais avec un fichier Windows et j'ai besoin de conserver ces CRLF - ma solution sous Linux:

sed 's/\r//g' orig | awk '{if (NR>1) printf("\r\n"); printf("%s",$0)}' > tweaked

sed -n "1 x;1 !H
$ {x;s/\n*$//p;}
" YourFile

Devrait supprimer toute dernière occurrence de \ n dans le fichier. Ne fonctionne pas sur un fichier énorme (en raison de la limitation du tampon sed)

rubis:

ruby -ne 'print $stdin.eof ? $_.strip : $_'

ou:

ruby -ane 'q=p;p=$_;puts q if $.>1;END{print p.strip!}'