Forum d'entraide PHPFrance

Bonsoir,

Je cherche un moyen pour attribuer une valeur à une variable.

Bon je m'explique,

Imaginons une fonction

maFonction('arguement',$maVariableDeRetour);


et cette fonction renverrai par exemple un bool et écrirai dans la variable
de se fait, on pourrai par exemple imaginer :

if (maFonction('arguement',$maVariableDeRetour))
{
echo $maVariableDeRetour;
}

et ceci sans avoir déclaré $maVariableDeRetour


est-il possible de le faire ?

edit : sans passer par la POO


Résolut : ici

Bonsoir,

La comme sa je ne voi aucun moyen? mais peut être que d'autre pourrais t'aider.

Par contre je sais pas si sa peut t'être utile, mais tu pourrais utiliser un tableau pour renvoyer plusieurs variables à partir de ta fonction, par exemple :

function retourner_plusieurs_valeurs() {
	$variable_n_1 = 'One';
	$variable_n_2 = 'Two';
	$variable_n_3 = '333';
	
	return array($variable_n_1, $variable_n_2, $variable_n_3);
}


list($variable_n_1, $variable_n_2, $variable_n_3) = retourner_plusieurs_valeurs();

echo "La valeur n_1 : " . $variable_n_1 . "<br />";
echo "La valeur n_2 : " . $variable_n_2 . "<br />";
echo "La valeur n_3 : " . $variable_n_3 . "<br />";

++

http://fr2.php.net/manual/fr/functions.user-defined.php
et

<?PHP
	
	function carre ($nombre)
	{
		$resultat = $nombre *$nombre;
		return $resultat;
	}
	$mon_truc =12;
	$mon_bidule = carre($mon_truc);
	print "$mon_bidule";
?>

list($variable_n_1, $variable_n_2, $variable_n_3) = retourner_plusieurs_valeurs();

Voila exactement ce que je cherche.

J'ai essayé de le faire avec la déclaration global
Mais ça ne fonctionnes pas, pourtant, il doit y avoir un moyen

J'ai aussi pensé utiliser get_defined_vars(), malheureusement si il se trouve dans la fonction, il renvoi Array ( [0] => valeur [1] => mavaleur ) et non supervar

Sa fonctionne très bien avec les variables global essaye avec :

function test($valeur)
{
global $mavaleur;
$mavaleur = $valeur;
}

test('qqkch');

echo $mavaleur;

Sa fonctionne très bien avec les variables global essaye avec :

function test($valeur)
{
global $mavaleur;
$mavaleur = $valeur;
}

test('qqkch');

echo $mavaleur;

Tout à fais d'accord, l’inconvénient est que la variable (ici $mavariable) est et doit être connu, alors que pour ma fonction j'ai besoin de la déclarer à l'appel de la fonction

Ah ok je comprends mieux, ton erreur a été de la déclarer en tant que variable, la c'est mieux :

function test($valeur, $mavaleur)
{
Global $$mavaleur;
$$mavaleur = $valeur;
}

test('qqkch', 'supervar');

echo $supervar;

Ohlala... Tu fais quoi quand ta variable est pas une globale ?

Rien,

Sinon ce n'est pas possible.

Je pense qu'il te faut revoir la porté des variables.

Perso je ne vois l'intérêt d'une telle chose autant utiliser les possibilités de retour de la fonction plutôt que de ré créer un mécanisme de déclaration des variables ^^

@+

Le propre d'une fonction est justement de retourner des valeurs exploitables par un programme principal. On distingue parfois entre fonctions qui retournent une valeur et procédures qui font quelque chose sans retourner de valeur.
Les paramètres (ou arguments de la fonction) sont des valeurs connues du programme appelant qui lui sont passées à des fins de calcul: ce sont soit des constantes, soit des variables du programme appelant. C'est ce que l'on appelle passage par valeur.
Aucune des variables du programme appelant n'est connue de la fonction, et aucune variable déclarée dans la fonction n'est connue en-dehors de celle-ci.

<?PHP
function suivant ($x)
{
     $y = $x +1;
    return $y;
}
$x = 0;
$y  = suivant ($x);
$d = suivant(suivant($x));
print "$x $y $d";
?>

En particulier ce code est intéressant:

<?PHP
function suivant ($x)
{
     $x ++;
print "x dans la fonction $x<br />";
}
$x = 0;
$y  = suivant ($x);
$d = suivant(suivant($x));
print "x $x  y $y d $d";
?>

Une deuxième façon de passer les paramètres est de les passer par référence (par adresse) ce qui entraîne qu'une modification de cette valeur à l'intérieur de la fonction se retrouve dans le pogramme appelant:

<?PHP
function suivant (&$reference)
{
     $reference ++;
}
$x = 0;
print "x initial $x<br />";
suivant ($x);
print " après fonction $x ";
?>

Pour qu'une fonction puisse utiliser une variable déclarée en-dehors d'elle, on peut, à l'intérieur de la fonction, la déclarer globale :

<?PHP
function feminin_valeur ($mot)
{
     return $mot."e";
}
function feminin_reference (&$mot)
{
     $mot.= "e";
}
function feminin_global ()
{
     global $prenom;
	 return $prenom.="e";
}

$prenom = "Michel";
$feminin_valeur = feminin_valeur ($prenom);
print "prenom $prenom après valeur et son féminin $feminin_valeur <br />";
feminin_reference($prenom);
print "prenom $prenom après référence <br />";
feminin_global();
print "prenom après global $prenom";
?>

Quant aux $$var que j'ai aperçus dans tes essais c'est tout autre chose...

Pour qu'une fonction puisse utiliser une variable déclarée en-dehors d'elle, on peut, à l'intérieur de la fonction, la déclarer globale :

Sauf que si la variable en question n'est pas globale à la base, ça ne fonctionnera pas. Le passage de la variable par référence serait plus approprié au cas présenté (je pense)

mais ce qui est sûr c'est que ce qui a été dit au départ n'est certainement pas la chose à faire, que ce soit pour la compréhensibilité du code ou tout simplement sa fiabilité.

Sauf que si la variable en question n'est pas globale à la base, ça ne fonctionnera pas. Le passage de la variable par référence serait plus approprié au cas présenté (je pense)

J'aimerais bien savoir ce qu'est une variable globale à la base, avec un bout de code nécessairement... Ça fait dix ans que je me sers de global sans avoir jamais pensé à ça.
À ce propos, si on met dans un fichier include fic_1 des constantes (define ...), celles-ci sont connues du script qui les inclut ET des fonctions de ce script, y compris celles qui sont chargées par un autre include fic_2); en revanche, et c'est cohérent, si fic_1 contient des définitions de variables ($z= "w"), plus commodes à faire avec la syntaxe heredoc, il faut déclarer celles-ci globales dans les fonctions où on en a besoin... À moins qu'il existe une ruse que je n'ai pas repérée...

une variable déclaré dans le script est utilisable "partout" sauf dans une fonction / classe.
Il est possible de lever cette limite avec le mot clef globale.

donc "globale à la base" est a mon avis pour indiquer que la variable doit exister avant d'indiquer dans une fonction que l'on utilise une variable globale

ceci dit après test

<?php
function jetest($x ) {
    global $pff;
    $pff = 'X vaut : '.$x;
    }
jetest('une valeur');
echo $pff;
?>

contrairement a ce que j'ai dit avant il n'y a pas d'erreur

bon après généralement on utilise pas des variables qui sortent de nulle part mais ceci est une autre histoire

@+

une variable déclaré dans le script est utilisable "partout"

dans le script où elle a été déclarée,

sauf dans une fonction / classe.

Cela je le savais déjà.

Il est possible de lever cette limite avec le mot clef globale.

Je le savais aussi

donc "globale à la base" est a mon avis pour indiquer que la variable doit exister avant d'indiquer dans une fonction que l'on utilise une variable globale

est une expression dépourvue de tout sens et qui risque de laisser entendre qu'il existe plusieurs façons de déclarer les variables suivant qu'elles sont ou non globales.
Je me sers surtout des globales pour les messages d'aide et les boutons avec leur title..... Il est plus simple de les déclarer en constantes qui, elles, sont toujours vues, mais je n'arrive pas à enfiler la syntaxe heredoc dans certaines constantes..

Code : Tout sélectionner

<?PHP function suivant (&$reference) {      $reference ++; } $x = 0; print "x initial $x<br />"; suivant ($x); print " après fonction $x "; ?>

Voila une réponse en or massif.

Problème résolut