Tengo un archivo que foo.txtcontiene las siguientes líneas:

a
b
c

Quiero un comando simple que resulte en el contenido de foo.txtser:

a
b

Utilizando GNU sed:

sed -i '$ d' foo.txt

La -iopción no existe en GNU sedversiones anteriores a 3.95, por lo que debe usarla como filtro con un archivo temporal:

cp foo.txt foo.txt.tmp
sed '$ d' foo.txt.tmp > foo.txt
rm -f foo.txt.tmp

Por supuesto, en ese caso también podría usar en head -n -1lugar de sed.

Mac OS:

En Mac OS X (a partir de 10.7.4), el equivalente del sed -icomando anterior es

sed -i '' -e '$ d' foo.txt

Esta es, con mucho, la solución más rápida y sencilla, especialmente en archivos grandes:

head -n -1 foo.txt > temp.txt ; mv temp.txt foo.txt

si desea eliminar la línea superior, use esto:

tail -n +2 foo.txt

lo que significa líneas de salida que comienzan en la línea 2.

No lo use sedpara eliminar líneas de la parte superior o inferior de un archivo; es muy lento si el archivo es grande.

Tuve problemas con todas las respuestas aquí porque estaba trabajando con un archivo ENORME (~ 300Gb) y ninguna de las soluciones se ajustó. Aquí está mi solución:

dd if=/dev/null of=<filename> bs=1 seek=$(echo $(stat --format=%s <filename> ) - $( tail -n1 <filename> | wc -c) | bc )

En palabras: descubra la longitud del archivo con el que desea terminar (longitud del archivo menos la longitud de su última línea, usando bc) y configure esa posición para que sea el final del archivo ( ddingresando un byte de /dev/null a eso).

Esto es rápido porque tailcomienza a leer desde el final y ddsobrescribirá el archivo en su lugar de copiar (y analizar) cada línea del archivo, que es lo que hacen las otras soluciones.

NOTA: ¡Esto elimina la línea del archivo en su lugar! ¡Haga una copia de seguridad o pruebe en un archivo ficticio antes de probarlo en su propio archivo!

Para eliminar la última línea de un archivo sin leer el archivo completo o reescribir nada , puede usar

tail -n 1 "$file" | wc -c | xargs -I {} truncate "$file" -s -{}

Para eliminar la última línea y también imprimirla en stdout ("pop"), puede combinar ese comando con tee:

tail -n 1 "$file" | tee >(wc -c | xargs -I {} truncate "$file" -s -{})

Estos comandos pueden procesar eficientemente un archivo muy grande. Esto es similar e inspirado por la respuesta de Yossi, pero evita el uso de algunas funciones adicionales.

Si va a usarlos repetidamente y desea manejar errores y algunas otras funciones, puede usar el poptailcomando aquí: https://github.com/donm/evenmoreutils

Usuarios de Mac

si solo desea que la última línea elimine la salida sin cambiar el archivo, haga

sed -e '$ d' foo.txt

si desea eliminar la última línea del archivo de entrada, haga

sed -i '' -e '$ d' foo.txt

Para usuarios de Mac:

En Mac, head -n -1 no funcionará. Y estaba tratando de encontrar una solución simple [sin preocuparme por el tiempo de procesamiento] para resolver este problema solo usando los comandos "head" y / o "tail".

Intenté la siguiente secuencia de comandos y me alegré de poder resolverlo simplemente usando el comando "tail" [con las opciones disponibles en Mac]. Entonces, si está en Mac y desea usar solo "cola" para resolver este problema, puede usar este comando:

cat file.txt | cola -r | cola -n +2 | cola -r

Explicacion:

1> tail -r: simplemente invierte el orden de las líneas en su entrada

2> tail -n +2: imprime todas las líneas que comienzan desde la segunda línea en su entrada

echo -e '$d\nw\nq'| ed foo.txt

awk 'NR>1{print buf}{buf = $0}'

Esencialmente, este código dice lo siguiente:

Para cada línea después de la primera, imprima la línea almacenada

para cada línea, reinicie el búfer

El búfer está retrasado por una línea, por lo tanto, termina imprimiendo las líneas 1 a n-1

awk "NR != `wc -l < text.file`" text.file |> text.file

Este fragmento hace el truco.

Ambas soluciones están aquí en otras formas. Encontré esto un poco más práctico, claro y útil:

Usando dd:

BADLINESCOUNT=1
ORIGINALFILE=/tmp/whatever
dd if=${ORIGINALFILE} of=${ORIGINALFILE}.tmp status=none bs=1 count=$(printf "$(stat --format=%s ${ORIGINALFILE}) - $(tail -n${BADLINESCOUNT} ${ORIGINALFILE} | wc -c)\n" | bc )
/bin/mv -f ${ORIGINALFILE}.tmp ${ORIGINALFILE}

Usando truncar:

BADLINESCOUNT=1
ORIGINALFILE=/tmp/whatever
truncate -s $(printf "$(stat --format=%s ${ORIGINALFILE}) - $(tail -n${BADLINESCOUNT} ${ORIGINALFILE} | wc -c)\n" | bc ) ${ORIGINALFILE}

Linux

$ es la última línea, d para eliminar:

sed '$d' ~/path/to/your/file/name

Mac OS

Equivalente de sed -i

sed -i '' -e '$ d' ~/path/to/your/file/name

Así es como puede hacerlo manualmente (yo personalmente uso mucho este método cuando necesito eliminar rápidamente la última línea de un archivo):

vim + [FILE]

Ese + signo allí significa que cuando el archivo se abre en el editor de texto vim, el cursor se colocará en la última línea del archivo.

Ahora solo presione ddos veces en su teclado. Esto hará exactamente lo que desea: eliminar la última línea. Después de eso, presione :seguido de xy luego presione Enter. Esto guardará los cambios y lo llevará de regreso al shell. Ahora, la última línea se ha eliminado con éxito.

Rubí (1.9+)

ruby -ne 'BEGIN{prv=""};print prv ; prv=$_;' file