Как я могу удалить новую строку, если это последний символ в файле?

Вы можете воспользоваться тем фактом, что shell замены команд удалить завершающие символы новой строки:

Простая форма, которая работает в bash, ksh, zsh:

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

Портативная (POSIX-совместимая) альтернатива (немного менее эффективная):

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

Примечание:

• Если in.txt заканчивается несколькими символами новой строки, подстановка команд удаляет все из них - thanks, @Sparhawk. (Он не удаляет пробельные символы, кроме конечных строк.)
• Так как этот подход считывает весь входной файл в память, он рекомендуется только для небольших файлов.
• printf %s гарантирует, что никакая новая строка не добавляется к выходу (это альтернатива, совместимая с POSIX для нестандартного echo -n, см. http://pubs.opengroup.org/onlinepubs/009696799/utilities/echo.html и https://unix.stackexchange.com/a/65819)

A руководство по другим ответам:

• Если Perl доступен, выберите принятый ответ - он прост и эффективен с точки зрения памяти (не читает весь входной файл сразу).

• В противном случае рассмотрим ghostdog74 Awk ответ - он неясен, но также эффективен с точки зрения памяти; более читаемый эквивалент (совместимый с POSIX):

  • awk 'NR > 1 { print prev } { prev=$0 } END { ORS=""; print }' in.txt
  • Печать задерживается на одну строку, так что последняя строка может быть обработана в блоке END, где она печатается без конечного \n из-за установки разделителя выходной записи (OFS) на пустой строка.

• Если вам требуется подробное, но быстрое и надежное решение, которое действительно редактирует на месте (в отличие от создания временного файла, который затем заменяет оригинал), рассмотрите jrockway Perl script.

Вы можете сделать это с помощью head от GNU coreutils, он поддерживает аргументы, относящиеся к концу файла. Поэтому, чтобы опустить последний байт, используйте:

head -c -1

Чтобы проверить окончание новой строки, вы можете использовать tail и wc. Следующий пример сохраняет результат во временном файле и затем перезаписывает оригинал:

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

Вы также можете использовать sponge из moreutils для редактирования "на месте":

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

Вы также можете сделать общую функцию многократного использования, добавив ее в свой файл .bashrc:

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

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

Изменить 2:

Вот версия awk (исправлена), которая не накапливает потенциально огромный массив:

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

Gawk

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

Если вы хотите сделать это правильно, вам нужно что-то вроде этого:

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

Мы открываем файл для чтения и добавления; открытие для добавления означает, что мы уже seek ed до конца файла. Затем мы получаем числовое положение конца файла с помощью tell. Мы используем это число для поиска одного символа, а затем мы читаем этот символ. Если это новая строка, мы обрезаем файл символу перед этой новой строкой, иначе мы ничего не делаем.

Это выполняется в постоянном времени и постоянном пространстве для любого ввода и не требует больше дискового пространства.

Вот хорошее, аккуратное решение Python. Я не пытался быть здесь кратким.

Это изменяет файл на месте, вместо того, чтобы делать копию файла и снимать новую строку с последней строки копии. Если файл большой, это будет намного быстрее, чем решение Perl, которое было выбрано в качестве лучшего ответа.

Он обрезает файл двумя байтами, если последние два байта CR/LF или один байт, если последний байт является LF. Он не пытается изменить файл, если последний байт не являются (CR) LF. Он обрабатывает ошибки. Протестировано в Python 2.6.

Поместите это в файл с именем striplast и 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)

P.S. В духе "Perl golf", здесь мое кратчайшее решение Python. Он вырывает весь файл со стандартного ввода в память, удаляет все строки новой строки с конца и записывает результат в стандартный вывод. Не такой уж короткий, как Perl; вы просто не можете победить Perl за небольшие хитроумные быстрые вещи вроде этого.

Удалите "\n" из вызова .rstrip(), и он будет удалять все пробелы с конца файла, включая несколько пустых строк.

Поместите это в "slurp_and_chomp.py", а затем запустите python slurp_and_chomp.py < inputfile > outputfile.

import sys

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

Еще один perl WTDI:

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

Очень простой метод для однострочных файлов, требующий от GNU echo от coreutils:

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

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

См. также Соответствует любому символу (включая символы перевода строки) в sed.

В быстром решении используется утилита утилиты gnu:

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

Тест будет истинным, если файл имеет завершающую новую строку.

Удаление происходит очень быстро, по-настоящему на месте, новый файл не требуется, и поиск также считывает с конца только один байт (tail -c1).

perl -pi -e 's/\n$// if(eof)' your_file

Использование 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

Предположим, что тип файла Unix и вы хотите, чтобы последняя новая строка работала.

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

Он не будет работать с несколькими символами новой строки...

* Работает только в том случае, если последняя строка является пустой строкой.

Еще один ответ FTR (и мой любимый!): echo/cat - вещь, которую вы хотите снять и захватить вывод через обратные ссылки. Окончательная новая строка будет удалена. Например:

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

рубин:

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

или

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

sed -n "1 x;1 !H
$ {x;s/\n*$//p;}
" YourFile

Должно удалить любое последствие \n в файле. Не работает над огромным файлом (из-за ограничения буфера sed)

У меня была аналогичная проблема, но я работал с файлом Windows, и мне нужно сохранить эти CRLF - мое решение в linux:

sed 's/\r//g' orig | awk '{if (NR>1) printf("\r\n"); printf("%s",$0)}' > tweaked

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

Единственный раз, когда я хотел это сделать, - это использовать код для гольфа, а затем я только что скопировал свой код из файла и вставлял его в оператор echo -n 'content'>file.