Come posso eliminare una nuova riga se è l'ultimo carattere di un file?

Ho alcuni file che vorrei cancellare l'ultima riga se è l'ultimo carattere di un file. od -cmi mostra che il comando che eseguo scrive il file con una nuova riga finale:

0013600   n   t  >  \n

Ho provato alcuni trucchi con sed, ma il meglio che mi viene in mente non è fare il trucco:

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

Qualche idea su come fare questo?

perl -pe 'chomp if eof' filename >filename2

oppure, per modificare il file in atto:

perl -pi -e 'chomp if eof' filename

^{[Nota del redattore: -pi -eoriginariamente -pie, ma, come notato da molti commentatori e spiegato da @hvd, quest'ultimo non funziona.]}

Questo è stato descritto come una "bestemmia perl" sul sito Web awk che ho visto.

Ma, in un test, ha funzionato.

Puoi trarre vantaggio dal fatto che le sostituzioni di comandi della shell rimuovono i caratteri di nuova riga finali :

Forma semplice che funziona in bash, ksh, zsh:

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

Alternativa portatile (conforme a POSIX) (leggermente meno efficiente):

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

Nota:

• Se in.txttermina con più caratteri di nuova riga, la sostituzione del comando li rimuove tutti - grazie @Sparhawk. (Non rimuove i caratteri di spazi bianchi oltre alle nuove righe finali.)
• Poiché questo approccio legge l'intero file di input in memoria , è consigliabile solo per file più piccoli.
• printf %sassicura che nessuna nuova riga sia aggiunta all'output (è l'alternativa conforme POSIX al non standard echo -n; vedere http://pubs.opengroup.org/onlinepubs/009696799/utilities/echo.html e https: //unix.stackexchange. com / a / 65819 )

Una guida alle altre risposte :

• Se Perl è disponibile, cerca la risposta accettata : è semplice ed efficiente in termini di memoria (non legge l'intero file di input in una volta).

• Altrimenti, considera la risposta Awk di ghostdog74 : è oscura, ma anche efficiente in termini di memoria ; un equivalente più leggibile (conforme a POSIX) è:

  • awk 'NR > 1 { print prev } { prev=$0 } END { ORS=""; print }' in.txt
  • La stampa è ritardata di una riga in modo che la riga finale possa essere gestita nel ENDblocco, dove viene stampata senza trascinamento a \ncausa dell'impostazione del separatore del record di output ( OFS) su una stringa vuota.

• Se vuoi una soluzione dettagliata, ma veloce e robusta che modifichi davvero sul posto (invece di creare un file temporaneo che poi sostituisca l'originale), considera lo script Perl di jrockway .

Puoi farlo con headda GNU coreutils, supporta argomenti relativi alla fine del file. Quindi per lasciare l'ultimo byte usare:

head -c -1

Per verificare la presenza di una nuova riga finale è possibile utilizzare taile wc. L'esempio seguente salva il risultato in un file temporaneo e successivamente sovrascrive l'originale:

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

Puoi anche usare spongeda moreutilsper eseguire modifiche "sul posto":

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

Puoi anche rendere una funzione riutilizzabile generale inserendola nel tuo .bashrcfile:

# 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
}

Aggiornare

Come notato da KarlWilbur nei commenti e utilizzato nella risposta di Sorentar , truncate --size=-1può sostituire head -c-1e supportare la modifica sul posto.

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

Modifica 2:

Ecco una awkversione (corretta) che non accumula un array potenzialmente enorme:

awk '{if (line) linea di stampa; line = $ 0} END {printf $ 0} 'abc

allocco

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

Un metodo molto semplice per i file a riga singola, che richiede l'eco GNU da coreutils:

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

Se vuoi farlo nel modo giusto, hai bisogno di qualcosa del genere:

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;
}

Apriamo il file per la lettura e l'aggiunta; l'apertura per accodamento significa che siamo già stati modificati seekalla fine del file. Otteniamo quindi la posizione numerica della fine del file contell . Usiamo quel numero per cercare un personaggio, quindi leggiamo quel personaggio. Se si tratta di una nuova riga, tronciamo il file al personaggio prima di quella nuova riga, altrimenti non facciamo nulla.

Questo viene eseguito in tempo costante e spazio costante per qualsiasi input e non richiede neanche più spazio su disco.

Ecco una bella, ordinata soluzione Python. Non ho fatto alcun tentativo di essere conciso qui.

Ciò modifica il file sul posto, anziché creare una copia del file e rimuovere la nuova riga dall'ultima riga della copia. Se il file è di grandi dimensioni, sarà molto più veloce della soluzione Perl che è stata scelta come la migliore risposta.

Tronca un file di due byte se gli ultimi due byte sono CR / LF o di un byte se l'ultimo byte è LF. Non tenta di modificare il file se gli ultimi byte non sono (CR) LF. Gestisce errori. Testato in Python 2.6.

Mettilo in un file chiamato "striplast" e 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 Nello spirito di "Perl golf", ecco la mia soluzione Python più corta. Assorbe l'intero file dallo standard input in memoria, rimuove tutte le righe dalla fine e scrive il risultato sullo standard output. Non così conciso come il Perl; semplicemente non puoi battere Perl per piccole cose veloci difficili come questa.

Rimuovere "\ n" dalla chiamata a .rstrip() e tutto lo spazio bianco dalla fine del file, incluse più righe vuote.

Metti questo in "slurp_and_chomp.py" e poi esegui python slurp_and_chomp.py < inputfile > outputfile.

import sys

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

Una soluzione rapida sta usando l'utilità gnu truncate:

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

Il test sarà vero se il file ha una nuova riga finale.

La rimozione è molto veloce, veramente a posto, non è necessario alcun nuovo file e la ricerca legge anche alla fine solo un byte ( tail -c1).

Ancora un altro perl WTDI:

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

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

Vedi anche Abbina qualsiasi personaggio (comprese le nuove linee) in sed .

Usando 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

Supponendo il tipo di file Unix e si desidera solo l'ultima riga che funzioni.

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

Non funzionerà su più newline ...

* Funziona solo se l'ultima riga è vuota.

Ancora un'altra risposta FTR (e la mia preferita!): Echo / cat la cosa che vuoi spogliare e catturare l'output tramite backtick. La nuova riga finale verrà eliminata. Per esempio:

# 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.

Questa è una buona soluzione se ne hai bisogno per lavorare con pipe / reindirizzamento invece di leggere / produrre da o verso un file. Funziona con linee singole o multiple. Funziona indipendentemente dal fatto che esista o meno una riga finale.

# 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

Dettagli:

• head -c -1tronca l'ultimo carattere della stringa, indipendentemente da quale sia il carattere. Quindi se la stringa non termina con una nuova riga, allora perdi un carattere.
• Quindi, per l'indirizzo che il problema, aggiungiamo un altro comando che aggiunge un carattere di fine riga se non ce n'è uno: sed '$s/$//'. Il primo $significa applicare solo il comando all'ultima riga. s/$//significa sostituire la "fine della linea" con "niente", che sostanzialmente non sta facendo nulla. Ma ha un effetto collaterale nell'aggiungere una nuova riga finale se non ce n'è una.

Nota: l'impostazione predefinita del Mac headnon supporta l' -copzione. Puoi fare brew install coreutilse usare gheadinvece.

L'unica volta che ho voluto farlo è per il golf del codice, quindi ho appena copiato il mio codice dal file e incollato in una echo -n 'content'>filedichiarazione.

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

Ho avuto un problema simile, ma stavo lavorando con un file Windows e ho bisogno di mantenere quei CRLF - la mia soluzione su 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

Dovrebbe rimuovere l'ultima occorrenza di \ n nel file. Non funziona su file di grandi dimensioni (a causa della limitazione del buffer sed)

rubino:

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

o:

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