Förstå alternativet -exec för `hitta`

find . -name "FILENAME" -exec rm {} \; 

Detta svar finns i följande delar:

• Grundläggande användning av -exec
• Användning av -exec i kombination med sh -c
• Med -exec ... {} +
• Användning av -execdir

---

Grundläggande användning av -exec

Alternativet -exec tar ett externt verktyg med valfria argument som argumentet och kör det.

Om strängen {} finns någonstans i det givna kommandot kommer varje förekomst av den att ersättas med sökvägen som för närvarande behandlas ( t.ex. ./some/path/FILENAME). I de flesta skal behöver de två tecknen {} inte citeras.

Kommandot måste avslutas med en ; för find för att veta var det slutar (eftersom det kan finnas fler alternativ efteråt s). För att skydda ; från skalet måste det citeras som \; eller ";" annars kommer skalet att se det som slutet på find -kommandot.

Exempel (\ slutet på de två första raderna är bara för linjefortsättningar):

find . -type f -name "*.txt" \ -exec grep -q "hello" {} ";" \ -exec cat {} ";" 

Detta hittar alla vanliga filer (-type f) vars namn matchar mönstret *.txt i eller under den aktuella katalogen. Det kommer sedan att testa om strängen hello förekommer i någon av de hittade filerna med grep -q (som inte ger någon utdata, bara en utgång status). För de filer som innehåller strängen kommer cat att köras för att mata ut innehållet i filen till terminalen.

Varje -exec fungerar också som ett ”test” på sökvägarna som hittats av find, precis som -type och -name gör det. Om kommandot returnerar en nollutgångsstatus (vilket betyder ”framgång”) beaktas nästa del av find -kommandot, annars tas find kommandot fortsätter med nästa sökväg. Detta används i exemplet ovan för att hitta filer som innehåller strängen hello, men för att ignorera alla andra filer.

Ovanstående exempel illustrerar de två vanligaste användningarna fall av -exec:

1. Som ett test för att ytterligare begränsa sökningen.
2. Att utföra någon form av åtgärd på den hittade sökväg (vanligtvis men inte nödvändigtvis i slutet av find -kommandot).

---

Använd -exec i kombination med sh -c

Kommandot som -exec kan utföra är begränsat till ett externt verktyg med valfria argument.Att använda inbyggda skal, funktioner, villkor, rörledningar, omdirigeringar etc. direkt med -exec är inte möjligt, om inte inslagna i något som en sh -c underskal.

Om bash -funktioner krävs, använd sedan bash -c istället för sh -c.

sh -c kör /bin/sh med ett skript på kommandoraden, följt av valfria kommandoradsargument till det skriptet.

Ett enkelt exempel på att använda sh -c i sig själv utan find :

sh -c "echo "You gave me $1, thanks!"" sh "apples" 

Detta skickar två argument till det underordnade skalskriptet. Dessa kommer att placeras i $0 och $1 för att manuset ska kunna användas.

1. The sträng sh. Detta kommer att finnas tillgängligt som $0 inuti skriptet, och om det interna skalet matar ut ett felmeddelande kommer det att förpeka det med den här strängen.

2. Argumentet apples är tillgängligt som $1 i skriptet, och om det hade funnits fler argument hade dessa varit tillgängliga som $2, $3 etc. De skulle också vara tillgängliga i listan "$@" $0 som inte skulle vara en del av "$@").

Detta är användbart i kombination med -exec eftersom det tillåter oss att skapa godtyckligt komplexa skript som verkar på sökvägarna som hittas av find.

Exempel: Hitta alla vanliga filer som har ett visst filnamnssuffix och ändra det filnamnssuffixet till något annat suffix, där suffixen förvaras i variabler:

from=text # Find files that have names like something.text to=txt # Change the .text suffix to .txt find . -type f -name "*.$from" -exec sh -c "mv "$3" "${3%.$1}.$2"" sh "$from" "$to" {} ";" 

Inuti integrationen rnalt skript, $1 skulle vara strängen text, $2 skulle vara strängen txt och $3 skulle vara vad sökvägen find har hittat för oss. Parameterutvidgningen ${3%.$1} tar sökvägen och tar bort suffixet .text från den.

Eller med dirname / basename:

find . -type f -name "*.$from" -exec sh -c " mv "$3" "$(dirname "$3")/$(basename "$3" ".$1").$2"" sh "$from" "$to" {} ";" 

eller med tillagda variabler i internt skript:

find . -type f -name "*.$from" -exec sh -c " from=$1; to=$2; pathname=$3 mv "$pathname" "$(dirname "$pathname")/$(basename "$pathname" ".$from").$to"" sh "$from" "$to" {} ";" 

Observera att variablerna from och i underskalet skiljer sig från variablerna med samma namn i det externa skriptet.

Ovanstående är det rätta sättet att anropa ett godtyckligt komplext skript från -exec med find. Att använda find i en slinga som

for pathname in $( find ... ); do 

är felbenägen och inelegant (personlig åsikt). Det delar upp filnamn på mellanslag, åberopar filnamn globbing och tvingar också skalet att expandera det fullständiga resultatet av find innan du till och med kör den första iterationen av slingan.

Se också:

• Varför är looping över hitta ’ s utgång dålig praxis?
• Är det möjligt att använda `hitta -exec sh -c` säkert?

---

Med -exec ... {} +

; i slutet kan ersättas med +. Detta gör att find kör det givna kommandot med så många argument (hittade sökvägar) som möjligt snarare än en gång för varje hittat sökväg. Strängen {} måste förekomma precis innan + för att detta ska fungera .

find . -type f -name "*.txt" \ -exec grep -q "hello" {} ";" \ -exec cat {} + 

Här samlar find de resulterande sökvägarna och kör cat på så många av dem som möjligt samtidigt.

find . -type f -name "*.txt" \ -exec grep -q "hello" {} ";" \ -exec mv -t /tmp/files_with_hello/ {} + 

På samma sätt kommer mv att utföras som några gånger som möjligt. Det sista exemplet kräver GNU mv från coreutils (som stöder alternativet -t).

Använd -exec sh -c ... {} + är också ett effektivt sätt att slingra över en uppsättning söknamn med ett godtyckligt komplext skript.

Grunderna är desamma som när du använder -exec sh -c ... {} ";", men skriptet tar nu en mycket längre lista med argument. Dessa kan slingras genom att slingra över "$@" inuti skriptet.

Vårt exempel från det sista avsnittet som ändrar filnamnssuffix: ”b398bedbfe”>

find . -type f -name "*.txt" \ -execdir mv {} done-texts/{}.done \; 

find . -type f -name "*.txt" -exec sh -c " for name do mv "$name" "$( dirname "$name" )/done-texts/$( basename "$name" ).done" done" sh {} + 

find . -type f -name "*.txt" -exec sh -c " for name do mv "$name" "${name%/*}/done-texts/${name##*/}.done" done" sh {} +