Bonjour,

La question est dans le code.

MErci d'avance

<?php
function dir_texte($qui, $texte='bonjour'){
if(empty($qui)){
return FALSE;
}else{
echo "$texte $qui <br />" ;
return TRUE;
}
}

A quoi sert le point d'exclamation ici ???

//dir_texte('bill');
if(!dir_texte("")){
echo "erreur<br />";
}
if(!dir_texte("bill")){

}
?>

Est ce que le symbole ! ne veut pas dire "différent de", je ne comprends pas trop avec le cas ci dessus

On va reprendre un peu l'explication du fonctionnement d'une fonction.

Tu construis une fonction pour traiter des données en lui envoyant des paramètres, certains obligatoires, d'autres facultatifs. Dans le cas de ta fonction dir_texte(), tu as défini deux paramètres : le premier est obligatoire, le second est facultatif puisque tu lui as assigné une valeur par défaut.

Ensuite, je vais te recommander une modification qui va simplifier un peu. Il faut partir du principe que tu ne devrais pas gérer un quelconque affichage directement depuis ta fonction : une fonction traite de la donnée et retourne ou non un résultat : tu gères l'affichage depuis le code qui fait appel à cette fonction. Ta fonction ré-écrite devrait donc ressembler davantage à ceci :

<?php
/**
 * Fonction de création d'un message d'accueil
 *
 * @param  String $qui      Nom de la personne à qui est destinée le message;
 * @param  String $texte    (Facultatif) Texte du message, valeur par défaut = "bonjour";
 * @return String           Message d'accueil ou FALSE si le nom est absent.
 */
function dir_texte($qui, $texte='bonjour')
{
    /* On commence par initialiser la variable qui sera retournée par la fonction */
    $retour = false;
    /* On vérifie que le paramètre $qui n'est pas vide */
    if(!empty($qui))
    {
        /**
         * Comme $qui n'est pas vide, on va assigner une nouvelle valeur
         * à notre variable $retour :
         * On construit le message complet
         */
        $retour = $texte." ". $qui ."<br />" ;
    }
    /* On renvoie le résultat */
    return $retour;
}
?>

J'y ai rajouté les commentaires : comme tu peux voir, elle va maintenant soit retourner un message, soit retourner "false".

La suite de ton code n'a, dans cette optique, plus vraiment de sens.
Signification du "!" : Lorsque tu écris par exemple :

if(!empty($qui))

C'est exactement comme si tu écrivais :

if(empty($qui) == false)

En clair, le "!" vérifie que la fonction qui suit retourne FALSE au lieu de TRUE.

Quant tu écris :

if(!dir_texte(""))

Ça n'a pas de sens parce que tu sais que ta fonction retournera FALSE si le premier paramètre est vide : or tu envoies une chaine vide comme premier paramètre, tu sais donc d'avance que le retour sera FALSE.

Si tu fais du traitement dynamique, tu ne connais pas la valeur qui est envoyée : par exemple, tu as un formulaire où l'internaute écrit son nom, tu récupères ce nom et tu l'envoies à la fonction pour construire le message. Tu pourrais donc faire quelque chose comme ça :

/* Récupération du nom */
$internaute = (isset($_POST['nom'])) ? $_POST['nom'] : "";
/* On appelle la fonction en envoyant le paramètre */
$message = dir_texte($internaute);
/**
 * On vérifie la valeur du retour : s'il vaut false, on 
 * affiche un message d'erreur, sinon, on affiche le retour
 */
if($message == false)
{
    echo "erreur<br />";
}
else
{
    echo $message;
}

Bon dev

pourtant quand je fais ce test:

<?php 
function dir_texte($qui, $texte='bonjour'){ 
if(empty($qui)){ 
return FALSE; 
}else{ 
echo "$texte $qui <br />" ; 
return TRUE; 
} 
} 


if(!dir_texte("")){ 
echo "erreur<br />"; 
// -->> renvoit erreur
} 
if(!dir_texte("bill")){ 
// -->> renvoit bonjour bill alors que rien n'est déclaré, c'est là que je ne  comprends pas :( 
// est ce que cette condition dit bien: si la fonction dir_texte n'as pas bill comme argument alors tu renvois "bonjour bill" ???
// c'est le sens que donne le "!" qui m'interpelle dans ce cas

} 
?>

(c'est un éxemple du livre php5 avancé sur le test de la valeur de retour lors de l'appel d'une fonction)

Précisément parce que l'affichage est fait dans la fonction : donc quand tu fais appel à la fonction, les instructions qu'elle contient sont exécutées. C'est pour cette raison que je recommande de sortir la partie affichage des données de la fonction elle-même.

Le premier appel envoie une chaine vide : selon le code de la fonction, aucune instruction d'affichage n'est exécuté par la fonction qui se contente de retourner FALSE. Ce qui est alors affiché est la partie qui se trouve être l'instruction que contient ton "if()"
Dans le second cas, la valeur envoyée n'est pas vide, donc les instruction de la fonction son exécutées et affichent le message. Mais aucune instruction ne suit ce "if", rien d'autre n'est alors exécuté.

Essaye de distinguer ce qui vient de la fonction et ce qui vient du code autre.

On va modifier un peu ce code original pour que tu visualises mieux :

<?php 
function dir_texte($qui, $texte='bonjour')
{
    if(empty($qui))
    {
        return FALSE;
    }
    else
    {
        echo "Message affiché par la fonction : ". $texte ." ". $qui ."<br />" ;
        return TRUE;
    }
}


if(!dir_texte(""))
{
    echo "Message affiché par le code procédural : erreur<br />";
}
if(!dir_texte("bill"))
{
    // aucune instruction particulière.
}
?>

Teste ça et reviens si un point t'échappe encore.

je commence à comprendre, pourtant quand on écrit:

if(!dir_texte("")) 
{ 
    echo "Message affiché par le code procédural : erreur<br />"; 
}

dir_texte("") renvoit FALSE et pourtant dans la condition on dit si dir_texte("") renvoit qqch différent de FALSE alors tu écrits le texte suivant.

Là aussi je bloque

Je crois que ce que tu as du mal à saisir, c'est "qui fait quoi", ou plutôt, "qui affiche quoi" :

Nous faisons face à la gestion d'affichage d'informations. Dans l'ensemble de ce code, il y a deux instructions qui affichent une information.
- L'une se trouve dans la fonction : elle est donc exécutée selon certaines conditions lorsque la fonction est appelée.
- L'autre est dans le code procédural indépendant de la fonction.

Lorsque tu écris :

if(!dir_texte(""))

Il y a appel de la fonction, et écrit de cette manière, récupération implicite d'un résultat booléen.

On va modifier à nouveau pour essayer d'y voir plus clairement :

<?php 
function dir_texte($qui, $texte='bonjour')
{
    if(empty($qui))
    {
        return FALSE;
    }
    else
    {
        echo "Message affiché par la fonction : ". $texte ." ". $qui ."<br />" ;
        return TRUE;
    }
}

?>
<h3>Première instruction</h3>
<?php
if(!dir_texte(""))
{
    echo "Message affiché par le code procédural : erreur<br />Aucun message n'a été retourné par la fonction, ele a retourné false";
}
?>
<hr />
<h3>Seconde instruction</h3>
<?php
if(!dir_texte("bill"))
{
    echo "Message affiché par le code procédural : nous avons deux lignes affichées";
}
?>

Exécute ça et observe ce qui se passe.

je pense avoir compris, le ! verifie si la condition est false et il est indépendant de la fonction.

C'est cela ?

Merci de ta patience

le ! ne vérifi pas forcément si la condition est false, il inverse le retour de la fonction içi, essaye ce code:

print_r(!true);
print_r(!false);

tu verras que le premier donnera false, et le second donnera true, en gros:

(!true)==false;
(!false)==true;

@cyrano, si je m'ai trompé faut m'y dire hein ?

alors comment comprendre le "!" ?

je pensais avoir compris

est-ce que tu es familier avec les maths ?
Si oui on peut faire une analogie avec le signe -,
ainsi: jusque là on est d'accord
pour l'instant je n'ai fait que dire pour en revenir à php maintenant, rajoutons un - devant nos expressions ce qui donne en php est-ce que ça va mieux là ?

j'avais compris de ce côté là, c'était plutôt le résultat qui m'interpellait

Il faut comprendre que ce qui est entre les parenthèses du if() peut être soit un appel de fonction, soit une comparaison de valeurs : dans tous les cas, if() va vérifier si ce qui est entre ces parenthèses est vrai ou faux : TRUE ou FALSE.

Reprenons encore une fois ce même exemple avec une petite modification :

<?php 
function dir_texte($qui, $texte="bonjour")
{
    if(empty($qui))
    {
        return false;
    }
    else
    {
        echo "Message affiché par la fonction : ". $texte ." ". $qui ."<br />" ;
        return true;
    }
}

?>
<h3>Première instruction</h3>
<?php
$test1 = dir_texte("");
if(!$test1)
{
    echo "Message affiché par le code procédural : erreur<br />\n";
    echo "La fonction a retourné :<br />\n";
    var_dump($test1);
}
?>
<hr />
<h3>Seconde instruction</h3>
<?php
$test2 = dir_texte("bill");
if($test2)
{
    echo "Message affiché par le code procédural : nous avons deux lignes affichées<br />\n";
    echo "La fonction a retourné :<br />\n";
    var_dump($test2);
}
?>

Note bien comment j'ai procédé : d'abord, je définis une variable en lui assignant comme valeur le retour de la fonction : on a donc $test1 et $test2.

Dans les if(), je teste en fin de compte si ces variables valent TRUE ou FALSE, à un détail près toutefois :

if(!$test1)

Là, je vérifie si $test1 vaut bien FALSE (utilisation du "!" que je n'aurais pas utilisé pour tester si $test1 valait TRUE)

Exécute ça et regarde à nouveau le résultat.