Удалите все, кроме самых последних X-файлов в bash

Удалите все, кроме 5 (или любого другого числа) самых последних файлов в каталоге.

rm `ls -t | awk 'NR>5'`

(ls -t|head -n 5;ls)|sort|uniq -u|xargs rm

Эта версия поддерживает имена с пробелами:

(ls -t|head -n 5;ls)|sort|uniq -u|sed -e 's,.*,"&",g'|xargs rm

Если в именах файлов нет пробелов, это сработает:

ls -C1 -t| awk 'NR>5'|xargs rm

Если в именах файлов есть пробелы, что-то вроде

ls -C1 -t | awk 'NR>5' | sed -e "s/^/rm '/" -e "s/$/'/" | sh

Основная логика:

• получить список файлов в хронологическом порядке, одна колонка
• получить все, кроме первых 5 (в этом примере n = 5)
• первая версия: отправьте их в rm
• вторая версия: создать скрипт, который удалит их должным образом

Все эти ответы терпят неудачу, если в текущем каталоге есть каталоги. Вот что работает:

find . -maxdepth 1 -type f | xargs -x ls -t | awk 'NR>5' | xargs -L1 rm

Этот:

1. работает, когда в текущем каталоге есть каталоги

2. пытается удалить каждый файл, даже если предыдущий не удалось удалить (из-за разрешений и т. д.)

3. не безопасен, когда количество файлов в текущем каталоге чрезмерно, и xargs обычно вас облажает (-x)

4. не учитывает пробелы в именах файлов (возможно, вы используете неправильную ОС?)

find . -maxdepth 1 -type f -printf '%T@ %p\0' | sort -r -z -n | awk 'BEGIN { RS = "\0"; ORS = "\0"; FS = "" } NR > 5 { sub("^[0-9]*(.[0-9]*)? ", ""); print }' | xargs -0 rm -f

Требуется поиск GNU для -printf и сортировка GNU для -z, GNU awk для "\ 0" и GNU xargs для -0, но обрабатывает файлы со встроенными символами новой строки или пробелами.

Игнорирование символов новой строки означает игнорирование безопасности и хорошего кодирования. wnoise имел единственный хороший ответ. Вот его вариант, в котором имена файлов помещаются в массив $ x

while IFS= read -rd ''; do 
    x+=("${REPLY#* }"); 
done < <(find . -maxdepth 1 -printf '%T@ %p\0' | sort -r -z -n )

С zsh

Предполагая, что вас не интересуют текущие каталоги, и у вас не будет более 999 файлов (выберите большее число, если хотите, или создайте цикл while).

[ 6 -le `ls *(.)|wc -l` ] && rm *(.om[6,999])

В *(.om[6,999]). означает файлы, o означает порядок сортировки вверх, m означает дату модификации (укажите a для времени доступа или c для изменения inode), [6,999] выбирает диапазон файлов, поэтому не оставляет 5 первый.

Более простой вариант ответа thelsdj:

ls -tr | head -n -5 | xargs --no-run-if-empty rm 

ls -tr отображает все файлы, сначала самые старые (-t сначала самые новые, -r наоборот).

head -n -5 отображает все, кроме 5 последних строк (т.е. 5 самых новых файлов).

xargs rm вызывает rm для каждого выбранного файла.

leaveCount=5
fileCount=$(ls -1 *.log | wc -l)
tailCount=$((fileCount - leaveCount))

# avoid negative tail argument
[[ $tailCount < 0 ]] && tailCount=0

ls -t *.log | tail -$tailCount | xargs rm -f

ls -tQ | tail -n+4 | xargs rm

Список имен файлов по времени модификации, заключая в кавычки каждое имя файла. Исключить первые 3 (3 последних). Удалите оставшееся.

ИЗМЕНИТЬ после полезного комментария от mklement0 (спасибо!): Исправлен аргумент -n + 3, и обратите внимание, что это не будет работать должным образом, если имена файлов содержат символы новой строки и / или каталог содержит подкаталоги.

Проблемы с существующими ответами:

• невозможность обрабатывать имена файлов со встроенными пробелами или символами новой строки.
  • в случае решений, которые вызывают rm непосредственно при подстановке команд без кавычек (rm `...`), существует дополнительный риск непреднамеренного подстановки.
• невозможность различать файлы и каталоги (то есть, если каталоги окажется среди 5 последних измененных элементов файловой системы, вы фактически сохраните меньше, чем 5 файлов, и применение rm к каталогам не удастся).

Wnoise ответ решает эти проблемы, но решение является специфичным для GNU (и довольно сложным).

Вот прагматичный POSIX-совместимое решение, который поставляется только с одно предостережение: он не может обрабатывать имена файлов со встроенным новые строки - но я не считаю, что это реальная проблема для большинства людей.

^{For the record, here's the explanation for why it's generally not a good idea to parse ls output: http://mywiki.wooledge.org/ParsingLs}

ls -tp | grep -v '/$' | tail -n +6 | xargs -I {} rm -- {}

^{Note: This command operates in the current directory; to target a directory explicitly, use a subshell ((...)):
(cd /path/to && ls -tp | grep -v '/$' | tail -n +6 | xargs -I {} rm -- {})
The same applies analogously to the commands below.}

Вышеупомянутое - неэффективный, потому что xargs должен вызвать rm один раз для имени файла каждый. xargs вашей платформы может помочь вам решить эту проблему:

Если у вас есть GNUxargs, используйте -d '\n', который заставляет xargs рассматривать каждую строку ввода как отдельный аргумент, но передает столько аргументов, сколько поместится в командной строке сразу:

ls -tp | grep -v '/$' | tail -n +6 | xargs -d '\n' -r rm --

^{-r (--no-run-if-empty) ensures that rm is not invoked if there's no input.}

Если у вас есть BSDxargs (включая macOS), вы можете использовать -0 для обработки ввода, разделенного NUL, после первого перевода новой строки в символы NUL (0x0), который также передает (обычно) все имена файлов сразу (также будет работать с GNU xargs) :

ls -tp | grep -v '/$' | tail -n +6 | tr '\n' '\0' | xargs -0 rm --

Объяснение:

• ls -tp печатает имена элементов файловой системы, отсортированные по дате их изменения, в порядке убывания (сначала измененные элементы) (-t), а каталоги печатаются с пометкой / в конце, чтобы пометить их как таковые (-p).

  • Примечание. Тот факт, что ls -tp всегда выводит только файл / каталог имена, а не полные пути, требует упомянутого выше подхода подоболочки для нацеливания на каталог, отличный от текущего ((cd /path/to && ls -tp ...)).

• Затем grep -v '/$' исключает каталоги из результирующего списка, опуская (-v) строки, которые имеют завершающий / (/$).

  • Предостережение: поскольку символическая ссылка, указывающая на каталог технически не является каталогом, такие символические ссылки будут исключены.

• tail -n +6 пропускает первые записи 5 в листинге, фактически возвращая все но 5 последних измененных файлов, если таковые имеются. Обратите внимание, что для исключения файлов N необходимо передать N+1 в tail -n +.

• xargs -I {} rm -- {} (и его варианты) затем вызывает rm для всех этих файлов; если совпадений нет вообще, xargs ничего не сделает.

  • xargs -I {} rm -- {} определяет заполнитель {}, который представляет каждую строку ввода в целом, поэтому rm затем вызывается один раз для каждой строки ввода, но с правильной обработкой имен файлов со встроенными пробелами.
  • -- во всех случаях гарантирует, что любые имена файлов, которые начинаются с -, не будут ошибочно приняты rm за опции.

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

# One by one, in a shell loop (POSIX-compliant):
ls -tp | grep -v '/$' | tail -n +6 | while IFS= read -r f; do echo "$f"; done

# One by one, but using a Bash process substitution (<(...), 
# so that the variables inside the `while` loop remain in scope:
while IFS= read -r f; do echo "$f"; done < <(ls -tp | grep -v '/$' | tail -n +6)

# Collecting the matches in a Bash *array*:
IFS=$'\n' read -d '' -ra files  < <(ls -tp | grep -v '/$' | tail -n +6)
printf '%s\n' "${files[@]}" # print array elements

Я превратил это в сценарий оболочки bash. Использование: keep NUM DIR, где NUM - количество файлов, которые нужно сохранить, а DIR - это каталог, который нужно очистить.

#!/bin/bash
# Keep last N files by date.
# Usage: keep NUMBER DIRECTORY
echo ""
if [ $# -lt 2 ]; then
    echo "Usage: $0 NUMFILES DIR"
    echo "Keep last N newest files."
    exit 1
fi
if [ ! -e $2 ]; then
    echo "ERROR: directory '$1' does not exist"
    exit 1
fi
if [ ! -d $2 ]; then
    echo "ERROR: '$1' is not a directory"
    exit 1
fi
pushd $2 > /dev/null
ls -tp | grep -v '/' | tail -n +"$1" | xargs -I {} rm -- {}
popd > /dev/null
echo "Done. Kept $1 most recent files in $2."
ls $2|wc -l

нашел интересный cmd в Sed-One Liners - удалите последние 3 строки - считаю, что он идеально подходит для другого способа снять шкуру с кошки (хорошо, нет), но идея:

 #!/bin/bash
 # sed cmd chng #2 to value file wish to retain

 cd /opt/depot 

 ls -1 MyMintFiles*.zip > BigList
 sed -n -e :a -e '1,2!{P;N;D;};N;ba' BigList > DeList

 for i in `cat DeList` 
 do 
 echo "Deleted $i" 
 rm -f $i  
 #echo "File(s) gonzo " 
 #read junk 
 done 
 exit 0

Я понимаю, что это старая ветка, но, возможно, кому-то это пригодится. Эта команда найдет файлы в текущем каталоге:

for F in $(find . -maxdepth 1 -type f -name "*_srv_logs_*.tar.gz" -printf '%T@ %p\n' | sort -r -z -n | tail -n+5 | awk '{ print ; }'); do rm $F; done

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

find . -maxdepth 1 -type f -name "*_srv_logs_*.tar.gz" -printf '%T@ %p\n'

Затем отсортируйте их по отметкам времени:

sort -r -z -n

Затем удалите из списка 4 последних файла:

tail -n+5

Возьмите второй столбец (имя файла, а не метку времени):

awk '{ print ; }'

А затем заверните все это в оператор for:

for F in $(); do rm $F; done

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

Удаляет все файлы, кроме 10 последних (большинство недавних).

ls -t1 | head -n $(echo $(ls -1 | wc -l) - 10 | bc) | xargs rm

Если меньше 10 файлов, файл не будет удален, и у вас будет: заголовок ошибки: недопустимое количество строк - 0

Чтобы подсчитать файлы с помощью bash

Мне нужно было элегантное решение для busybox (роутера), все решения xargs или массивов были для меня бесполезны - там нет такой команды. find и mtime - неправильный ответ, поскольку мы говорим о 10 элементах, а не обязательно о 10 днях. Ответ Эспо был самым коротким, ясным и, вероятно, самым исчерпывающим.

Ошибки с пробелами и отсутствие файлов для удаления решаются стандартным способом:

rm "$(ls -td *.tar | awk 'NR>7')" 2>&-

Более образовательная версия: мы можем сделать все это, если будем использовать awk по-другому. Обычно я использую этот метод для передачи (возврата) переменных из awk в sh. Поскольку мы все время читаем, что сделать невозможно, я позволю себе отличиться: вот метод.

Пример для файлов .tar без проблем с пробелами в имени файла. Для проверки замените «rm» на «ls».

eval $(ls -td *.tar | awk 'NR>7 { print "rm \"" $0 "\""}')

Объяснение:

ls -td *.tar перечисляет все файлы .tar, отсортированные по времени. Чтобы применить ко всем файлам в текущей папке, удалите часть «d * .tar».

awk 'NR>7... пропускает первые 7 строк

print "rm \"" $0 "\"" создает строку: rm «имя файла».

eval выполняет это

Поскольку мы используем rm, я бы не стал использовать указанную выше команду в сценарии! Более разумное использование:

(cd /FolderToDeleteWithin && eval $(ls -td *.tar | awk 'NR>7 { print "rm \"" $0 "\""}'))

В случае использования ls -t команда не навредит на таких глупых примерах, как: touch 'foo " bar' и touch 'hello * world'. Не то чтобы мы когда-либо создавали файлы с такими именами в реальной жизни!

Примечание. Если бы мы хотели передать переменную в sh таким образом, мы бы просто изменили print (простая форма, пробелы не допускаются):

print "VarName = "$1

чтобы установить для переменной VarName значение $1. За один раз можно создать несколько переменных. Этот VarName становится обычной переменной sh и впоследствии может использоваться в сценарии или оболочке. Итак, чтобы создать переменные с помощью awk и вернуть их оболочке:

eval $(ls -td *.tar | awk 'NR>7 { print "VarName=\""$1"\""  }'); echo "$VarName"