Como posso excluir uma nova linha se este for o último caractere de um arquivo?

Eu tenho alguns arquivos que gostaria de excluir a última nova linha, se for o último caractere de um arquivo. od -cmostra que o comando que eu executo grava o arquivo com uma nova linha à direita:

0013600   n   t  >  \n

Eu tentei alguns truques com o sed, mas o melhor que pude pensar não está fazendo o truque:

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

Alguma idéia de como fazer isso?

perl -pe 'chomp if eof' filename >filename2

ou, para editar o arquivo no local:

perl -pi -e 'chomp if eof' filename

^{[Nota do editor: -pi -efoi originalmente -pie, mas, como observado por vários comentaristas e explicado por @hvd, o último não funciona.]}

Isso foi descrito como uma 'blasfêmia perl' no site do awk que eu vi.

Mas, em um teste, funcionou.

Você pode tirar vantagem do fato de que as substituições de comandos do shell removem os caracteres de nova linha à direita :

Forma simples que funciona em bash, ksh, zsh:

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

Alternativa portátil (compatível com POSIX) (um pouco menos eficiente):

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

Nota:

• Se in.txtterminar com vários caracteres de nova linha, a substituição do comando removerá todos eles - obrigado, @Sparhawk. (Ele não remove caracteres de espaço em branco que não sejam linhas novas à direita).
• Como essa abordagem lê todo o arquivo de entrada na memória , é recomendável apenas para arquivos menores.
• printf %sgarante que nenhuma nova linha seja anexada à saída (é a alternativa compatível com POSIX para a não-padrão echo -n; consulte http://pubs.opengroup.org/onlinepubs/009696799/utilities/echo.html e https: //unix.stackexchange. com / a / 65819 )

Um guia para as outras respostas :

• Se o Perl estiver disponível, escolha a resposta aceita - é simples e economiza memória (não lê o arquivo de entrada inteiro de uma vez).

• Caso contrário, considere a resposta Awk de ghostdog74 - é obscura, mas também eficiente em termos de memória ; um equivalente mais legível (compatível com POSIX) é:

  • awk 'NR > 1 { print prev } { prev=$0 } END { ORS=""; print }' in.txt
  • A impressão está atrasada em uma linha, para que a linha final possa ser manuseada no ENDbloco, onde é impressa sem deixar rasto, \ndevido à definição do separador de registros de saída ( OFS) como uma sequência vazia.

• Se você deseja uma solução detalhada, porém rápida e robusta, que realmente edite no local (em vez de criar um arquivo temporário que substitui o original), considere o script Perl do jrockway .

Você pode fazer isso com o headGNU coreutils, ele suporta argumentos relativos ao final do arquivo. Portanto, para deixar de fora o último byte, use:

head -c -1

Para testar uma nova linha final, você pode usar taile wc. O exemplo a seguir salva o resultado em um arquivo temporário e sobrescreve o original:

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

Você também pode usar spongefrom moreutilspara fazer a edição "no local":

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

Você também pode criar uma função reutilizável geral colocando isso em seu .bashrcarquivo:

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

Atualizar

Conforme observado por KarlWilbur nos comentários e usado na resposta de Sorentar , truncate --size=-1pode substituir head -c-1e oferecer suporte à edição no local.

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

Edição 2:

Aqui está uma awkversão (corrigida) que não acumula uma matriz potencialmente enorme:

awk '{if (linha) linha de impressão; line = $ 0} END {printf $ 0} 'abc

gawk

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

Um método muito simples para arquivos de linha única, exigindo o eco GNU do coreutils:

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

Se você quiser fazer o que é certo, precisará de algo como isto:

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

Abrimos o arquivo para leitura e anexação; abrir para anexar significa que já estamos seekno final do arquivo. Em seguida, obtemos a posição numérica do final do arquivo com tell. Usamos esse número para procurar um caractere e depois lemos esse caractere. Se for uma nova linha, truncamos o arquivo para o caractere antes dessa nova linha, caso contrário, não fazemos nada.

Isso é executado em tempo constante e espaço constante para qualquer entrada e também não requer mais espaço em disco.

Aqui está uma solução Python agradável e arrumada. Não tentei ser conciso aqui.

Isso modifica o arquivo no local, em vez de fazer uma cópia do arquivo e remover a nova linha da última linha da cópia. Se o arquivo for grande, será muito mais rápido que a solução Perl que foi escolhida como a melhor resposta.

Ele trunca um arquivo em dois bytes se os últimos dois bytes forem CR / LF ou em um byte se o último byte for LF. Ele não tenta modificar o arquivo se o último byte (s) não for (CR) LF. Ele lida com erros. Testado em Python 2.6.

Coloque isso em um arquivo chamado "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 No espírito do "Perl golf", aqui está a minha solução Python mais curta. Ele retira o arquivo inteiro da entrada padrão para a memória, retira todas as novas linhas do final e grava o resultado na saída padrão. Não é tão conciso quanto o Perl; você simplesmente não pode vencer o Perl por coisas rápidas e complicadas como essa.

Remova o "\ n" da chamada .rstrip()e removerá todo o espaço em branco do final do arquivo, incluindo várias linhas em branco.

Coloque isso em "slurp_and_chomp.py" e execute python slurp_and_chomp.py < inputfile > outputfile.

import sys

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

Uma solução rápida é usar o utilitário gnu truncate:

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

O teste será verdadeiro se o arquivo tiver uma nova linha à direita.

A remoção é muito rápida, realmente implementada, nenhum novo arquivo é necessário e a pesquisa também está lendo no final apenas um byte ( tail -c1).

Ainda outro perl WTDI:

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

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

Consulte também Corresponder qualquer caractere (incluindo novas linhas) no 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

Assumindo o tipo de arquivo Unix e você deseja apenas a última nova linha que funcione.

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

Não funcionará em várias novas linhas ...

* Funciona apenas se a última linha for uma linha em branco.

Outra resposta FTR (e a minha favorita!): Faz eco / cat a coisa que você deseja retirar e capturar a saída através de backticks. A nova linha final será removida. Por exemplo:

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

Essa é uma boa solução se você precisar trabalhar com pipes / redirecionamentos em vez de ler / produzir um ou para um arquivo. Isso funciona com uma ou várias linhas. Funciona se existe uma nova linha à direita ou não.

# 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

Detalhes:

• head -c -1trunca o último caractere da sequência, independentemente de qual seja o caractere. Portanto, se a sequência não terminar com uma nova linha, você estaria perdendo um caractere.
• Então, para resolver esse problema, nós adicionamos um outro comando que irá adicionar uma nova linha de fuga se não houver um: sed '$s/$//'. O primeiro $meio aplica apenas o comando à última linha. s/$//significa substituir o "fim da linha" por "nada", que basicamente não está fazendo nada. Mas tem um efeito colateral de adicionar uma nova linha à direita, se não houver uma.

Nota: O padrão do Mac headnão suporta a -copção. Você pode fazer brew install coreutilse usar em seu gheadlugar.

A única vez que eu queria fazer isso é no código de golfe e, em seguida, copiei meu código do arquivo e colei em uma echo -n 'content'>fileinstrução.

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

Eu tive um problema semelhante, mas estava trabalhando com um arquivo do Windows e precisava manter os CRLF - minha solução no 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

Deve remover qualquer última ocorrência de \ n no arquivo. Não funciona em arquivos grandes (devido à limitação do buffer sed)

rubi:

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

ou:

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