Automatizált nagytakarítás: Így törölj rekurzívan fájlokat név alapján egy mappából AutoIt segítségével!

Ahányan vagyunk, annyian ismerjük azt az érzést, amikor a számítógépünk merevlemeze lassanként megtelik, vagy éppen egy adott projekt mappájában hemzsegnek a felesleges, ideiglenes vagy elavult állományok. Ezek az apró digitális porcicák, amelyek egyenként talán nem jelentenek sokat, de felhalmozódva komoly fejfájást okozhatnak. Lassuló rendszer, nehezen átlátható struktúra, és persze a bosszantó „nincs elég hely” üzenetek. Ilyenkor jönne jól egy alapos, mélyreható takarítás, nem igaz? De mi van, ha ezt a takarítást nem nekünk kell elvégeznünk, hanem egy okos programra bízhatjuk? Mi van, ha ez a program az AutoIt, és mi magunk szabhatjuk meg, mit, hol és hogyan tüntessen el? A következőkben pont erről lesz szó: hogyan hozhatunk létre egy hatékony AutoIt scriptet, amely rekurzívan, azaz az almappákba is benyúlva, töröl specifikus névvel rendelkező fájlokat. Készülj fel, hogy visszanyerd az irányítást a digitális rendetlenség felett! 🧹

**Miért éppen AutoIt a megoldás?**

Amikor felmerül az automatizálás igénye, számos eszköz juthat eszünkbe, a PowerShelltől a Pythonig. De miért az AutoIt a tökéletes választás erre a feladatra? A válasz egyszerű: az AutoIt egy szabad, könnyen elsajátítható scriptnyelv, amelyet elsősorban Windows alapú automatizálásra terveztek. Képességei túlmutatnak a billentyűzet- és egérmozgások szimulálásán, képes fájlokat kezelni, mappákat létrehozni, hálózati erőforrásokkal kommunikálni, sőt, akár felhasználói felületeket is készíthetünk vele. A nyelvezet rendkívül intuitív, közel áll a BASIC-hez, így még azok is gyorsan bele tudnak rtanulni, akiknek nincsen komoly programozói előképzettségük. Ráadásul az elkészült scripteket önállóan futtatható `.exe` fájlokká fordíthatjuk, ami rendkívül rugalmas és hordozható megoldást eredményez. Nem kell tehát külön futtatókörnyezet ahhoz, hogy a kollégáid is profitálhassanak a nagytakarításból.

**A digitális rendetlenség természete és a rekurzió ereje**

Valljuk be őszintén, mindannyian hajlamosak vagyunk hagyni, hogy bizonyos típusú fájlok felhalmozódjanak. Gondoljunk csak a `temp` mappákra, a `log` kiterjesztésű naplófájlokra, a szoftverfejlesztés során keletkező `.obj` vagy `.bak` állományokra, vagy éppen a letöltések között rekedt, már felesleges `setup.exe` vagy `update.zip` fájlokra. Ezek a fájlok gyakran több almappában, szanaszét helyezkednek el, ami manuálisan szinte lehetetlenné teszi az átfogó, alapos takarítást. Itt jön képbe a rekurzív törlés.
A rekurzió azt jelenti, hogy egy folyamat önmagát hívja meg addig, amíg egy bizonyos feltétel nem teljesül. Fájltörlés esetén ez azt jelenti, hogy a script nem csak a megadott forrásmappát vizsgálja át, hanem az abban található összes almappát is, egészen a legmélyebb szintekig. Ez a módszer biztosítja, hogy egyetlen digitális zugban se maradjon rejtve a felesleges állomány, ha egyszer beállítottuk a megfelelő paramétereket.

**Felkészülés a nagytakarításra: Az AutoIt telepítése és az alapok**

Mielőtt belevágnánk a kódolásba, szükségünk lesz az AutoIt telepítésére.
1. Látogass el az AutoIt hivatalos weboldalára (autoitscript.com).
2. Töltsd le és telepítsd az AutoIt v3 telepítőjét. A telepítés során válaszd az „Install SciTE Lite” opciót is, ez egy nagyszerű, beépített kódszerkesztő, amely kiemeli a szintaktikát és megkönnyíti a hibakeresést.
Miután telepítetted, indítsd el a SciTE Lite szerkesztőt. Egy üres lap fogad, ahol elkezdhetjük megírni a takarító scriptünket.

**A forgatókönyv megtervezése: Mit akarunk pontosan?**

A célunk, hogy egy adott forrásmappában és annak összes almappájában töröljünk olyan fájlokat, amelyeknek a neve (vagy kiterjesztése) megfelel egy bizonyos mintának. Ehhez a következő lépésekre lesz szükségünk:
1. Meghatározni a gyökér mappát, ahonnan a törlést indítani szeretnénk.
2. Meghatározni a fájlnév mintát (pl. „*.tmp”, „logfile*”, „cache*.*”).
3. Át kell vizsgálni a gyökér mappát és rekurzívan az összes almappáját.
4. Minden egyes fájlnál ellenőrizni kell, hogy a neve illeszkedik-e a mintához.
5. Ha illeszkedik, akkor törölni kell az állományt.
6. **Biztonság!** Mielőtt élesben törölnénk, érdemes egy „száraz futás” (dry run) módot implementálni, ahol csak kilistázzuk a törlendő fájlokat, de nem hajtjuk végre a tényleges törlést. Ez kulcsfontosságú, hogy elkerüljük a véletlen adatvesztést. ⚠️

**Az AutoIt kód lépésről lépésre 💻**

Nézzük meg, hogyan épül fel a scriptünk.

„`autoit
#Region ;**** Directives created by AutoIt3Wrapper_GUI ****
#RequireAdmin ; A script futtatásához rendszergazdai jogosultság szükséges
#EndRegion ;**** Directives created by AutoIt3Wrapper_GUI ****

; <<<<<<<<<< Cikkhez írt, kommentelt AutoIt script >>>>>>>>>>

; — Konfigurációs beállítások —
Global Const $sRootFolder = „C:UsersYourUserDesktopTestFolder” ; Ide írd be a takarítandó gyökér mappa elérési útját
Global Const $aFilePatterns = StringSplit(„*.tmp|*.log|old_backup_*.zip”, „|”) ; A törlendő fájlok mintái, pipe-pal elválasztva
; Példák: „*.tmp”, „temp_file_*.txt”, „backup_v1.*”
Global Const $bDryRun = True ; True esetén csak listázza a fájlokat, de nem törli. False esetén törli.
Global Const $bConfirmBeforeDelete = True ; True esetén minden törlés előtt megerősítést kér. Csak $bDryRun = False esetén releváns.

; — Fő programrész —
_Main()

Func _Main()
If Not FileExists($sRootFolder) Then
MsgBox(16, „Hiba”, „A megadott gyökér mappa (” & $sRootFolder & „) nem létezik!”)
Exit
EndIf

MsgBox(64, „Automatizált Nagytakarítás”, „A takarítás indítása a következő mappából: ” & $sRootFolder & @CRLF & _
„Törlendő minták: ” & StringReplace(StringJoin($aFilePatterns, „, „), „|”, „, „) & @CRLF & _
„Mód: ” & ($bDryRun ? „Száraz futás (nem töröl)” : „Éles törlés”) & @CRLF & _
„Készülj fel a műveletre! Nyomj OK-t a folytatáshoz.”)

Local $iDeletedCount = 0
Local $iScannedCount = 0

; Indítjuk a rekurzív keresést és törlést
_ProcessFolder($sRootFolder, $iDeletedCount, $iScannedCount)

MsgBox(64, „Automatizált Nagytakarítás Befejezve”, „A művelet befejeződött!” & @CRLF & _
„Átvizsgált fájlok száma: ” & $iScannedCount & @CRLF & _
„Törölt/Listázott fájlok száma: ” & $iDeletedCount & @CRLF & _
„Mappa: ” & $sRootFolder)
EndFunc

; — Rekurzív mappa feldolgozó függvény —
Func _ProcessFolder($sCurrentFolder, ByRef $iDeletedCounter, ByRef $iScannedCounter)
; Fájlok feldolgozása az aktuális mappában
Local $hSearch = FileFindFirstFile($sCurrentFolder & „*”) ; Az összes fájl és mappa keresése
If $hSearch = -1 Then Return ; Hiba, vagy üres mappa

While True
Local $sFileOrDir = FileFindNextFile($hSearch)
If @error Then ExitLoop ; Nincs több fájl/mappa

If $sFileOrDir = „.” Or $sFileOrDir = „..” Then Continue ; Aktuális és szülő mappa kihagyása

Local $sFullPath = $sCurrentFolder & „” & $sFileOrDir

If FileGetAttrib($sFullPath) = „D” Then ; Ha ez egy mappa
; Rekurzívan hívjuk önmagunkat az almappára
_ProcessFolder($sFullPath, $iDeletedCounter, $iScannedCounter)
Else ; Ez egy fájl
$iScannedCounter += 1
; Ellenőrizzük, hogy a fájlnév illeszkedik-e a mintákhoz
For $i = 1 To $aFilePatterns[0] ; A $aFilePatterns[0] tartalmazza az elemek számát
If StringRegExp($sFileOrDir, _FilePatternToRegEx($aFilePatterns[$i]), 1) Then
; A fájl illeszkedik a mintához
If $bDryRun Then
; Száraz futás mód: csak listázunk
ConsoleWrite(„DRY RUN: Törlendő: ” & $sFullPath & @CRLF)
$iDeletedCounter += 1
Else
; Éles törlés mód
Local $bProceed = True
If $bConfirmBeforeDelete Then
If MsgBox(4, „Törlés megerősítése”, „Biztosan törölni szeretnéd a következő fájlt?” & @CRLF & $sFullPath) = 7 Then ; 7 = No
$bProceed = False
EndIf
EndIf

If $bProceed Then
If FileDelete($sFullPath) Then
ConsoleWrite(„Törölve: ” & $sFullPath & @CRLF)
$iDeletedCounter += 1
Else
ConsoleWrite(„HIBA: Nem sikerült törölni: ” & $sFullPath & @CRLF)
EndIf
Else
ConsoleWrite(„Kihagyva (felhasználó kérése): ” & $sFullPath & @CRLF)
EndIf
EndIf
ExitLoop ; Ha egy minta illeszkedik, lépjünk ki, és ne keressünk tovább
EndIf
Next
EndIf
WEnd
FileClose($hSearch)
EndFunc

; — Segédfüggvény: fájlmintát reguláris kifejezéssé alakít —
Func _FilePatternToRegEx($sPattern)
$sPattern = StringReplace($sPattern, „.”, „.”) ; Pontok escape-elése
$sPattern = StringReplace($sPattern, „*”, „.*”) ; Csillagok lecserélése „bármi” (zero or more) mintára
$sPattern = StringReplace($sPattern, „?”, „.”) ; Kérdőjelek lecserélése „bármilyen egy karakter” mintára
Return „(?i)^” & $sPattern & „$” ; (?i) a case-insensitive kereséshez, ^ és $ a teljes egyezéshez
EndFunc
„`

**A kód magyarázata és működése:**

1. **`#RequireAdmin`**: Ez a direktíva gondoskodik róla, hogy a script rendszergazdai jogosultságokkal fusson. Gyakran szükséges fájlok törléséhez, különösen védett rendszermappákban.
2. **Konfigurációs beállítások**:
* `$sRootFolder`: Ide kell beírnod azt a fő mappát, ahonnan a takarítást indítani szeretnéd. **FONTOS:** Győződj meg róla, hogy helyes az elérési út!
* `$aFilePatterns`: Egy tömb, amely a törlendő fájlok mintáit tartalmazza. Használhatsz `*` (bármennyi karakter) és `?` (egy karakter) helyettesítő karaktereket, pontosan úgy, mint a parancssorban. Az `@CRLF` az AutoIt-ban sortörést jelent.
* `$bDryRun`: Ha `True` (igaz), a script csak kiírja a konzolra, hogy mely fájlokat törölné, de nem hajtja végre a tényleges törlést. Ez az első védelmi vonal! Mindig ezzel kezdd!
* `$bConfirmBeforeDelete`: Ha `True` és `$bDryRun` `False`, akkor minden egyes törlés előtt rákérdez egy megerősítő ablakkal. Ez egy lassabb, de rendkívül biztonságos módszer.
3. **`_Main()` függvény**: Ez a script belépési pontja.
* Ellenőrzi, hogy a megadott gyökér mappa létezik-e.
* Üdvözlő üzenetet jelenít meg a konfigurált beállításokról.
* Inicializálja a számlálókat a törölt és átvizsgált fájlok számára.
* Elindítja a rekurzív `_ProcessFolder` függvényt.
* Befejező üzenetet jelenít meg a takarítás statisztikájával.
4. **`_ProcessFolder($sCurrentFolder, ByRef $iDeletedCounter, ByRef $iScannedCounter)` függvény**: Ez a script szíve és lelke, amely rekurzív módon járja be a mappaszerkezetet.
* A `FileFindFirstFile` és `FileFindNextFile` függvények segítségével sorra veszi a mappa tartalmát.
* Ha egy alkönyvtárat talál (`FileGetAttrib($sFullPath) = „D”`), akkor **önmagát hívja meg** arra az alkönyvtárra – ez a rekurzió!
* Ha egy fájlt talál, megnöveli az átvizsgált fájlok számlálóját (`$iScannedCounter`).
* Végighalad a `$aFilePatterns` tömbön, és minden mintát összehasonlít a fájlnévvel a `StringRegExp` és a segéd `_FilePatternToRegEx` függvény segítségével.
* Ha illeszkedés van:
* Ha `$bDryRun` `True`, akkor csak kiírja a fájl elérési útját a konzolra (F8 a SciTE-ben a konzol megnyitásához).
* Ha `$bDryRun` `False`:
* Ha `$bConfirmBeforeDelete` `True`, akkor megerősítést kér.
* Ha a felhasználó jóváhagyja, vagy nincs megerősítés beállítva, akkor a `FileDelete()` függvénnyel törli a fájlt.
* Minden műveletről (törlés, hiba, kihagyás) visszajelzést ad a konzolon.
5. **`_FilePatternToRegEx($sPattern)` függvény**: Ez egy segédfüggvény, amely a felhasználó által megadott egyszerű `*.tmp` stílusú mintákat reguláris kifejezésekké alakítja át. Ez teszi lehetővé, hogy a `StringRegExp` függvény hatékonyan és rugalmasan tudja összehasonlítani a fájlneveket. A `(?i)` rész biztosítja, hogy a keresés ne tegyen különbséget kis- és nagybetűk között (case-insensitive).

> „Sokan azt hiszik, az automatizálás csak a nagyvállalatok kiváltsága. Pedig egy jól megírt script a hétköznapi digitális életünkben is óriási terhet vehet le a vállunkról, felszabadítva értékes időt és erőforrásokat. A kulcs a gondos tervezés és a biztonsági mechanizmusok beépítése.”

**A biztonság mindenekelőtt! ⚠️**

Ez a cikk egy erőteljes eszközről szól, amely képes véglegesen eltávolítani fájlokat. Éppen ezért elengedhetetlen, hogy minden óvintézkedést megtegyünk.
* **Mindig kezdj `$bDryRun = True` beállítással!** Futtasd le a scriptet száraz futás módban többször is, ellenőrizd a konzol kimenetét, és győződj meg róla, hogy csak azokat a fájlokat listázza, amelyeket valóban törölni akarsz. A „valós adatokon alapuló vélemény” itt az, hogy sok felhasználó (köztük én is, a kezdetekben) elkövetett hibát azzal, hogy azonnal éles módban futtatott egy törlő scriptet, és sajnos fontos adatok vesztek el. Ez a tapasztalat azt diktálja, hogy a száraz futás nem opció, hanem kötelező első lépés.
* **Készíts biztonsági mentést!** Különösen, ha először használod, vagy ha bizonytalan vagy a minták helyességében, készíts mentést a célmappáról.
* **Légy pontos a mappaelérési úttal és a mintákkal!** Egy rosszul megadott mappa vagy egy túl tág minta katasztrófához vezethet.
* **Kezdd kis területtel!** Ne az egész merevlemezen indítsd el azonnal, hanem egy kisebb, kontrollált mappán teszteld először a scriptet.
* **Használd a `$bConfirmBeforeDelete` opciót!** Bár lassabbá teszi a folyamatot, extrém biztonságot nyújt minden egyes törlés előtt.

**Gyakorlati alkalmazások és továbbfejlesztési lehetőségek ✅**

Ez az AutoIt script nem csupán egy digitális szemetes kuka, hanem egy rendkívül rugalmas eszköz a rendszeres karbantartáshoz.
* **Fejlesztői környezetek takarítása**: Felesleges `.obj`, `.exe`, `.pdb`, `*.user`, `*.suo` fájlok, ideiglenes fordítási eredmények eltávolítása.
* **Logfájlok kezelése**: Rendszeresen törölheted a régebbi `.log` vagy `.txt` naplókat, amelyek már nem szükségesek, de foglalják a helyet.
* **Ideiglenes fájlok**: Bár a Windows rendelkezik saját temp mappával, sok program saját ideiglenes fájlokat hoz létre, amiket ez a script könnyedén eltávolíthat.
* **Régi mentések**: Ha gyakran készítesz manuális mentéseket (`projekt_backup_20231026.zip`), beállíthatod a scriptet, hogy a megadott dátumnál régebbi verziókat törölje. (Ez a mostani script annyit tud, hogy egy _nevet_ töröl, dátum alapú törléshez egy kicsit összetettebb logika szükséges, de AutoIt-ban ez is megvalósítható.)
* **Fájlméret alapú szűrés**: A script továbbfejleszthető lenne úgy, hogy nem csak név, hanem fájlméret alapján is szűrjön.

**Továbbfejlesztési tippek:**
* **Dátum alapú szűrés**: Implementálhatnál egy funkciót, amely csak bizonyos dátumnál régebbi fájlokat töröl.
* **Kivétel lista**: Hozz létre egy listát olyan mappákról vagy fájlokról, amelyeket soha nem szabad törölni, még akkor sem, ha illeszkednek a mintához.
* **Naplózás**: A script kimenetét ne csak a konzolra írja, hanem egy külön naplófájlba is, így visszamenőleg ellenőrizhető lesz, mi történt.
* **Grafikus felület (GUI)**: Mivel az AutoIt képes GUI-t is létrehozni, könnyedén készíthetnél egy felhasználóbarát felületet, ahol beállíthatod a gyökér mappát, a mintákat, és a biztonsági opciókat anélkül, hogy a kódot kellene módosítanod.

**Összegzés**

Az **automatizált nagytakarítás AutoIt segítségével** egy rendkívül hatékony és megfizethető (hiszen ingyenes) módja annak, hogy rendet tarts a digitális világodban. A script elkészítése nem igényel mély programozói ismereteket, mégis óriási szabadságot és kontrollt ad a kezedbe. Ne feledd, a kulcs a gondos tervezésben, a lépésről lépésre történő tesztelésben és a biztonsági protokollok betartásában rejlik. Ha ezeket szem előtt tartod, egy megbízható segítőtársat kapsz a felesleges fájlok elleni harcban, és örökre búcsút inthetsz a manuális, időrabló takarításnak. Adj neki egy esélyt, és tapasztald meg a tiszta, átlátható digitális környezet előnyeit!