खोज में किसी निर्देशिका को बाहर कैसे करें। आदेश

Question

मैं findसभी जावास्क्रिप्ट फ़ाइलों के लिए एक कमांड चलाने की कोशिश कर रहा हूं , लेकिन मैं एक विशिष्ट निर्देशिका को कैसे बाहर कर सकता हूं?

यहां वह findकोड है जिसका हम उपयोग कर रहे हैं।

for file in $(find . -name '*.js')
do 
  java -jar config/yuicompressor-2.4.2.jar --type js $file -o $file
done

Comments

वह निर्देशिका जो आपको बाहर करने की आवश्यकता है?

— आर्कितपाल पॉल

इसका उपयोग करना बेहतर है find ... | while read -r file ...। इसके अलावा, उत्तरों को स्वीकार करना और बढ़ाना बेहतर है।

— अगली सूचना तक रोक दिया गया।

पढ़ने के दौरान धीमी गति से, के लिए तेजी से है

— एमपीईजी

@mpapis को सही ढंग से पढ़ते समय व्हॉट्सएप के साथ पूरी लाइनों को संभालता है।

— जीन-फिलिप पेलेट

बस उनके नाम में रिक्त स्थान वाली फ़ाइलों के साथ एक फ़ोल्डर में इसे चलाएं for file in $(find .); do echo "$file"; done:। रिक्त स्थान वाले नाम विभाजित हैं, जो हम नहीं चाहते हैं।

— जीन-फिलिप पेलेट

Answer 1

-pruneस्विच का उपयोग करें । उदाहरण के लिए, यदि आप miscनिर्देशिका को बाहर करना चाहते हैं, तो बस -path ./misc -prune -oअपनी खोज कमांड में जोड़ें :

find . -path ./misc -prune -o -name '*.txt' -print

यहाँ कई निर्देशिकाओं के साथ एक उदाहरण दिया गया है:

find . -type d \( -path dir1 -o -path dir2 -o -path dir3 \) -prune -o -print

यहाँ हम को बाहर dir1 , dir2 और dir3 , के बाद से में findभाव यह एक कार्रवाई है कि मापदंड पर कार्य करता है -path dir1 -o -path dir2 -o -path dir3(यदि dir1 या dir2 या dir3 ), के साथ anded type -d।

आगे की कार्रवाई है -o print, बस प्रिंट करें।

Comments

हम्म। यह मेरे लिए काम नहीं करता है क्योंकि इसमें आउटपुट में अनदेखा निर्देशिका "./misc" शामिल होगा।

— औनी

@ यह शायद आपके लिए काम नहीं करता क्योंकि आपने -printस्पष्ट रूप से एक (या कोई अन्य कार्रवाई) नहीं जोड़ा था -name। उस स्थिति में, -oअंत मुद्रण के दोनों "पक्ष" , यदि आप उपयोग करते हैं -print, तो केवल उस तरफ प्रिंट करता है।

— डैनियल सी। सोबराल

मैनपेज से: Because -delete implies -depth, you cannot usefully use -prune and -delete together.तो, मैं डिलीट से विशिष्ट निर्देशिकाओं को बाहर करना चाहता हूं, तो मैं इसे हटाने के बारे में कैसे पता लगाऊंगा?

— जानिस एल्मरिस

परिणामों के उपयोग से पूरी निर्देशिका को हटाने के लिए find . -not -path "./.git*":। ./dir*इसके बजाय ./dir/*निर्देशिका का उपयोग करने के साथ ही आउटपुट से सामग्री को निकालता है।

— मिहब्लू

यह प्रश्न और उत्तरों में भ्रम इस बात का प्रकटीकरण है कि उपयोगकर्ता इंटरफ़ेस कितनी बुरी तरह से मेल खाता है, जिसकी लोगों को आवश्यकता है।

— जोहान्स ओवरमैन

Answer 2

यदि -pruneआप के लिए काम नहीं करता है, यह होगा:

find -name "*.js" -not -path "./directory/*"

कैविएट: सभी अवांछित निर्देशिकाओं का पता लगाने की आवश्यकता है।

Comments

स्वीकृत उत्तर में टिप्पणियों में से एक समस्या को इंगित करता है। -pruneनिर्देशिका को स्वयं बाहर नहीं करता है, यह इसकी सामग्री को बाहर करता है, जिसका अर्थ है कि आप बहिष्कृत निर्देशिका के साथ आउटपुट में एक अवांछित लाइन प्राप्त करने जा रहे हैं।

— GetFree

बहुत बढ़िया जवाब। मैं इस के लिए जोड़ चाहते हैं कि आप पहली बार बदलकर किसी भी स्तर पर एक निर्देशिका बाहर कर सकते हैं .करने के लिए *। इसलिए find -name "*.js" -not -path "*/omitme/*"गहराई से किसी भी स्तर पर "ओमिटम" नामक एक निर्देशिका से फ़ाइलों को छोड़ देगा।

— डेडे

यह अभी भी अवांछित निर्देशिका के सभी का पता लगाता है । मैं अपना जवाब जोड़ रहा हूं। :-)

— डैनियल सी। सोबरल

हालाँकि, ध्यान दें कि यदि आप -printस्पष्ट रूप से उपयोग नहीं करते हैं, तो यह prune विकल्प केवल काम नहीं करता है ।

— डैनियल सी। सोबराल

यह कहना बेहतर होगा "यह उपयोग करने के लिए एक विकल्प है -प्र्यून"। -प्रूव करने का सुझाव देने वाले उत्तर स्पष्ट रूप से गलत नहीं हैं, वे सिर्फ उस तरह से नहीं हैं जैसे आप इसे करेंगे।

— जिम्बो

Answer 3

मैं अन्य प्रस्तावित समाधानों की तुलना में निम्नलिखित कारण आसान करता हूं:

find build -not \( -path build/external -prune \) -name \*.js
# you can also exclude multiple paths
find build -not \( -path build/external -prune \) -not \( -path build/blog -prune \) -name \*.js

महत्वपूर्ण नोट: आपके द्वारा टाइप किए जाने वाले रास्तों का -pathमिलान बिल्कुल सही होना चाहिए findजो बहिष्करण के बिना प्रिंट होगा। यदि यह वाक्य आपको भ्रमित करता है तो इस तरह से पूरे कमांड को पूरा करने के लिए पूर्ण पथ का उपयोग करना सुनिश्चित करें :। यदि आप एक बेहतर समझ चाहते हैं तो नोट [1] देखें।find /full/path/ -not \( -path /full/path/exclude/this -prune \) ...

अंदर \(और \)एक अभिव्यक्ति है जो वास्तव में मेल खाएगा build/external(ऊपर महत्वपूर्ण नोट देखें), और, सफलता पर, नीचे कुछ भी पता लगाने से बचें । इसके बाद बची हुई कोष्ठक के साथ एक एकल अभिव्यक्ति के रूप में समूहीकृत किया जाता है, और इसके साथ उपसर्ग किया जाता है, -notजो findउस अभिव्यक्ति से मिलान किए गए किसी भी चीज़ को छोड़ देगा ।

कोई यह पूछ सकता है कि क्या जोड़ने -notसे अन्य सभी फ़ाइलें -pruneफिर से दिखाई नहीं देंगी , और उत्तर नहीं है। जिस तरह से -pruneकाम करता है वह यह है कि कुछ भी हो जाने के बाद, उस निर्देशिका के नीचे की फ़ाइलों को स्थायी रूप से अनदेखा कर दिया जाता है।

यह एक वास्तविक उपयोग के मामले से आता है, जहां मुझे विंटस्मिथ द्वारा उत्पन्न कुछ फाइलों पर यूआई-कंप्रेसर को कॉल करने की आवश्यकता थी, लेकिन अन्य फ़ाइलों को छोड़ दें जिन्हें आवश्यकतानुसार भेजा जाना चाहिए।

---

नोट [१] : यदि आप बहिष्कृत करना चाहते हैं /tmp/foo/barऔर आप इस तरह पाते हैं " find /tmp \(..." तो आपको निर्दिष्ट करना होगा -path /tmp/foo/bar। अगर दूसरी तरफ आप दौड़ते हैं cd /tmp; find . \(...तो आपको ऐसा लगता है कि आपको निर्दिष्ट करना चाहिए -path ./foo/bar।

Comments

उत्कृष्ट उत्तर, धन्यवाद। यह कई बहिष्करणों के लिए काम करता है और स्केलेबल (पठनीय) है। आप एक सज्जन और विद्वान महोदय हैं। कई बहिष्करणों के उदाहरण के लिए धन्यवाद

— स्वतंत्रता

यह काम नहीं करता है, अगर मैं find . -not \( -path ./CVS -prune \) -type f -mtime +100 -delete find: The -delete action atomatically turns on -depth, but -prune does nothing when -depth is in effect. If you want to carry on anyway, just explicitly use the -depth option.

— -सेट

@ जानिस आप -exec rm -rf {} \;इसके बजाय उपयोग कर सकते हैं -delete।

— डैनियल सी। सोबरल

के उत्पादन की जांच करके find, यह वास्तव में स्पष्ट है, लेकिन इसने मुझे उलझा दिया। यदि आप वर्तमान निर्देशिका में खोज कर रहे हैं ( .खोज पथ के रूप में निर्दिष्ट करके , या किसी एक को निर्दिष्ट नहीं कर रहे हैं), तो आप सबसे अधिक संभावना अपने पैटर्न -pathको शुरू करने के बाद चाहते हैं ./, जैसे find -not \( -path ./.git -prune \) -type f:।

— ज़ांटियर

इस पद्धति का एक और अधिक सटीक (और POSIX संगत) भिन्नता: find searchdir \! \( -type d \( -path './excludedir/*' -o -path './excludedir2/*' -o -path './excludedir3/*' \) -prune \)किसी भी स्थिति के बाद जो आपको दिख रही है उससे मेल खाना चाहिए।

— वॉल्फ

Answer 4

यहां स्पष्ट रूप से कुछ भ्रम है कि किसी निर्देशिका को स्किप करने के लिए पसंदीदा सिंटैक्स क्या होना चाहिए।

ग्नू राय

To ignore a directory and the files under it, use -prune

GNU से मैन पेज ढूंढें

विचार

-prunefindएक निर्देशिका में उतरने से रोकता है। सिर्फ निर्दिष्ट -not -pathकरना अभी भी छोड़ दी गई निर्देशिका में उतरना होगा , लेकिन -not -pathजब भी findप्रत्येक फ़ाइल का परीक्षण किया जाएगा तो यह गलत होगा ।

के साथ जारी करता है -prune

-prune इसका उद्देश्य क्या है, लेकिन इसका उपयोग करते समय आपको कुछ बातों का ध्यान रखना होगा।

1. find छंटाई निर्देशिका प्रिंट करता है।

   • सच है कि यह व्यवहार का इरादा है, यह अभी इसमें नहीं उतरता है। निर्देशिका को पूरी तरह से प्रिंट करने से बचने के लिए, एक सिंटैक्स का उपयोग करें जो तार्किक रूप से इसे छोड़ देता है।

2. -pruneकेवल साथ काम करता है -printऔर कोई अन्य कार्य नहीं करता है ।

   • सही नहीं है । -pruneको छोड़कर किसी भी कार्रवाई के साथ काम करता है -delete। इसे हटाने के साथ काम क्यों नहीं करता है? के लिए -deleteकाम करने के लिए,, डीएफएस क्रम में निर्देशिका पार करने के बाद की जरूरत है खोजने के -deleteपहले ... लेकिन निर्दिष्ट करने के लिए छोड़ देता है, तो पत्ते, आदि के माता-पिता को नष्ट करेगा -pruneमेकअप भावना को, findयह उतरते एक निर्देशिका और बंद हिट करने के लिए की जरूरत है, जो स्पष्ट रूप से -depthया साथ कोई मतलब नहीं है -delete।

प्रदर्शन

मैं इस सवाल (प्रतिस्थापित पर तीन शीर्ष upvoted जवाब में से एक साधारण परीक्षण की स्थापना -printके साथ -exec bash -c 'echo $0' {} \;एक और कार्रवाई उदाहरण दिखाने के लिए)। परिणाम नीचे हैं

----------------------------------------------
# of files/dirs in level one directories
.performance_test/prune_me     702702    
.performance_test/other        2         
----------------------------------------------

> find ".performance_test" -path ".performance_test/prune_me" -prune -o -exec bash -c 'echo "$0"' {} \;
.performance_test
.performance_test/other
.performance_test/other/foo
  [# of files] 3 [Runtime(ns)] 23513814

> find ".performance_test" -not \( -path ".performance_test/prune_me" -prune \) -exec bash -c 'echo "$0"' {} \;
.performance_test
.performance_test/other
.performance_test/other/foo
  [# of files] 3 [Runtime(ns)] 10670141

> find ".performance_test" -not -path ".performance_test/prune_me*" -exec bash -c 'echo "$0"' {} \;
.performance_test
.performance_test/other
.performance_test/other/foo
  [# of files] 3 [Runtime(ns)] 864843145

निष्कर्ष

दोनों f10bit की वाक्य रचना और डैनियल सी Sobral के वाक्य रचना औसत पर चलने के लिए 10-25ms ले लिया। GetFree का सिंटैक्स , जो उपयोग नहीं करता है -prune, 865ms लिया। तो, हाँ यह एक अतिवादी उदाहरण है, लेकिन अगर आप रन टाइम की परवाह करते हैं और कुछ भी कर रहे हैं तो आपको दूर से ही इसका उपयोग करना चाहिए -prune।

नोट डैनियल सी। सोबरल के सिंटैक्स ने दो सिंटैक्स का बेहतर प्रदर्शन किया -prune; लेकिन, मुझे दृढ़ता से संदेह है कि यह कुछ कैशिंग का नतीजा है क्योंकि दोनों ने जिस क्रम में विपरीत परिणाम दिया, उस क्रम को बंद कर दिया, जबकि गैर-प्रून संस्करण हमेशा सबसे धीमा था।

टेस्ट स्क्रिप्ट

#!/bin/bash

dir='.performance_test'

setup() {
  mkdir "$dir" || exit 1
  mkdir -p "$dir/prune_me/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/w/x/y/z" \
    "$dir/other"

  find "$dir/prune_me" -depth -type d -exec mkdir '{}'/{A..Z} \;
  find "$dir/prune_me" -type d -exec touch '{}'/{1..1000} \;
  touch "$dir/other/foo"
}

cleanup() {
  rm -rf "$dir"
}

stats() {
  for file in "$dir"/*; do
    if [[ -d "$file" ]]; then
      count=$(find "$file" | wc -l)
      printf "%-30s %-10s\n" "$file" "$count"
    fi
  done
}

name1() {
  find "$dir" -path "$dir/prune_me" -prune -o -exec bash -c 'echo "$0"'  {} \;
}

name2() {
  find "$dir" -not \( -path "$dir/prune_me" -prune \) -exec bash -c 'echo "$0"' {} \;
}

name3() {
  find "$dir" -not -path "$dir/prune_me*" -exec bash -c 'echo "$0"' {} \;
}

printf "Setting up test files...\n\n"
setup
echo "----------------------------------------------"
echo "# of files/dirs in level one directories"
stats | sort -k 2 -n -r
echo "----------------------------------------------"

printf "\nRunning performance test...\n\n"

echo \> find \""$dir"\" -path \""$dir/prune_me"\" -prune -o -exec bash -c \'echo \"\$0\"\'  {} \\\;
name1
s=$(date +%s%N)
name1_num=$(name1 | wc -l)
e=$(date +%s%N)
name1_perf=$((e-s))
printf "  [# of files] $name1_num [Runtime(ns)] $name1_perf\n\n"

echo \> find \""$dir"\" -not \\\( -path \""$dir/prune_me"\" -prune \\\) -exec bash -c \'echo \"\$0\"\' {} \\\;
name2
s=$(date +%s%N)
name2_num=$(name2 | wc -l)
e=$(date +%s%N)
name2_perf=$((e-s))
printf "  [# of files] $name2_num [Runtime(ns)] $name2_perf\n\n"

echo \> find \""$dir"\" -not -path \""$dir/prune_me*"\" -exec bash -c \'echo \"\$0\"\' {} \\\;
name3
s=$(date +%s%N)
name3_num=$(name3 | wc -l)
e=$(date +%s%N)
name3_perf=$((e-s))
printf "  [# of files] $name3_num [Runtime(ns)] $name3_perf\n\n"

echo "Cleaning up test files..."
cleanup

Comments

बहुत अच्छे विश्लेषण के लिए धन्यवाद। कैश को साफ़ करने के लिए "मुझे संदेह है कि यह कुछ कैशिंग का परिणाम है" आप इस कमांड को चला सकते हैं: sudo sh -c "free && Sync && echo 3> / proc / sys / vm / drop_caches && free" । stackexchange.com/questions/87908/… )।

— ndemou

उन दो पर कुछ परीक्षणों के बाद -pruneमैं बता सकता हूं कि शायद ही कोई अंतर है। ध्यान रखें कि जो कमांड पहले शुरू होती है वह सीपीयू प्रदर्शन से लाभान्वित होती है, बाद में सीपीयू वार्म अप> प्रदर्शन ड्रॉप मामूली रूप से धीमा हो जाता है (मैंने @ कमांड के रूप में प्रत्येक कमांड से पहले कैश कैश किया)

— Huy.PhamNhu

name1() name2() name3()मैंने जो कुछ कहा उसके बारे में एक दृश्य प्राप्त करने के लिए निष्पादन आदेश को बदलने के लिए ऊपर @BroSlow परीक्षण स्क्रिप्ट में स्विच नंबर का प्रयास करें । वास्तविक जीवन में, यह उन दोनों के बीच किसी का ध्यान नहीं है।

— Hu.P.PhamNhu

तालियां। इस गुणवत्ता उत्तर के लिए धन्यवाद।

— स्टीफन

आपको -o का मतलब नहीं होना चाहिए या। इसलिए आप पहले चरण में आगे बढ़ रहे हैं और फिर अगले में इसके बारे में सब भूल रहे हैं।

— mmm

Answer 5

यह एकमात्र ऐसा है जिसने मेरे लिए काम किया।

find / -name MyFile ! -path '*/Directory/*'

"MyFile" के लिए खोज "निर्देशिका" को छोड़कर। सितारों पर जोर दें *।

Comments

यह विधि macOS पर काम करती है जबकि स्वीकृत उत्तर नहीं देता है। मुझे पता है कि मूल प्रश्न लिनक्स के लिए है।

— जेवियर रुबियो जंसाना

ध्यान दें कि आप ! -path '*/Directory/*'उत्तराधिकार में अपने कमांड में कई निर्देशिकाओं को अनदेखा करने के लिए कई जोड़ सकते हैं

— Aclwitt

MacOS पर काम करता है, लेकिन यह linux पर नहीं है ... पुष्टि की गई

— Marcello de Sales

के साथ एक docker containerही काम करता हैsh -c "find..."

— Marcello de Sales

@ मार्सेलो डे की बिक्री निश्चित रूप से यह लिनक्स पर काम करती है।

— दिमिदाक

Answer 6

एक विकल्प उन सभी परिणामों को बाहर करना होगा जिनमें grep के साथ निर्देशिका नाम शामिल है। उदाहरण के लिए:

find . -name '*.js' | grep -v excludeddir

Comments

यह आपकी खोज को बहुत धीमा कर देगा

— डोरियन

यह एक मेरे लिए काम करता है, अन्य (जो उपयोग करते हैं -prune) - नहीं करता है।

— एंड्रॉन

बड़े परिणामों में धीमा, लेकिन छोटे सेट में उपयोगी। लेकिन grep का उपयोग करके कई निर्देशिकाओं को बाहर कैसे करें? बेशक इस तरह से: find . -name '*.js' | grep -v excludeddir | grep -v excludedir2 | grep -v excludedir3लेकिन वहाँ कुछ एक तरह से हो सकता है।

— तिमो किक्कनेन

यदि आप एक से अधिक greps करना चाहते हैं तो आप इसे नियमित अभिव्यक्ति के रूप में लिखना बेहतर होगा egrep -v '(dir1|dir2|dir3)':। हालांकि, इस विशिष्ट मामले के अध्ययन में, निर्देशिका को findअपने भीतर से बाहर करना बेहतर होगा ।

— लॉरेंस

हां, और आपको कोष्ठकों की आवश्यकता नहीं है और यह सुनिश्चित करने के लिए ^ का उपयोग करना बेहतर होगा कि यह स्ट्रिंग के प्रारंभ में डायरेक्टरीनाम से मेल खाता है जैसे: खोजे। -नाम '* .js' | egrep -v "^ \ /। बहिष्कृत 1 | ^ \ /। बहिष्कृत 2"

— सोफीजा

Answer 7

मैं -notनोटेशन पसंद करता हूँ ... यह अधिक पठनीय है:

find . -name '*.js' -and -not -path directory

Comments

क्षमा करें, यह काम नहीं करता है। के लिए आदमी पृष्ठ findकहता है: "एक निर्देशिका और इसके तहत फ़ाइलों को अनदेखा करने के लिए, उपयोग -प्र्यून"।

— ईसाई डेवन

ये गलत है। यह निर्देशिका को दर्ज करने और अंदर की सभी फ़ाइलों को ट्रेस करने से नहीं रोकता है।

— GetFree

find . -iname '*' -and -not -path './somePath'यह कहा निर्देशिका में प्रवेश करने से नहीं रोकता है।

— लेमिंग्स 19

इससे मुझे find . -iname '*' -not -path './.git/*'

— .गित

@ क्रेन: विशेष रूप find . -not -path "*/.git*"से वही होगा जो आप चाहते हैं।

— बेन

Answer 8

-Prune विकल्प का उपयोग करें। तो, कुछ इस तरह:

find . -type d -name proc -prune -o -name '*.js'

'-Type d -name proc -prune' केवल उन निर्देशिकाओं की तलाश करता है, जिन्हें बहिष्कृत करने के लिए proc नाम दिया गया है।
'-ओ' एक 'ओआर' ऑपरेटर है।

Comments

यह एकमात्र शुद्ध- "खोज" समाधान है जो मेरे लिए काम करता है। जिन निर्देशिकाओं को मैं बाहर करना चाहता था, वे वर्तमान कार्यशील निर्देशिका से तुरंत नीचे नहीं हैं।

— लैम्बर्ट

हालाँकि, -printअंत में जोड़ने से परिणामों में सुधार हो सकता है। find . -type d -name .hg -prune -o -name data(एकाधिक) .hgनिर्देशिकाओं की सामग्री को अनदेखा किया , लेकिन .hgनिर्देशिकाओं को स्वयं सूचीबद्ध किया। इसके साथ -print, यह केवल "डेटा" निर्देशिकाओं को सूचीबद्ध करता है जो मैं चाह रहा था।

— लाम्बर्ट

Answer 9

-prune निश्चित रूप से काम करता है और सबसे अच्छा जवाब है क्योंकि यह डीआर में उतरने से रोकता है जिसे आप बाहर करना चाहते हैं। -not -pathजो अभी भी अपवर्जित डीआईआर को खोजता है, यह सिर्फ परिणाम को प्रिंट नहीं करता है, जो एक मुद्दा हो सकता है यदि बाहर रखा गया डायर माउंट किया गया है नेटवर्क वॉल्यूम या आप अनुमति नहीं देते हैं।

मुश्किल हिस्सा यह है कि findतर्कों के क्रम के बारे में बहुत विशेष है, इसलिए यदि आप उन्हें सही नहीं पाते हैं, तो आपका आदेश काम नहीं कर सकता है। तर्कों का क्रम आम तौर पर इस प्रकार है:

find {path} {options} {action}

{path}: पहले रास्ते संबंधी सभी तर्क रखें, जैसे . -path './dir1' -prune -o

{options}: मुझे -name, -iname, etcइस समूह में अंतिम विकल्प के रूप में डालते समय सबसे अधिक सफलता मिली है । उदाहरण के लिए-type f -iname '*.js'

{action}: आप -printका उपयोग करते समय जोड़ना चाहते हैं-prune

यहाँ एक काम कर उदाहरण है:

# setup test
mkdir dir1 dir2 dir3
touch dir1/file.txt; touch dir1/file.js
touch dir2/file.txt; touch dir2/file.js
touch dir3/file.txt; touch dir3/file.js

# search for *.js, exclude dir1
find . -path './dir1' -prune -o -type f -iname '*.js' -print

# search for *.js, exclude dir1 and dir2
find . \( -path './dir1' -o -path './dir2' \) -prune -o -type f -iname '*.js' -print

Answer 10

यह वह प्रारूप है जिसका उपयोग मैंने कुछ रास्तों को बाहर करने के लिए किया था:

$ find ./ -type f -name "pattern" ! -path "excluded path" ! -path "excluded path"

मैंने इसका उपयोग सभी फ़ाइलों को "। *" पथों में खोजने के लिए किया है:

$ find ./ -type f -name "*" ! -path "./.*" ! -path "./*/.*"

Comments

मैंने यह कोशिश की और यह अभी भी निर्देशिका में उतरता है, इसलिए निश्चित रूप से गति में सुधार नहीं हुआ है।

— Br.Bill

Answer 11

-पथ -प्र्यून दृष्टिकोण भी मार्ग में वाइल्डकार्ड के साथ काम करता है। यहाँ एक खोज कथन है जो एक git सर्वर के लिए निर्देशिकाओं को खोजेगा जो कई git रिपॉजिटरी की सेवा करता है जो git आंतरिक निर्देशिकाओं को छोड़ रहा है:

find . -type d \
   -not \( -path */objects -prune \) \
   -not \( -path */branches -prune \) \
   -not \( -path */refs -prune \) \
   -not \( -path */logs -prune \) \
   -not \( -path */.git -prune \) \
   -not \( -path */info -prune \) \
   -not \( -path */hooks -prune \)  

Answer 12

कई निर्देशिकाओं को बाहर करने के लिए:

find . -name '*.js' -not \( -path "./dir1" -o -path "./dir2/*" \)

निर्देशिकाओं को जोड़ने के लिए, जोड़ें -o -path "./dirname/*":

find . -name '*.js' -not \( -path "./dir1" -o -path "./dir2/*" -o -path "./dir3/*"\)

लेकिन शायद आपको एक नियमित अभिव्यक्ति का उपयोग करना चाहिए , अगर बाहर करने के लिए कई निर्देशिकाएं हैं।

Answer 13

बहुत सारे अच्छे उत्तर हैं, मुझे यह समझने में कुछ समय लगा कि कमांड का प्रत्येक तत्व क्या था और इसके पीछे का तर्क क्या था।

find . -path ./misc -prune -o -name '*.txt' -print

खोज वर्तमान निर्देशिका में फ़ाइलों और निर्देशिकाओं को खोजना शुरू कर देगी, इसलिए find .।

-oविकल्प के लिए एक तार्किक या के लिए खड़ा है और आदेश के दो हिस्सों को अलग करती है:

[ -path ./misc -prune ] OR [ -name '*.txt' -print ]

किसी भी निर्देशिका या फ़ाइल है कि नहीं ./misc निर्देशिका पहले टेस्ट पास नहीं होगा -path ./misc। लेकिन उन्हें दूसरी अभिव्यक्ति के खिलाफ परीक्षण किया जाएगा। यदि उनका नाम उस पैटर्न से मेल खाता है, जो *.txtवे -printविकल्प के कारण मुद्रित होते हैं ।

जब खोज ./misc निर्देशिका में पहुँचती है, तो यह निर्देशिका केवल पहली अभिव्यक्ति को संतुष्ट करती है। तो उस पर -pruneविकल्प लागू होगा। यह खोज कमांड को उस निर्देशिका का पता नहीं लगाने के लिए कहता है । तो ./isc में किसी भी फ़ाइल या निर्देशिका को खोजने से भी नहीं पता चलेगा, अभिव्यक्ति के दूसरे भाग के खिलाफ परीक्षण नहीं किया जाएगा और मुद्रित नहीं किया जाएगा।

Comments

हर किसी को एक समाधान मिल गया है लेकिन तुम्हारा सबसे अच्छा इसे समझाया। मैं -path के बजाय पहले -नाम का उपयोग करने के लिए अडिग था। मैं जो चाहता था, उस पर आने के लिए आपका स्पष्टीकरण पर्याप्त था। खोजो। -name "* .txt" -print -o -path ./misc -prune

— वेंडेट्टा वी

Answer 14

एक काम के समाधान के लिए (Ubuntu 12.04 (सटीक पैंगोलिन) पर परीक्षण किया गया) ...

find ! -path "dir1" -iname "*.mp3"

dir1 सबफ़ोल्डर को छोड़कर वर्तमान फ़ोल्डर और सबफ़ोल्डर में MP3 फ़ाइलों की खोज करेगा।

उपयोग:

find ! -path "dir1" ! -path "dir2" -iname "*.mp3"

... dir1 और dir2 को बाहर करने के लिए

Comments

मेरे लिए काम नहीं करता है। न ही उपरोक्त में से कोई उत्तर दें। लाल टोपी।

— थारपा

Answer 15

मुद्रण कम कर दिए हैं निर्देशिकाओं से बचने के लिए एक अच्छा चाल उपयोग करने के लिए है -print(के लिए काम करता है -execके दाईं ओर के बाद भी) -orके बाद -prune। उदाहरण के लिए, ...

find . -path "*/.*" -prune -or -iname "*.j2"

मौजूदा निर्देशिका के नीचे सभी फाइलों के पथ को .j2 "एक्सटेंशन के साथ प्रिंट करेगा, सभी छिपी निर्देशिकाओं को छोड़ देगा। नीट। लेकिन यह प्रिंट को भी प्रिंट करेगा प्रत्येक निर्देशिका का पूरा पथ एक लंघन है, जैसा कि ऊपर उल्लेख किया गया है। हालांकि। निम्नलिखित नहीं है, ...

find . -path "*/.*" -prune -or -iname "*.j2" -print

क्योंकि तार्किक रूप -andसे -inameऑपरेटर के बाद और -प्रिंट से पहले एक छिपा हुआ है । यह इसे -orऑपरेशन और संबद्धता के बूलियन आदेश के कारण खंड के दाहिने हिस्से में बांधता है । लेकिन डॉक्स का कहना है कि -printअगर वहाँ (या उसके किसी भी चचेरे भाई ... -print0आदि) को छिपाया गया है, तो वह निर्दिष्ट नहीं है। तो -orछपाई का बायाँ हिस्सा क्यों नहीं है ? जाहिरा तौर पर (और मैं इसे अपने पहले आदमी पृष्ठ को पढ़ने से नहीं समझता था), यह सच है कि अगर कोई -print- कोई -execभी नहीं है, तो उस स्थिति में, -प्रिंट तार्किक रूप से ऐसे चारों ओर छिड़का हुआ है कि सब कुछ मुद्रित हो जाता है। अगर एक भीprint -स्टाइल ऑपरेशन किसी भी खंड में व्यक्त नहीं किया गया है, तो उन सभी छिपे हुए तार्किक दूर चले जाते हैं और आपको केवल वही मिलता है जो आप उल्लिखित करना। अब स्पष्ट रूप से, मैंने इसे दूसरे तरीके से पसंद किया होगा, लेकिन फिर एfindकेवल वर्णनात्मक ऑपरेटरों के साथ जाहिरा तौर पर कुछ भी नहीं होगा, इसलिए मुझे लगता है कि यह समझ में आता है। जैसा कि ऊपर उल्लेख किया गया है, यह सब साथ -execही साथ काम करता है , इसलिए निम्नलिखित ls -laवांछित एक्सटेंशन के साथ प्रत्येक फ़ाइल के लिए पूरी सूची देता है , लेकिन प्रत्येक छिपी निर्देशिका के पहले स्तर को सूचीबद्ध नहीं करता है, ...

find . -path "*/.*" -prune -or -iname "*.j2" -exec ls -la -- {} +

मेरे लिए (और इस धागे पर अन्य), findसिंटैक्स बहुत जल्दी से बहुत बारोक हो जाता है, इसलिए मैं हमेशा यह सुनिश्चित करने के लिए कि मैं क्या बांधता हूं, बनाने के लिए परेंस में फेंक देता हूं, इसलिए मैं आमतौर पर टाइप-क्षमता के लिए एक मैक्रो बनाता हूं और इस तरह के सभी बयान बनाता हूं। ..

find . \( \( ... description of stuff to avoid ... \) -prune \) -or \
\( ... description of stuff I want to find ... [ -exec or -print] \)

इस तरह से दुनिया को दो हिस्सों में बांटकर गलत करना मुश्किल है। मुझे उम्मीद है कि यह मदद करता है, हालांकि यह किसी के लिए 30 + वें उत्तर तक पढ़ने और इसे वोट करने की संभावना नहीं है, लेकिन कोई भी उम्मीद कर सकता है। :-)

Answer 16

इसे प्राप्त करने के लिए आप prune विकल्प का उपयोग कर सकते हैं। उदाहरण के लिए:

find ./ -path ./beta/* -prune -o -iname example.com -print

या उलटा grep "grep -v" विकल्प:

find -iname example.com | grep -v beta

आप लिनक्स में विस्तृत निर्देश और उदाहरण पा सकते हैं और खोज से निर्देशिका को बाहर कर सकते हैं ।

Comments

Grep समाधान केवल एक ही है जो सभी निर्देशिकाओं को एक ही नाम से बाहर करता है। "नोड_मॉड्यूल्स" को बाहर करने की कोशिश करते समय यह काफी उपयोगी है।

— bmacnaughton

@bmacnaughton - सच नहीं है! मैं विशेष रूप से "नोड_मॉड्यूल्स" को बाहर करने के लिए यहां आया था और कई ठीक जवाबों को पढ़ने के बाद मैं बस गया था find . -type f -print -o -path "*/node_modules" -prune... वाइल्डकार्ड का उपयोग करके किसी भी स्तर पर इस "नोड_मॉड्यूल्स" को छोड़ देता हूं; -printपहले विकल्प पर उपयोग करने -type f -printसे केवल वह भाग प्रिंट होता है, इसलिए "नोड_मॉड्यूल्स" निर्देशिका स्वयं सूचीबद्ध नहीं होती हैं। (यह भी उलट जा सकता है: find . -path "*/node_modules" -prune -o -type f -print)

— स्टीफन पी

वहाँ क्या है / कर रहा है। सटीक फ़ाइल जिसे आप बाहर करना चाहते हैं। क्या आप वाइल्डकार्ड के रूप में इसका उपयोग कर रहे हैं?

— सिजु वी

@StephenP, इसे इंगित करने के लिए धन्यवाद; मैंने इसका उपयोग करने ./node_modulesऔर */node_modulesइसके बीच का अंतर सीखा । मेरे मामले के लिए, जहां node_modulesकेवल निर्देशिका में मौजूद है मैं (और उस node_modulesनिर्देशिका के तहत ) खोज शुरू करता हूं, मैं उपयोग कर सकता हूं find . -type f -print -o -path "./node_modules" -prune क्योंकि node_modulesकिसी अन्य निर्देशिका के तहत निर्देशिका नहीं होगी ।

— bmacnaughton

@SijuV - उस निर्देशिका में जहां मैं खोज रहा था कि एक node_modulesउपनिर्देशिका थी, लेकिन ऐसे उपनिर्देशिकाएं भी थीं जिनके अपने स्वयं के नोड_मॉड्यूल्स थे ... वर्तमान निर्देशिका के तहत ./node_modulesकेवल उपनिर्देशिका का उपयोग करते हुए और इसे prunes; माचिस का उपयोग करना और किसी भी गहराई पर डायरेक्टरी को प्रूव करना, क्योंकि एक ग्लोब किसी भी प्रमुख पथ उपसर्ग से मेल खाता है, जैसे कि , केवल उपसर्ग ही नहीं । एक वाइल्डकार्ड है, लेकिन एक regex के रूप में नहीं एक ग्लोब के रूप में। node_modules.*/node_modules*./test5/main/node_modules./*

— स्टीफन पी

Answer 17

find . -name '*.js' -\! -name 'glob-for-excluded-dir' -prune

Comments

यह एक काम करने के लिए नहीं मिल सकता है। find ~/Projects -name '*.js' -\! -name 'node_modules' -pruneअभी भी node_modulesउनके रास्ते में फ़ाइलों को चालू कर रहा है

— एमपीपेन

@mpen, stackoverflow.com/questions/4210042/… से , मैंने सीखा कि आप जो सिंटैक्स चाहते हैं find ~/Projects -path ~/Projects/node_modules -prune -o -name '*.js' -print। उस पथ का नाम ठीक उसी तरह से मेल खाना चाहिए जो निर्देशिका प्रिंट करने के लिए जा रहा था तो वह क्या प्रिंट करेगा।

— 18

Answer 18

find -name '*.js' -not -path './node_modules/*' -not -path './vendor/*'

के रूप में ही काम करने लगता है

find -name '*.js' -not \( -path './node_modules/*' -o -path './vendor/*' \)

और IMO को याद रखना आसान है।

Answer 19

TLDR: अपनी रूट निर्देशिकाओं को समझें और -path <excluded_path> -prune -oविकल्प का उपयोग करके अपनी खोज को वहां से दूर करें । /बहिष्कृत पथ के अंत में एक अनुगामी शामिल न करें ।

उदाहरण:

find / -path /mnt -prune -o -name "*libname-server-2.a*" -print

---

प्रभावी ढंग से उपयोग करने के लिए findमुझे विश्वास है कि आपकी फाइल सिस्टम निर्देशिका संरचना की अच्छी समझ होना लाजमी है। मेरे होम कंप्यूटर पर मेरे पास मल्टी-टीबी हार्ड ड्राइव है, जिसमें से लगभग आधी सामग्री का उपयोग करके बैकअप किया गया है rsnapshot(यानी, rsync)। हालाँकि एक शारीरिक रूप से स्वतंत्र (डुप्लिकेट) ड्राइव के लिए बैक अप, यह मेरे सिस्टम रूट ( /) निर्देशिका के तहत मुहिम की जाती है /mnt/Backups/rsnapshot_backups/:

/mnt/Backups/
└── rsnapshot_backups/
    ├── hourly.0/
    ├── hourly.1/
    ├── ...
    ├── daily.0/
    ├── daily.1/
    ├── ...
    ├── weekly.0/
    ├── weekly.1/
    ├── ...
    ├── monthly.0/
    ├── monthly.1/
    └── ...

/mnt/Backups/rsnapshot_backups/निर्देशिका वर्तमान में ~ साथ 60M फ़ाइलों और फ़ोल्डरों, पर है ~ 2.9 टीबी; बस उन सामग्रियों का पता लगाने में समय लगता है:

## As sudo (#), to avoid numerous "Permission denied" warnings:

time find /mnt/Backups/rsnapshot_backups | wc -l
60314138    ## 60.3M files, folders
34:07.30    ## 34 min

time du /mnt/Backups/rsnapshot_backups -d 0
3112240160  /mnt/Backups/rsnapshot_backups    ## 3.1 TB
33:51.88    ## 34 min

time rsnapshot du    ## << more accurate re: rsnapshot footprint
2.9T    /mnt/Backups/rsnapshot_backups/hourly.0/
4.1G    /mnt/Backups/rsnapshot_backups/hourly.1/
...
4.7G    /mnt/Backups/rsnapshot_backups/weekly.3/
2.9T    total    ## 2.9 TB, per sudo rsnapshot du (more accurate)
2:34:54          ## 2 hr 35 min

इस प्रकार, कभी-कभी मुझे अपने /(रूट) विभाजन पर एक फ़ाइल की तलाश करने की आवश्यकता होती है, मुझे अपने बैकअप विभाजन को ट्रेस करने (यदि संभव हो तो) से बचने की आवश्यकता है।

---

उदाहरण

इस सूत्र में सुझाए गए विभिन्न तरीकों में से ( खोज में कमांड को बाहर करने का तरीका ), मुझे लगता है कि स्वीकृत उत्तर का उपयोग करने वाली खोजें बहुत हैं तेजी से होती हैं - कैविटीज़ के साथ।

समाधान 1

मान लीजिए कि मैं सिस्टम फ़ाइल ढूंढना चाहता हूं libname-server-2.a, लेकिन मैं अपने rsnapshotबैकअप के माध्यम से खोज नहीं करना चाहता । जल्दी से एक प्रणाली फ़ाइल ढूंढने के लिए, पथ को बाहर का उपयोग /mnt(यानी, उपयोग /mnt, नहीं /mnt/, या /mnt/Backups, या ...):

## As sudo (#), to avoid numerous "Permission denied" warnings:

time find / -path /mnt -prune -o -name "*libname-server-2.a*" -print
/usr/lib/libname-server-2.a
real    0m8.644s              ## 8.6 sec  <<< NOTE!
user    0m1.669s
 sys    0m2.466s

## As regular user (victoria); I also use an alternate timing mechanism, as
## here I am using 2>/dev/null to suppress "Permission denied" warnings:

$ START="$(date +"%s")" && find 2>/dev/null / -path /mnt -prune -o \
    -name "*libname-server-2.a*" -print; END="$(date +"%s")"; \
    TIME="$((END - START))"; printf 'find command took %s sec\n' "$TIME"
/usr/lib/libname-server-2.a
find command took 3 sec     ## ~3 sec  <<< NOTE!

... बस कुछ ही सेकंड में उस फ़ाइल को ढूँढता है, जबकि यह बहुत अधिक समय लेता है ("अपवर्जित निर्देशिका" के सभी के माध्यम से पुन: प्राप्त करने के लिए प्रकट होता है:

## As sudo (#), to avoid numerous "Permission denied" warnings:

time find / -path /mnt/ -prune -o -name "*libname-server-2.a*" -print
find: warning: -path /mnt/ will not match anything because it ends with /.
/usr/lib/libname-server-2.a
real    33m10.658s            ## 33 min 11 sec (~231-663x slower!)
user    1m43.142s
 sys    2m22.666s

## As regular user (victoria); I also use an alternate timing mechanism, as
## here I am using 2>/dev/null to suppress "Permission denied" warnings:

$ START="$(date +"%s")" && find 2>/dev/null / -path /mnt/ -prune -o \
    -name "*libname-server-2.a*" -print; END="$(date +"%s")"; \
    TIME="$((END - START))"; printf 'find command took %s sec\n' "$TIME"
/usr/lib/libname-server-2.a
find command took 1775 sec    ## 29.6 min

समाधान २

इस सूत्र में प्रस्तुत अन्य समाधान ( SO # 4210042 ) भी खराब प्रदर्शन करता है:

## As sudo (#), to avoid numerous "Permission denied" warnings:

time find / -name "*libname-server-2.a*" -not -path "/mnt"
/usr/lib/libname-server-2.a
real    33m37.911s            ## 33 min 38 sec (~235x slower)
user    1m45.134s
 sys    2m31.846s

time find / -name "*libname-server-2.a*" -not -path "/mnt/*"
/usr/lib/libname-server-2.a
real    33m11.208s            ## 33 min 11 sec
user    1m22.185s
 sys    2m29.962s

---

सारांश | निष्कर्ष

" समाधान 1 " में चित्रित दृष्टिकोण का उपयोग करें

find / -path /mnt -prune -o -name "*libname-server-2.a*" -print

अर्थात

... -path <excluded_path> -prune -o ...

यह देखते हुए कि जब भी आप अनुगामी /पथ में अनुगामी जोड़ते हैं , findतब कमांड पुनरावर्ती रूप से (उन सभी) /mnt/*निर्देशिकाओं में प्रवेश करती है - जो कि मेरे मामले में, /mnt/Backups/rsnapshot_backups/*उपनिर्देशिकाओं के कारण, इसके अलावा ~ 2.9 टीबी फ़ाइलों की खोज भी शामिल है! अनुगामी न जोड़कर/ खोज को लगभग तुरंत (सेकंड के भीतर) पूरा करना चाहिए।

"समाधान 2" ( ... -not -path <exclude path> ...) इसी तरह अपवर्जित निर्देशिकाओं के माध्यम से पुन: खोज करने के लिए प्रकट होता है - अपवर्जित मैचों को नहीं लौटाता है, लेकिन अनावश्यक रूप से उस खोज समय का उपभोग करता है।

---

उन के भीतर खोज rsnapshot बैकअप के :

मेरे प्रति घंटा / दैनिक / साप्ताहिक / मासिक rsnapshotबैकअप में से एक में फ़ाइल खोजने के लिए ):

$ START="$(date +"%s")" && find 2>/dev/null /mnt/Backups/rsnapshot_backups/daily.0 -name '*04t8ugijrlkj.jpg'; END="$(date +"%s")"; TIME="$((END - START))"; printf 'find command took %s sec\n' "$TIME"
/mnt/Backups/rsnapshot_backups/daily.0/snapshot_root/mnt/Vancouver/temp/04t8ugijrlkj.jpg
find command took 312 sec   ## 5.2 minutes: despite apparent rsnapshot size
                            ## (~4 GB), it is in fact searching through ~2.9 TB)

एक नेस्टेड निर्देशिका को छोड़कर:

यहाँ, मैं एक नेस्टेड निर्देशिका, जैसे बाहर करना चाहते हैं /mnt/Vancouver/projects/ie/claws/data/*जब से खोज /mnt/Vancouver/projects/:

$ time find . -iname '*test_file*'
./ie/claws/data/test_file
./ie/claws/test_file
0:01.97

$ time find . -path '*/data' -prune -o -iname '*test_file*' -print
./ie/claws/test_file
0:00.07

---

एक तरफ:-print कमांड के अंत में जोड़ने से बाहर की निर्देशिका के प्रिंटआउट को दबा दिया जाता है:

$ find / -path /mnt -prune -o -name "*libname-server-2.a*"
/mnt
/usr/lib/libname-server-2.a

$ find / -path /mnt -prune -o -name "*libname-server-2.a*" -print
/usr/lib/libname-server-2.a

Comments

यह फाइल के आकार को धीमा नहीं करता है find, यह निर्देशिका प्रविष्टियों की संख्या है जिसे इसकी जांच करनी चाहिए। तो यह बहुत बुरा है अगर आपके पास कई, कई छोटी फाइलें हैं (खासकर अगर वे सभी बहु-प्रकार से जुड़ी हुई हैं!) की तुलना में अगर आपके पास बस बहुत सी बहु-गीगाबाइट फाइलें हैं।

— टोबे स्पाइट

@TobySpeight: अच्छी बात है। मैंने पैमाने को इंगित करने के लिए खोज स्थान आकार का उल्लेख किया, जिसमें कई फाइलें भी हैं। रूट की एक त्वरित खोज (/) के साथ sudo ls -R / | wc -lइंगित करता है ~ 76.5M फाइलें (जिनमें से अधिकांश "गैर-कॉन्फ़िगरेशन" सिस्टम फ़ाइलों को छोड़कर समर्थित हैं); संकेत के /mnt/Vancouver/साथ ls -R | wc -l~ 2.35M फ़ाइलें; /home/victoria/जिसमें 0.668M फाइलें हैं।

— विक्टोरिया स्टुअर्ट

Answer 20

आप कुछ फ़ाइलों को शामिल करने / छोड़ने के लिए नियमित अभिव्यक्ति का उपयोग कर सकते हैं / अपनी खोज को कुछ इस तरह से उपयोग कर सकते हैं:

find . -regextype posix-egrep -regex ".*\.(js|vue|s?css|php|html|json)$" -and -not -regex ".*/(node_modules|vendor)/.*" 

यह आपको केवल js, vue, css, आदि सभी फाइल्स देगा लेकिन सभी फाइल्स node_modulesऔर vendorफोल्डर्स को छोड़कर ।

Answer 21

मैं findफ़ाइलों की एक सूची प्रदान करने के लिए उपयोग कर रहा था xgettext, और एक विशिष्ट निर्देशिका और इसकी सामग्री को छोड़ना चाहता था। मैंने -pathसंयुक्त के कई क्रमपरिवर्तन की कोशिश की, -pruneलेकिन उस निर्देशिका को पूरी तरह से बाहर करने में असमर्थ था जो मैं चाहता था।

हालाँकि मैं उस निर्देशिका की सामग्री को अनदेखा करने में सक्षम था जिसे मैंने अनदेखा कर दिया था, findफिर उस परिणाम के रूप में निर्देशिका को स्वयं वापस कर दिया , जिसके कारणxgettext परिणामस्वरूप दुर्घटना (निर्देशिका को स्वीकार नहीं करता; केवल फाइलें)।

मेरा समाधान केवल grep -vउस निर्देशिका को छोड़ने के लिए उपयोग करना था जिसे मैं परिणामों में नहीं चाहता था:

find /project/directory -iname '*.php' -or -iname '*.phtml' | grep -iv '/some/directory' | xargs xgettext

find100% काम करेगा या नहीं, इसके लिए एक तर्क है , मैं निश्चित रूप से नहीं कह सकता। grepकुछ सिरदर्द के बाद त्वरित और आसान समाधान का उपयोग करना था।

Answer 22

पिछले उत्तरों में से कोई भी उबंटू पर अच्छा नहीं है। इसे इस्तेमाल करे:

find . ! -path "*/test/*" -type f -name "*.js" ! -name "*-min-*" ! -name "*console*"

मैंने इसे यहां पाया है

Comments

मुझे कोई कारण नहीं दिखता कि 100 से अधिक अंकों के साथ कोई भी उत्तर उबंटू पर काम न करे।

— एक्सल बेकेर्ट

mmm चलो देखते हैं? शायद इसलिए कि मैंने उन सभी की कोशिश की?

— छह्रो

सभी लिनक्स वितरणों पर हर जगह समान कार्यान्वयन है - GNU प्रोजेक्ट से। केवल अंतर संस्करणों हो सकता है। लेकिन पिछले एक दशक में परिवर्तन उस आक्रामक नहीं थे, शायद अनुमति मिलान के अलावा।

— एक्सल बेकर्ट

Answer 23

यह मेरे लिए मैक पर उपयुक्त है:

find . -name *.php -or -path "./vendor" -prune -or -path "./app/cache" -prune

यह बाहर निकाल देगा vendorऔर app/cacheखोज का नाम है जिसके साथ प्रत्यय के लिए dir php।

Comments

बेहतर '* .php' के आसपास एकल उद्धरण या आप क्या आप के लिए देख रहे हैं खोजने के लिए नहीं जा रहे हैं।

— Br.Bill

Answer 24

यूनिक्स के पुराने संस्करणों पर आप में से जो उपयोग नहीं कर सकते हैं, जो के लिए -path या -not

SunOS 5.10 bash 3.2 और SunOS 5.11 bash 4.4 पर परीक्षण किया गया

find . -type f -name "*" -o -type d -name "*excluded_directory*" -prune -type f

Comments

निर्दिष्ट निर्देशिका से अधिक पारित कर सकता है।

— MUY बेल्जियम

Answer 25

कैसे-का-उपयोग-prune-option-of-find-of-sh लारेंस Gonsalves द्वारा कैसे -pruneकाम करता है पर एक उत्कृष्ट जवाब है ।

और यहाँ जेनेरिक समाधान है:

find /path/to/search                    \
  -type d                               \
    \( -path /path/to/search/exclude_me \
       -o                               \
       -name exclude_me_too_anywhere    \
     \)                                 \
    -prune                              \
  -o                                    \
  -type f -name '*\.js' -print

/path/to/seach/कई बार टाइपिंग से बचने के लिए find, एक pushd .. popdजोड़ी में लपेटें ।

pushd /path/to/search;                  \
find .                                  \
  -type d                               \
    \( -path ./exclude_me               \
       -o                               \
       -name exclude_me_too_anywhere    \
     \)                                 \
    -prune                              \
  -o                                    \
  -type f -name '*\.js' -print;         \
 popd

Comments

से stackoverflow.com/questions/4210042/... , मुझे पता चला कि के लिए इस्तेमाल किया वाक्य रचना -pathऐसा नाम है जो मिल जाए ऐसा निर्देशिका मुद्रित करने के लिए थे प्रिंट होता है, उदाहरण के लिए, से मेल खाना चाहिए find . -path ./.git -prune -o -print, या find $HOME/foo -path $HOME/foo/.git -prune -o -print जवाब में से कुछ सिर्फ इतना कहना -path somedirजो दुर्भाग्य है उपयोगी होने के लिए पर्याप्त सटीक नहीं है।

— 18

Answer 26

जिस चीज के लिए मुझे इसकी आवश्यकता थी वह इस तरह काम करती है, landscape.jpgसभी सर्वर को रूट से शुरू करना और /varनिर्देशिका में खोज को बाहर करना :

find / -maxdepth 1 -type d | grep -v /var | xargs -I '{}' find '{}' -name landscape.jpg

find / -maxdepth 1 -type dमें सभी डी अप्रत्यक्ष सूची/

grep -v /var सूची से `/ var 'को बाहर करता है

xargs -I '{}' find '{}' -name landscape.jpgfindसूची से प्रत्येक निर्देशिका / परिणाम के साथ किसी भी कमांड को निष्पादित करें

Comments

एक सेकंड रुको, /अभी तक बाहर नहीं किया गया है। आपको जरूरत पड़ सकती है sed 1d।

— Simba

Answer 27

निम्नलिखित आदेश काम करते हैं:

find . -path ./.git -prune -o -print

यदि आपको खोजने में कोई समस्या है, -D treeतो अभिव्यक्ति विश्लेषण जानकारी देखने के लिए विकल्प का उपयोग करें।

find -D tree . -path ./.git -prune -o -print

या -D all, सभी निष्पादन जानकारी देखने के लिए।

find -D all . -path ./.git -prune -o -print

Answer 28

मुझे C स्रोतों फ़ाइलों में * .o और बहिष्कृत * .swp और बहिष्कृत (नियमित फ़ाइल नहीं) और इस आदेश के साथ dir आउटपुट बाहर करने के लिए फ़ंक्शन का नाम मिला:

find .  \( ! -path "./output/*" \) -a \( -type f \) -a \( ! -name '*.o' \) -a \( ! -name '*.swp' \) | xargs grep -n soc_attach

Answer 29

लूप की execतुलना में क्रिया का बेहतर उपयोग करें for:

find . -path "./dirtoexclude" -prune \
    -o -exec java -jar config/yuicompressor-2.4.2.jar --type js '{}' -o '{}' \;

exec ... '{}' ... '{}' \;ब्रेसिज़ की जगह हर मिलान फ़ाइल के लिए एक बार निष्पादित किया जाएगा, '{}'वर्तमान फ़ाइल नाम के साथ।

ध्यान दें कि ब्रेस एकल उद्धरण चिह्नों में संलग्न हैं, उन्हें व्याख्या से बचाने के लिए शेल स्क्रिप्ट विराम चिह्न ^* ।

---

टिप्पणियाँ

^*find (GNU findutils) 4.4.2 मैन पेज के EXAMPLES सेक्शन से

Comments

बहुत पुराना सवाल है, लेकिन अभी भी सुधार के लिए कमरे के साथ। मैंने इसे समान समस्या को हल करने का प्रयास करके पाया, और कोई भी उत्तर संतोषजनक नहीं था।

— अल्बर्टो

मैं execअक्सर कार्रवाई का उपयोग करता हूं और इसे बहुत उपयोगी पाता हूं । मैं आमतौर पर उस {}मामले के बीच उद्धरण जोड़ता हूं जब फ़ाइल पथ में रिक्त स्थान होते हैं जो देता है "{}"।

— लुडोविक क्रूट

@lkuty मैं आपकी टिप्पणी को प्रतिबिंबित करने के लिए अपनी पोस्ट को संपादित करने वाला था, लेकिन एक त्वरित परीक्षण के बाद (उद्धृत किए बिना, {}उनके नाम पर व्हाट्सएप के साथ फाइलों के लिए काम करता है) और मैन पेजों पर एक नज़र, ऐसा लगता है कि उद्धरण केवल बचने के लिए आवश्यक है उन्हें शेल स्क्रिप्ट विराम चिह्न के रूप में गलत समझा जा सकता है। इस मामले में, आप एकल उद्धरण का उपयोग करेंगे:'{}'

— अल्बर्टो

मुझे लगता है कि मैं इसे बनाने के लिए इस्तेमाल किया था cpया mvया rm। मैं इसे बाहर की जाँच करूँगा

— लुडोविक क्यूट

Answer 30

मैंने ऊपर कमांड की कोशिश की, लेकिन "-प्र्यून" का उपयोग करने वालों में से कोई भी मेरे लिए काम नहीं करता है। आखिरकार मैंने नीचे कमांड के साथ इसे आजमाया:

find . \( -name "*" \) -prune -a ! -name "directory"