සොයාගැනීමේදී නාමාවලිය බැහැර කරන්නේ කෙසේද. විධානය

මම findසියලු ජාවාස්ක්‍රිප්ට් ලිපිගොනු සඳහා විධානයක් ක්‍රියාත්මක කිරීමට උත්සාහ කරමි , නමුත් විශේෂිත නාමාවලියක් බැහැර කරන්නේ කෙසේද?

මෙන්න findඅපි භාවිතා කරන කේතය.

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

-pruneස්විචය භාවිතා කරන්න . උදාහරණයක් ලෙස, ඔබට miscනාමාවලිය බැහැර කිරීමට අවශ්‍ය නම් -path ./misc -prune -oඔබේ සොයා ගැනීමේ විධානයට a එක් කරන්න:

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

බහුවිධ නාමාවලි සහිත උදාහරණයක් මෙන්න:

find . -type d \( -path dir1 -o -path dir2 -o -path dir3 \) -prune -false -o -name '*.txt'

මෙහිදී අපි වත්මන් නාමාවලියෙහි ./dir1 , ./dir2 සහ ./dir3 බැහැර කරමු , මන්ද findප්‍රකාශනවල එය නිර්ණායක මත ක්‍රියා කරන ක්‍රියාවක් වන බැවින් -path dir1 -o -path dir2 -o -path dir3( dir1 හෝ dir2 හෝ dir3 නම් ), ANDed සමඟ type -d.

ඕනෑම මට්ටමකින් නාමාවලි නාමය බැහැර කිරීමට, භාවිතා කරන්න -name:

find . -type d \( -name node_modules -o -name dir2 -o -path name \) -prune -false -o -name '*.json'

ඔබ -pruneවෙනුවෙන් වැඩ නොකරන්නේ නම් , මෙය:

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

Caveat: සියලු අනවශ්‍ය නාමාවලි හරහා ගමන් කිරීම අවශ්‍ය වේ.

වෙනත් යෝජිත විසඳුම් වලට වඩා පහත සඳහන් කරුණු තර්ක කිරීම පහසු යැයි මට පෙනේ:

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ක්‍රියා කරන ආකාරය නම්, එය ලඟා වූ පසු, එම නාමාවලියට පහළින් ඇති ගොනු ස්ථිරවම නොසලකා හරිනු ලැබේ.

මෙය සත්‍ය භාවිත නඩුවකින් පැමිණේ, එහිදී මට ශීත m තු විසින් ජනනය කරන ලද සමහර ලිපිගොනු සඳහා යූ-කොම්ප්‍රෙෂර් ඇමතීමට අවශ්‍ය විය, නමුත් එවිය යුතු වෙනත් ලිපිගොනු අතහැර දමන්න.

සටහන [1] : ඔබට බැහැර කිරීමට අවශ්‍ය නම් /tmp/foo/barසහ ඔබ මේ ආකාරයට සොයාගතහොත් " find /tmp \(..." ඔබ සඳහන් කළ යුතුය -path /tmp/foo/bar. අනෙක් අතට ඔබ දුවන්නේ මේ ආකාරයට cd /tmp; find . \(...නම් ඔබ සඳහන් කළ යුතුය -path ./foo/bar.

නාමාවලිය මඟ හැරීම සඳහා වඩාත් කැමති වාක්‍ය ඛණ්ඩය කුමක් විය යුතුද යන්න පිළිබඳව මෙහි යම් ව්‍යාකූලතාවයක් ඇත.

GNU මතය

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

GNU වෙතින් man පිටුව සොයා ගන්න

තර්කනය

-prunefindනාමාවලියකට බැසීම නතර කරයි. නියම කිරීම -not -pathතවමත් මඟ හැරුණු නාමාවලියට බැස යනු ඇත , නමුත් සෑම ගොනුවක්ම පරීක්ෂා කරන සෑම -not -pathවිටම එය අසත්‍ය findවේ.

සමඟ ගැටළු -prune

-prune එය අදහස් කරන දේ කරයි, නමුත් එය භාවිතා කිරීමේදී ඔබ සැලකිලිමත් විය යුතු සමහර දේවල් තවමත් පවතී.

1. find කප්පාදු කළ නාමාවලිය මුද්‍රණය කරයි.

   • සත්‍යය එය අපේක්ෂිත හැසිරීමයි, එය එයට බැස නොයයි. නාමාවලිය මුලුමනින්ම මුද්‍රණය නොකිරීමට, තර්කානුකූලව මඟ හැරුණු සින්ටැක්ස් භාවිතා කරන්න.

2. -pruneපමණක් ක්‍රියා කරන -printඅතර වෙනත් ක්‍රියා නොමැත.

   • සත්‍ය නොවේ . -pruneහැර වෙනත් ඕනෑම ක්‍රියාවක් සමඟ ක්‍රියා කරයි -delete. මකාදැමීම සමඟ එය ක්‍රියා නොකරන්නේ ඇයි? සඳහා -deleteවැඩ කිරීමට, සිට, DFS පිණිස බහලුම තරණය කිරීමට අවශ්යතා සොයා -deleteපළමු, කොළ, දෙමාපියන්, පසුව කොළ මකා ආදිය ඇත ... නමුත් නියම සඳහා -pruneතේරුමක් කිරීමට, findඑය බැස නාමාවලියක් හා නැවතුම් පහර කිරීමට අවශ්ය, වන පැහැදිලිවම -depthහෝ සමඟ කිසිදු තේරුමක් නැත -delete.

කාර්ය සාධනය

මෙම ප්‍රශ්නයට ඉහළින් ඉහළට ඔසවා ඇති පිළිතුරු තුන පිළිබඳ සරල පරීක්ෂණයක් මම සකස් කළෙමි ( වෙනත් ක්‍රියාකාරී උදාහරණයක් පෙන්වීමට ආදේශ -printකර -exec bash -c 'echo $0' {} \;ඇත). ප්‍රති Results ල පහතින්

----------------------------------------------
# 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, මීටර් 865 ක් ගතවිය. ඉතින්, ඔව් මෙය තරමක් ආන්තික උදාහරණයකි, නමුත් ඔබ ධාවන කාලය ගැන සැලකිලිමත් වන අතර දුරස්ථව දැඩි ලෙස යමක් කරන්නේ නම් ඔබ භාවිතා කළ යුතුය -prune.

සටහන ඩැනියෙල් සී. සොබ්රාල්ගේ වාක්‍ය ඛණ්ඩය වාක්‍ය දෙකෙන් වඩා හොඳ -pruneප්‍රති performed ල ලබා දුන්නේය . නමුත්, මම තදින්ම සැක කරන්නේ මෙය යම් හැඹිලියක ප්‍රති the ලය ප්‍රතිවිරුද්ධ ප්‍රති result ලයට හේතු වූ අතර, කප්පාදු නොකරන ලද අනුවාදය සැමවිටම මන්දගාමී විය.

පරීක්ෂණ පිටපත

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

මට වැඩ කළ එකම එක මෙයයි.

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

"නාමාවලිය" හැර "MyFile" සඳහා සෙවීම. තරු අවධාරණය කරන්න *.

එක් විකල්පයක් වනුයේ grep සමඟ නාමාවලි නාමය අඩංගු සියලුම ප්‍රති results ල බැහැර කිරීමයි. උදාහරණයක් වශයෙන්:

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

මම -notඅංකනයට කැමතියි ... එය වඩාත් කියවිය හැකි ය:

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

-Pruune විකල්පය භාවිතා කරන්න. ඉතින්, වැනි දෙයක්:

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

'-Type d -name proc -prune' බැහැර කිරීම සඳහා proc නම් නාමාවලි පමණක් සොයයි.
'-O' යනු 'හෝ' ක්‍රියාකරුවෙකි.

-pruneනියත වශයෙන්ම ක්‍රියාත්මක වන අතර හොඳම පිළිතුර එය බැහැර කිරීමට අවශ්‍ය ඩිරයට බැස යාම වළක්වන බැවිනි. -not -pathඑය තවමත් බැහැර කරන ලද ඩර් සොයන අතර, එය ප්‍රති result ලය මුද්‍රණය නොකරයි, බැහැර කරන ලද ඩර් ජාල පරිමාව සවිකර තිබේ නම් හෝ ඔබට අවසර නොදෙන්නේ නම් එය ගැටළුවක් විය හැකිය.

උපක්‍රමශීලී කොටස නම් 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

සමහර මාර්ග බැහැර කිරීමට මා භාවිතා කළ ආකෘතිය මෙයයි:

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

". *" මාර්ගවල නොමැති සියලුම ගොනු සොයා ගැනීමට මම මෙය භාවිතා කළෙමි:

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

-Path -prune ප්‍රවේශය ද මාර්ගයේ ඇති ආදේශක කාඩ්පත් සමඟ ක්‍රියා කරයි. 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 \)  

බහු නාමාවලි බැහැර කිරීම සඳහා:

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

නාමාවලි එක් කිරීමට, එකතු කරන්න -o -path "./dirname/*":

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

බැහැර කිරීම සඳහා බොහෝ නාමාවලි තිබේ නම් සමහර විට ඔබ සාමාන්‍ය ප්‍රකාශනයක් භාවිතා කළ යුතුය .

හොඳ පිළිතුරු ඕනෑ තරම් තිබේ, විධානයේ සෑම අංගයක් සඳහාම සහ එය පිටුපස ඇති තර්කනය තේරුම් ගැනීමට මට යම් කාලයක් ගත විය.

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

සොයා ගැනීම වත්මන් නාමාවලියෙහි ගොනු සහ නාමාවලි සොයා ගැනීම ආරම්භ කරනු ඇත, එබැවින් find ..

මෙම -oවිකල්පය, තාර්කික සඳහා කි්රයා හෝ හා විධානය කොටස් දෙකක් වෙන්:

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

./Misc නාමාවලිය නොවන ඕනෑම ඩිරෙක්ටරියක් හෝ ගොනුවක් පළමු පරීක්ෂණයෙන් සමත් නොවේ -path ./misc. නමුත් දෙවන ප්රකාශනයට එරෙහිව ඒවා පරීක්ෂා කරනු ලැබේ. ඔවුන්ගේ නම *.txtමුද්‍රණය වන රටාවට අනුරූප වන්නේ නම්-printවිකල්පය .

සොයා ගැනීම ./misc බහලුම වෙත ළඟා වූ විට, මෙම නාමාවලිය තෘප්තිමත් වන්නේ පළමු ප්‍රකාශනය පමණි. එබැවින් -pruneවිකල්පය එයට අදාළ වේ. එම නාමාවලිය ගවේෂණය නොකරන ලෙස එය සෙවුම් විධානයට පවසයි . එබැවින් ./misc හි ඇති ඕනෑම ගොනුවක් හෝ නාමාවලියක් සොයා ගැනීමෙන් පවා ගවේෂණය නොකෙරේ, ප්‍රකාශනයේ දෙවන කොටසට එරෙහිව පරීක්ෂා නොකෙරෙන අතර මුද්‍රණය නොකෙරේ.

වැඩ කරන විසඳුමක් සඳහා (උබුන්ටු 12.04 (නිරවද්‍ය පැන්ගෝලින්) මත පරීක්ෂා කර ඇත) ...

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

dir1 උප ෆෝල්ඩරය හැර වත්මන් ෆෝල්ඩරයේ සහ උප ෆෝල්ඩර වල MP3 ගොනු සොයනු ඇත.

භාවිත:

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

... dir1 සහ dir2 බැහැර කිරීමට

මෙම අනුමැතිය ලබාදුන් බහලුම් මුද්රණය ගැනීම සඳහා වන හොඳ උපක්රමය භාවිතා කිරීමයි -print(සඳහා ක්රියා -execඇති දකුණු පැත්තේ පසු මෙන්ම) -orපසු -prune. උදාහරණයක් වශයෙන්, ...

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

වත්මන් ඩිරෙක්ටරියට යටින් ඇති සියලුම ලිපිගොනු වල මාර්ගය “.j2” දිගුව සමඟ මුද්‍රණය කරනු ඇත, සියලු සැඟවුණු නාමාවලි මඟහරිනු ඇත. පිළිවෙලින් එය මුද්‍රණය කරනු ඇත. පහත දැක්වෙන්නේ නැත, ...

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

තාර්කිකව ක්‍රියාකරුට -andපසුව -inameසහ මුද්‍රණයට පෙර සැඟවී ඇති බැවිනි . -orමෙහෙයුම්වල බූලියන් අනුපිළිවෙල සහ ආශ්‍රිතතාවය හේතුවෙන් මෙය වගන්තියේ දකුණු කොටසට බැඳේ. නමුත් -print(හෝ එහි ous ාති සහෝදරයන්ගෙන් කිසිවෙකු ... -print0, ආදිය) නිශ්චිතව දක්වා නොමැති නම් සැඟවුණු බව ලේඛනය පවසයි . ඉතින් -orමුද්‍රණයේ වම් කොටස නොවන්නේ ඇයි ? පෙනෙන විදිහට (සහ මගේ පළමු පිටුව කියවීමෙන් මට මෙය තේරුණේ නැත), එය සත්‍යයකි, විස්තරාත්මක ක්‍රියාකරුවන් පමණක් නොමැති නම් පෙනෙන පරිදි කිසිවක් නොකරනු ඇත, එබැවින් එය අර්ථවත් යැයි මම සිතමි. ඉහත සඳහන් කළ පරිදි, මේ සියල්ල ද ක්‍රියාත්මක වේ, එබැවින් පහත දැක්වෙන්නේ අපේක්ෂිත දිගුව සමඟ එක් එක් ගොනුව සඳහා සම්පූර්ණ ලැයිස්තුවක් ලබා දෙයි , නමුත් එක් එක් සැඟවුණු නාමාවලියෙහි පළමු මට්ටම ලැයිස්තුගත නොකිරීම, ...-print හෝ හෝ-exec අවස්ථාවකදී, මුද්‍රණය තාර්කිකව සෑම දෙයක්ම මුද්‍රණය වන පරිදි ඉසිනු ලැබේ. එකක් වුවදprint කිසිදු වගන්තියක ශෛලීය ක්‍රියාකාරිත්වයක් , එම සැඟවුණු තාර්කික සියල්ල ඉවත්ව යන අතර ඔබට ලැබෙන්නේ ඔබ සඳහන් කළ දේ පමණි. දැන් අවංකවම, මම එය වෙනත් ආකාරයකින් කැමති වන්නට ඇත, නමුත් පසුව අfind-execls -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 + වන පිළිතුර කියවා ඡන්දය ප්‍රකාශ කිරීම කිසිවෙකුට අපහසු යැයි පෙනුනත්, මෙය උපකාරී වනු ඇතැයි මම බලාපොරොත්තු වෙමි, නමුත් කෙනෙකුට බලාපොරොත්තු විය හැකිය. :-)

මෙය සාක්ෂාත් කර ගැනීම සඳහා ඔබට කප්පාදු විකල්පය භාවිතා කළ හැකිය. උදාහරණයක් ලෙස:

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

හෝ ප්‍රතිලෝම grep “grep -v” විකල්පය:

find -iname example.com | grep -v beta

ඔබට ලිනක්ස් සෙවුම් විධානයෙන් සවිස්තරාත්මක උපදෙස් සහ උදාහරණ සොයාගත හැකිය .

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

සමහර ලිපිගොනු ඇතුළත් කිරීමට / බැහැර කිරීමට ඔබට නිත්‍ය ප්‍රකාශන භාවිතා කළ හැකිය.

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

මෙම පමණක් ඔබ සියලු JS, VUE, CSS, ආදිය ගොනු දෙන්න නමුත් සියලු ගොනු හැර ඇත node_modulesහා vendorෆෝල්ඩර.

පෙර පිළිතුරු කිසිවක් උබුන්ටු වල හොඳ නැත. මේක උත්සාහ කරන්න:

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

මම මෙය මෙහි සොයාගෙන ඇත

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

පෙනෙන ආකාරයටම ක්‍රියා කරයි

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

සහ IMO මතක තබා ගැනීම පහසුය.

ටීඑල්ඩීආර්:-path <excluded_path> -prune -o විකල්පය භාවිතා කර ඔබේ මූල නාමාවලි තේරුම් ගෙන එතැන් සිට ඔබේ සෙවුම සකස් කරන්න . /බැහැර කරන ලද මාර්ගය අවසානයේ පසුපසින් ඇතුළත් නොකරන්න .

උදාහරණයක්:

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

Effectively ලදායී ලෙස භාවිතා කිරීම සඳහා findඔබේ ගොනු පද්ධති නාමාවලි ව්‍යුහය පිළිබඳ මනා අවබෝධයක් තිබීම අත්‍යවශ්‍ය බව මම විශ්වාස කරමි. මගේ නිවසේ පරිගණකයේ මා සතුව බහු-ක්ෂය දෘ hard තැටි ඇත, එම අන්තර්ගතයෙන් අඩක් පමණ උපස්ථ කර ඇත 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

විසඳුම 2

මෙම ත්‍රෙඩ් එකේ ඉදිරිපත් කර ඇති අනෙක් විසඳුම ( 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 TB ලිපිගොනු ඇතුළත් වේ! පසුපසින් නොපැමිණීමෙන් /සෙවීම වහාම පාහේ සම්පූර්ණ විය යුතුය (තත්පර කිහිපයකින්).

"විසඳුම 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

මම findලිපිගොනු ලැයිස්තුවක් සැපයීමට භාවිතා කළ xgettextඅතර නිශ්චිත නාමාවලියක් සහ එහි අන්තර්ගතය මඟ හැරීමට අවශ්‍ය විය. මම -pathඒකාබද්ධව බොහෝ ප්‍රේරණයන් උත්සාහ කළ -pruneනමුත් මට අවශ්‍ය නාමාවලිය සම්පූර්ණයෙන් බැහැර කිරීමට නොහැකි විය.

මට නොසලකා හැරීමට අවශ්‍ය නාමාවලියෙහි අන්තර්ගතය නොසලකා හැරීමට මට හැකි වුවද, ප්‍රති the ලවලින්find එකක් ලෙස නාමාවලිය නැවත ලබා දෙන ලදී.xgettext ප්‍රති result ලයක් ලෙස බිඳ වැටීමට හේතු විය (ඩිරෙක්ටරි භාර නොගනී; ගොනු පමණක්).

මගේ විසඳුම වූයේ grep -vප්‍රති results ල වලදී මට අවශ්‍ය නොවූ නාමාවලිය මඟ හැරීම සඳහා භාවිතා කිරීමයි:

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

ඒ සඳහා තර්කයක් තිබේද නැද්ද යන්න find100% ක්ම ක්‍රියාත්මක වේ, මට නිශ්චිතවම පැවසිය නොහැක. grepයම් හිසරදයකින් පසු භාවිතා කිරීම ඉක්මන් හා පහසු විසඳුමක් විය.

මෙය මැක්හි මට සුදුසු ය:

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

එය ඉවත් කරනු ඇත vendorහා app/cacheසමග භා තා කරන සෝදිසි නම සඳහා හිස් තීරුවෙහි php.

භාවිතා කළ නොහැකි වූ යුනික්ස් පැරණි අනුවාද මත ඔබ අයට -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

කෙසේද-භාවිතා කරන්නේ-කප්පාදු-විකල්පය-සොයා ගැනීම- ෂෝ හි ලෝරන්ස් ගොන්සාල්වෙස්ගේ විශිෂ්ට පිළිතුරකි-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

මට අවශ්‍ය දේ සඳහා මෙය ක්‍රියාත්මක landscape.jpgවූයේ, මුල සිට ආරම්භ වන සියලුම සේවාදායකයන් සොයා ගැනීම සහ /varනාමාවලියෙහි සෙවීම බැහැර කිරීම :

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

find / -maxdepth 1 -type dසියලුම d නාමාවලි ලැයිස්තුගත කරයි/

grep -v /var `/ var 'ලැයිස්තුවෙන් බැහැර කරයි

xargs -I '{}' find '{}' -name landscape.jpgfindලැයිස්තුවෙන් එක් එක් නාමාවලිය / ප්‍රති result ල මෙන් ඕනෑම විධානයක් ක්‍රියාත්මක කරන්න

පහත දැක්වෙන විධානයන් ක්‍රියාත්මක වේ:

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

සී ප්‍රභව ලිපිගොනු වල ශ්‍රිත නාමය * .o සහ බැහැර කරන්න.

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

ලූපයට වඩා execක්‍රියාව භාවිතා කිරීම වඩා හොඳය for:

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

මෙම exec ... '{}' ... '{}' \;වන සඟල වෙනුවට, සෑම ගැලපෙන ගොනුව සඳහා එක් වරක් ක්රියාත්මක කරනු ලැබේ '{}'වර්තමාන ගොනුව නම සමඟ.

ෂෙල් තිර රචනය විරාම ලෙස අර්ථ ඔවුන් ආරක්ෂා කිරීමට සඟල තනි උපුටා ලකුණු බහා ඇති බව දැනුම් ^* .

සටහන්

^* Man find (GNU findutils) 4.4.2පිටුවේ EXAMPLES කොටසේ සිට

මම ඉහත විධානය උත්සාහ කළෙමි, නමුත් "-ප්රූන්" භාවිතා කරන කිසිවෙකු මට වැඩ නොකරයි. අවසානයේදී මම පහත විධානයෙන් මෙය අත්හදා බැලුවෙමි:

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