is_executable()

Cos'è la funzione is_executable()?

is_executable() è una funzione PHP built-in che indica se un file esiste e può essere eseguito come programma dal processo corrente. Restituisce true solo quando entrambe le condizioni sono soddisfatte; altrimenti restituisce false.

"Eseguibile" qui significa che il sistema operativo consentirebbe l'esecuzione del file — ad esempio uno script shell, un binario compilato o un file .exe su Windows. Un normale file di testo o un file sorgente .php di solito non è eseguibile, anche se PHP può leggerlo.

Questa pagina tratta la sintassi, il significato del valore restituito, le differenze di comportamento tra sistemi operativi e le insidie (cache, file mancanti, bit di permesso) che causano problemi.

Sintassi

is_executable(string $filename): bool

Valore restituito — true se il file esiste ed è eseguibile, false altrimenti. PHP emette anche un E_WARNING se il percorso non è valido (ad esempio, se una directory nel percorso non è attraversabile).

Un esempio di base

La funzione restituisce un valore booleano, quindi si inserisce direttamente in una condizione if. Qui puntiamo al binario PHP; su un tipico server Linux quel percorso è eseguibile e viene eseguito il primo ramo. Il percorso esatto varia a seconda del sistema, motivo per cui il prossimo esempio crea un file che controlliamo completamente.

Creazione e test di un file

La verifica è più significativa quando si controllano i bit di permesso del file. L'esempio seguente scrive un piccolo script shell, lo contrassegna come eseguibile con chmod() e conferma il risultato:

<?php

$script = sys_get_temp_dir() . '/hello.sh';
file_put_contents($script, "#!/bin/sh\necho hi\n");

// Before chmod: readable but not executable.
var_dump(is_executable($script)); // bool(false)

chmod($script, 0755);             // owner rwx, group/other r-x
clearstatcache();                 // forget the cached result

var_dump(is_executable($script)); // bool(true)

unlink($script);

Due cose da notare:

• Il file non è eseguibile finché non viene impostato il bit di permesso di esecuzione, anche se già esisteva ed era leggibile.
• Dopo aver modificato i permessi è necessario chiamare clearstatcache() (vedi sotto).

Consulta chmod() per capire come il modo ottale 0755 si traduce nei permessi di proprietario/gruppo/altri.

L'insidia della cache stat

PHP mette in cache il risultato delle chiamate stat al filesystem (usate da is_executable(), is_readable(), is_writable(), file_exists() e simili) per motivi di prestazioni. Se si modificano i permessi di un file durante la stessa richiesta e poi lo si ricontrolla, si potrebbe ottenere la risposta obsoleta:

<?php

$file = sys_get_temp_dir() . '/cache-demo';
touch($file);

is_executable($file);   // result is now cached for this path

chmod($file, 0755);
var_dump(is_executable($file)); // may still report the OLD value

clearstatcache();
var_dump(is_executable($file)); // bool(true) — fresh check

unlink($file);

Chiama clearstatcache() dopo qualsiasi chmod(), chown(), rename() o unlink() se si intende verificare di nuovo lo stesso percorso nella stessa esecuzione.

Comportamento sui diversi sistemi operativi

• Linux / macOS — il risultato segue il bit di esecuzione Unix (x) per la classe utente/gruppo/altri rilevante. Un file con modalità 0644 non è eseguibile; 0755 lo è.
• Windows — non esiste un bit di permesso di esecuzione. PHP deduce "eseguibile" dall'estensione del file: i percorsi che terminano in .exe, .bat, .cmd o .com sono trattati come eseguibili. Prima di PHP 7.4, is_executable() restituiva sempre false su Windows, quindi è importante testare sulla versione di destinazione.

A causa di queste differenze, non si può assumere che uno script che riporta true su Linux faccia lo stesso su Windows, o viceversa.

Quando usarla?

• Prima di eseguire un programma esterno con exec(), shell_exec() o proc_open() — verificare che il binario sia effettivamente eseguibile e fornire un errore chiaro in caso contrario, invece di fallire all'interno della chiamata.
• Deployment / controlli di integrità — confermare che uno script di supporto (un cron job, un hook di build) abbia i permessi corretti dopo essere stato copiato o estratto dal controllo di versione, dove il bit di esecuzione a volte viene perso.
• Controllo di sicurezza — combinato con un percorso fisso, rifiutare di eseguire qualsiasi cosa che non sia un eseguibile noto con i permessi corretti.

Funzioni correlate

is_executable() appartiene a una famiglia di controlli su permessi e tipo — scegliere quella che corrisponde alla domanda da porre:

• is_file() — il percorso è un file normale (non una directory)?
• is_dir() — il percorso è una directory?
• is_readable() — il file può essere letto?
• is_writable() — il file può essere scritto?
• file_exists() — il percorso esiste (file o directory)?
• fileperms() — legge i bit di permesso grezzi.
• chmod() — modifica i bit di permesso di un file.

Conclusione

is_executable() restituisce true solo quando un file esiste e ha il permesso di esecuzione per il processo corrente. Ricordare tre cose: il risultato dipende dal sistema operativo (bit di esecuzione Unix vs. estensione Windows), è memorizzato nella cache stat quindi è necessario chiamare clearstatcache() dopo aver modificato i permessi, ed è più utile come guardia prima di eseguire programmi esterni.

Esercitazione