Jak rekurencyjnie znajdować i wyświetlać najnowsze zmodyfikowane pliki w katalogu z podkatalogami i godzinami?

• System operacyjny: Linux

• Typ systemu plików: ext3

• Preferowane rozwiązanie: bash (skrypt / oneliner), ruby, python

Mam kilka katalogów z kilkoma podkatalogami i plikami. Muszę sporządzić listę wszystkich tych katalogów, która jest zbudowana w taki sposób, że każdy katalog pierwszego poziomu jest wyświetlany obok daty i godziny najnowszego utworzonego / zmodyfikowanego pliku w nim.

Aby wyjaśnić, jeśli dotknę pliku lub zmodyfikuję jego zawartość o kilka poziomów podkatalogów w dół, znacznik czasu powinien być wyświetlany obok nazwy katalogu pierwszego poziomu. Powiedzmy, że mam katalog o takiej strukturze:

./alfa/beta/gamma/example.txt

i modyfikuję zawartość pliku example.txt, potrzebuję czasu wyświetlanego obok katalogu pierwszego poziomu alfaw czytelnej dla człowieka formie, a nie epoce. Próbowałem kilka rzeczy za pomocą znalezienia xargs, sorti lubi, ale nie mogę obejść ten problem, że timestamp plików z „alfa” nie zmienia się podczas tworzenia / modyfikowania plików kilka poziomów w dół.

Spróbuj tego:

#!/bin/bash
find $1 -type f -exec stat --format '%Y :%y %n' "{}" \; | sort -nr | cut -d: -f2- | head

Uruchom go ze ścieżką do katalogu, w którym powinien rozpocząć skanowanie rekurencyjnie (obsługuje nazwy plików ze spacjami).

Jeśli jest dużo plików, może to chwilę potrwać, zanim cokolwiek zwróci. Wydajność można poprawić, jeśli xargszamiast tego zastosujemy :

#!/bin/bash
find $1 -type f -print0 | xargs -0 stat --format '%Y :%y %n' | sort -nr | cut -d: -f2- | head

co jest nieco szybsze.

Aby znaleźć wszystkie pliki, których status został ostatnio zmieniony N minut temu:

find -cmin -N

na przykład:

find -cmin -5

GNU Find (patrz man find) ma -printfparametr do rozproszenia plików EPOC mtime i względnej nazwy ścieżki.

redhat> find . -type f -printf '%T@ %P\n' | sort -n | awk '{print $2}'

Skróciłem niesamowitą odpowiedź halo na ten jednowarstwowy

stat --printf="%y %n\n" $(ls -tr $(find * -type f))

Zaktualizowano : Jeśli w nazwach plików znajdują się spacje, możesz użyć tej modyfikacji

OFS="$IFS";IFS=$'\n';stat --printf="%y %n\n" $(ls -tr $(find . -type f));IFS="$OFS";

Spróbuj tego

#!/bin/bash
stat --format %y $(ls -t $(find alfa/ -type f) | head -n 1)

Służy finddo gromadzenia wszystkich plików z katalogu, lswyświetlania ich posortowanych według daty modyfikacji, headwybierania pierwszego pliku i wreszcie statwyświetlania czasu w ładnym formacie.

W tej chwili nie jest bezpieczne dla plików z białymi znakami lub innymi znakami specjalnymi w ich nazwach. Napisz pochwałę, jeśli jeszcze nie spełnia twoich potrzeb.

To polecenie działa w systemie Mac OS X:

find "$1" -type f -print0 | xargs -0 stat --format '%Y :%y %n' | sort -nr | cut -d: -f2- | head

W systemie Linux, zgodnie z pytaniem oryginalnego plakatu, użyj statzamiast gstat.

Ta odpowiedź jest oczywiście znakomitym rozwiązaniem użytkownika user37078 , awansowanym od komentarza do pełnej odpowiedzi. I mieszać w CharlesB wglądu „s do użytku gstatw systemie Mac OS X. Dostałem Coreutils z DarwinPorts zamiast homebrew , nawiasem mówiąc.

A oto jak spakowałem to w proste polecenie ~/bin/ls-recent.shdo ponownego użycia:

#!/bin/bash
# ls-recent: list files in a dir tree, most recently modified first
#
# Usage: ls-recent path [-10 | more]
# 
# Where "path" is a path to target directory, "-10" is any arg to pass
# to "head" to limit the number of entries, and "more" is a special arg
# in place of "-10" which calls the pager "more" instead of "head".
if [ "more" = "$2" ]; then
   H=more; N=''
else
   H=head; N=$2
fi

find "$1" -type f -print0 |xargs -0 gstat --format '%Y :%y %n' \
    |sort -nr |cut -d: -f2- |$H $N

Zarówno rozwiązania Perla, jak i Pythona w tym poście pomogły mi rozwiązać ten problem w systemie Mac OS X: /unix/9247/how-to-list-files-sorted-by-modification-date-recursively -no-stat-polecenie-dostępne .

Cytowanie z postu:

Perl:

find . -type f -print |
perl -l -ne '
    $_{$_} = -M;  # store file age (mtime - now)
    END {
        $,="\n";
        print sort {$_{$b} <=> $_{$a}} keys %_;  # print by decreasing age
    }'

Pyton:

find . -type f -print |
python -c 'import os, sys; times = {}
for f in sys.stdin.readlines(): f = f[0:-1]; times[f] = os.stat(f).st_mtime
for f in sorted(times.iterkeys(), key=lambda f:times[f]): print f'

Ignorowanie ukrytych plików - z ładnym i szybkim znacznikiem czasu

Dobrze radzi sobie ze spacjami w nazwach plików - nie żebyś ich używał!

$ find . -type f -not -path '*/\.*' -printf '%TY.%Tm.%Td %THh%TM %Ta %p\n' |sort -nr |head -n 10

2017.01.28 07h00 Sat ./recent
2017.01.21 10h49 Sat ./hgb
2017.01.16 07h44 Mon ./swx
2017.01.10 18h24 Tue ./update-stations
2017.01.09 10h38 Mon ./stations.json

Więcej findobfitości można znaleźć, klikając link.

Pokazuję to dla ostatniego czasu dostępu, możesz łatwo to zmodyfikować, aby zrobić najnowszy czas modyfikacji.

Można to zrobić na dwa sposoby:

1) Jeśli chcesz uniknąć globalnego sortowania, które może być kosztowne, jeśli masz dziesiątki milionów plików, możesz: (ustawić się w katalogu głównym katalogu, w którym chcesz rozpocząć wyszukiwanie)

linux> touch -d @0 /tmp/a;
linux> find . -type f -exec tcsh -f -c test `stat --printf="%X" {}` -gt  `stat --printf="%X" /tmp/a`  ; -exec tcsh -f -c touch -a -r {} /tmp/a ; -print 

Powyższa metoda drukuje nazwy plików z coraz nowszym czasem dostępu, a ostatnim drukowanym plikiem jest plik z najnowszym czasem dostępu. Możesz oczywiście uzyskać najnowszy czas dostępu, używając „ogona -1”.

2) Możesz znaleźć rekursywnie wydrukować nazwę, czas dostępu do wszystkich plików w podkatalogu, a następnie posortować według czasu dostępu i ogona największego wpisu:

linux> \find . -type f -exec stat --printf="%X  %n\n" {} \; | \sort -n | tail -1

I masz to ...

Mam ten alias w moim .profile, którego używam dość często

$ alias | grep xlogs
xlogs='sudo find . \( -name "*.log" -o -name "*.trc" \) -mtime -1 | sudo xargs ls -ltr --color | less -R'

Robi to, czego szukasz (z wyjątkiem tego, że nie przemierza wielu poziomów daty / godziny) - szuka najnowszych plików (w tym przypadku plików * .log i * .trc); także wyszukuje tylko pliki zmodyfikowane w ciągu ostatniego dnia, a następnie sortuje według czasu i potoków generuje mniej:

sudo find . \( -name "*.log" -o -name "*.trc" \) -mtime -1 | sudo xargs ls -ltr --color | less -R

ps. Zauważ, że nie mam root na niektórych serwerach, ale zawsze mam sudo, więc możesz nie potrzebować tej części.

Możesz wydać komendę printf, aby znaleźć próbę

% Czasu ostatniego dostępu do pliku Ak w formacie określonym przez k, który jest @' or a directive for the C funkcją strftime. Możliwe wartości dla k są wymienione poniżej; niektóre z nich mogą nie być dostępne we wszystkich systemach z powodu różnic w „strftime” między systemami.

Funkcja szybkiego uderzenia:

# findLatestModifiedFiles(directory, [max=10, [format="%Td %Tb %TY, %TT"]])
function findLatestModifiedFiles() {
    local d="${1:-.}"
    local m="${2:-10}"
    local f="${3:-%Td %Tb %TY, %TT}"

    find "$d" -type f -printf "%T@ :$f %p\n" | sort -nr | cut -d: -f2- | head -n"$m"
}

Znajdź najnowszy zmodyfikowany plik w katalogu:

findLatestModifiedFiles "/home/jason/" 1

Możesz również określić swój własny format daty / godziny jako trzeci argument.

Poniższe zwraca ciąg znacznika czasu i nazwę pliku z najnowszym znacznikiem czasu:

find $Directory -type f -printf "%TY-%Tm-%Td-%TH-%TM-%TS %p\n" | sed -r 's/([[:digit:]]{2})\.([[:digit:]]{2,})/\1-\2/' |     sort --field-separator='-' -nrk1 -nrk2 -nrk3 -nrk4 -nrk5 -nrk6 -nrk7 | head -n 1

Wynikające z wyniku formularza: <yy-mm-dd-hh-mm-ss.nanosec> <filename>

Oto jedna wersja, która działa z nazwami plików, które mogą również zawierać spacje, znaki nowej linii, znaki globalne:

find . -type f -printf "%T@ %p\0" | sort -zk1nr

• find ... -printfwypisuje modyfikację pliku (wartość EPOCH), po której następuje spacja i \0zakończone nazwy plików.
• sort -zk1nr odczytuje zakończone NUL dane i sortuje je odwrotnie numerycznie

Ponieważ pytanie jest oznaczone gnulinuksem, zakładam, że narzędzia są dostępne.

Możesz wykonać potok powyżej:

xargs -0 printf "%s\n"

aby wydrukować czas modyfikacji i nazwy plików posortowane według czasu modyfikacji (najnowsze od pierwszego) zakończonego znakiem nowej linii.

Właśnie tego używam (bardzo wydajny):

function find_last () { find "${1:-.}" -type f -printf '%TY-%Tm-%Td %TH:%TM %P\n' 2>/dev/null | sort | tail -n "${2:-10}" }

Plusy:

• spawnuje tylko 3 procesy

STOSOWANIE:

find_last [dir [number]]

gdzie:

• dir - katalog do przeszukania [aktualny katalog]
• number - liczba najnowszych plików do wyświetlenia [10]

Dane wyjściowe dla find_last /etc 4wygląda następująco:

2019-07-09 12:12 cups/printers.conf
2019-07-09 14:20 salt/minion.d/_schedule.conf
2019-07-09 14:31 network/interfaces
2019-07-09 14:41 environment

Aby uzyskać zwykły lswydruk, użyj tego. Nie ma listy argumentów, więc nie może być za długa:

find . | while read FILE;do ls -d -l "$FILE";done

I upiększony cuttylko datami, godzinami i nazwami:

find . | while read FILE;do ls -d -l "$FILE";done | cut --complement -d ' ' -f 1-5

EDYCJA : Właśnie zauważyłem, że aktualna najwyższa odpowiedź sortuje według daty modyfikacji. Jest to równie łatwe z drugim przykładem tutaj, ponieważ data modyfikacji jest pierwsza w każdym wierszu - klaps sortuj na końcu:

find . | while read FILE;do ls -d -l "$FILE";done | cut --complement -d ' ' -f 1-5 | sort

Można to również zrobić za pomocą funkcji rekurencyjnej w bash

Niech F wyświetla funkcję pliku, która musi być leksykograficznie sortowalna rrrr-mm-dd itd. (Zależna od systemu operacyjnego?)

F(){ stat --format %y "$1";}                # Linux
F(){ ls -E "$1"|awk '{print$6" "$7}';}      # SunOS: maybe this could be done easier

R funkcja rekurencyjna działająca w katalogach

R(){ local f;for f in "$1"/*;do [ -d "$f" ]&&R $f||F "$f";done;}

I w końcu

for f in *;do [ -d "$f" ]&&echo `R "$f"|sort|tail -1`" $f";done