Quelle est la différence entre PHP echo et PHP return en anglais)?
Oui, j'ai googlé cette question et j'ai même fait référence à mon manuel (PHP par Don Gosselin) mais je n'arrive vraiment pas à comprendre l'explication.
De ma compréhension:
echo = montre le résultat final d'une fonction
return = retourne la valeur d'une fonction
J'ai appliqué à la fois echo et return dans les fonctions suivantes. Je ne vois pas la différence ou 'l'efficacité' de l'utilisation de return au lieu de echo.
<?php
echo "<h1 style='font-family:Helvetica; color:red'>Using <em>echo</em></h1>";
function add1($x, $y){
$total = $x + $y;
echo $total;
}
echo "<p>2 + 2 = ", add1(2, 2), "</p>";
echo "<h1 style='font-family:Helvetica; color:red'>Using <em>return</em></h1>";
function add2($x, $y){
$total = $x + $y;
return $total;
}
echo "<p>2 + 2 = ", add2(2, 2), "</p>";
?>
Les deux affichent le résultat! Qu'est-ce que je ne comprends pas?
Je vais donner une réponse complètement non technique à ce sujet.
Disons qu'il y a une fille nommée Sally Function. Vous voulez savoir si elle vous aime ou non. Donc, puisque vous êtes à l'école primaire, vous décidez de passer une note à Sally (appelez la fonction avec des paramètres) lui demandant si elle vous aime ou non. Maintenant, ce que vous prévoyez de faire, c'est de lui demander ceci et de dire à tout le monde ce qu'elle vous dit. Au lieu de cela, vous lui demandez et ensuite elle le dit à tout le monde. Cela équivaut à revenir (vous obtenez les informations et faites quelque chose avec) contre son écho (dire à tout le monde sans que vous ayez le moindre contrôle).
Dans votre cas, ce qui se passe, c'est que lorsque Sally echos elle vous prend le contrôle et dit "je vais le dire aux gens maintenant" au lieu que vous puissiez prendre sa réponse et faire ce que vous voulait en faire. Le résultat final est, cependant, que vous disiez aux gens en même temps puisque vous répétiez ce qu'elle avait déjà répété mais n'est pas revenu (elle vous a coupé au milieu de vous dire à votre classe si elle vous a aimé ou non)
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 sortie réelle est:
GoodbyeHello
La raison en est que "Au revoir" est répercuté (écrit) en sortie, dès que la fonction est appelée. "Bonjour", en revanche, est renvoyé au $hello variable. le $goodbye est en fait vide, car la fonction d'adieu ne renvoie rien.
Je vois que vous postez toujours des commentaires qui suggèrent que vous êtes confus parce que vous ne comprenez pas le flux du code. Peut-être que 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 cela:
$hello = sayHelloLater();
$goodbye = sayGoodbyeNow();
echo $hello;
echo $goodbye;
Vous vous retrouverez avec "GoodbyeHello" sur votre écran.
Voici pourquoi. Le code fonctionnera 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.
Alors
return add1(2, 3) + add1(10, 10);
affichera:
25
tandis que
echo add2(2, 3) + add2(10, 10);
affichera:
5
20
0
Comme il n'y a pas de result d'add2. Ce qu'il fait, c'est seulement faire écho à des trucs. Ne jamais renvoyer réellement une valeur au code qui l'a appelée.
Btw, vous n'êtes pas stupide. Vous n'êtes qu'un débutant. Nous sommes tous des débutants au début, et il y a un certain seuil que vous devrez franchir au début. Vous aurez probablement beaucoup de questions "stupides" au début, mais continuez simplement à essayer et surtout expérience, et vous apprendrez.
Donc, en gros, vous voudrez utiliser echo chaque fois que vous voulez sortir quelque chose vers le navigateur, et utiliser return lorsque vous voulez terminer le script ou la fonction et transmettre des données à une autre partie de votre script.
il y a quelques différences que j'ai trouvées après l'avoir testé
1) return retourne simplement la valeur d'une fonction pour la réutiliser plus tard après l'avoir stockée dans une variable mais écho affiche simplement la valeur lorsque vous appelez la fonction et ne renvoie rien.
voici le court exemple pour cela
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 .
echo rend le texte, etc. dans le document, return renvoie les données d'une fonction/méthode, etc. à celui qui l'a appelé. Si vous faites écho à un retour, il le restituera (en supposant que c'est du texte/nombre, etc. - pas un objet, etc.).
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>";
?>
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 à enregistrer par exemple dans les variables.
$result = add2(2, 2);
// do more with result ... ?
// output the result
echo $result;
Fondamentalement, pour sortir PHP en HTML, nous devons utiliser echo. Dans un autre Word, nous devons l'écho.
Ces deux exemples ci-dessous donneront 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 $ resultat en html pour chaque échantillon:
pour l'échantillon 1, nous devons utiliser <?php echo $result ?>
pour l'échantillon 2, nous devons utiliser <?php $result ?>
Sur l'échantillon 2, nous n'avons pas besoin de l'écho, car nous l'avons en écho dans 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 de base imbriquées, 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 était 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 à mon point de vue est:
le type de données du résultat pour chacun.
lorsque nous écrivons certaines 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, les deux nous donneront 151 comme valeur de sortie.
Mais, dans le cas return, nous imprimerons firstFunction($value) comme un type de données int.
D'autre part, dans le cas echo, nous imprimerons secondFunction($value) comme un type de données NULL.
Vous pouvez essayer d'imprimer chacun d'eux 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 traiterons certaines valeurs qui reviennent des bases de données, en particulier dans les opérations mathématiques comme (le nombre de vues post) ou quelque chose comme ça.
Cela aura du sens par rapport à ce qui a été écrit ici.
j'espère que je l'ai expliqué facilement.