Quelle est la différence entre PHP echo et PHP return en anglais?

considérer ce qui suit:

<?php
function sayHelloLater(){
    return "Hello";
}

function sayGoodbyeNow(){
    echo "Goodbye";
}

$hello = sayHelloLater(); // "Hello" returned and stored in $hello 
$goodbye = sayGoodbyeNow(); // "Goodbye" is echo'ed and nothing is returned

echo $hello; // "Hello" is echo'ed
echo $goodbye; // nothing is echo'ed
?>

vous pourriez vous attendre à ce que la sortie soit:

HelloGoodbye

la production réelle est:

GoodbyeHello

la raison est que" Goodbye " est echo'ed (écrit) en sortie, dès que la fonction est appelée. "Hello", d'autre part, est retourné à la variable $hello . le $goodbye est en fait vide, puisque la fonction "au revoir" ne renvoie rien.

je vois que vous postez encore des commentaires qui suggèrent que vous êtes confus parce que vous ne comprenez pas le flux du code. Peut-être cela vous aidera (en particulier avec réponse de Mathias R. Jessen ).

reprenez donc ces deux fonctions:

function sayHelloLater() {
    return 'Hello';
}

function sayGoodbyeNow() {
    echo 'Goodbye';
}

maintenant si vous faites ceci:

$hello = sayHelloLater();
$goodbye = sayGoodbyeNow();

echo $hello;
echo $goodbye;

il vous restera "GoodbyeHello" sur votre écran.

voilà pourquoi. Le le code s'exécute comme ceci:

$hello = sayHelloLater();  ---->-------->-------->------->------>--
                                                                  ¦
  ¦           ^                                                   ¦
  ¦           ¦                                           Call the function
  v           ¦                                                   ¦
  ¦           ^                                                   ¦
  ¦           ¦                                                   v
  ¦
  v         "return" simply sends back                 function sayHelloLater() {
  ¦          'Hello' to wherever the     <----<----        return 'Hello';
  ¦             function was called.                   }
  v           Nothing was printed out
  ¦          (echoed) to the screen yet.
  ¦
  v

$hello variable now has whatever value
the sayHelloLater() function returned,
so $hello = 'Hello', and is stored for
whenever you want to use it.

  ¦
  ¦
  v
  ¦
  ¦
  v

$goodbye = sayGoodbyeNow();  ---->-------->-------->------->------
                                                                 ¦
  ¦              ^                                               ¦
  ¦              ¦                                       Call the function
  v              ¦                                               ¦
  ¦              ^                                               ¦
  ¦              ¦                                               v
  ¦              ¦
  v              ¦                                    function sayGoodbyeNow() {
  ¦                                                       echo 'Goodbye';
  ¦        The function didn't return                 }
  ¦        anything, but it already
  v         printed out 'Goodbye'                                ¦
  ¦                                                              v
  ¦           ^
  ¦           ¦                                    "echo" actually prints out
  v           <-----------<-----------<---------     the word 'Goodbye' to
  ¦                                                 the page immediately at
  ¦                                                       this point.
  ¦
  v

Because the function sayGoodbyeNow() didn't
return anything, the $goodbye variable has
a value of nothing (null) as well.

  ¦
  ¦
  ¦
  v
  ¦
  ¦
  ¦
  v

echo $hello;  -------->------->   Prints 'Hello' to the screen at
                                  this point. So now your screen says
  ¦                               'GoodbyeHello' because 'Goodbye' was
  ¦                               already echoed earlier when you called
  ¦                               the sayGoodbyeNow() function.
  v

echo $goodbye;  ------>------->   This variable is null, remember? So it
                                  echoes nothing.
  ¦
  ¦
  ¦
  v

And now your code is finished and you're left with
'GoodbyeHello' on your screen, even though you echoed
$hello first, then $goodbye.

avec return la fonction elle-même peut être traitée un peu comme une variable.

Donc

return add1(2, 3) + add1(10, 10);

sortira:

25

, alors que

echo add2(2, 3) + add2(10, 10);

sortira:

5
20
0

car il n'y a pas de result d'add2. Ce qu'il fait, c'est faire écho à des trucs. Ne jamais retourner une valeur au code qui l'a appelé.

Btw, vous ne sont pas stupides. Vous êtes juste un débutant. Nous sommes tous débutants au début, et il y a un certain seuil que vous devrez franchir au début. Vous aurez probablement beaucoup de "stupide" des questions au début, mais juste continuer à essayer et surtout expérience , et vous apprendrez.

donc, fondamentalement, vous voudrez utiliser echo chaque fois que vous voulez sortir quelque chose au navigateur, et utiliser le retour lorsque vous voulez terminer le script ou la fonction et passer sur les données à une autre partie de votre script.

il y a quelques différences que j'ai trouvé après l'avoir testé

1) retourner il suffit de retourner la valeur d'une fonction pour qu'elle soit utilisée plus tard après l'avoir stockée dans une variable, mais echo affiche simplement la valeur comme vous appelez la fonction et ne renvoie rien.

voici le court exemple pour ce

function myfunc() { echo "i am a born programmer"; }

$value = myfunc(); \ it is going to print the 'i am a born programmer' as function would be called

if(empty($value)===true)  {
  echo "variable is empty because function returns nothing"; 

}

la différence entre la réponse d'une fonction est que" echo "envoie quelque chose au navigateur (DOM ) , tandis que" return " renvoie quelque chose à l'appelant.

function myFunction(
    return 5;
}

$myVar= myFunction(); //myVar equals 5
echo $myVar; // will show a "5 " on the screen


function myFunction() {
    echo 5;
}

$myVar= myFunction(); // myVar equals 0, but the screen gets a "5"
echo $myVar; // a zero on the screen next to "5" printed by function appears .

en utilisant une légère modification de votre exemple:

<?php

echo "<h1 style='font-family:Helvetica; color:red'>Using <em>echo</em></h1>";

function add1($x, $y){
    $total = $x + $y;
    echo $total;
}

$result = add1(2, 2);

echo "<p>2 + 2 = ", $result, "</p>";

echo "<h1 style='font-family:Helvetica; color:red'>Using <em>return</em></h1>";

function add2($x, $y){
    $total = $x + $y;
    return $total;
}

$result = add2(2, 2);

echo "<p>2 + 2 = ", $result, "</p>";

?>

Pouvez-vous voir la différence?

echo rend le texte etc dans le document, return renvoie les données d'une fonction/méthode etc à ce qui l'a appelé. Si vous echo un retour, il va le rendre (en supposant qu'il est Texte/Nombre etc - pas un objet etc).

derrière les deux fonctions vous avez une ligne, qui bascule votre sortie:

echo "<p>2 + 2 = ", add1(2, 2), "</p>";
echo "<p>2 + 2 = ", add2(2, 2), "</p>";

echo imprime la valeur pour que vous puissiez la lire. return renvoie la valeur pour sauvegarder par exemple des variables.

$result = add2(2, 2);
// do more with result ... ?
// output the result
echo $result;

en gros, pour sortir PHP en HTML, nous devrions utiliser echo. En d'autres termes, nous devons faire écho.

Ces deux exemples ci-dessous donnent une compréhension claire :

function myfunction() {
// script content here, and sample out maybe like this :

return $result; ---> sample 1
echo $result;   ---> sample 2

}

pour afficher $résultat en html pour chaque échantillon :

pour l'échantillon 1 nous devrions utiliser <?php echo $result ?>

pour l'échantillon 2, nous devrions utiliser <?php $result ?>

sur l'échantillon 2 nous n'avons pas besoin de faire écho, parce que nous avons l'écho l'intérieur de la fonction.

une chose que j'ai apprise en faisant des changements dans Buddypress, c'est qu'il utilise le retour principalement sur les fonctions centrales imbriquées et puis avec l'utilisation de sprintf il lie les variables dynamiques dans le HTML et renvoie ce morceau de html à la fonction principale où il a été appelé et seulement alors il résonne une fois à la fonction principale. Ce faisant, le code devient modulaire et plus facile à déboguer.

la différence la plus importante entre echo et return dans mon point de vue est:

le type de données de résultat pour chacun.

quand nous écrivons quelques fonctions comme ci-dessous:

<?php
    $value = 150;

    function firstFunction($value) {
        return $value + 1;
    }
    echo firstFunction($value) . '<br />';

    function secondFunction($value) {
        echo $value + 1;
    }
    secondFunction($value);

et oui, tous les deux nous donneront 151 comme valeur de sortie.

mais , dans le cas return , nous allons imprimer firstFunction($value) comme type de données int .

Autrement dit, dans le cas echo , nous imprimerons secondFunction($value) comme un type de données NULL .

Vous pouvez essayer d'imprimer chacun avec la fonction var_dump() pour comprendre ce que je voulais dire.

<?php
    var_dump(firstFunction($value)); ?>
    <br />
<?php
    var_dump(secondFunction($value));

cette différence nous sera bénéfique lorsque nous traitons certaines valeurs qui reviennent des bases de données, en particulier dans les opérations mathématiques comme (post vues comte) ou quelque chose comme ça.

Cela aura du sens par rapport à ce qui a été écrit ici.

j'espère l'avoir expliqué facilement.