Jak mogę usunąć nową linię, jeśli jest to ostatni znak w pliku?

Mam kilka plików, z których chciałbym usunąć ostatni znak nowej linii, jeśli jest to ostatni znak w pliku. od -cpokazuje mi, że polecenie, które wykonuję, zapisuje plik z końcową nową linią:

0013600   n   t  >  \n

Wypróbowałem kilka sztuczek z sedem, ale najlepsze, o czym przyszło mi do głowy, nie działa:

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

Jakieś pomysły, jak to zrobić?

perl -pe 'chomp if eof' filename >filename2

lub, aby edytować plik w miejscu:

perl -pi -e 'chomp if eof' filename

^{[Od redakcji: -pi -ebyło pierwotnie -pie, ale, jak zauważyło kilku komentatorów i wyjaśniło @hvd, to drugie nie działa.]}

Na stronie awk, którą widziałem, zostało to opisane jako „bluźnierstwo perla”.

Ale w teście zadziałało.

Możesz wykorzystać fakt, że podstawienia poleceń powłoki usuwają końcowe znaki nowej linii :

Prosta forma, która działa w bash, ksh, zsh:

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

Przenośna (zgodna z POSIX) alternatywa (nieco mniej wydajna):

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

Uwaga:

• Jeśli in.txtkończy się wieloma znakami nowej linii, podstawienie polecenia usuwa je wszystkie - dzięki, @Sparhawk. (Nie usuwa białych znaków innych niż końcowe znaki nowej linii).
• Ponieważ takie podejście odczytuje cały plik wejściowy do pamięci , jest zalecane tylko w przypadku mniejszych plików.
• printf %szapewnia, że ​​do danych wyjściowych nie zostanie dołączony znak nowej linii (jest to zgodna z POSIX alternatywa dla niestandardowego echo -n; patrz http://pubs.opengroup.org/onlinepubs/009696799/utilities/echo.html i https: //unix.stackexchange. pl / a / 65819 )

Podręcznik do innych odpowiedzi :

• Jeśli Perl jest dostępny, wybierz zaakceptowaną odpowiedź - jest prosta i wydajna w pamięci (nie czyta od razu całego pliku wejściowego).

• W przeciwnym razie rozważ odpowiedź Awk ghostdog74 - jest niejasna, ale także wydajna pod względem pamięci ; równoważne bardziej czytelne (POSIX) stanowi:

  • awk 'NR > 1 { print prev } { prev=$0 } END { ORS=""; print }' in.txt
  • Drukowanie jest opóźnione o jedną linię, dzięki czemu ostatnia linia może być obsłużona w ENDbloku, gdzie jest drukowana bez \nkońca z powodu ustawienia separatora rekordów wyjściowych ( OFS) na pusty łańcuch.

• Jeśli chcesz uzyskać szczegółowe, ale szybkie i niezawodne rozwiązanie, które naprawdę edytuje w miejscu (w przeciwieństwie do tworzenia pliku tymczasowego, który następnie zastępuje oryginał), rozważ skrypt Perl jrockway .

Możesz to zrobić z headGNU coreutils, obsługuje argumenty, które są względne do końca pliku. Aby więc zostawić ostatnie użycie bajtu:

head -c -1

Aby przetestować końcową linię nowej linii, możesz użyć taili wc. Poniższy przykład zapisuje wynik w pliku tymczasowym, a następnie zastępuje oryginał:

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

Możesz również użyć spongefrom, moreutilsaby przeprowadzić edycję „lokalną”:

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

Możesz również utworzyć ogólną funkcję wielokrotnego użytku, umieszczając ją w swoim .bashrcpliku:

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

Aktualizacja

Jak zauważył KarlWilbur w komentarzach i użyty w odpowiedzi Sorentara , truncate --size=-1może zastępować head -c-1i wspierać edycję w miejscu.

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

Edycja 2:

Oto awkwersja (poprawiona) , która nie gromadzi potencjalnie ogromnej tablicy:

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

gapić się

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

Bardzo prosta metoda dla plików jednowierszowych, wymagająca echa GNU z coreutils:

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

Jeśli chcesz to zrobić dobrze, potrzebujesz czegoś takiego:

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

Otwieramy plik do odczytu i dołączenia; otwarcie do dołączenia oznacza, że ​​jesteśmy już seekna końcu pliku. Następnie otrzymujemy numeryczną pozycję końca pliku za pomocą tell. Używamy tej liczby do wyszukiwania wstecz jednego znaku, a następnie czytamy ten jeden znak. Jeśli jest to znak nowej linii, skracamy plik do znaku przed tą linią, w przeciwnym razie nic nie robimy.

Działa to w stałym czasie i stałej przestrzeni dla dowolnego wejścia i nie wymaga też więcej miejsca na dysku.

Oto ładne, uporządkowane rozwiązanie w języku Python. Nie próbowałem tu być lakoniczny.

To modyfikuje plik na miejscu, zamiast tworzyć kopię pliku i usuwać znak nowej linii z ostatniego wiersza kopii. Jeśli plik jest duży, będzie to znacznie szybsze niż rozwiązanie Perla, które zostało wybrane jako najlepsza odpowiedź.

Obcina plik o dwa bajty, jeśli ostatnie dwa bajty to CR / LF, lub o jeden bajt, jeśli ostatni bajt to LF. Nie podejmuje próby modyfikacji pliku, jeśli ostatnie bajty nie są (CR) LF. Obsługuje błędy. Przetestowano w Pythonie 2.6.

Umieść to w pliku o nazwie „striplast” i 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 W duchu „Perl golfa”, oto moje najkrótsze rozwiązanie w Pythonie. Siorbi cały plik ze standardowego wejścia do pamięci, usuwa wszystkie znaki nowej linii z końca i zapisuje wynik na standardowe wyjście. Nie tak zwięzły jak Perl; po prostu nie możesz pokonać Perla w takich drobnych, szybkich rzeczach.

Usuń znak „\ n” z wywołania do .rstrip()i usunie cały biały znak na końcu pliku, w tym wiele pustych wierszy.

Umieść to w „slurp_and_chomp.py” i uruchom python slurp_and_chomp.py < inputfile > outputfile.

import sys

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

Szybkim rozwiązaniem jest użycie narzędzia gnu truncate:

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

Test będzie prawdziwy, jeśli plik ma na końcu nową linię.

Usuwanie jest bardzo szybkie, naprawdę na miejscu, nie jest potrzebny nowy plik, a wyszukiwanie również odczytuje od końca tylko jeden bajt ( tail -c1).

Jeszcze inny perl WTDI:

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

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

Zobacz także Dopasuj dowolny znak (w tym znaki nowej linii) w sed .

Korzystanie z 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

Zakładając typ pliku Unix i chcesz, aby tylko ostatnia nowa linia działała.

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

Nie będzie działać na wielu nowych liniach ...

* Działa tylko wtedy, gdy ostatnia linia jest pusta.

Jeszcze inna odpowiedź FTR (i moja ulubiona!): Echo / cat to, co chcesz rozebrać i przechwycić dane wyjściowe za pomocą backticks. Ostatnia nowa linia zostanie usunięta. Na przykład:

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

Jest to dobre rozwiązanie, jeśli chcesz, aby działało z potokami / przekierowaniami zamiast odczytywania / wyprowadzania z lub do pliku. Działa to z jedną lub wieloma liniami. Działa niezależnie od tego, czy jest końcowy znak nowej linii, czy nie.

# 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

Detale:

• head -c -1obcina ostatni znak ciągu, niezależnie od tego, jaki to znak. Więc jeśli ciąg nie kończy się znakiem nowej linii, tracisz znak.
• Tak, aby adres ten problem, możemy dodać kolejną komendę, która doda końcowym znakiem nowej linii, jeśli nie jest jeden: sed '$s/$//'. Pierwszy $oznacza zastosowanie polecenia tylko do ostatniej linii. s/$//oznacza zastąpienie „końca wiersza” słowem „nic”, co oznacza nic nie robienie. Ale ma to efekt uboczny dodania końcowego znaku nowej linii, jeśli go nie ma.

Uwaga: domyślnie Mac headnie obsługuje tej -copcji. Możesz to zrobić brew install coreutilsi użyć gheadzamiast tego.

Chciałem to zrobić tylko dla kodu golfa, a potem po prostu skopiowałem kod z pliku i wkleiłem go do echo -n 'content'>fileinstrukcji.

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

Miałem podobny problem, ale pracowałem z plikiem Windows i muszę zachować te CRLF - moje rozwiązanie w systemie 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

Powinno usunąć ostatnie wystąpienie \ nw pliku. Nie działa na dużym pliku (z powodu ograniczenia bufora seda)

rubin:

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

lub:

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