Comment vérifier si une commande shell existe depuis PHP

J'ai besoin de quelque chose comme ça en php:

If (!command_exists('makemiracle')) {
  print 'no miracles';
  return FALSE;
}
else {
  //safely call the command knowing that it exists in the host system
  shell_exec('makemiracle');
}

Existe-il des solutions?

Double Possible: Comment faire pour vérifier si une commande peut être exécutée?

InformationsquelleAutor mimrock | 2012-09-14

45

Sur Linux/Mac OS Essayez ceci:
```
function command_exist($cmd) {
    $return = shell_exec(sprintf("which %s", escapeshellarg($cmd)));
    return !empty($return);
}
```
Ensuite l'utiliser dans le code:
```
if (!command_exist('makemiracle')) {
    print 'no miracles';
} else {
    shell_exec('makemiracle');
}
```
Mise à jour:
Comme suggéré par @camilo-martin vous pouvez simplement utiliser:
```
if (`which makemiracle`) {
    shell_exec('makemiracle');
}
```
- Cela peut être raccourcie à return !empty(shell_exec("which $cmd"));
- encore plus court: return !!`which $cmd`. C'est en fait tellement court que je ne l'utiliserais comme ça à une condition: if (`which foo`) { ... }
- Aussi pas, vous pouvez utiliser where sur windows.
- je ne pense pas que vous devriez utiliser which pour cela.
- "which %s" sera la cause de la sortie sur la sortie STDERR si il ne peut pas trouver le programme, et la sortie à l'écran (si vous exécutez à partir de la CLI) ou le journal des erreurs (s'il est exécuté à partir du web). Utilisation "which %s 2>/dev/null" pour supprimer cette sortie.
InformationsquelleAutor docksteaderluke
12

Windows utilise where, les systèmes UNIX which pour permettre de localiser une commande. Les deux renvoie une chaîne vide dans STDOUT si la commande n'est pas trouvée.

PHP_OS est actuellement WINNT pour charge toutes les version de Windows par PHP.

Alors, voici une solution portable:
```
/**
 * Determines if a command exists on the current environment
 *
 * @param string $command The command to check
 * @return bool True if the command has been found ; otherwise, false.
 */
function command_exists ($command) {
  $whereIsCommand = (PHP_OS == 'WINNT') ? 'where' : 'which';

  $process = proc_open(
    "$whereIsCommand $command",
    array(
      0 => array("pipe", "r"), //STDIN
      1 => array("pipe", "w"), //STDOUT
      2 => array("pipe", "w"), //STDERR
    ),
    $pipes
  );
  if ($process !== false) {
    $stdout = stream_get_contents($pipes[1]);
    $stderr = stream_get_contents($pipes[2]);
    fclose($pipes[1]);
    fclose($pipes[2]);
    proc_close($process);

    return $stdout != '';
  }

  return false;
}
```
- Pour Unix, d'un usage qui n'est pas recommandé - voir stackoverflow.com/questions/592620/...
- Il y a $whereIsCommand pourrait être command -v pour UNIX si qui ne donnent pas satisfaction, comme indiqué par la question et compte tenu par @rr.
- where effectivement échoue si vous passez le chemin complet de la commande. Récentes de Windows, il s'attend à un path:wildcard et pas un nom de fichier
- Windows n'est pas toujours nécessairement renvoie une chaîne vide si la commande n'est pas trouvée. Des choses comme des INFO: Could not find files for the given pattern(s). sont possibles.
- PHP n'est pas BASH. La fraie un bash processus est sans doute plus lourd que d'un processus. Si il est une binaire qui permet de ne pas retourner un code d'erreur, alors c'est cassé et ce n'est pas quelque chose que les développeurs doivent se préoccuper.
InformationsquelleAutor Dereckson
4

Vous pouvez utiliser is_executable pour vérifier si il est exécutable, mais vous avez besoin de connaître le chemin d'accès de la commande, vous pouvez utiliser which de commande pour l'obtenir.
- Eh bien, si shell_exec( 'which curl' ) me donne /usr/bin/curl cela signifie que curl commande shell existe, non? Pourquoi ai-je encore besoin is_executable dans le cas?
- Fichier existe et est exécutable sont des choses différentes.
- À partir de la page de man de qui: "qui renvoie les chemins d'accès des fichiers (ou des liens), qui serait exécuté dans le contexte actuel"
InformationsquelleAutor xdazz

Plate-forme indépendante de solution:

function cmd_exists($command)
{
    if (\strtolower(\substr(PHP_OS, 0, 3)) === 'win')
    {
        $fp = \popen("where $command", "r");
        $result = \fgets($fp, 255);
        $exists = ! \preg_match('#Could not find files#', $result);
        \pclose($fp);   
    }
    else # non-Windows
    {
        $fp = \popen("which $command", "r");
        $result = \fgets($fp, 255);
        $exists = ! empty($result);
        \pclose($fp);
    }

    return $exists;
}

Le “impossible de trouver les fichiers” chaîne de recherche ne fonctionne que sur la version anglaise de Windows plates-formes. Pour avoir une solution portable, il obtient, au lieu STDOUT, que les “INFO: impossible de trouver les fichiers pour la configuration donnée(s).” est envoyé sur la sortie STDERR.
Pourquoi voudriez-vous mettre ces barres obliques à l'avant de la norme de fonctions de php?

InformationsquelleAutor srcspider

Basé sur @jcubic et que "qui" devrait être évité, c'est la croix-plate-forme, je suis venu avec:

function verifyCommand($command) :bool {
  $windows = strpos(PHP_OS, 'WIN') === 0;
  $test = $windows ? 'where' : 'command -v';
  return is_executable(trim(shell_exec("$test $command")));
}

InformationsquelleAutor botris

Basé sur @xdazz réponse, fonctionne sur Windows et Linux. Il devrait également travailler sur MacOSX trop, puisque c'est unix.

function is_windows() {
  return strtoupper(substr(PHP_OS, 0, 3)) === 'WIN';
}

function command_exists($command) {
    $test = is_windows() ? "where" : "which";
    return is_executable(trim(shell_exec("$test $command")));
}

InformationsquelleAutor jcubic

-1
```
function checkIfCommandExists($cmd){
    $prefix = strpos(strtolower(PHP_OS),'win') > -1 ? 'where' : 'which';
    exec("{$prefix} {$cmd}", $output, $returnVal);
    $returnVal !== 0
}
```
celui-ci est compatible solution à l'aide de la valeur de retour de "où" et le "qui" 🙂
- C'est potentiellement incorrect (vérifiez ci-dessus), tout en essayant de prendre le crédit pour le travail des autres (c'est à dire rien ajouté à la conversation)
InformationsquelleAutor Omer s
-3

Non, il n'y a pas.

Même en ayant un accès direct à un shell, vous ne savez pas si une commande existe. Il y a quelques trucs comme wheris ou find /-name yourcommand mais que pas une garantie à 100% que vous pouvez exécuter la commande.
- Est-ce toujours précis, étant donné les autres réponses? Élaboration pourquoi ils sont insuffisantes pourrait être utile.
- Ceci est incorrect. which et whereis sont plus que suffisantes pour vous dire si une commande existe. Vous pouvez également exécuter la commande si c'est sécuritaire de le faire, par exemple, curl --version &>/dev/null sera vide si la commande ne pas existent.
InformationsquelleAutor JvdBerg

Vous devez vous connecter pour publier un commentaire.