¿Cómo puedo eliminar una nueva línea si es el último carácter de un archivo?

Tengo algunos archivos que me gustaría eliminar la última línea nueva si es el último carácter de un archivo. od -cme muestra que el comando que ejecuto escribe el archivo con una nueva línea al final:

0013600   n   t  >  \n

He intentado algunos trucos con sed, pero lo mejor que se me ocurre no es hacer el truco:

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

¿Alguna idea de como hacer esto?

perl -pe 'chomp if eof' filename >filename2

o, para editar el archivo en su lugar:

perl -pi -e 'chomp if eof' filename

^{[Nota del editor: -pi -efue originalmente -pie, pero, como lo señalaron varios comentaristas y lo explicó @hvd, este último no funciona].}

Esto fue descrito como una 'blasfemia perl' en el sitio web awk que vi.

Pero, en una prueba, funcionó.

Puede aprovechar el hecho de que las sustituciones de comandos de shell eliminan los caracteres de nueva línea finales :

Forma simple que funciona en bash, ksh, zsh:

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

Alternativa portátil (compatible con POSIX) (ligeramente menos eficiente):

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

Nota:

• Si in.txtextremos con múltiples caracteres de nueva línea, la sustitución de comandos elimina todas ellas - gracias, @Sparhawk. (No elimina los caracteres de espacio en blanco que no sean líneas nuevas al final).
• Dado que este enfoque lee todo el archivo de entrada en la memoria , solo es recomendable para archivos más pequeños.
• printf %sgarantiza que no se agregue una nueva línea a la salida (es la alternativa compatible con POSIX a la no estándar echo -n; consulte http://pubs.opengroup.org/onlinepubs/009696799/utilities/echo.html y https: //unix.stackexchange. com / a / 65819 )

Una guía para las otras respuestas :

• Si Perl está disponible, busque la respuesta aceptada : es simple y eficiente en la memoria (no lee todo el archivo de entrada de una vez).

• De lo contrario, considere la respuesta Awk de ghostdog74 : es oscura, pero también eficiente en memoria ; un equivalente más legible (compatible con POSIX) es:

  • awk 'NR > 1 { print prev } { prev=$0 } END { ORS=""; print }' in.txt
  • La impresión se retrasa una línea para que la línea final se pueda manejar en el ENDbloque, donde se imprime sin un final \ndebido a la configuración del separador de registro de salida ( OFS) en una cadena vacía.

• Si desea una solución detallada, rápida y robusta que realmente edite en el lugar (en lugar de crear un archivo temporal que luego reemplace el original), considere el script Perl de jrockway .

Puede hacer esto con los headcoreutils de GNU, admite argumentos relacionados con el final del archivo. Entonces, para dejar de usar el último byte:

head -c -1

Para probar una nueva línea final, puede usar taily wc. El siguiente ejemplo guarda el resultado en un archivo temporal y posteriormente sobrescribe el original:

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

También puede usar spongedesde moreutilspara hacer la edición "in situ":

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

También puede hacer una función reutilizable general rellenando esto en su .bashrcarchivo:

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

Actualizar

Como señaló KarlWilbur en los comentarios y utilizado en la respuesta de Sorentar , truncate --size=-1puede reemplazar head -c-1y admite la edición en el lugar.

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

Edición 2:

Aquí hay una awkversión (corregida) que no acumula una matriz potencialmente enorme:

awk '{if (línea) línea de impresión; line = $ 0} END {printf $ 0} 'abc

papar moscas

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

Un método muy simple para archivos de una sola línea, que requiere eco GNU de coreutils:

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

Si quieres hacerlo bien, necesitas algo como esto:

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 el archivo para leer y agregar; abrir para agregar significa que ya estamos seekeditados al final del archivo. Luego obtenemos la posición numérica del final del archivo con tell. Usamos ese número para buscar un carácter, y luego leemos ese carácter. Si se trata de una nueva línea, truncamos el archivo al carácter antes de esa nueva línea; de lo contrario, no hacemos nada.

Esto se ejecuta en tiempo constante y espacio constante para cualquier entrada, y tampoco requiere más espacio en disco.

Aquí hay una buena y ordenada solución de Python. No hice ningún intento de ser conciso aquí.

Esto modifica el archivo en el lugar, en lugar de hacer una copia del archivo y quitar la nueva línea de la última línea de la copia. Si el archivo es grande, será mucho más rápido que la solución Perl elegida como la mejor respuesta.

Trunca un archivo en dos bytes si los dos últimos bytes son CR / LF, o en un byte si el último byte es LF. No intenta modificar el archivo si los últimos bytes no son (CR) LF. Maneja errores. Probado en Python 2.6.

Ponga esto en un archivo llamado "striplast" y 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)

PD: En el espíritu del "Perl golf", aquí está mi solución Python más corta. Extrae todo el archivo de la entrada estándar a la memoria, elimina todas las líneas nuevas del final y escribe el resultado en la salida estándar. No tan conciso como el Perl; simplemente no puedes vencer a Perl por pequeñas cosas rápidas como esta.

Elimine el "\ n" de la llamada .rstrip()y eliminará todo el espacio en blanco desde el final del archivo, incluidas varias líneas en blanco.

Pon esto en "slurp_and_chomp.py" y luego ejecuta python slurp_and_chomp.py < inputfile > outputfile.

import sys

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

Una solución rápida es usar la utilidad gnu truncate:

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

La prueba será verdadera si el archivo tiene una nueva línea final.

La eliminación es muy rápida, realmente en su lugar, no se necesita ningún archivo nuevo y la búsqueda también lee desde el final solo un byte ( tail -c1).

Otro perl WTDI:

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

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

Consulte también Hacer coincidir cualquier carácter (incluidas las nuevas líneas) en 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

Asumiendo el tipo de archivo Unix y solo desea la última línea nueva, esto funciona.

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

No funcionará en múltiples líneas nuevas ...

* Funciona solo si la última línea es una línea en blanco.

Sin embargo, otra respuesta FTR (¡y mi favorita!): Echo / cat lo que quieres quitar y capturar la salida a través de backticks. La nueva línea final será eliminada. Por ejemplo:

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

Esta es una buena solución si necesita que funcione con tuberías / redirección en lugar de lectura / salida desde o hacia un archivo. Esto funciona con líneas simples o múltiples. Funciona si hay una nueva línea final o no.

# 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

Detalles:

• head -c -1trunca el último carácter de la cadena, independientemente de cuál sea el carácter. Entonces, si la cadena no termina con una nueva línea, entonces estaría perdiendo un carácter.
• Así que para resolver ese problema, se añade otro comando que va a añadir un salto de línea final si no hay uno: sed '$s/$//'. El primer $medio solo aplica el comando a la última línea. s/$//significa sustituir el "final de la línea" con "nada", que básicamente no hace nada. Pero tiene un efecto secundario de agregar una nueva línea final si no hay una.

Nota: el valor predeterminado de Mac headno admite la -copción. Puedes hacer brew install coreutilsy usar gheaden su lugar.

La única vez que he querido hacer esto es para el código golf, y luego simplemente copié mi código del archivo y lo pegué en una echo -n 'content'>filedeclaración.

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

Tuve un problema similar, pero estaba trabajando con un archivo de Windows y necesito mantener esos CRLF: mi solución en 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

Debería eliminar cualquier última aparición de \ n en el archivo. No funciona en archivos grandes (debido a la limitación del búfer de sed)

rubí:

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

o:

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