Usuń wszystkie oprócz najnowszych plików X w bash

Czy istnieje prosty sposób, w całkiem standardowym środowisku UNIX z bash, aby uruchomić polecenie usunięcia wszystkich plików X z katalogu oprócz najnowszych?

Aby dać trochę więcej konkretnego przykładu, wyobraź sobie jakąś pracę crona zapisującą plik (powiedzmy, plik dziennika lub sparowaną kopię zapasową) do katalogu co godzinę. Chciałbym mieć uruchomione inne zadanie crona, które usuwałoby najstarsze pliki w tym katalogu, aż będzie ich mniej niż, powiedzmy, 5.

Dla jasności jest tylko jeden plik, którego nigdy nie należy usuwać.

Problemy z istniejącymi odpowiedziami:

• niemożność obsługi nazw plików z osadzonymi spacjami lub znakami nowej linii.
  • w przypadku rozwiązań, które wywołują rmbezpośrednio niecytowane polecenie substitution ( rm `...`), istnieje dodatkowe ryzyko niezamierzonego globowania.
• niezdolność do rozróżnienia plików i katalogów (tj. jeśli katalogi znalazły się wśród 5 ostatnio zmodyfikowanych elementów systemu plików, efektywnie zachowałbyś mniej niż 5 plików, a zastosowanie rmdo katalogów nie powiedzie się).

Odpowiedź wnoise rozwiązuje te problemy, ale rozwiązanie jest specyficzne dla GNU (i dość złożone).

Oto pragmatyczne, zgodne z POSIX rozwiązanie, które ma tylko jedno zastrzeżenie : nie obsługuje nazw plików z osadzonymi znakami nowej linii - ale nie uważam tego za prawdziwą troskę większości ludzi.

^{Dla przypomnienia, oto wyjaśnienie, dlaczego generalnie analizowanie lswyników nie jest dobrym pomysłem : http://mywiki.wooledge.org/ParsingLs}

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

Powyższe jest nieefektywne , ponieważ xargsmusi wywołać rmjeden raz dla każdej nazwy pliku.
Twoja platforma xargsmoże pozwolić ci rozwiązać ten problem:

Jeśli masz GNU xargs , użyj -d '\n', co sprawia, xargsże każdy wiersz wejściowy jest traktowany jako oddzielny argument, a jednocześnie przekazuje tyle argumentów, ile zmieści się w wierszu poleceń jednocześnie :

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

^{-r( --no-run-if-empty) zapewnia, że rmnie jest wywoływana, jeśli nie ma danych wejściowych.}

Jeśli masz BSD xargs (w tym na macOS ), możesz użyć -0do obsługi NULoddzielonych danych wejściowych, po pierwszej translacji znaków nowej linii na NUL( 0x0) znaki., Co również przekazuje (zwykle) wszystkie nazwy plików naraz (będzie również działać z GNU xargs):

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

Wyjaśnienie:

• ls -tpwypisuje nazwy elementów systemu plików posortowane według czasu, kiedy zostały ostatnio zmodyfikowane, w porządku malejącym (najpierw ostatnio zmodyfikowane elementy) ( -t), z katalogami drukowanymi z końcem /oznaczającym je jako takie ( -p).
• grep -v '/$'następnie usuwa katalogi z wynikowego listingu, pomijając ( -v) wiersze, które mają na końcu /( /$).
  • Uwaga : ponieważ dowiązanie symboliczne wskazujące na katalog z technicznego punktu widzenia nie jest katalogiem, takie dowiązania symboliczne nie zostaną wykluczone.
• tail -n +6pomija pierwsze 5 wpisów na liście, w efekcie zwraca wszystkie oprócz 5 ostatnio zmodyfikowanych plików, jeśli takie istnieją.
  Zauważ, że aby wykluczyć Npliki, N+1należy je przekazać do tail -n +.
• xargs -I {} rm -- {}(i jego odmiany) następnie wywołuje rmna wszystkich tych plikach; jeśli w ogóle nie ma dopasowań, xargsnic nie zrobi.
  • xargs -I {} rm -- {}definiuje symbol zastępczy, {}który reprezentuje każdy wiersz wejściowy jako całość , więc rmjest następnie wywoływany raz dla każdego wiersza wejściowego, ale z nazwami plików z osadzonymi spacjami obsługiwanymi poprawnie.
  • --we wszystkich przypadkach gwarantuje, że wszystkie nazwy plików, które zdarzają się na początek -nie są mylone z opcji użytkownika rm.

Zmienność w oryginalnym problem, w przypadku zgodnych plików muszą być przetwarzane indywidualnie lub zebrane w tablicy powłoki :

# 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

Usuń wszystkie ostatnie pliki z katalogu z wyjątkiem 5 (lub dowolnej liczby).

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

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

Ta wersja obsługuje nazwy ze spacjami:

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

Prostszy wariant odpowiedzi thelsdj:

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

ls -tr wyświetla wszystkie pliki, zaczynając od najstarszych (-t od najnowszych, -r do tyłu).

head -n -5 wyświetla wszystkie oprócz 5 ostatnich linii (tj. 5 najnowszych plików).

xargs rm wywołuje rm dla każdego wybranego pliku.

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

Wymaga wyszukiwania GNU dla -printf i sortowania GNU dla -z, awk GNU dla "\ 0" i GNU xargs dla -0, ale obsługuje pliki z osadzonymi znakami nowej linii lub spacjami.

Wszystkie te odpowiedzi kończą się niepowodzeniem, gdy w bieżącym katalogu znajdują się katalogi. Oto coś, co działa:

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

To:

1. działa, gdy w bieżącym katalogu są katalogi

2. próbuje usunąć każdy plik, nawet jeśli poprzedniego nie można było usunąć (z powodu uprawnień itp.)

3. nie powiedzie się, gdy liczba plików w bieżącym katalogu jest nadmierna i xargsnormalnie cię przekręca ( -x)

4. nie obsługuje spacji w nazwach plików (być może używasz niewłaściwego systemu operacyjnego?)

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

Lista nazw plików według czasu modyfikacji, cytując każdą nazwę pliku. Wyklucz pierwsze 3 (3 najnowsze). Usuń pozostałe.

EDYTUJ po pomocnym komentarzu mklement0 (dzięki!): Poprawiono argument -n + 3 i zauważ, że nie będzie to działać zgodnie z oczekiwaniami, jeśli nazwy plików zawierają nowe linie i / lub katalog zawiera podkatalogi.

Ignorowanie nowych linii oznacza ignorowanie bezpieczeństwa i dobrego kodowania. Wnoise miał jedyną dobrą odpowiedź. Oto jego odmiana, która umieszcza nazwy plików w tablicy $ x

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

Jeśli nazwy plików nie zawierają spacji, zadziała:

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

Jeśli nazwy plików zawierają spacje, na przykład

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

Podstawowa logika:

• uzyskać listę plików w porządku czasowym, jedna kolumna
• pobierz wszystkie oprócz pierwszych 5 (w tym przykładzie n = 5)
• pierwsza wersja: wyślij je do rm
• druga wersja: gen skrypt, który usunie je poprawnie

Dzięki zsh

Zakładając, że nie dbasz o obecne katalogi i nie będziesz mieć więcej niż 999 plików (wybierz większą liczbę, jeśli chcesz, lub utwórz pętlę while).

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

W *(.om[6,999])The .plików oznacza, że ośrodki porządek sortowania w górę, mśrodki według daty modyfikacji (wkleja ado czasu dostępu lub cna zmianę węzła), przy czym [6,999]wybiera zakres pliku, więc nie RM 5 Pierwszy.

Zdaję sobie sprawę, że to stary wątek, ale może ktoś na tym skorzysta. To polecenie znajdzie pliki w bieżącym katalogu:

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 $2; }'); do rm $F; done

Jest to trochę bardziej niezawodne niż niektóre z poprzednich odpowiedzi, ponieważ pozwala ograniczyć domenę wyszukiwania do wyrażeń pasujących do plików. Najpierw znajdź pliki spełniające dowolne warunki. Wydrukuj te pliki ze znacznikami czasu obok nich.

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

Następnie posortuj je według sygnatur czasowych:

sort -r -z -n

Następnie usuń 4 najnowsze pliki z listy:

tail -n+5

Weź drugą kolumnę (nazwę pliku, a nie sygnaturę czasową):

awk '{ print $2; }'

A następnie zawiń to wszystko w oświadczenie:

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

Może to być bardziej szczegółowe polecenie, ale miałem dużo większe szczęście, że mogłem kierować na pliki warunkowe i wykonywać bardziej złożone polecenia przeciwko nim.

znalazłem interesujące cmd w Sed-Onliners - Usuń ostatnie 3 wiersze - znajdź to idealne miejsce na inny sposób skórowania kota (okej), ale pomysł:

 #!/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

Usuwa wszystkie oprócz 10 najnowszych (najbardziej aktualnych) plików

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

Jeśli mniej niż 10 plików, żaden plik nie zostanie usunięty i otrzymasz: nagłówek błędu: niedozwolona liczba wierszy - 0

Aby policzyć pliki za pomocą bash

Potrzebowałem eleganckiego rozwiązania dla busyboxa (routera), wszystkie xargi czy rozwiązania macierzowe były dla mnie bezużyteczne - nie ma tam takiego polecenia. find i mtime nie są właściwą odpowiedzią, ponieważ mówimy o 10 elementach, a niekoniecznie o 10 dniach. Odpowiedź Espo była najkrótsza, najczystsza i prawdopodobnie najbardziej nieodwracalna.

Błędy ze spacjami i brak plików do usunięcia są po prostu rozwiązywane w standardowy sposób:

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

Wersja nieco bardziej edukacyjna: możemy to wszystko zrobić, jeśli używamy awk w inny sposób. Zwykle używam tej metody do przekazywania (zwracania) zmiennych z awk do sh. Ponieważ cały czas czytamy, że nie można tego zrobić, błagam o różnicę: oto metoda.

Przykład dla plików .tar bez problemu dotyczącego spacji w nazwie pliku. Aby przetestować, zamień „rm” na „ls”.

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

Wyjaśnienie:

ls -td *.tarwyświetla wszystkie pliki .tar posortowane według czasu. Aby zastosować do wszystkich plików w bieżącym folderze, usuń część „d * .tar”

awk 'NR>7... pomija pierwsze 7 wierszy

print "rm \"" $0 "\"" konstruuje linię: rm "nazwa pliku"

eval wykonuje to

Ponieważ używamy rm, nie użyłbym powyższego polecenia w skrypcie! Mądrzejsze użycie to:

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

W przypadku użycia ls -tpolecenia nie zaszkodzi na tak głupich przykładach jak: touch 'foo " bar'i touch 'hello * world'. Nie żebyśmy kiedykolwiek tworzyli pliki o takich nazwach w prawdziwym życiu!

Dygresja. Gdybyśmy chcieli w ten sposób przekazać zmienną do sh, po prostu zmodyfikowalibyśmy print (prosta forma, bez spacji):

print "VarName="$1

aby ustawić zmienną VarNamena wartość $1. Za jednym razem można utworzyć wiele zmiennych. To VarNamestaje się normalną zmienną sh i może być później normalnie użyte w skrypcie lub powłoce. Tak więc, aby utworzyć zmienne za pomocą awk i przekazać je z powrotem powłoce:

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

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

Zrobiłem to w skrypcie powłoki bash. Użycie: keep NUM DIRgdzie NUM to liczba plików do zachowania, a DIR to katalog do wyszorowania.

#!/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