doc-fr/reference/var/functions/is-callable.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- $Revision$ -->
<!-- EN-Revision: 83a17a7324c2597bd6385148abf19f76127229f5 Maintainer: yannick Status: ready -->
<!-- Reviewed: yes -->
<refentry xml:id="function.is-callable" xmlns="http://docbook.org/ns/docbook">
 <refnamediv>
  <refname>is_callable</refname>
  <refpurpose>
   Détermine si une valeur peut être appelé comme une fonction
   dans la portée courante.
  </refpurpose>
 </refnamediv>

 <refsect1 role="description">
  &reftitle.description;
  <methodsynopsis>
   <type>bool</type><methodname>is_callable</methodname>
   <methodparam><type>mixed</type><parameter>value</parameter></methodparam>
   <methodparam choice="opt"><type>bool</type><parameter>syntax_only</parameter><initializer>&false;</initializer></methodparam>
   <methodparam choice="opt"><type>string</type><parameter role="reference">callable_name</parameter><initializer>&null;</initializer></methodparam>
  </methodsynopsis>
  <para>
   Vérifie qu'une variable est un <type>callable</type>.
  </para>
 </refsect1>

 <refsect1 role="parameters">
  &reftitle.parameters;
  <para>
   <variablelist>
    <varlistentry>
     <term><parameter>value</parameter></term>
     <listitem>
      <para>
       La valeur à vérifier.
      </para>
     </listitem>
    </varlistentry>
    <varlistentry>
     <term><parameter>syntax_only</parameter></term>
     <listitem>
      <para>
       Si l'argument <parameter>syntax_only</parameter> vaut &true;, la
       fonction ne va vérifier que si <parameter>value</parameter> 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.
      </para>
     </listitem>
    </varlistentry>
    <varlistentry>
     <term><parameter>callable_name</parameter></term>
     <listitem>
      <para>
       L'argument <parameter>callable_name</parameter> reçoit le nom
       à utiliser. Dans l'exemple ci-dessous, il vaut
       <literal>"someClass::someMethod"</literal>. Notez que, bien que
       <literal>someClass::someMethod()</literal> puisse être appelée sous forme
       statique, ce n'est pas le cas.
      </para>
     </listitem>
    </varlistentry>
   </variablelist>
  </para>
 </refsect1>

 <refsect1 role="returnvalues">
  &reftitle.returnvalues;
  <para>
   Retourne &true; si <parameter>value</parameter> peut être appelé comme
   une fonction, &false; sinon.
  </para>
 </refsect1>

 <refsect1 role="examples">
  &reftitle.examples;
  <para>
   <example>
    <title>Exemple avec <function>is_callable</function></title>
    <programlisting role="php">
<![CDATA[
<?php
//  Comment vérifier qu'une variable peut être appelée
//  comme fonction ?

//
//  Variable simple contenant une fonction
//

function someFunction()
{
}

$functionVariable = 'someFunction';

var_dump(is_callable($functionVariable, false, $callable_name));  // bool(true)

echo $callable_name, "\n";  // someFunction

//
//  Tableau contenant une méthode
//

class someClass {

  function someMethod() 
  {
  }

}

$anObject = new someClass();

$methodVariable = array($anObject, 'someMethod');

var_dump(is_callable($methodVariable, true, $callable_name));  //  bool(true)

echo $callable_name, "\n";  //  someClass::someMethod

?>
]]>
    </programlisting>
   </example>
   <example>
    <title><function>is_callable</function> et les constructeurs</title>
    <simpara>
     <function>is_callable</function> rapporte les constructeurs comme
     n'étant pas appelable.
    </simpara>
    <programlisting role="php">
<![CDATA[
<?php

class Foo
{
    public function __construct() {}
    public function foo() {}
}

var_dump(
    is_callable(array('Foo', '__construct')),
    is_callable(array('Foo', 'foo'))
);
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
bool(false)
bool(false)
]]>
    </screen>
   </example>
  </para>
 </refsect1>

 <refsect1 role="notes">
  <simplelist>
   <member>
    Un object est tout le temps appelable s'il implémente
    <link linkend="object.invoke">__invoke()</link>, et que la méthode est visible
    dans le portée courante.
   </member>
   <member>Un nom de classe est appelable si elle implémente
    <link linkend="object.callstatic">__callStatic()</link>
   </member>
   <member>
    Si un object implémente <link linkend="object.call">__call()</link>, alors cette fonction
    retournera &true; pour n'importe quelle méthode sur cet object, même si
    la méthode n'est pas définie.
   </member>
   <member>
    Cette fonction peut déclancher l'autochargement si appelé avec le nom
    d'une classe.
   </member>
  </simplelist>
 </refsect1>

 <refsect1 role="seealso">
  &reftitle.seealso;
  <para>
   <simplelist>
    <member><function>function_exists</function></member>
    <member><function>method_exists</function></member>
   </simplelist>
  </para>
 </refsect1>

</refentry>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->