Linux में find कमांड: नाम, आकार और तारीख़ से फ़ाइलें खोजना — उदाहरण

find डायरेक्टरी ट्री में घूमकर शर्तों के हिसाब से फ़ाइलें खोजता है: नाम, टाइप, आकार, बदलाव की तारीख़, मालिक और अनुमतियाँ। सामान्य ढाँचा है — find [कहाँ खोजें] [शर्तें] [क्रिया]। नीचे find linux उदाहरण दिए हैं जो रोज़ के कामों में काम आते हैं: कोई कॉन्फ़िग फ़ाइल ढूँढना, पुराने लॉग साफ़ करना, या यह पता करना कि डिस्क की जगह किसने घेरी है।

find कमांड का सिंटैक्स

find /var/log -type f -name '*.log' -mtime +30 -print

इसे हिस्सों में समझते हैं:

• /var/log — शुरुआती बिंदु। कई डायरेक्टरी एक साथ दी जा सकती हैं, या . (मौजूदा)। बिना पाथ के GNU find मौजूदा डायरेक्टरी में खोजता है।
• -type f -name '*.log' -mtime +30 — शर्तें (दस्तावेज़ में इन्हें tests कहा जाता है)। इनके बीच डिफ़ॉल्ट रूप से «और» (AND) का संबंध होता है।
• -print — क्रिया: पाथ छापना। कोई और क्रिया न हो तो यह अपने-आप लगती है।

find सभी अंदर की डायरेक्टरी में रिकर्सिव रूप से जाता है। अगर आप सामान्य यूज़र के रूप में सिस्टम पाथ पर चलाते हैं, तो Permission denied की लाइनें आउटपुट भर देंगी। इन्हें त्रुटि-स्ट्रीम को रीडायरेक्ट करके हटाएँ:

find / -name 'nginx.conf' 2>/dev/null

नाम से खोज: -name और -iname

-name केवल फ़ाइल का नाम (पाथ के बिना) पैटर्न से मिलाता है। पैटर्न में * (कोई भी अक्षर), ? (एक अक्षर) और [abc] (दिए गए अक्षरों में से एक) चल सकते हैं।

# ठीक वही नाम
find /etc -name 'hosts'

# सभी .conf फ़ाइलें
find /etc -name '*.conf'

# केस को अनदेखा करके: README.md, readme.MD, Readme.md
find ~/projects -iname 'readme.md'

# report_1.csv से report_9.csv तक
find . -name 'report_?.csv'

पैटर्न हमेशा उद्धरण चिह्नों में लिखें। उनके बिना shell मौजूदा डायरेक्टरी की फ़ाइलों से *.conf को ख़ुद फैला देता है, और find को पैटर्न की जगह फ़ाइलों की सूची मिलती है। नतीजा या तो अजीब होगा या कमांड paths must precede expression त्रुटि के साथ रुकेगा।

पाथ से खोज: -path और -regex

अगर डायरेक्टरी भी मायने रखती है, तो -path इस्तेमाल करें, जो पूरे पाथ को पैटर्न से मिलाता है:

# केवल src डायरेक्टरी के भीतर की .js फ़ाइलें
find . -path '*/src/*' -name '*.js'

जटिल पैटर्न के लिए -regex है (regular expression भी पूरे पाथ पर लगती है), और केस-अनदेखी के लिए -iregex:

find . -regextype posix-extended -regex '.*\.(jpg|jpeg|png)$'

डायरेक्टरी को छोड़ना

ताकि find node_modules या .git में न जाए, -prune इस्तेमाल होता है:

find . -path ./node_modules -prune -o -name '*.js' -print

इसे ऐसे पढ़ें: «अगर पाथ ./node_modules है, तो उसके अंदर न उतरो, वरना (-o) *.js फ़ाइलें छापो»। अंत में -print ज़रूरी है, वरना छोड़ी गई डायरेक्टरी का नाम भी आउटपुट में आ जाएगा। एक आसान पर धीमा तरीका है -not -path '*/node_modules/*': find फिर भी उस डायरेक्टरी में जाता है, बस नतीजे छाँट देता है।

टाइप से खोज: -type

# केवल logs नाम वाली डायरेक्टरी
find / -type d -name 'logs' 2>/dev/null

# खाली फ़ाइलें और खाली डायरेक्टरी
find . -type f -empty
find . -type d -empty

# टूटे हुए सिम्बॉलिक लिंक
find . -xtype l

आकार से खोज: -size

-size संख्या के साथ इकाई लेता है: c — बाइट, k — किलोबाइट, M — मेगाबाइट, G — गीगाबाइट। + का मतलब «से बड़ा», - का मतलब «से छोटा», और कुछ न हो तो «ठीक उतना»।

# पूरे सिस्टम में 100 MB से बड़ी फ़ाइलें
find / -type f -size +100M 2>/dev/null

# 10 से 50 MB के बीच
find . -type f -size +10M -size -50M

# 1 KB से छोटी
find . -type f -size -1k

एक बारीकी है: आकार इकाई तक ऊपर की ओर गोल होता है। इसलिए -size -1M केवल खाली फ़ाइलें देगा, क्योंकि गोल करने के बाद कोई भी ग़ैर-खाली फ़ाइल «कम से कम 1 मेगाबाइट» गिनी जाती है। सटीक सीमा के लिए छोटी इकाई लें: -size -1024k।

डिस्क पर सबसे ज़्यादा जगह कौन घेर रहा है

find को ls और sort के साथ जोड़कर सबसे बड़ी फ़ाइलें दिखती हैं:

find /var -type f -size +50M -exec ls -lh {} + 2>/dev/null | sort -k5 -rh | head

-rw-r----- 1 syslog adm  1.2G Oct 14 09:12 /var/log/syslog.1
-rw-r--r-- 1 root   root 412M Oct 10 03:00 /var/backups/db.sql.gz
-rw-r----- 1 root   adm   96M Oct 14 09:15 /var/log/nginx/access.log

पूरी डायरेक्टरी का आकार आँकने के लिए du -sh बेहतर है, और find तब काम आता है जब किसी गहराई में एक ही बड़ी फ़ाइल जगह खा रही हो।

तारीख़ से खोज: -mtime, -mmin, -newer

हर फ़ाइल के तीन समय-चिह्न होते हैं, और find हर एक से फ़िल्टर कर सकता है:

चिह्न आकार वाले नियम जैसे ही काम करते हैं: -mtime -7 — 7 दिन से कम पहले बदली, -mtime +30 — 30 दिन से ज़्यादा पहले बदली।

# पिछले हफ़्ते बदली फ़ाइलें
find ~/projects -type f -mtime -7

# 30 दिन से पुराने लॉग
find /var/log -type f -name '*.log' -mtime +30

# पिछले 15 मिनट में बदली फ़ाइलें
find /etc -type f -mmin -15

दिन पूरे 24-घंटे के अंतराल में गिने जाते हैं, भिन्नात्मक हिस्सा छोड़ दिया जाता है। इसी वजह से -mtime +1 24 घंटे नहीं, 48 घंटे से पुरानी फ़ाइलें देता है, और यह एक आम जाल है। सटीकता चाहिए तो मिनट लें: -mmin +1440।

किसी फ़ाइल या तारीख़ से नई फ़ाइलें

# वे फ़ाइलें जो deploy.lock के बदलने के बाद बदलीं
find . -type f -newer deploy.lock

# किसी तारीख़ के बाद बदली फ़ाइलें (GNU find)
find . -type f -newermt '2026-10-01'

# तारीख़ों की सीमा के भीतर
find . -type f -newermt '2026-10-01' ! -newermt '2026-10-08'

मालिक और अनुमतियों से खोज

# alice की फ़ाइलें
find /home -user alice

# जिन फ़ाइलों का मौजूदा मालिक नहीं है (यूज़र हटाने के बाद)
find / -nouser 2>/dev/null

# जिनकी अनुमति ठीक 777 है
find /var/www -type f -perm 777

# जो सबके लिए लिखने योग्य हैं
find /var/www -perm -o=w

# SUID बिट वाली फ़ाइलें — सुरक्षा ऑडिट के लिए उपयोगी
find / -perm -4000 -type f 2>/dev/null

-perm के तीन रूप हैं: बिना चिह्न के — अनुमतियाँ बिल्कुल मेल खाएँ; - के साथ — दिए गए सभी बिट चालू हों; / के साथ — उनमें से कम से कम एक चालू हो।

शर्तों का तर्क: और, या, नहीं

शर्तें डिफ़ॉल्ट रूप से «और» से जुड़ती हैं। «या» के लिए -o है, और नकार के लिए ! या -not। समूह बनाने के लिए कोष्ठक लगते हैं, जिन्हें shell से बचाना पड़ता है:

# jpg या png तस्वीरें
find . -type f \( -name '*.jpg' -o -name '*.png' \)

# .tmp फ़ाइलों को छोड़कर सब कुछ
find . -type f ! -name '*.tmp'

कोष्ठक के बिना -type f «या» जोड़ी की केवल पहली शर्त पर लगेगा, और नतीजे में *.png नाम की डायरेक्टरी भी आ जाएँगी। \( और \) के आसपास स्पेस ज़रूरी हैं।

खोज की गहराई: -maxdepth और -mindepth

# केवल मौजूदा डायरेक्टरी, अंदर की नहीं
find . -maxdepth 1 -type f -name '*.sh'

# दूसरे स्तर की गहराई से शुरू
find . -mindepth 2 -name '*.md'

# दूसरी फ़ाइल सिस्टम में न जाएँ
find / -xdev -type f -size +1G

-maxdepth को पाथ के ठीक बाद लिखें, बाक़ी शर्तों से पहले, वरना GNU find चेतावनी देगा। / में खोजते समय -xdev उपयोगी है: find /proc, नेटवर्क और माउंट किए गए डिस्क में नहीं जाएगा।

मिली फ़ाइलों पर क्रिया: -exec, -delete, xargs

-exec: हर फ़ाइल पर कमांड चलाना

{} की जगह find फ़ाइल का पाथ रखता है। कमांड \; या + पर ख़त्म होती है:

# हर फ़ाइल के लिए अलग चलाना
find . -name '*.sh' -exec chmod +x {} \;

# सभी फ़ाइलें एक सूची में — तेज़
find . -name '*.log' -exec gzip {} +

# हर फ़ाइल के लिए पुष्टि के साथ
find . -name '*.bak' -ok rm {} \;

+ वाला रूप पाथ को गुच्छों में जोड़कर कमांड को बहुत कम बार चलाता है, इसलिए हज़ारों फ़ाइलों पर यह कई गुना तेज़ है। \; वाला रूप तब चाहिए जब कमांड एक ही फ़ाइल लेती हो, या {} आख़िर में न हो।

-delete: मिली चीज़ें मिटाना

# पहले देखें कि क्या मिटेगा
find /tmp/build -type f -name '*.o' -mtime +7

# फिर मिटाएँ
find /tmp/build -type f -name '*.o' -mtime +7 -delete

हमेशा पहले -delete के बिना चलाकर सूची जाँचें। और -delete को आख़िर में रखें: find व्यंजक बाएँ से दाएँ चलाता है, इसलिए find . -delete -name '*.o' डायरेक्टरी की हर चीज़ मिटा देगा, नाम की जाँच उसके बाद होगी।

find और xargs

क्लासिक जोड़ी है फ़ाइलों की सूची xargs से किसी और प्रोग्राम को देना। स्पेस वाले नामों पर गड़बड़ न हो, इसके लिए शून्य बाइट (null) विभाजक लें:

find . -type f -name '*.txt' -print0 | xargs -0 wc -l

xargs का -P फ्लैग प्रोसेसिंग को समानांतर चलाता है:

find ./images -name '*.png' -print0 | xargs -0 -P 4 -n 10 optipng

find और grep: फ़ाइलों के अंदर टेक्स्ट खोजना

find फ़ाइलें खोजता है, उनकी सामग्री नहीं। किसी लाइन को चुनी हुई फ़ाइलों में खोजने के लिए उन्हें grep को दें:

# nginx की कॉन्फ़िग में listen 8080 कहाँ है
find /etc/nginx -type f -name '*.conf' -exec grep -Hn 'listen 8080' {} +

/etc/nginx/sites-enabled/app.conf:4:    listen 8080;

-H फ़ाइल का नाम छापता है, -n लाइन नंबर, और grep -l केवल वे फ़ाइल नाम देता है जिनमें मिलान है। अगर फ़िल्टर केवल एक्सटेंशन का है, तो grep ख़ुद काफ़ी है: grep -rn --include='*.conf' 'listen 8080' /etc/nginx।

अपना आउटपुट फ़ॉर्मेट: -printf

GNU find केवल पाथ ही नहीं, और भी बहुत कुछ छाप सकता है, जैसे आकार, तारीख़ और नाम:

find . -maxdepth 1 -type f -printf '%s\t%TY-%Tm-%Td\t%p\n' | sort -n

यहाँ %s बाइट में आकार है, %T... बदलाव की तारीख़ के हिस्से, और %p पाथ। स्क्रिप्ट के लिए यह सुविधाजनक है, क्योंकि ls का आउटपुट पार्स नहीं करना पड़ता।

रोज़ के काम के लिए find linux उदाहरण — चीट-शीट

आम गलतियाँ

• बिना उद्धरण वाला पैटर्न। find . -name *.log तब टूटता है जब मौजूदा डायरेक्टरी में एक भी .log फ़ाइल हो। '*.log' लिखें।
• Permission denied की बाढ़। 2>/dev/null जोड़ें, या पूरी डिस्क चाहिए तो sudo से चलाएँ।
• -delete सही जगह पर नहीं। वह हमेशा आख़िर में होता है, और उससे पहले बिना मिटाए जाँच चलानी चाहिए।
• पाइप में स्पेस वाले नाम। find ... | xargs rm «My File.txt» को दो आर्गुमेंट में तोड़ देगा। -print0 और xargs -0 या -exec इस्तेमाल करें।
• -mtime से सटीक दिनों की उम्मीद। सटीक अंतराल के लिए -mmin या -newermt लें।

निष्कर्ष

find फ़ाइल सिस्टम में खोज का बहुमुखी टूल है: पाथ, फिर नाम, टाइप, आकार, तारीख़ और अनुमति की शर्तें, और फिर क्रिया। पाँच स्तंभ सीख लें — -name, -type, -size, -mtime और -exec ... + — तो ज़्यादातर काम एक लाइन में हो जाएँगे। ये find linux उदाहरण अपने टर्मिनल में ज़रूर दोहराएँ, और find को grep, sed और awk के साथ जोड़ने के तरीक़े हम अपने Linux कोर्स के उस लेक्चर में व्यवहार में सिखाते हैं जो टेक्स्ट प्रोसेसिंग पर है।