Bonsoir Emilie75,

Tu as une solution.

Tu écris un fichier général qui contient toutes tes fonctions et des autres petits que tu include dans ce gros.
Quand tu as besoin du gros, tu l'include et petits suivront.
Quand tu as besoin que des petits, tu les include ponctuellement.

C'est bon ?

Merci Spols, je connais le fonctionnement des variables globales mais cela ne correspond pas à ma recherche :)

Je sais pas si cela peut te correspondre, mais il y a aussi une autre technique intéressante.

Si dans ton fichier inclut tu as quelque chose plus comme
$a = ...;
$b = ...;

plutot que
function a() {return ...}

Alors tu peux accèder à $a même dans tes fonctions en utilisant le mot clé global

en début de fonction tu ajoute global $a, $b; et tu pourras accéder au contenu de $a et $b plutôt que souvent faire appel à la fonction qui rempli ces variables.
Mais attention si tu modifie ces variables, elles seront modifié partout.

<?php
require_once 'includes/includes.php';

<?php
require_once 'config.php';
require_once 'database.php';
require_once 'functions.php';

Souvent dans un script procédurale classique lorsque chaque page correspond à un script php, tu vas trouver au début de chaque script un include style :
[php]<?php
require_once 'includes/includes.php';[/php]
Le répertoire includes/ contient les différents scripts à inclure comme par exemple config.php, database.php, functions.php et le script includes.php ressemblera donc à ceci :
[php]<?php
require_once 'config.php';
require_once 'database.php';
require_once 'functions.php';[/php]
Tu auras peut être des problèmes de chemin d'accès aux différents scripts avec ce code tel quel mais ça peut être géré d'une façon ou d'une autre.

Je te remercie Saian, je pense que je vais essayer de mieux organiser mon code. Ma demande est surement la conséquence d'un manque d'organisation que j'essaie de récupérer en "bricolant"

Et bien dans ce cas tu te fais un fichier d'include dans lequel tu mets tout ce qui peut être inclus et tu l'inclus au début de chacune de tes pages.

Une autre approche est d'avoir un front controller, c'est à dire un script (généralement index.php) qui reçoit toutes les demandes et inclus ensuite le script relatif à la demande. Ce front controller inclura tous les scripts nécessaires.

Le but était de ne pas multiplier les fichiers séparés à inclure ... c'est tout :)

Le code que tu veux insérer doit bien être défini (écrit) quelque part.
Il y a deux possibilités, soit il est défini directement dans la page, soit il est défini dans une page séparée que tu devras inclure dans la page.

Quel est le but précis de la manœuvre ? qu'est ce qui te dérange dans le fait d'inclure un script externe ?

Merci à vous deux pour vos réponse, mais en fait je pense m'être mal exprimée, et l'exemple avec MEGA n'est pas clair du tout.

Imaginons que j'ai un fichier php qui s'appelle definitions.php (qui contient tout et n'importe quoi : des fonctions, des bouts de codes, etc)
Pour l'insérer dans mon fichier principal je fais : [b]include(definitions.php)[/b].
Cela fonctionne (et le code est inséré "brutalement")

Maintenant, j'aimerais savoir s'il est possible de faire [b]la même chose[/b] sans placer le code de 'definition.php' dans un fichier séparé : De la placer "brutalement" [b]dans le code de la page principale[/b], sous une forme que je ne connais pas (un peu comme une fonction qui ne s'interpréterait pas ).

Merci :)

function MEGA() {
	$a = 1;
	$b = 2;
	
	if(!function_exists('a')) {
	function a() {
		echo 'a';	
	}}
	
	if(!function_exists('b')) {
	function b() {
		echo 'b';
	}}
	
	return array('a' => $a, 'b' => $b);
}

// utilisation
extract(MEGA());

echo $a;// 1
echo $b;// 2
a();// a
b();// b

Salut, tu peux faire une fonction dans le genre :
[php]function MEGA() {
$a = 1;
$b = 2;

if(!function_exists('a')) {
function a() {
echo 'a';
}}

if(!function_exists('b')) {
function b() {
echo 'b';
}}

return array('a' => $a, 'b' => $b);
}

// utilisation
extract(MEGA());

echo $a;// 1
echo $b;// 2
a();// a
b();// b[/php]

<?php
function mafonction($nombre)
{
    $nombre += 2;
    return $nombre;
}

$a = 1;
echo mafonction($a); // Donnera 3
?>

Bonjour,
Le principe est relativement simple et semblable aux autres langages.
Il suffit de créer ta fonction tout au début et de l'appeler en lui envoyant les arguments adéquats.

Voici un exemple :
[php]<?php
function mafonction($nombre)
{
$nombre += 2;
return $nombre;
}

$a = 1;
echo mafonction($a); // Donnera 3
?>[/php]

$a = function_a($id, $text);
$b = function_b($id, $text2);

$MEGA() = [ $a = function_a($id, $text); $b = function_b($id, $text2); ]

Bonsoir,

J'ai besoin de réutiliser souvent [b]un même morceau de code[/b] : dans différentes fonctions, dans différentes pages. Il s'agit d'un morceau où je définis pas mal de variables locales, etc.

Une solution — qui fonctionne — est de placer ce morceau de code dans un fichier indépendant et de l'appeler par une [b] include[/b]().

J'aimerais savoir s'il est possible de faire la même chose sans include, c'est à dire de définir une sorte de fonction qui lorsque je l'appelle se borne à insérer du code, mais sans l'interpreter comme function(). Disons faire une sorte d'include qui ne se réfèrerait pas à un fichier externe, mais à une portion de code, comme une function()

Suis je claire ?
Merci


par exemple,

j'ai souvent besoin de faire appel à ce code :
[php]$a = function_a($id, $text);
$b = function_b($id, $text2);[/php]

et j'aimerais donc définir une sorte de "variable" qui contiendrait "betement" tout ce code pour pouvoir l'inclure juste en appelant cette variable.

genre :

[php]$MEGA() = [ $a = function_a($id, $text); $b = function_b($id, $text2); ][/php]

et a chaque appel de $MEGA, mon code serait enrichit ... comme si je faisais un include(MEGA.php).

Merci