# Riferimento Rapido find

*Ricerca file per nome, tipo, dimensione, tempo, permessi e azioni*

> Source: GNU Findutils (gnu.org/software/findutils) · MIT

## Ricerca Base

### Eseguire find

```
find .                              # elenca tutti i file ricorsivamente
find /var/log                       # ricerca da percorso specifico
find . -name "*.txt"               # trova per nome
find / -name "config" 2>/dev/null  # sopprimi errori permesso
find dir1 dir2 -name "*.py"        # cerca in più directory
```

### Sintassi Generale

| Command | Description |
|---------|-------------|
| `find [path...] [tests] [actions]` | Forma generale — percorsi, poi test, poi azioni |
| `path` | Directory di partenza (default: directory corrente) |
| `test` | Condizione per filtrare file (`-name`, `-type`, ecc.) |
| `action` | Cosa fare con le corrispondenze (`-print`, `-exec`, ecc.) |
| `Azione predefinita` | `-print` se nessuna azione è specificata |

## Pattern di Nome

### Corrispondenza Nome

```
find . -name "*.log"               # glob case-sensitive
find . -iname "readme*"            # glob case-insensitive
find . -name "*.py" -o -name "*.js"  # OR: file Python o JS
find . -path "*/src/*.ts"          # corrispondenza percorso completo
find . -regex '.*\.\(py\|js\)'    # regex POSIX su percorso completo
```

### Test Nome

| Command | Description |
|---------|-------------|
| `-name pattern` | Basename corrisponde a glob shell (case-sensitive) |
| `-iname pattern` | Basename corrisponde a glob (case-insensitive) |
| `-path pattern` | Percorso completo corrisponde a glob shell |
| `-ipath pattern` | Percorso completo corrisponde a glob (case-insensitive) |
| `-regex pattern` | Percorso completo corrisponde a espressione regolare |
| `-iregex pattern` | Percorso completo corrisponde a regex (case-insensitive) |

## Filtri per Tipo

### Filtra per Tipo

```
find . -type f                     # solo file regolari
find . -type d                     # solo directory
find . -type l                     # link simbolici
find . -type f -name "*.sh"        # combina tipo + nome
```

### Tipi di File

| Command | Description |
|---------|-------------|
| `-type f` | File regolare |
| `-type d` | Directory |
| `-type l` | Link simbolico |
| `-type b` | Dispositivo a blocchi |
| `-type c` | Dispositivo a caratteri |
| `-type p` | Pipe con nome (FIFO) |
| `-type s` | Socket |
| `-empty` | File o directory vuota |

## Dimensione e Tempo

### Esempi Dimensione e Tempo

```
find . -size +100M                 # più grande di 100 MB
find . -size -1k                   # più piccolo di 1 KB
find . -mtime -7                   # modificato negli ultimi 7 giorni
find . -mmin -30                   # modificato negli ultimi 30 minuti
find . -newer reference.txt        # più recente del file di riferimento
```

### Test Dimensione e Tempo

| Command | Description |
|---------|-------------|
| `-size +/-Nc` | Dimensione in byte (c), kilobyte (k), megabyte (M), gigabyte (G) |
| `-mtime +/-N` | Modificato N*24 ore fa (+più vecchio, -più recente) |
| `-atime +/-N` | Acceduto N*24 ore fa |
| `-ctime +/-N` | Stato cambiato N*24 ore fa |
| `-mmin +/-N` | Modificato N minuti fa |
| `-newer file` | Modificato più di recente del file |
| `-newermt date` | Modificato dopo la stringa data (GNU) |

## Permessi

### Esempi Permessi

```
find . -perm 644                   # permessi esatti: rw-r--r--
find . -perm -u+x                  # utente ha bit execute
find . -perm /o+w                  # altri hanno write (qualsiasi)
find . -user root                  # di proprietà di root
find . -group www-data -type f     # di proprietà del gruppo
```

### Test Permessi

| Command | Description |
|---------|-------------|
| `-perm mode` | Corrispondenza esatta dei permessi |
| `-perm -mode` | Tutti i bit specificati sono impostati |
| `-perm /mode` | Almeno un bit specificato è impostato |
| `-user name` | Di proprietà dell'utente (nome o UID) |
| `-group name` | Di proprietà del gruppo (nome o GID) |
| `-nouser` | Nessun utente corrispondente in /etc/passwd |
| `-nogroup` | Nessun gruppo corrispondente in /etc/group |

## Azioni

### Esempi di Azioni

```
find . -name "*.log" -print        # stampa percorsi (default)
find . -name "*.tmp" -delete       # elimina file corrispondenti
find . -type f -ls                 # lista dettagliata
find . -name "*.txt" -print0       # output delimitato da null
find . -type f -printf "%p %s\n"   # formato personalizzato (GNU)
```

### Riferimento Azioni

| Command | Description |
|---------|-------------|
| `-print` | Stampa percorso (delimitato da newline) |
| `-print0` | Stampa percorso (delimitato da null, sicuro per xargs) |
| `-ls` | Stampa dettagli file (come `ls -dils`) |
| `-delete` | Elimina file corrispondenti (implica `-depth`) |
| `-printf format` | Formato output personalizzato (GNU): `%p` percorso, `%s` dimensione |
| `-fprint file` | Scrive percorsi su file |
| `-quit` | Esce dopo la prima corrispondenza |

## Combinare Test

### Operatori Logici

```
find . -name "*.py" -type f         # AND implicito
find . -name "*.py" -a -size +10k   # AND esplicito
find . -name "*.py" -o -name "*.js" # OR
find . ! -name "*.log"              # NOT
find . \( -name "*.py" -o -name "*.js" \) -type f
```

### Riferimento Operatori

| Command | Description |
|---------|-------------|
| `expr1 expr2 / expr1 -a expr2` | AND — entrambi devono essere veri (default) |
| `expr1 -o expr2` | OR — almeno uno deve essere vero |
| `! expr / -not expr` | NOT — nega l'espressione |
| `\( expr \)` | Raggruppa espressioni (escape parentesi nella shell) |
| `Ordine valutazione` | Da sinistra a destra; `-a` lega più stretto di `-o` |

## Exec e Delete

### Esempi Exec

```
find . -name "*.sh" -exec chmod +x {} \;
find . -name "*.log" -exec rm {} +
find . -type f -exec grep -l "TODO" {} +
find . -name "*.bak" -ok rm {} \;   # chiede conferma
find . -name "*.tmp" -print0 | xargs -0 rm
```

### Riferimento Exec

| Command | Description |
|---------|-------------|
| `-exec cmd {} \;` | Esegui cmd una volta per file (`{}` = percorso file) |
| `-exec cmd {} +` | Esegui cmd con più file insieme (più veloce) |
| `-ok cmd {} \;` | Come `-exec` ma chiede conferma |
| `-execdir cmd {} \;` | Esegui cmd dalla directory del file |
| `xargs -0` | Abbinare a `-print0` per elaborazione batch sicura |
| `-delete` | Elimina file; processa prima i più profondi |

## Profondità e Pruning

### Esempi Profondità e Prune

```
find . -maxdepth 1 -type f          # solo directory corrente
find . -mindepth 2 -name "*.py"     # salta livello superiore
find . -name ".git" -prune -o -print # salta dir .git
find . -depth -name "*.tmp" -delete  # processa figli prima
```

### Opzioni Profondità

| Command | Description |
|---------|-------------|
| `-maxdepth N` | Scendi al massimo N livelli (0 = solo percorso iniziale) |
| `-mindepth N` | Non applicare test a livelli inferiori a N |
| `-depth` | Processa contenuto directory prima della directory stessa |
| `-prune` | Non scende nella directory corrispondente |
| `-mount / -xdev` | Non attraversa i confini del filesystem |
| `-follow / -L` | Segue i link simbolici |

## Pattern Comuni

### One-Liner

```
find . -name "*.pyc" -delete             # pulisci bytecode Python
find . -type f -size 0 -delete            # rimuovi file vuoti
find . -mtime +30 -name "*.log" -delete   # elimina log vecchi
find . -type f -name "*.md" | wc -l       # conta file Markdown
find . -type d -empty -delete             # rimuovi dir vuote
```

### Ricette

| Command | Description |
|---------|-------------|
| `Trova file più grandi` | `find . -type f -printf '%s %p\n' \| sort -rn \| head` |
| `Trova duplicati per nome` | `find . -type f \| awk -F/ '{print $NF}' \| sort \| uniq -d` |
| `Rinomina estensione` | `find . -name '*.txt' -exec rename 's/.txt/.md/' {} +` |
| `Trova link simbolici rotti` | `find . -xtype l` |
| `Archivia file recenti` | `find . -mtime -7 -print0 \| tar czf recent.tar.gz --null -T -` |
| `Cerca in file codice` | `find . -name '*.py' -exec grep -l 'pattern' {} +` |