¿Cómo agregar una nueva línea al final de un archivo?

Al usar los sistemas de control de versiones, me molesta el ruido cuando dice el diff No newline at end of file.

Entonces me preguntaba: ¿Cómo agregar una nueva línea al final de un archivo para deshacerme de esos mensajes?

Para desinfectar recursivamente un proyecto, uso este oneliner:

git ls-files -z | while IFS= read -rd '' f; do tail -c1 < "$f" | read -r _ || echo >> "$f"; done

Explicación:

• git ls-files -zenumera los archivos en el repositorio. Toma un patrón opcional como parámetro adicional que puede ser útil en algunos casos si desea restringir la operación a ciertos archivos / directorios. Como alternativa, puede usar find -print0 ...programas similares para enumerar los archivos afectados, solo asegúrese de que emita NULentradas delimitadas.

• while IFS= read -rd '' f; do ... done itera a través de las entradas, manejando de manera segura los nombres de archivo que incluyen espacios en blanco y / o nuevas líneas.

• tail -c1 < "$f" lee el último carácter de un archivo.

• read -r _ sale con un estado de salida distinto de cero si falta una nueva línea final.

• || echo >> "$f" agrega una nueva línea al archivo si el estado de salida del comando anterior era distinto de cero.

Aquí tiene :

sed -i -e '$a\' file

Y alternativamente para OS X sed:

sed -i '' -e '$a\' file

Esto se agrega \nal final del archivo solo si aún no termina con una nueva línea. Entonces, si lo ejecuta dos veces, no agregará otra nueva línea:

$ cd "$(mktemp -d)"
$ printf foo > test.txt
$ sed -e '$a\' test.txt > test-with-eol.txt
$ diff test*
1c1
< foo
\ No newline at end of file
---
> foo
$ echo $?
1
$ sed -e '$a\' test-with-eol.txt > test-still-with-one-eol.txt
$ diff test-with-eol.txt test-still-with-one-eol.txt
$ echo $?
0

Echar un vistazo:

$ echo -n foo > foo 
$ cat foo
foo$
$ echo "" >> foo
$ cat foo
foo

entonces echo "" >> noeol-filedebería hacer el truco. (¿O quiso pedir identificar estos archivos y corregirlos?)

editar retira el ""de echo "" >> foo(ver el comentario de @ yuyichao) Edit2 añadió el ""nuevo ( pero ver el comentario de @Keith Thompson)

Otra solución usando ed. Esta solución solo afecta a la última línea y solo si \nfalta:

ed -s file <<< w

Básicamente funciona abriendo el archivo para editarlo a través de un script, el script es el wcomando único que escribe el archivo nuevamente en el disco. Se basa en esta oración que se encuentra en la ed(1)página del manual:

Limitaciones
       (...)

       Si un archivo de texto (no binario) no termina con un carácter de nueva línea,
       luego ed agrega uno para leerlo / escribirlo. En el caso de un binario
       file, ed no agrega una nueva línea en lectura / escritura.

Una manera simple, portátil y compatible con POSIX de agregar una nueva línea final ausente a un archivo de texto sería:

[ -n "$(tail -c1 file)" ] && echo >> file

Este enfoque no necesita leer el archivo completo; simplemente puede buscar EOF y trabajar desde allí.

Este enfoque tampoco necesita crear archivos temporales a sus espaldas (por ejemplo, sed -i), por lo que los enlaces duros no se ven afectados.

echo agrega una nueva línea al archivo solo cuando el resultado de la sustitución del comando es una cadena no vacía. Tenga en cuenta que esto solo puede suceder si el archivo no está vacío y el último byte no es una nueva línea.

Si el último byte del archivo es una nueva línea, tail lo devuelve, luego la sustitución del comando lo elimina; El resultado es una cadena vacía. La prueba -n falla y echo no se ejecuta.

Si el archivo está vacío, el resultado de la sustitución del comando también es una cadena vacía, y nuevamente echo no se ejecuta. Esto es deseable, porque un archivo vacío no es un archivo de texto no válido, ni es equivalente a un archivo de texto no vacío con una línea vacía.

Agregar nueva línea independientemente:

echo >> filename

Aquí hay una manera de verificar si existe una nueva línea al final antes de agregar una, utilizando Python:

f=filename; python -c "import sys; sys.exit(open(\"$f\").read().endswith('\n'))" && echo >> $f

La solución más rápida es:

[ -n "$(tail -c1 file)" ] && printf '\n' >>file 

1. Es realmente rapido.
   En un archivo de tamaño mediano, seq 99999999 >fileesto lleva milisegundos.
   Otras soluciones llevan mucho tiempo:

   [ -n "$(tail -c1 file)" ] && printf '\n' >>file  0.013 sec
   vi -ecwq file                                    2.544 sec
   paste file 1<> file                             31.943 sec
   ed -s file <<< w                             1m  4.422 sec
   sed -i -e '$a\' file                         3m 20.931 sec

2. Funciona en ash, bash, lksh, mksh, ksh93, attsh y zsh pero no en yash.

3. No cambia la marca de tiempo del archivo si no es necesario agregar una nueva línea.
   Todas las demás soluciones presentadas aquí cambian la marca de tiempo del archivo.
4. Todas las soluciones anteriores son POSIX válidas.

Si necesita una solución portátil para cortar (y todos los demás shells enumerados anteriormente), puede ser un poco más complejo:

f=file
if       [ "$(tail -c1 "$f"; echo x)" != "$(printf '\nx')" ]
then     printf '\n' >>"$f"
fi

La forma más rápida de probar si el último byte de un archivo es una nueva línea es leer solo ese último byte. Eso podría hacerse con tail -c1 file. Sin embargo, la forma simplista de probar si el valor de byte es una nueva línea, dependiendo de la eliminación habitual de una nueva línea final dentro de una expansión de comando falla (por ejemplo) en yash, cuando el último carácter del archivo es un UTF- 8 valor.

La forma correcta, compatible con POSIX, de todos los shells (razonables) para encontrar si el último byte de un archivo es una nueva línea es usar xxd o hexdump:

tail -c1 file | xxd -u -p
tail -c1 file | hexdump -v -e '/1 "%02X"'

Luego, comparar la salida de arriba 0Aproporcionará una prueba robusta.
Es útil para evitar agregar una nueva línea a un archivo vacío.
Archivo que no proporcionará un último carácter de 0A, por supuesto:

f=file
a=$(tail -c1 "$f" | hexdump -v -e '/1 "%02X"')
[ -s "$f" -a "$a" != "0A" ] && echo >> "$f"

Corto y dulce. Esto lleva muy poco tiempo, ya que solo lee el último byte (buscar EOF). No importa si el archivo es grande. Luego solo agregue un byte si es necesario.

No se necesitan ni se usan archivos temporales. No hay enlaces duros afectados.

Si esta prueba se ejecuta dos veces, no agregará otra nueva línea.

Es mejor corregir el editor del usuario que editó el archivo por última vez. Si usted es la última persona que ha editado el archivo, ¿qué editor está utilizando, supongo que textmate ...?

Si solo desea agregar rápidamente una nueva línea al procesar alguna tubería, use esto:

outputting_program | { cat ; echo ; }

También es compatible con POSIX.

Luego, por supuesto, puede redirigirlo a un archivo.

Siempre que no haya valores nulos en la entrada:

paste - <>infile >&0

... bastaría con añadir siempre una nueva línea al final de un archivo si aún no tenía una. Y solo necesita leer el archivo de entrada una vez para hacerlo bien.

Aunque no responde directamente a la pregunta, aquí hay un script relacionado que escribí para detectar archivos que no terminan en nueva línea. Es muy rápido.

find . -type f | # sort |        # sort file names if you like
/usr/bin/perl -lne '
   open FH, "<", $_ or do { print " error: $_"; next };
   $pos = sysseek FH, 0, 2;                     # seek to EOF
   if (!defined $pos)     { print " error: $_"; next }
   if ($pos == 0)         { print " empty: $_"; next }
   $pos = sysseek FH, -1, 1;                    # seek to last char
   if (!defined $pos)     { print " error: $_"; next }
   $cnt = sysread FH, $c, 1;
   if (!$cnt)             { print " error: $_"; next }
   if ($c eq "\n")        { print "   EOL: $_"; next }
   else                   { print "no EOL: $_"; next }
'

El script perl lee una lista de nombres de archivos (opcionalmente ordenados) desde stdin y para cada archivo lee el último byte para determinar si el archivo termina en una nueva línea o no. Es muy rápido porque evita leer todo el contenido de cada archivo. Produce una línea para cada archivo que lee, con el prefijo "error:" si se produce algún tipo de error, "vacío:" si el archivo está vacío (¡no termina con nueva línea!), "EOL:" ("fin de línea ") si el archivo termina con nueva línea y" sin EOL: "si el archivo no termina con nueva línea.

Nota: el script no maneja los nombres de archivo que contienen nuevas líneas. Si está en un sistema GNU o BSD, puede manejar todos los nombres de archivo posibles agregando -print0 para buscar, -z para ordenar y -0 para perl, de esta manera:

find . -type f -print0 | sort -z |
/usr/bin/perl -ln0e '
   open FH, "<", $_ or do { print " error: $_"; next };
   $pos = sysseek FH, 0, 2;                     # seek to EOF
   if (!defined $pos)     { print " error: $_"; next }
   if ($pos == 0)         { print " empty: $_"; next }
   $pos = sysseek FH, -1, 1;                    # seek to last char
   if (!defined $pos)     { print " error: $_"; next }
   $cnt = sysread FH, $c, 1;
   if (!$cnt)             { print " error: $_"; next }
   if ($c eq "\n")        { print "   EOL: $_"; next }
   else                   { print "no EOL: $_"; next }
'

Por supuesto, aún tendría que encontrar una forma de codificar los nombres de archivo con nuevas líneas en la salida (dejada como ejercicio para el lector).

La salida podría filtrarse, si se desea, para agregar una nueva línea a aquellos archivos que no tienen uno, más simplemente con

 echo >> "$filename"

La falta de una nueva línea final puede causar errores en las secuencias de comandos, ya que algunas versiones de shell y otras utilidades no manejarán correctamente una nueva línea final faltante al leer dicho archivo.

En mi experiencia, la falta de una nueva línea final se debe al uso de varias utilidades de Windows para editar archivos. Nunca he visto que vim cause una nueva línea final faltante al editar un archivo, aunque informará sobre dichos archivos.

Finalmente, hay secuencias de comandos mucho más cortas (pero más lentas) que pueden recorrer sus entradas de nombre de archivo para imprimir aquellos archivos que no terminan en nueva línea, como:

/usr/bin/perl -ne 'print "$ARGV\n" if /.\z/' -- FILE1 FILE2 ...

Los vi/ vim/ exeditores agregan automáticamente <EOL>en EOF a menos que el archivo ya lo tenga.

Así que prueba cualquiera de los dos:

vi -ecwq foo.txt

que es equivalente a:

ex -cwq foo.txt

Pruebas:

$ printf foo > foo.txt && wc foo.txt
0 1 3 foo.txt
$ ex -scwq foo.txt && wc foo.txt
1 1 4 foo.txt

Para corregir varios archivos, verifique: ¿Cómo reparar 'No hay nueva línea al final del archivo' para muchos archivos? en SO

¿Por qué esto es tan importante? Para mantener nuestros archivos POSIX compatibles .

Para aplicar la respuesta aceptada a todos los archivos en el directorio actual (más subdirectorios):

$ find . -type f -exec sed -i -e '$a\' {} \;

Esto funciona en Linux (Ubuntu). En OS X, probablemente tenga que usar -i ''(no probado).

Al menos en las versiones de GNU, simplemente grep ''oawk 1 canoniza su entrada, agregando una nueva línea final si aún no está presente. Copian el archivo en el proceso, lo que lleva tiempo si es grande (¿pero la fuente no debería ser demasiado grande para leer de todos modos?) Y actualiza el modtime a menos que haga algo como

 mv file old; grep '' <old >file; touch -r old file

(aunque puede estar bien en un archivo que está registrando porque lo modificó) y pierde enlaces duros, permisos no predeterminados y ACL, etc. a menos que sea aún más cuidadoso.

Esto funciona en AIX ksh:

lastchar=`tail -c 1 *filename*`
if [ `echo "$lastchar" | wc -c` -gt "1" ]
then
    echo "/n" >> *filename*
fi

En mi caso, si al archivo le falta la nueva línea, el wccomando devuelve un valor de 2y escribimos una nueva línea.

Agregando a la respuesta de Patrick Oscity , si solo desea aplicarlo a un directorio específico, también puede usar:

find -type f | while read f; do tail -n1 $f | read -r _ || echo >> $f; done

Ejecute esto dentro del directorio al que desea agregar nuevas líneas.

echo $'' >> <FILE_NAME> agregará una línea en blanco al final del archivo.

echo $'\n\n' >> <FILE_NAME> agregará 3 líneas en blanco al final del archivo.

Si su archivo finaliza con terminaciones de línea de Windows\r\n y está en Linux, puede usar este sedcomando. Solo se agrega \r\na la última línea si aún no está allí:

sed -i -e '$s/\([^\r]\)$/\1\r\n/'

Explicación:

-i    replace in place
-e    script to run
$     matches last line of a file
s     substitute
\([^\r]\)$    search the last character in the line which is not a \r
\1\r\n    replace it with itself and add \r\n

Si la última línea ya contiene un, \r\nentonces la expresión regular de búsqueda no coincidirá, por lo tanto, no sucederá nada.

Podrías escribir un fix-non-delimited-lineguión como:

#! /bin/zsh -
zmodload zsh/system || exit
ret=0
for file do
  if sysopen -rwu0 -- "$file"; then
    if sysseek -w end -1; then
      read -r x || print -u0
    else
      syserror -p "Can't seek in $file before the last byte: "
      ret=1
    fi
  else
    ret=1
  fi
done
exit $ret

Contrariamente a algunas de las soluciones dadas aquí,

• debería ser eficiente ya que no bifurca ningún proceso, solo lee un byte para cada archivo y no reescribe el archivo (solo agrega una nueva línea)
• no romperá enlaces simbólicos / enlaces duros ni afectará a los metadatos (también, ctime / mtime solo se actualizan cuando se agrega una nueva línea)
• debería funcionar bien incluso si el último byte es un NUL o es parte de un carácter de varios bytes.
• debería funcionar bien independientemente de qué caracteres o no caracteres puedan contener los nombres de archivo
• Debe manejar correctamente los archivos ilegibles, no escribibles o no buscables (e informar los errores en consecuencia)
• No debe agregar una nueva línea a los archivos vacíos (pero informa un error sobre una búsqueda no válida en ese caso)

Puedes usarlo por ejemplo como:

that-script *.txt

o:

git ls-files -z | xargs -0 that-script

POSIXY, podría hacer algo funcionalmente equivalente con

export LC_ALL=C
ret=0
for file do
  [ -s "$file" ] || continue
  {
    c=$(tail -c 1 | od -An -vtc)
    case $c in
      (*'\n'*) ;;
      (*[![:space:]]*) printf '\n' >&0 || ret=$?;;
      (*) ret=1;; # tail likely failed
    esac
  } 0<> "$file" || ret=$? # record failure to open
done