Déterminer si l'argument peut être appelé comme fonction avec la fonction is_callable de php

La fonction is_callable()

(PHP 4 >= 4.0.6, PHP 5)

La fonction is_callable() détermine si l'argument peut être appelé comme fonction

Syntaxe :

La fonction is_callable() vérifie qu'une variable peut être appelée comme fonction.

Cette fonction peut vérifier qu'une variable contient un nom de fonction valide, ou bien qu'elle contient un tableau, avec un objet et un nom de méthode.

$name

Peut être le nom d'une fonction stockée dans une variable de chaîne, ou un objet, et un nom de méthode pour cet objet, sous la forme :

array($unObjet, 'NomDeMethode' )

$syntax_only

Si l'argument syntax_only vaut TRUE, la fonction ne va vérifier que si name peut être une fonction ou une méthode. Il va simplement rejeter les variables qui ne sont pas des chaînes, ou des tableaux qui n'ont pas la bonne structure pour être utilisés comme fonction de rappel. Les tableaux valides sont supposés n'avoir que deux entrées, le premier étant un objet ou une chaîne, et le second une chaîne.

$callable_name

L'argument callable_name reçoit le nom à utiliser. Dans l'exemple ci-dessous, il vaut "MaClasse::MaMethod". Notez que, bien que MaClasse::MaMethod() puisse être appelée sous forme statique,mais ce n'est pas le cas.

La fonction is_callable() retourne TRUE si l'argument $name peut être appelé comme une fonction, FALSE sinon.

Exemple :

Exemple :      Copier le code

<?php
//  Comment vérifier qu'une variable peut être appelée
//  comme fonction ?
//
//  Variable simple contenant une fonction
//
function uneFonction()
{
}
$functionVariable = 'uneFonction';
var_dump(is_callable($functionVariable, false, $callable_name));  //Affiche bool(true)
echo $callable_name, "\n";  //Affiche uneFonction
//
//  Tableau contenant une méthode
//
class MaClasse {
  function MaMethod()
  {
  }
}
$unObject = new MaClasse();
$methodVariable = array($unObject, 'MaMethod');
var_dump(is_callable($methodVariable, true, $callable_name));  // Affiche
bool(true)
echo $callable_name, "\n";  // Affiche MaClasse::MaMethod
?>

Exemple : Un exemple avec les classes

Exemple :      Copier le code

  <?php
  function regular_function() {}
  abstract class ParentTest
  {
      public function public_parent_method() {}
      protected function protected_parent_method() {}
      public static function static_method() {}
      protected static function protected_static_method() {}
  }
  class CallableTest extends ParentTest implements Countable
  {
      public function __invoke() { } // Introduced in 5.3, see
  http://php.net/manual/language.oop5.magic.php
      protected function protected_method() { }
      public function is_callable($args)
      {
          return is_callable($args);
      }
      // Countable
      public function count()
      {
          return 1;
      }
  }
  $o = new CallableTest();
  var_dump(is_callable('regular_function')); // true
  var_dump(is_callable($o)); // true if PHP >= 5.3, false otherwise
  var_dump(is_callable(array($o, 'count'))); // true
  var_dump(is_callable(array($o, 'protected_method'))); // false
  var_dump($o->is_callable(array($o, 'protected_method'))); // true
  var_dump(is_callable(array($o, 'public_parent_method'))); // true
  var_dump(is_callable(array($o, 'protected_parent_method'))); // false
  var_dump($o->is_callable(array($o, 'protected_parent_method'))); // true
  var_dump(is_callable('CallableTest::static_method')); // true
  var_dump(is_callable('CallableTest::protected_static_method')); // false 
  var_dump($o->is_callable( 'CallableTest::protected_static_method')); // true
  ?>