Alt dizinleri ve süreleri olan bir dizindeki en son değiştirilen dosyaları özyinelemeli olarak nasıl bulur ve listeler?

• İşletim sistemi: Linux

• Dosya sistemi türü: ext3

• Tercih edilen çözüm: bash (script / oneliner), ruby, python

İçinde birkaç alt dizin ve dosyaları ile birkaç dizin var. Her birinci düzey dizini, içinde en son oluşturulan / değiştirilmiş dosyanın tarih ve saatinin yanında listelenecek şekilde yapılandırılmış tüm bu dizinlerin bir listesini yapmak gerekir.

Açıklığa kavuşturmak için, bir dosyaya dokunduğumda veya içeriğini birkaç alt dizin düzeyinde aşağı değiştirdiğimde, bu zaman damgası birinci düzey dizin adının yanında görüntülenmelidir. Diyelim ki bu şekilde yapılandırılmış bir dizin var:

./alfa/beta/gamma/example.txt

ve ben dosyanın içeriğini değiştirmek, example.txto zaman alfadeğil, insan okunabilir formda birinci düzey dizinin yanında görüntülenen zamana ihtiyacım var . Ben, bul kullanarak bazı şeyleri denedim xargs, sortve seviyor ama ben 'alfa' bir dosya sistemi damgası ı oluşturduğunuzda / değiştirmek dosyaları birkaç seviyeleri aşağı değiştirmez sorunu etrafında alınamıyor.

Bunu dene:

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

Özyinelemeli olarak taramaya başlaması gereken dizine giden yolla yürütün (boşluklu dosya adlarını destekler).

Çok fazla dosya varsa, herhangi bir şey döndürmeden önce biraz zaman alabilir. xargsBunun yerine kullanırsak performans iyileştirilebilir :

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

ki bu biraz daha hızlı.

Dosya durumunun en son değiştirildiği tüm dosyaları N dakika önce bulmak için:

find -cmin -N

Örneğin:

find -cmin -5

GNU Find (bkz. man find) -printfDosyaları EPOC mtime ve göreceli yol adını dağıtmak için bir parametreye sahiptir .

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

Halo'nun bu tek astara verdiği müthiş cevabı kısalttım

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

Güncellendi : Dosya adlarında boşluk varsa, bu değişikliği kullanabilirsiniz

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

Bunu dene

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

O kullanır find, dizinin tüm dosyalar toplamak için lsonları, değişiklik tarihine göre sıralanmış listelemek için head1 dosyasını seçmek amacıyla ve son olarak statgüzel bir biçimde zaman gösterecek.

Şu anda, adlarında boşluk veya diğer özel karakterlere sahip dosyalar için güvenli değildir. Henüz ihtiyaçlarınızı karşılamıyorsa bir övgü yazın.

Bu komut Mac OS X'te çalışır:

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

Linux'ta, orijinal posterin istediği gibi, statyerine kullanın gstat.

Bu cevap, elbette, user37078'in olağanüstü çözümü, yorumdan tam cevaba yükseltildi. Ben karışık CharlesB kullanımına 'ın fikir gstatvar Mac OS X'in I coreutils gelen MacPorts ziyade homebrew arada.

Ve işte bunu ~/bin/ls-recent.shyeniden kullanım için basit bir komut halinde paketledim :

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

Bu yazıdaki perl ve Python çözümleri, Mac OS X'te bu sorunu çözmeme yardımcı oldu: /unix/9247/how-to-list-files-sorted-by-modification-date-recursively -no-stat-command-avail .

Gönderiden alıntı:

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

Python:

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'

Gizli dosyaları yok saymak - güzel ve hızlı zaman damgasıyla

Dosya adlarındaki boşlukları iyi işler - bunları kullanmamalısınız!

$ 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

findBağlantıyı takip ederek daha fazla bolluk bulabilirsiniz.

Bunu en son erişim zamanı için gösteriyorum, en son mod süresini yapmak için bunu kolayca değiştirebilirsiniz.

Bunu yapmanın iki yolu vardır:

1) On milyonlarca dosyanız varsa pahalı olabilen küresel sıralamayı önlemek istiyorsanız, şunları yapabilirsiniz: (kendinizi, aramanızın başlamasını istediğiniz dizinin köküne konumlandırın)

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 

Yukarıdaki yöntem, dosya adlarını giderek daha yeni erişim süresiyle yazdırır ve yazdırdığı son dosya en son erişim süresine sahip dosyadır. Açıkçası bir "kuyruk -1" kullanarak en son erişim zamanını alabilirsiniz.

2) Alt dizininizdeki tüm dosyaların adını, erişim süresini tekrar tekrar yazdırabilir ve daha sonra erişim süresine ve kuyruğa en büyük girdiye göre sıralayabilirsiniz:

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

İşte buyur...

.Profile dosyamda oldukça sık kullandığım bu takma ad var

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

Böylece aradığınızı yapar (istisna olarak, tarih / saati birden fazla seviyeyi değiştirmez) - en son dosyaları arar (bu durumda * .log ve * .trc dosyaları); ayrıca yalnızca son gün değiştirilen dosyaları bulur, daha sonra zamana göre sıralar ve çıktıyı daha az yoluyla yönlendirir:

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

ps. Dikkat Bazı sunucularda kök yok, ama her zaman sudo var, bu yüzden bu bölüme ihtiyacınız olmayabilir.

Denemek için printf komutunu verebilirsiniz.

% Ak Dosyasının @' or a directive for the C strftime işlevi olan k ile belirtilen formattaki son erişim süresi . K için olası değerler aşağıda listelenmiştir; bazı sistemler arasındaki `` strftime '' farklılıkları nedeniyle tüm sistemlerde bulunmayabilir.

Hızlı bash işlevi:

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

En son değiştirilen dosyayı bir dizinde bulun:

findLatestModifiedFiles "/home/jason/" 1

Üçüncü bağımsız değişken olarak kendi tarih / saat biçiminizi de belirleyebilirsiniz.

Aşağıda, zaman damgasının bir dizesini ve en son zaman damgasına sahip dosyanın adını döndürür:

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

Formun çıktısıyla sonuçlanan: <yy-mm-dd-hh-mm-ss.nanosec> <filename>

Alanlar, yeni satırlar, glob karakterler de içerebilen dosya adlarıyla çalışan bir sürüm:

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

• find ... -printfdosya değişikliği (EPOCH değeri) ve ardından bir boşluk ve \0sonlandırılmış dosya adları yazdırır .
• sort -zk1nr NUL sonlandırılmış verileri okur ve sayısal olarak tersine sıralar

Soru Linux ile etiketlendiğinden gnuaraçların mevcut olduğunu varsayıyorum .

Yukarıdakileri boru ile yapabilirsiniz:

xargs -0 printf "%s\n"

yeni satırlarla sonlandırılan değişiklik süresine (en son ilk) göre sıralanmış değişiklik zamanını ve dosya adlarını yazdırmak için.

Ben kullanıyorum (çok verimli):

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

Artıları:

• sadece 3 işlemi doğurur

KULLANIM:

find_last [dir [number]]

nerede:

• dir - aranacak bir dizin [geçerli dizin]
• number - görüntülenecek en yeni dosya sayısı [10]

Şuna find_last /etc 4benzer çıktı :

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

Düz lsçıktı için bunu kullanın. Argüman listesi yok, bu yüzden çok uzun olamaz:

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

Ve cutsadece tarihler, saatler ve isim için güzelleştirildi :

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

DÜZENLEME : Sadece mevcut üst yanıtın değişiklik tarihine göre sıralandığını fark ettim. Buradaki ikinci örnekle bu kadar kolay, çünkü değişiklik tarihi her satırda ilk olduğu için - sonuna bir çeşit tokat at:

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

Bu bash'da yinelemeli bir işlevle de yapılabilir

F ifadesinin sözlükbilimsel olarak sıralanabilir yyyy-aa-gg vb. Biçiminde görüntülenmesi gereken bir işlevi görüntüleyelim. (İşletim sistemine bağlı mı?)

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

D dizinleri üzerinden çalışan özyinelemeli işlev

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

Ve sonunda

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