यूनिक्स / लिनक्स खोजें और संशोधित तिथि के अनुसार क्रमबद्ध करें


138

मैं एक साधारण कैसे कर सकता हूं findजो हाल ही में संशोधित करके परिणामों का आदेश देगा?

यहां findमैं वर्तमान का उपयोग कर रहा हूं (मैं PHP में एक शेल एस्केप कर रहा हूं, ताकि चर के लिए तर्क हो):

find '$dir' -name '$str'\* -print | head -10

मैं हाल ही में संशोधित करके इस खोज को कैसे आदेश दे सकता हूं? (ध्यान दें कि मैं इसे 'खोज' के बाद क्रमबद्ध नहीं करना चाहता, बल्कि हाल ही में जो सबसे अधिक था उसके आधार पर परिणाम प्राप्त करना है)।


github.com/shadkam/recentmost क्या करना चाहता है - लेकिन इसे बनाने की आवश्यकता है
user3392225

जवाबों:


153

इसे इस्तेमाल करो:

find . -printf "%T@ %Tc %p\n" | sort -n

printfसे तर्क man find:

  • %Tk: निर्दिष्ट प्रारूप में फ़ाइल का अंतिम संशोधन समय k

  • @: 1 जनवरी, 1970 के बाद से सेकंड, 00:00 GMT, आंशिक भाग के साथ।

  • c: लोकेल की तारीख और समय (सत नव 04 12:02:33 ईएसटी 1989)।

  • %p: फ़ाइल का नाम।


5
+1 बहुत उपयोगी है, इसका पहला उत्तर मुझे एक पठनीय / उपयोगी तारीख आउटपुट के साथ मिला है
जेक एन

समय के रूप में सबसे विश्वसनीय (और बहुत सरल) को संख्यात्मक रूप से अनुक्रमिक (इसलिए हमेशा उचित रूप से छांटने योग्य) होने की अनुमति दी जाती है, thx!
कुंभ राशि

1
मेरे पास हाल की फ़ाइलों को खोजने के लिए यह उपनाम है ~/.zshrc: fr () { find ./ -iname "*"$@"*" -printf "%T@ %Td-%Tb-%TY %Tk:%TM %p\n" | sort -n | cut -d " " -f 2- | grep -i "$@" ; }यह पुनरावर्ती सभी फ़ाइलों को कमांड में पारित पहले तर्क के पैटर्न से युक्त पाता है ( fr <pattern>) और उन्हें सबसे हाल के एक के साथ क्रमबद्ध करता है।
जोएलोस्टब्लोम

यह भी खूब रही !!! सिमलिंक के साथ प्रयोग करने के लिए, का उपयोग करेंfind -L ...
वरुण चांडक

1
आप ssedसेकंड फ्रैक्शनल भाग से छुटकारा पाने के लिए उपयोग करना चाहते हैं और ISO8601 का उपयोग कर सकते हैं जैसा कि @PeterMortensen ने दिखाया:find . -type f -printf "%TY-%Tm-%TdT%TT %p\n" | sort -r | ssed -R 's/^([^.]+)\.\d+ (.*)$/\1 \2/'
लुडोविक

83

सबसे आसान तरीका zsh का उपयोग करना है, इसके ग्लोब क्वालिफायर के लिए धन्यवाद ।

print -lr -- $dir/**/$str*(om[1,10])

यदि आपके पास जीएनयू है, तो इसे फ़ाइल संशोधन बार प्रिंट करें और उसके आधार पर छाँटें।

find -type f -printf '%T@ %p\0' |
sort -zk 1nr |
sed -z 's/^[^ ]* //' | tr '\0' '\n' | head -n 10

यदि आपके पास GNU है, लेकिन अन्य GNU उपयोगिताओं में नहीं है, तो nulls के बजाय विभाजक के रूप में newlines का उपयोग करें; आप नए नाम वाले फ़ाइल नाम के लिए समर्थन खो देंगे।

find -type f -printf '%T@ %p\n' |
sort -k 1nr |
sed 's/^[^ ]* //' | head -n 10

यदि आपके पास पर्ल है (यहाँ मैं मान लूंगा कि फ़ाइल नामों में कोई नई सूची नहीं है):

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

यदि आपके पास पायथन है (फ़ाइल नामों में कोई नई सूची नहीं मान रहा है):

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], reverse=True))[:10]: print f'

शायद PHP में ऐसा ही करने का एक तरीका है, लेकिन मुझे यह पता नहीं है।

यदि आप केवल POSIX टूल के साथ काम करना चाहते हैं, तो यह अधिक जटिल है; देखें कि पुनरावृत्ति द्वारा संशोधित तिथि (उपलब्ध कोई स्टैट कमांड उपलब्ध नहीं है) की सूची कैसे बनाई जा सकती है! (पहले 10 को फिर से समझना आसान है)।


मुझे लगता है कि findसंस्करण सबसे पुरानी फ़ाइलों को दिखाता है, और आपको -rविकल्प जोड़ने की आवश्यकता है sort
क्वेंटिन प्रदीप

मेरी sed कहती है कि इसमें a -z विकल्प नहीं है।
केफ शेक्टर जूल

@KefSchecter तब विभाजक के रूप में नईलाइन्स का उपयोग करें, लेकिन आप फ़ाइल नामों में नईलाइन्स के लिए समर्थन खो देंगे।
गिल्स

ऊपर python2 के लिए है। यदि आपके पास केवल python3 है, तो कुछ छोटे परिवर्तन: python3 -c 'का आयात os, sys; sys.stdin.readlines (): f = f [0: -1] में f के लिए टाइम्स = {}; बार [f] = os.stat (f) .st_mtime for f के लिए (सॉर्ट किया हुआ (times.keys)), की = लैम्ब्डा f: टाइम्स [f], रिवर्स = ट्रू)) [: 10]: प्रिंट (f); '
नील मैकगिल

40

आपको PHP या अजगर की जरूरत नहीं है, बस ls :

man ls:
-t     sort by modification time
-r,    reverse order while sorting (--reverse )
-1     list one file per line

find /wherever/your/files/hide -type f -exec ls -1rt "{}" +;

यदि कमांड * एक विफलता की स्थिति के साथ बाहर निकलती है (यानी तर्क सूची बहुत लंबी है ), तो आप खोज के साथ पुनरावृत्ति कर सकते हैं। से परिमार्जित: एक नई प्रक्रिया के लिए तर्कों की अधिकतम लंबाई

  • find . -print0|xargs -0 command (गति को अनुकूलित करता है, यदि "-exec +" लागू नहीं होता है, लेकिन "-print0" जानता है)
  • find . -print|xargs command (यदि तर्कों में कोई श्वेत स्थान नहीं है)

यदि तर्कों के प्रमुख भाग में लंबे, पूर्ण या सापेक्ष पथ शामिल हैं, तो अपने कार्यों को निर्देशिका में स्थानांतरित करने का प्रयास करें: cd /directory/with/long/path; command *और एक और त्वरित समाधान कम तर्कों से मेल खाने के लिए हो सकता है:command [a-e]*; command [f-m]*; ...


1
यदि बहुत सारी फाइलें हैं, तो यह ls पर 'तर्क सूची बहुत लंबी' के साथ विफल हो जाती है।
8

1
यह सच है, लेकिन मेरा मानना ​​है कि सवाल यह था कि "मैं एक साधारण खोज कैसे करूँ ..."
butрослав Рахматуллин

2
ls एक तरह से फ़ाइल के नाम को उद्धृत नहीं कर सकते हैं xargs समझ सकते हैं (कोई -0 विकल्प नहीं है, और विभिन्न बोली शैलियाँ अपर्याप्त हैं)
तोबू

10

आपको केवल ls की आवश्यकता है

आप find /wherever/your/files/hide -type f -exec ls -1rt "{}" +;ऊपर बताए अनुसार कर सकते हैं ,

या

ls -1rt `find /wherever/your/file/hides -type f`

2
यदि बहुत सारी फाइलें हैं, तो यह ls पर 'तर्क सूची बहुत लंबी' के साथ विफल हो जाती है। शायद xargs का उपयोग करने के लिए recook?
8

2
लेकिन अगर कई बार xargsकॉल किया lsजाता है, तो सॉर्ट टूट जाएगा।
हारून डी। मर्सको

यह उनके नाम पर रिक्त स्थान वाली फ़ाइलों के लिए विफल रहता है। कोई सलाह?
उपयोगकर्ता 74094

बस इस जवाब पर ठोकर खाई और यह वैसा ही था जैसा मुझे एक समान स्थिति में चाहिए था। प्रश्न: +;अंत में क्या करता है? ऐसा लगता है कि इसके बिना एक ही परिणाम देने के लिए ;यह बिना काम नहीं करता है +?
रॉकेटनेट्स

यह 8 महीने पहले पोस्ट किए गए एक अन्य उत्तर के समान ही है, "ls -1rt` फाइंड ... `" का उपयोग करने वाले भाग को छोड़कर, जो टूटा हुआ है
क्लेमेंट

7

विस्तार user195696 के जवाब :

find . -type f -printf "%T@\t%Tc %6k KiB %p\n" | sort -n | cut -f 2-

प्रत्येक फ़ाइल के लिए, यह पहली आउटपुट सांख्यिक टाइमस्टैम्प (द्वारा छँटाई के लिए, सारणीकरण के बाद \t), तो एक मानव पठनीय टाइमस्टैम्प, तो फ़ाइल आकार (दुर्भाग्य findकी -printfmebibytes में ऐसा नहीं कर सकते, केवल kibibytes), तो रिश्तेदार के साथ फ़ाइल नाम पथ।

फिर sort -nइसे पहले सांख्यिक क्षेत्र द्वारा क्रमबद्ध करें।

फिर cutउस पहले संख्यात्मक क्षेत्र से छुटकारा मिलता है जो उपयोगकर्ता के लिए कोई दिलचस्पी नहीं है। (दूसरा क्षेत्र आगे की ओर प्रिंट करता है।) डिफ़ॉल्ट क्षेत्र विभाजक \tया सारणीकरण है।

आउटपुट का उदाहरण:

Thu 06 Feb 2014 04:49:14 PM EST     64 KiB ./057_h2_f7_10/h2_f7_10.class
Fri 07 Feb 2014 02:08:30 AM EST 7962976 KiB ./056_h2_f7_400/h2__rh_4e-4.mph
Fri 07 Feb 2014 02:23:24 AM EST 7962976 KiB ./056_h2_f7_400/h2_f7_400_out_Model.mph
Fri 07 Feb 2014 02:23:24 AM EST      0 KiB ./056_h2_f7_400/h2_f7_400_out.mph.status
Fri 07 Feb 2014 02:23:24 AM EST     64 KiB ./056_h2_f7_400/1579678.out
Fri 07 Feb 2014 03:47:31 AM EST 8132224 KiB ./057_h2_f7_10/h2__rh_1e-5.mph
Fri 07 Feb 2014 04:00:49 AM EST 8132224 KiB ./057_h2_f7_10/h2_f7_10_out_Model.mph
Fri 07 Feb 2014 04:00:49 AM EST      0 KiB ./057_h2_f7_10/h2_f7_10_out.mph.status
Fri 07 Feb 2014 04:00:49 AM EST     64 KiB ./057_h2_f7_10/1579679.out
Fri 07 Feb 2014 09:47:18 AM EST   9280 KiB ./056_h2_f7_400/h2__rh_4e-4.mat
Fri 07 Feb 2014 10:51:23 AM EST   9728 KiB ./018_bidomain/h2_plain__rh_1e-5.mat
Fri 07 Feb 2014 10:58:33 AM EST   9568 KiB ./057_h2_f7_10/h2__rh_1e-5.mat
Fri 07 Feb 2014 05:05:38 PM EST     64 KiB ./058_h2_f7_stationary/h2_f7_stationary.java
Fri 07 Feb 2014 06:06:29 PM EST     32 KiB ./058_h2_f7_stationary/slurm.slurm
Sat 08 Feb 2014 03:42:07 AM EST      0 KiB ./058_h2_f7_stationary/1581061.err
Sat 08 Feb 2014 03:42:14 AM EST     64 KiB ./058_h2_f7_stationary/h2_f7_stationary.class
Sat 08 Feb 2014 03:58:28 AM EST  70016 KiB ./058_h2_f7_stationary/h2s__rh_1e-5.mph
Sat 08 Feb 2014 04:12:40 AM EST  70304 KiB ./058_h2_f7_stationary/h2s__rh_4e-4.mph
Sat 08 Feb 2014 04:12:53 AM EST  70304 KiB ./058_h2_f7_stationary/h2_f7_stationary_out_Model.mph
Sat 08 Feb 2014 04:12:53 AM EST      0 KiB ./058_h2_f7_stationary/h2_f7_stationary_out.mph.status
Sat 08 Feb 2014 04:12:53 AM EST     32 KiB ./058_h2_f7_stationary/1581061.out
Mon 10 Feb 2014 11:40:54 AM EST    224 KiB ./058_h2_f7_stationary/h2s__rh_4e-4.mat
Mon 10 Feb 2014 11:42:32 AM EST    224 KiB ./058_h2_f7_stationary/h2s__rh_1e-5.mat
Mon 10 Feb 2014 11:50:08 AM EST     32 KiB ./plot_grid.m

मैंने जानबूझकर फ़ाइलों को फ़ील्ड 6 वर्णों में बनाया है, क्योंकि यदि इसे लंबा बनाते हैं, तो यह स्पष्ट रूप से अलग करना मुश्किल हो जाता है कि फाइलें कितनी बड़ी हैं। इस तरह, 1e6 KiB जूट की तुलना में बड़ी फाइलें: 1 char का मतलब 1-9 GB, 2 char का मतलब 10-99 GB इत्यादि है।


संपादित करें: यहां एक और संस्करण (चूंकि find . -printf "%Tc"MinGW / MSYS पर क्रैश):

find . -type f -printf "%T@\t%p\n" | sort -n | cut -f 2- | xargs -I{} ls -Glath --si {}

जैसे आउटपुट देना:

-rw-r--r-- 1 es 23K Jul 10  2010 ./laptop_0000071.jpg
-rw-r--r-- 1 es 43M Jul 29 19:19 ./work.xcf
-rw-r--r-- 1 es 87K Jul 29 20:11 ./patent_lamps/US Patent 274427 Maxim Lamp Holder.jpg
-rw-r--r-- 1 es 151K Jul 29 20:12 ./patent_lamps/Edison screw-in socket.png
-rw-r--r-- 1 es 50K Jul 29 20:13 ./patent_lamps/1157 Lamp.jpg
-rw-r--r-- 1 es 38K Jul 29 20:14 ./patent_lamps/US06919684-20050719-D00001.png

कहाँ पे:

  • -I{}{}एक तर्क द्वारा प्रतिस्थापित होने की घटना का कारण बनता है, और अब नई दलीलें तर्क विभाजक हैं (ऊपर फ़ाइल नाम में रिक्त स्थान पर ध्यान दें)।

  • ls -G समूह के नाम (अंतरिक्ष की बर्बादी) को दबाता है।

  • ls -h --siमानव-पठनीय फ़ाइल आकार (अधिक सही --si) बनाता है ।

  • ls -t समय के अनुसार, जो यहाँ अप्रासंगिक है, लेकिन यही मैं आमतौर पर उपयोग करता हूं।


1
नोट: इसके बजाय फ़ाइल आकार के आधार पर छांटने के लिए , बस उपरोक्त दोनों में से किसी एक T@को बदलें s
इवगेनी सर्गेव

3

@ User195696 के जवाब का OS X संस्करण:

  1. टाइमस्टैम्प के साथ:

    find . -type f -exec stat -f "%Sm %N" -t "%Y%y%m%d%H%M" {} \; | sort -r
    
  2. टाइमस्टैम्प के बिना:

    find . -type f -exec stat -f "%Sm %N" -t "%Y%y%m%d%H%M" {} \; | sort -r | awk -F' ' '{ print substr($0, length($1) + 2) }'
    

2

मैंने पाया कि यह मैक ओएस एक्स पर काम करता है (और अन्य यूनिक्स पर भी काम करने के लिए पर्याप्त सामान्य):

find . -type f -ls | awk '{print $(NF-3), $(NF-2), $(NF-1), $NF}' | sort

2
अफसोस की बात है, यह मेरे क्रोएशियाई सेटअप पर स्थानीय महीनों के नामों को प्रिंट करता है, जिससे यह गलत हो जाता है।
इवान वूइका

user195696 का उत्तर क्रोएशियाई सेटअप (और अन्य) के लिए काम करता है।
पीटर मोर्टेंसन

1

यदि आपका findचयन बहुत सरल है, तो आप इसके बिना कर सकते हैं, और बस उपयोग करें ls:

ls -1 *.cc # -r -t optional

1

प्रयत्न, कोशिश:

find '$dir' -name '$str'\* -print | xargs ls -tl | head -10

लेकिन यह -mmin/ -mtimeऔर द्वारा डेटा को फ़िल्टर करने के लिए भी उपयोगी है -type


1

उपयोग:

find . -type f -mtime 0 -printf "[%TD %TI:%TM%Tp] %s %p\n" | sort -n | awk '{
    hum[1024**4]="TB"; hum[1024**3]="GB"; hum[1024**2]="MB"; hum[1024]="KB"; hum[0]="B";
    for (x=1024**4; x>=1024; x/=1024){
    if ($3>=x) { printf $1" "$2"\t%7.2f %s\t%s\n",$3/x,hum[x],$4;break }
    }}';

यह आदेश संशोधित तिथि के आधार पर फाइलों को क्रमबद्ध करेगा।

और प्रदर्शित करें जैसे:

[12/05/13 03:10PM] 1.75 MB ./file.text
[12/06/13 11:52PM] 2.90 MB ./file2.mp4
[12/07/13 04:11PM] 4.88 MB ./file3.mp4
[12/07/13 09:17PM] 4.74 MB ./test.apk

मैं इस sript फ़ाइल नाम में खाली स्थान के संभालने के लिए, को देखने के सुधार superuser.com/a/777007/134532
जनवरी

1

मेरे पास एक सरल समाधान है जो FreeBSD (OS X) और लिनक्स दोनों के लिए काम करता है:

find . -type f -exec ls -t {} +

यह पूरी तरह से काम करता है - सही उत्तर होना चाहिए, या कम से कम उच्च मूल्यांकन किया जाना चाहिए!
डिजिटलटैस्ट

0

मुझे नहीं लगता कि findआउटपुट ऑर्डर को संशोधित करने का कोई विकल्प है। -mtimeऔर -mminआपको परिणामों को उन फ़ाइलों तक सीमित कर देगा जो एक निश्चित समय विंडो के भीतर संशोधित किए गए हैं, लेकिन आउटपुट सॉर्ट नहीं किया जाएगा - आपको स्वयं ऐसा करना होगा। जीएनयू के findपास एक -printfविकल्प है जो अन्य बातों के अलावा, आपको मिली प्रत्येक फ़ाइल के संशोधन समय को प्रिंट करने देगा (प्रारूप स्ट्रिंग %tया %Tk); इससे आपको findअपनी इच्छानुसार आउटपुट को सॉर्ट करने में मदद मिल सकती है ।


0

मैंने फिल्म्स में स्क्रिप्ट को व्हाट्सएप को सही ढंग से बनाकर आकाश के उत्तर को बेहतर बनाया:

find . -type f -mtime 0 -printf ";[%TD %TI:%TM%Tp];%s;%p\n" | sort -n | awk -F ";" '{
    hum[1024**4]="TB"; hum[1024**3]="GB"; hum[1024**2]="MB"; hum[1024]="KB"; hum[0]="B";
    for (x=1024**4; x>=1024; x/=1024){
    if ($3>=x) { printf $1" "$2"\t%7.2f %s\t%s\n",$3/x,hum[x],$4;break }
    }}';

0

यदि आप समय-समय पर सभी पीएनजी फाइलें ऑर्डर करना चाहते हैं $PWD:

यह साधारण वन-लाइनर regexp के सभी लचीलेपन को findऔर पर देता है ls

find $PWD -name "*.png" -print0 | xargs -0 ls -laht | less

0

आप statBSD और Linux (POSIX पर नहीं) का इस प्रकार उपयोग कर सकते हैं :

$ stat -f "%m%t%N" /[the dir]/* | sort -rn | cut -f2-

यदि आप संख्या को सीमित करना चाहते हैं:

$ stat -f "%m%t%N" /[the dir]/* | sort -rn | head -[the number] | cut -f2-

0

sort | headतारीख से साफ और मजबूत तरीका है :

ls -lसुंदर प्रिंट के लिए उपयोग करना

find . ! -type d -printf "%T@ %p\0" |
    sort -zrn |
    head -zn 10 |
    sed -z 's/^[0-9.]\+ //' |
    xargs -0 ls -lt

एक के रूप में समारोह:

findByDate() {
    local humansize=''
    [ "$1" = "-h" ] && humansize='h' && shift
    find . ${2:-! -type d} -printf "%T@ %p\0" |
        sort -zrn |
        head -zn ${1:--0} |
        sed -z 's/^[0-9.]\+ //' |
        xargs -0 ls -dlt${humansize}
}

यह एक या दो तर्क के साथ चल सकता है, या बिना भी:

Usage: findByDate [-h] [lines] [find options]

नमूना:

findByDate

तिथि के अनुसार क्रमबद्ध सभी गैर निर्देशिकाओं को सूचीबद्ध करेगा । नोटा:

यहां तक ​​कि बड़े फाइलसिस्टम ट्री पर, जैसा कि xargs पहले से ही सॉर्ट की गई सूची को पुन: प्राप्त करना है, फ़ाइल ऑर्डर सही रहता है, भले ही lsउसे कई बार चलाया जाना चाहिए।

findByDate -h 12

सूची में 12 और पुनरावृत्त गैर निर्देशिकाओं को सूचीबद्ध किया जाएगा, जिनका आकार मानव पठनीय रूप में मुद्रित होगा

findByDate 42 '-type l'

42 और सूचियों को सहानुभूति पर पुनर्विचार करेगा

findByDate -0 '( -type l -o -type b -o -type s -o -type c )'

तिथि के अनुसार क्रमबद्ध सभी सिमलिंक, ब्लॉक डिवाइस, सॉकेट्स और कैरेक्टर डिवाइस को सूचीबद्ध करेगा।

क्रम में बदलना

जगह headसे tailऔर के स्विच को बदलने sortऔर ls:

findByDate() {
    local humansize=''
    [ "$1" = "-h" ] && humansize='h' && shift
    find . ${2:-! -type d} -printf "%T@ %p\0" |
        sort -zn |
        tail -zn ${1:-+0} |
        sed -z 's/^[0-9.]\+ //' |
        xargs -0 ls -dltr${humansize}
}

एक ही कार्य, एक ही उपयोग:

Usage: findByDate [-h] [lines] [find options]

-1

यदि आप प्रत्येक आइटम का पूर्ण पथ प्राप्त करना चाहते हैं, तो आप इस तरह से लिख सकते हैं।

 find FIND_ROOT -maxdepth 1 -type f -printf "%T@ %p\n" | sort -nr | head -10 | cut -d ' ' -f 2

जहां
-प्रिंटफ " छंटनी मानदंड (दिनांक) के लिए "% T @% p \ n " , दिनांक के अनुसार छंटाई के लिए
'सॉर्ट-एनआरआर' , शीर्ष 10 परिणामों को सूचीबद्ध करने के लिए
हेड -10 , कटिंग के लिए
कट -d '' -f 2 प्रत्येक लाइन पर अग्रणी टाइमस्टैम्प।


cut -d ' ' -f 2फ़ाइल नाम रिक्त स्थान होने पर टूट जाएगा।
एफ। हौरी

-3

मेरे पास एक सरल उपाय है।

cdएक निर्देशिका के बाद , का उपयोग करें

find . -iname "*" -ls


1
यह संशोधित तिथि के अनुसार नहीं है।
DavidPostill
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.