J'ai un traitement répétitif ( = une boucle principale externe ) à
faire dans un script php.
Le problème, est que ce script php contient d'autres scripts php
inclus ( tous dans le même répertoire que le script initial ), avec
l'instruction include("script.php");
Cepndant, ces include sont contenus dans des blocs de code du script
initial, qui ne sont rencontrés à l'exécution, que dans des conditions
du type :
if($condition)
{ // bloc de code
include("script.php");
}
Comme l'exécution du script initial passera parfois avec certitude
sur ces conditions, ( parfois réalisées parfois non ), est-ce que je
peux être sûr, que ces scripts inclus, ont déjà leur code php inclus à
la compilation dans le script initial, et qu'il n'y aura pas d'effet de
bord quelconque, à faire ces includes ?
Sinon, est-ce-que des require sont ou des includes sont plus indiqués
pour que les inclusions soient "statiques", donc pour les codes inclus
donnent un script d'ensemble fixe quelles que soient les conditions
rencontrées lors de son exécution ?
Il me semble que cette question est classique, mais j'ai l'impression
que le PHP Manual est devenu depuis quelques temps, plus difficile à
comprendre.
J'ai un traitement répétitif ( = une boucle principale externe ) à
faire dans un script php.
Le problème, est que ce script php contient d'autres scripts php
inclus ( tous dans le même répertoire que le script initial ), avec
l'instruction include("script.php");
Cepndant, ces include sont contenus dans des blocs de code du script
initial, qui ne sont rencontrés à l'exécution, que dans des conditions
du type :
if($condition)
{ // bloc de code
include("script.php");
}
Comme l'exécution du script initial passera parfois avec certitude
sur ces conditions, ( parfois réalisées parfois non ), est-ce que je
peux être sûr, que ces scripts inclus, ont déjà leur code php inclus à
la compilation dans le script initial, et qu'il n'y aura pas d'effet de
bord quelconque, à faire ces includes ?
Sinon, est-ce-que des require sont ou des includes sont plus indiqués
pour que les inclusions soient "statiques", donc pour les codes inclus
donnent un script d'ensemble fixe quelles que soient les conditions
rencontrées lors de son exécution ?
Il me semble que cette question est classique, mais j'ai l'impression
que le PHP Manual est devenu depuis quelques temps, plus difficile à
comprendre.
J'ai un traitement répétitif ( = une boucle principale externe ) à
faire dans un script php.
Le problème, est que ce script php contient d'autres scripts php
inclus ( tous dans le même répertoire que le script initial ), avec
l'instruction include("script.php");
Cepndant, ces include sont contenus dans des blocs de code du script
initial, qui ne sont rencontrés à l'exécution, que dans des conditions
du type :
if($condition)
{ // bloc de code
include("script.php");
}
Comme l'exécution du script initial passera parfois avec certitude
sur ces conditions, ( parfois réalisées parfois non ), est-ce que je
peux être sûr, que ces scripts inclus, ont déjà leur code php inclus à
la compilation dans le script initial, et qu'il n'y aura pas d'effet de
bord quelconque, à faire ces includes ?
Sinon, est-ce-que des require sont ou des includes sont plus indiqués
pour que les inclusions soient "statiques", donc pour les codes inclus
donnent un script d'ensemble fixe quelles que soient les conditions
rencontrées lors de son exécution ?
Il me semble que cette question est classique, mais j'ai l'impression
que le PHP Manual est devenu depuis quelques temps, plus difficile à
comprendre.
Bonjour
J'ai un traitement répétitif ( = une boucle principale externe ) à
faire dans un script php.
Le problème, est que ce scripts php contient d'autres scripts php
inclus ( tous dans le même répertoire que le script initial ), avec
l'instruction include("script.php");
Bonjour
J'ai un traitement répétitif ( = une boucle principale externe ) à
faire dans un script php.
Le problème, est que ce scripts php contient d'autres scripts php
inclus ( tous dans le même répertoire que le script initial ), avec
l'instruction include("script.php");
Bonjour
J'ai un traitement répétitif ( = une boucle principale externe ) à
faire dans un script php.
Le problème, est que ce scripts php contient d'autres scripts php
inclus ( tous dans le même répertoire que le script initial ), avec
l'instruction include("script.php");
Bonjour,
Le 28/05/2014 12:59, Jean Francois Ortolo a écrit :
J'ai un traitement répétitif ( = une boucle principale externe ) à
faire dans un script php.
Le problème, est que ce script php contient d'autres scripts php
inclus ( tous dans le même répertoire que le script initial ), avec
l'instruction include("script.php");
Avant d'aller plus loin, est-ce que les scripts inclus définissent
des fonctions qu'il suffit de définir une fois pour toute, ou bien
s'agit-il de code qui doit vraiment être inclus plusieurs fois ?
Si c'est le dernier cas, permets-moi de douter que ce soit une bonne
façon de procéder. Je me trompe peut-être (et je ne demande qu'à être
convaincu du contraire) mais je pense qu'il doit y avoir un moyen
d'optimiser les choses : par exemple une fonction définie dans un
fichier inclus une seule fois, puis N appels à cette fonction lors
du traitement répétitif.
Si c'est le premier cas (et je suppose que c'est bien ça), peut-être
ne connais-tu pas la fonction include_once.
Une petite doc sur Alsacreations :
<http://www.alsacreations.com/actu/lire/254-le-point-sur-la-fonction-include-php.html>Cepndant, ces include sont contenus dans des blocs de code du script
initial, qui ne sont rencontrés à l'exécution, que dans des conditions
du type :
if($condition)
{ // bloc de code
include("script.php");
}
Comme l'exécution du script initial passera parfois avec certitude
sur ces conditions, ( parfois réalisées parfois non ), est-ce que je
peux être sûr, que ces scripts inclus, ont déjà leur code php inclus à
la compilation dans le script initial, et qu'il n'y aura pas d'effet de
bord quelconque, à faire ces includes ?
Tu veux dire, s'il y a une erreur dans l'un des scripts, le sauras-tu
même si l'inclusion est dans un if dont la condition est fausse ? Si
j'en crois la doc, c'est non pour include mais oui pour require :
<http://www.apc.univ-paris7.fr/~revenu/DocPhp/php/function.require.html>
Contrairement à include(), require() va toujours lire dans le fichier
cible, même si la ligne n'est jamais exécutée. Si vous souhaitez une
inclusion conditionnelle, utilisez include(). La condition ne va jamais
affecter require(). Cependant, si la ligne de require() n'est jamais
exécutée, le code du fichier ne le sera jamais non plus.
</>Sinon, est-ce-que des require sont ou des includes sont plus indiqués
pour que les inclusions soient "statiques", donc pour les codes inclus
donnent un script d'ensemble fixe quelles que soient les conditions
rencontrées lors de son exécution ?
Il me semble que cette question est classique, mais j'ai l'impression
que le PHP Manual est devenu depuis quelques temps, plus difficile à
comprendre.
Je ne suis pas sûr moi-même d'avoir compris ta question... ;-)
N'hésite pas à reformuler si jamais j'ai compris de travers.
Cordialement,
Bonjour,
Le 28/05/2014 12:59, Jean Francois Ortolo a écrit :
J'ai un traitement répétitif ( = une boucle principale externe ) à
faire dans un script php.
Le problème, est que ce script php contient d'autres scripts php
inclus ( tous dans le même répertoire que le script initial ), avec
l'instruction include("script.php");
Avant d'aller plus loin, est-ce que les scripts inclus définissent
des fonctions qu'il suffit de définir une fois pour toute, ou bien
s'agit-il de code qui doit vraiment être inclus plusieurs fois ?
Si c'est le dernier cas, permets-moi de douter que ce soit une bonne
façon de procéder. Je me trompe peut-être (et je ne demande qu'à être
convaincu du contraire) mais je pense qu'il doit y avoir un moyen
d'optimiser les choses : par exemple une fonction définie dans un
fichier inclus une seule fois, puis N appels à cette fonction lors
du traitement répétitif.
Si c'est le premier cas (et je suppose que c'est bien ça), peut-être
ne connais-tu pas la fonction include_once.
Une petite doc sur Alsacreations :
<http://www.alsacreations.com/actu/lire/254-le-point-sur-la-fonction-include-php.html>
Cepndant, ces include sont contenus dans des blocs de code du script
initial, qui ne sont rencontrés à l'exécution, que dans des conditions
du type :
if($condition)
{ // bloc de code
include("script.php");
}
Comme l'exécution du script initial passera parfois avec certitude
sur ces conditions, ( parfois réalisées parfois non ), est-ce que je
peux être sûr, que ces scripts inclus, ont déjà leur code php inclus à
la compilation dans le script initial, et qu'il n'y aura pas d'effet de
bord quelconque, à faire ces includes ?
Tu veux dire, s'il y a une erreur dans l'un des scripts, le sauras-tu
même si l'inclusion est dans un if dont la condition est fausse ? Si
j'en crois la doc, c'est non pour include mais oui pour require :
<http://www.apc.univ-paris7.fr/~revenu/DocPhp/php/function.require.html>
Contrairement à include(), require() va toujours lire dans le fichier
cible, même si la ligne n'est jamais exécutée. Si vous souhaitez une
inclusion conditionnelle, utilisez include(). La condition ne va jamais
affecter require(). Cependant, si la ligne de require() n'est jamais
exécutée, le code du fichier ne le sera jamais non plus.
</>
Sinon, est-ce-que des require sont ou des includes sont plus indiqués
pour que les inclusions soient "statiques", donc pour les codes inclus
donnent un script d'ensemble fixe quelles que soient les conditions
rencontrées lors de son exécution ?
Il me semble que cette question est classique, mais j'ai l'impression
que le PHP Manual est devenu depuis quelques temps, plus difficile à
comprendre.
Je ne suis pas sûr moi-même d'avoir compris ta question... ;-)
N'hésite pas à reformuler si jamais j'ai compris de travers.
Cordialement,
Bonjour,
Le 28/05/2014 12:59, Jean Francois Ortolo a écrit :
J'ai un traitement répétitif ( = une boucle principale externe ) à
faire dans un script php.
Le problème, est que ce script php contient d'autres scripts php
inclus ( tous dans le même répertoire que le script initial ), avec
l'instruction include("script.php");
Avant d'aller plus loin, est-ce que les scripts inclus définissent
des fonctions qu'il suffit de définir une fois pour toute, ou bien
s'agit-il de code qui doit vraiment être inclus plusieurs fois ?
Si c'est le dernier cas, permets-moi de douter que ce soit une bonne
façon de procéder. Je me trompe peut-être (et je ne demande qu'à être
convaincu du contraire) mais je pense qu'il doit y avoir un moyen
d'optimiser les choses : par exemple une fonction définie dans un
fichier inclus une seule fois, puis N appels à cette fonction lors
du traitement répétitif.
Si c'est le premier cas (et je suppose que c'est bien ça), peut-être
ne connais-tu pas la fonction include_once.
Une petite doc sur Alsacreations :
<http://www.alsacreations.com/actu/lire/254-le-point-sur-la-fonction-include-php.html>Cepndant, ces include sont contenus dans des blocs de code du script
initial, qui ne sont rencontrés à l'exécution, que dans des conditions
du type :
if($condition)
{ // bloc de code
include("script.php");
}
Comme l'exécution du script initial passera parfois avec certitude
sur ces conditions, ( parfois réalisées parfois non ), est-ce que je
peux être sûr, que ces scripts inclus, ont déjà leur code php inclus à
la compilation dans le script initial, et qu'il n'y aura pas d'effet de
bord quelconque, à faire ces includes ?
Tu veux dire, s'il y a une erreur dans l'un des scripts, le sauras-tu
même si l'inclusion est dans un if dont la condition est fausse ? Si
j'en crois la doc, c'est non pour include mais oui pour require :
<http://www.apc.univ-paris7.fr/~revenu/DocPhp/php/function.require.html>
Contrairement à include(), require() va toujours lire dans le fichier
cible, même si la ligne n'est jamais exécutée. Si vous souhaitez une
inclusion conditionnelle, utilisez include(). La condition ne va jamais
affecter require(). Cependant, si la ligne de require() n'est jamais
exécutée, le code du fichier ne le sera jamais non plus.
</>Sinon, est-ce-que des require sont ou des includes sont plus indiqués
pour que les inclusions soient "statiques", donc pour les codes inclus
donnent un script d'ensemble fixe quelles que soient les conditions
rencontrées lors de son exécution ?
Il me semble que cette question est classique, mais j'ai l'impression
que le PHP Manual est devenu depuis quelques temps, plus difficile à
comprendre.
Je ne suis pas sûr moi-même d'avoir compris ta question... ;-)
N'hésite pas à reformuler si jamais j'ai compris de travers.
Cordialement,
Bonjour,
Le 28/05/2014 12:59, Jean Francois Ortolo a écrit :
J'ai un traitement répétitif ( = une boucle principale externe ) à
faire dans un script php.
Le problème, est que ce script php contient d'autres scripts php
inclus ( tous dans le même répertoire que le script initial ), avec
l'instruction include("script.php");
Avant d'aller plus loin, est-ce que les scripts inclus définissent
des fonctions qu'il suffit de définir une fois pour toute, ou bien
s'agit-il de code qui doit vraiment être inclus plusieurs fois ?
Si c'est le dernier cas, permets-moi de douter que ce soit une bonne
façon de procéder. Je me trompe peut-être (et je ne demande qu'à être
convaincu du contraire) mais je pense qu'il doit y avoir un moyen
d'optimiser les choses : par exemple une fonction définie dans un
fichier inclus une seule fois, puis N appels à cette fonction lors
du traitement répétitif.
Si c'est le premier cas (et je suppose que c'est bien ça), peut-être
ne connais-tu pas la fonction include_once.
Une petite doc sur Alsacreations :
<http://www.alsacreations.com/actu/lire/254-le-point-sur-la-fonction-include-php.html>Cepndant, ces include sont contenus dans des blocs de code du script
initial, qui ne sont rencontrés à l'exécution, que dans des conditions
du type :
if($condition)
{ // bloc de code
include("script.php");
}
Comme l'exécution du script initial passera parfois avec certitude
sur ces conditions, ( parfois réalisées parfois non ), est-ce que je
peux être sûr, que ces scripts inclus, ont déjà leur code php inclus à
la compilation dans le script initial, et qu'il n'y aura pas d'effet de
bord quelconque, à faire ces includes ?
Tu veux dire, s'il y a une erreur dans l'un des scripts, le sauras-tu
même si l'inclusion est dans un if dont la condition est fausse ? Si
j'en crois la doc, c'est non pour include mais oui pour require :
<http://www.apc.univ-paris7.fr/~revenu/DocPhp/php/function.require.html>
Contrairement à include(), require() va toujours lire dans le fichier
cible, même si la ligne n'est jamais exécutée. Si vous souhaitez une
inclusion conditionnelle, utilisez include(). La condition ne va jamais
affecter require(). Cependant, si la ligne de require() n'est jamais
exécutée, le code du fichier ne le sera jamais non plus.
</>
Sinon, est-ce-que des require sont ou des includes sont plus indiqués
pour que les inclusions soient "statiques", donc pour les codes inclus
donnent un script d'ensemble fixe quelles que soient les conditions
rencontrées lors de son exécution ?
Il me semble que cette question est classique, mais j'ai l'impression
que le PHP Manual est devenu depuis quelques temps, plus difficile à
comprendre.
Je ne suis pas sûr moi-même d'avoir compris ta question... ;-)
N'hésite pas à reformuler si jamais j'ai compris de travers.
Cordialement,
Bonjour,
Le 28/05/2014 12:59, Jean Francois Ortolo a écrit :
J'ai un traitement répétitif ( = une boucle principale externe ) à
faire dans un script php.
Le problème, est que ce script php contient d'autres scripts php
inclus ( tous dans le même répertoire que le script initial ), avec
l'instruction include("script.php");
Avant d'aller plus loin, est-ce que les scripts inclus définissent
des fonctions qu'il suffit de définir une fois pour toute, ou bien
s'agit-il de code qui doit vraiment être inclus plusieurs fois ?
Si c'est le dernier cas, permets-moi de douter que ce soit une bonne
façon de procéder. Je me trompe peut-être (et je ne demande qu'à être
convaincu du contraire) mais je pense qu'il doit y avoir un moyen
d'optimiser les choses : par exemple une fonction définie dans un
fichier inclus une seule fois, puis N appels à cette fonction lors
du traitement répétitif.
Si c'est le premier cas (et je suppose que c'est bien ça), peut-être
ne connais-tu pas la fonction include_once.
Une petite doc sur Alsacreations :
<http://www.alsacreations.com/actu/lire/254-le-point-sur-la-fonction-include-php.html>
Cepndant, ces include sont contenus dans des blocs de code du script
initial, qui ne sont rencontrés à l'exécution, que dans des conditions
du type :
if($condition)
{ // bloc de code
include("script.php");
}
Comme l'exécution du script initial passera parfois avec certitude
sur ces conditions, ( parfois réalisées parfois non ), est-ce que je
peux être sûr, que ces scripts inclus, ont déjà leur code php inclus à
la compilation dans le script initial, et qu'il n'y aura pas d'effet de
bord quelconque, à faire ces includes ?
Tu veux dire, s'il y a une erreur dans l'un des scripts, le sauras-tu
même si l'inclusion est dans un if dont la condition est fausse ? Si
j'en crois la doc, c'est non pour include mais oui pour require :
<http://www.apc.univ-paris7.fr/~revenu/DocPhp/php/function.require.html>
Contrairement à include(), require() va toujours lire dans le fichier
cible, même si la ligne n'est jamais exécutée. Si vous souhaitez une
inclusion conditionnelle, utilisez include(). La condition ne va jamais
affecter require(). Cependant, si la ligne de require() n'est jamais
exécutée, le code du fichier ne le sera jamais non plus.
</>
Sinon, est-ce-que des require sont ou des includes sont plus indiqués
pour que les inclusions soient "statiques", donc pour les codes inclus
donnent un script d'ensemble fixe quelles que soient les conditions
rencontrées lors de son exécution ?
Il me semble que cette question est classique, mais j'ai l'impression
que le PHP Manual est devenu depuis quelques temps, plus difficile à
comprendre.
Je ne suis pas sûr moi-même d'avoir compris ta question... ;-)
N'hésite pas à reformuler si jamais j'ai compris de travers.
Cordialement,
Bonjour,
Le 28/05/2014 12:59, Jean Francois Ortolo a écrit :
J'ai un traitement répétitif ( = une boucle principale externe ) à
faire dans un script php.
Le problème, est que ce script php contient d'autres scripts php
inclus ( tous dans le même répertoire que le script initial ), avec
l'instruction include("script.php");
Avant d'aller plus loin, est-ce que les scripts inclus définissent
des fonctions qu'il suffit de définir une fois pour toute, ou bien
s'agit-il de code qui doit vraiment être inclus plusieurs fois ?
Si c'est le dernier cas, permets-moi de douter que ce soit une bonne
façon de procéder. Je me trompe peut-être (et je ne demande qu'à être
convaincu du contraire) mais je pense qu'il doit y avoir un moyen
d'optimiser les choses : par exemple une fonction définie dans un
fichier inclus une seule fois, puis N appels à cette fonction lors
du traitement répétitif.
Si c'est le premier cas (et je suppose que c'est bien ça), peut-être
ne connais-tu pas la fonction include_once.
Une petite doc sur Alsacreations :
<http://www.alsacreations.com/actu/lire/254-le-point-sur-la-fonction-include-php.html>Cepndant, ces include sont contenus dans des blocs de code du script
initial, qui ne sont rencontrés à l'exécution, que dans des conditions
du type :
if($condition)
{ // bloc de code
include("script.php");
}
Comme l'exécution du script initial passera parfois avec certitude
sur ces conditions, ( parfois réalisées parfois non ), est-ce que je
peux être sûr, que ces scripts inclus, ont déjà leur code php inclus à
la compilation dans le script initial, et qu'il n'y aura pas d'effet de
bord quelconque, à faire ces includes ?
Tu veux dire, s'il y a une erreur dans l'un des scripts, le sauras-tu
même si l'inclusion est dans un if dont la condition est fausse ? Si
j'en crois la doc, c'est non pour include mais oui pour require :
<http://www.apc.univ-paris7.fr/~revenu/DocPhp/php/function.require.html>
Contrairement à include(), require() va toujours lire dans le fichier
cible, même si la ligne n'est jamais exécutée. Si vous souhaitez une
inclusion conditionnelle, utilisez include(). La condition ne va jamais
affecter require(). Cependant, si la ligne de require() n'est jamais
exécutée, le code du fichier ne le sera jamais non plus.
</>
Sinon, est-ce-que des require sont ou des includes sont plus indiqués
pour que les inclusions soient "statiques", donc pour les codes inclus
donnent un script d'ensemble fixe quelles que soient les conditions
rencontrées lors de son exécution ?
Il me semble que cette question est classique, mais j'ai l'impression
que le PHP Manual est devenu depuis quelques temps, plus difficile à
comprendre.
Je ne suis pas sûr moi-même d'avoir compris ta question... ;-)
N'hésite pas à reformuler si jamais j'ai compris de travers.
Cordialement,
Donc... La fonction require() permet une telle inclusion "statique",
c'est-à-dire à la compilation.
Donc... La fonction require() permet une telle inclusion "statique",
c'est-à-dire à la compilation.
Donc... La fonction require() permet une telle inclusion "statique",
c'est-à-dire à la compilation.
Jean Francois Ortolo
écrivait :Donc... La fonction require() permet une telle inclusion "statique",
c'est-à-dire à la compilation.
Désolé, mais les fonctions include() et require() sont strictement
identiques à une seul exception près au niveau de la gestion des
erreurs.
L'instruction de langage include inclut et exécute le fichier spécifié
en argument.
Cette documentation s'applique aussi à l'instruction de langage require.
Les fichiers sont inclus suivant le chemin du fichier fourni ; si aucun
n'est fourni, l'include_path sera vérifié. Si le fichier n'est pas
trouvé dans l' include_path, include vérifiera dans le dossier du script
appelant et dans le dossier de travail courant avant d'échouer.
L'instruction include enverra une erreur de type warning si elle ne peut
trouver le fichier; ce comportement est différent de require, qui
enverra une erreur de niveau fatal.
Pourquoi n'allez-vous pas lire les documentations de PHP sur le sujet :
http://fr2.php.net/manual/fr/function.include.php
Jean Francois Ortolo <ortolo.jeanfrancois_nospam@free.fr.invalid>
écrivait :
Donc... La fonction require() permet une telle inclusion "statique",
c'est-à-dire à la compilation.
Désolé, mais les fonctions include() et require() sont strictement
identiques à une seul exception près au niveau de la gestion des
erreurs.
L'instruction de langage include inclut et exécute le fichier spécifié
en argument.
Cette documentation s'applique aussi à l'instruction de langage require.
Les fichiers sont inclus suivant le chemin du fichier fourni ; si aucun
n'est fourni, l'include_path sera vérifié. Si le fichier n'est pas
trouvé dans l' include_path, include vérifiera dans le dossier du script
appelant et dans le dossier de travail courant avant d'échouer.
L'instruction include enverra une erreur de type warning si elle ne peut
trouver le fichier; ce comportement est différent de require, qui
enverra une erreur de niveau fatal.
Pourquoi n'allez-vous pas lire les documentations de PHP sur le sujet :
http://fr2.php.net/manual/fr/function.include.php
Jean Francois Ortolo
écrivait :Donc... La fonction require() permet une telle inclusion "statique",
c'est-à-dire à la compilation.
Désolé, mais les fonctions include() et require() sont strictement
identiques à une seul exception près au niveau de la gestion des
erreurs.
L'instruction de langage include inclut et exécute le fichier spécifié
en argument.
Cette documentation s'applique aussi à l'instruction de langage require.
Les fichiers sont inclus suivant le chemin du fichier fourni ; si aucun
n'est fourni, l'include_path sera vérifié. Si le fichier n'est pas
trouvé dans l' include_path, include vérifiera dans le dossier du script
appelant et dans le dossier de travail courant avant d'échouer.
L'instruction include enverra une erreur de type warning si elle ne peut
trouver le fichier; ce comportement est différent de require, qui
enverra une erreur de niveau fatal.
Pourquoi n'allez-vous pas lire les documentations de PHP sur le sujet :
http://fr2.php.net/manual/fr/function.include.php
Le 29/05/2014 17:30, Otomatic a écrit :Jean Francois Ortolo
écrivait :Donc... La fonction require() permet une telle inclusion "statique",
c'est-à-dire à la compilation.
Désolé, mais les fonctions include() et require() sont strictement
identiques à une seul exception près au niveau de la gestion des
erreurs.
L'instruction de langage include inclut et exécute le fichier spécifié
en argument.
Cette documentation s'applique aussi à l'instruction de langage require.
Les fichiers sont inclus suivant le chemin du fichier fourni ; si aucun
n'est fourni, l'include_path sera vérifié. Si le fichier n'est pas
trouvé dans l' include_path, include vérifiera dans le dossier du script
appelant et dans le dossier de travail courant avant d'échouer.
L'instruction include enverra une erreur de type warning si elle ne peut
trouver le fichier; ce comportement est différent de require, qui
enverra une erreur de niveau fatal.
Pourquoi n'allez-vous pas lire les documentations de PHP sur le sujet :
http://fr2.php.net/manual/fr/function.include.php
Bonjour Monsieur
J'ai mieux que le PHP Manual, ( que j'ai déjà lu je m'empresse de le dire
).
Le commencement de la page dont Monsieur Miakinen me donne l'url (
Université Paris V ) :
----------------------------------------------------------------------
require() n'est pas vraiment une fonction PHP : c'est plus une instruction du
langage. Elle ne fonctionne pas comme les fonctions standards. Par exemple,
require() est indépendante des structures de contrôle (cela ne sert à rien de
la placer dans une condition, elle sera toujours exécutée). De plus, elle ne
retourne aucune valeur. Lire une valeur retournée par un require() retourne
une erreur d'analyse.
Contrairement à include(), require() va toujours lire dans le fichier
cible, même si la ligne n'est jamais exécutée. Si vous souhaitez une
inclusion conditionnelle, utilisez include(). La condition ne va jamais
affecter require(). Cependant, si la ligne de require() n'est jamais
exécutée, le code du fichier ne le sera jamais non plus.
Les boucles n'affectent pas le comportement de require(). Même si le code
contenu dans le fichier source est appelé dans la boucle, require() n'est
exécuté qu'une fois.
----------------------------------------------------------------------
Le 29/05/2014 17:30, Otomatic a écrit :
Jean Francois Ortolo <ortolo.jeanfrancois_nospam@free.fr.invalid>
écrivait :
Donc... La fonction require() permet une telle inclusion "statique",
c'est-à-dire à la compilation.
Désolé, mais les fonctions include() et require() sont strictement
identiques à une seul exception près au niveau de la gestion des
erreurs.
L'instruction de langage include inclut et exécute le fichier spécifié
en argument.
Cette documentation s'applique aussi à l'instruction de langage require.
Les fichiers sont inclus suivant le chemin du fichier fourni ; si aucun
n'est fourni, l'include_path sera vérifié. Si le fichier n'est pas
trouvé dans l' include_path, include vérifiera dans le dossier du script
appelant et dans le dossier de travail courant avant d'échouer.
L'instruction include enverra une erreur de type warning si elle ne peut
trouver le fichier; ce comportement est différent de require, qui
enverra une erreur de niveau fatal.
Pourquoi n'allez-vous pas lire les documentations de PHP sur le sujet :
http://fr2.php.net/manual/fr/function.include.php
Bonjour Monsieur
J'ai mieux que le PHP Manual, ( que j'ai déjà lu je m'empresse de le dire
).
Le commencement de la page dont Monsieur Miakinen me donne l'url (
Université Paris V ) :
----------------------------------------------------------------------
require() n'est pas vraiment une fonction PHP : c'est plus une instruction du
langage. Elle ne fonctionne pas comme les fonctions standards. Par exemple,
require() est indépendante des structures de contrôle (cela ne sert à rien de
la placer dans une condition, elle sera toujours exécutée). De plus, elle ne
retourne aucune valeur. Lire une valeur retournée par un require() retourne
une erreur d'analyse.
Contrairement à include(), require() va toujours lire dans le fichier
cible, même si la ligne n'est jamais exécutée. Si vous souhaitez une
inclusion conditionnelle, utilisez include(). La condition ne va jamais
affecter require(). Cependant, si la ligne de require() n'est jamais
exécutée, le code du fichier ne le sera jamais non plus.
Les boucles n'affectent pas le comportement de require(). Même si le code
contenu dans le fichier source est appelé dans la boucle, require() n'est
exécuté qu'une fois.
----------------------------------------------------------------------
Le 29/05/2014 17:30, Otomatic a écrit :Jean Francois Ortolo
écrivait :Donc... La fonction require() permet une telle inclusion "statique",
c'est-à-dire à la compilation.
Désolé, mais les fonctions include() et require() sont strictement
identiques à une seul exception près au niveau de la gestion des
erreurs.
L'instruction de langage include inclut et exécute le fichier spécifié
en argument.
Cette documentation s'applique aussi à l'instruction de langage require.
Les fichiers sont inclus suivant le chemin du fichier fourni ; si aucun
n'est fourni, l'include_path sera vérifié. Si le fichier n'est pas
trouvé dans l' include_path, include vérifiera dans le dossier du script
appelant et dans le dossier de travail courant avant d'échouer.
L'instruction include enverra une erreur de type warning si elle ne peut
trouver le fichier; ce comportement est différent de require, qui
enverra une erreur de niveau fatal.
Pourquoi n'allez-vous pas lire les documentations de PHP sur le sujet :
http://fr2.php.net/manual/fr/function.include.php
Bonjour Monsieur
J'ai mieux que le PHP Manual, ( que j'ai déjà lu je m'empresse de le dire
).
Le commencement de la page dont Monsieur Miakinen me donne l'url (
Université Paris V ) :
----------------------------------------------------------------------
require() n'est pas vraiment une fonction PHP : c'est plus une instruction du
langage. Elle ne fonctionne pas comme les fonctions standards. Par exemple,
require() est indépendante des structures de contrôle (cela ne sert à rien de
la placer dans une condition, elle sera toujours exécutée). De plus, elle ne
retourne aucune valeur. Lire une valeur retournée par un require() retourne
une erreur d'analyse.
Contrairement à include(), require() va toujours lire dans le fichier
cible, même si la ligne n'est jamais exécutée. Si vous souhaitez une
inclusion conditionnelle, utilisez include(). La condition ne va jamais
affecter require(). Cependant, si la ligne de require() n'est jamais
exécutée, le code du fichier ne le sera jamais non plus.
Les boucles n'affectent pas le comportement de require(). Même si le code
contenu dans le fichier source est appelé dans la boucle, require() n'est
exécuté qu'une fois.
----------------------------------------------------------------------
Jean Francois Ortolo :Le 29/05/2014 17:30, Otomatic a écrit :Jean Francois Ortolo
écrivait :Donc... La fonction require() permet une telle inclusion "statique",
c'est-à-dire à la compilation.
Désolé, mais les fonctions include() et require() sont strictement
identiques à une seul exception près au niveau de la gestion des
erreurs.
L'instruction de langage include inclut et exécute le fichier spécifié
en argument.
Cette documentation s'applique aussi à l'instruction de langage require.
Les fichiers sont inclus suivant le chemin du fichier fourni ; si aucun
n'est fourni, l'include_path sera vérifié. Si le fichier n'est pas
trouvé dans l' include_path, include vérifiera dans le dossier du script
appelant et dans le dossier de travail courant avant d'échouer.
L'instruction include enverra une erreur de type warning si elle ne peut
trouver le fichier; ce comportement est différent de require, qui
enverra une erreur de niveau fatal.
Pourquoi n'allez-vous pas lire les documentations de PHP sur le sujet :
http://fr2.php.net/manual/fr/function.include.php
Bonjour Monsieur
J'ai mieux que le PHP Manual, ( que j'ai déjà lu je m'empresse de
le dire ).
Le commencement de la page dont Monsieur Miakinen me donne l'url
( Université Paris V ) :
----------------------------------------------------------------------
require() n'est pas vraiment une fonction PHP : c'est plus une
instruction du langage. Elle ne fonctionne pas comme les fonctions
standards. Par exemple, require() est indépendante des structures de
contrôle (cela ne sert à rien de la placer dans une condition, elle
sera toujours exécutée). De plus, elle ne retourne aucune valeur. Lire
une valeur retournée par un require() retourne une erreur d'analyse.
Contrairement à include(), require() va toujours lire dans le
fichier cible, même si la ligne n'est jamais exécutée. Si vous
souhaitez une inclusion conditionnelle, utilisez include(). La
condition ne va jamais affecter require(). Cependant, si la ligne de
require() n'est jamais exécutée, le code du fichier ne le sera jamais
non plus.
Les boucles n'affectent pas le comportement de require(). Même si le
code contenu dans le fichier source est appelé dans la boucle,
require() n'est exécuté qu'une fois.
----------------------------------------------------------------------
Vous devriez pourtant faire confiance au manuel. Le texte en référence
me semble bien être un tissu d'âneries. Déjà écrire require() avec
parenthèses pour préciser que ce n'est "pas vraiment" une fonction,
alors que simplement *ce n'est pas* une fonction...
Tout le reste est soit incompréhensible soit faux. Ceci dit, je ne suis
pas expert PHP, je ne connais rien des très anciennes versions et un
truc doit m'échapper.
Jean Francois Ortolo :
Le 29/05/2014 17:30, Otomatic a écrit :
Jean Francois Ortolo <ortolo.jeanfrancois_nospam@free.fr.invalid>
écrivait :
Donc... La fonction require() permet une telle inclusion "statique",
c'est-à-dire à la compilation.
Désolé, mais les fonctions include() et require() sont strictement
identiques à une seul exception près au niveau de la gestion des
erreurs.
L'instruction de langage include inclut et exécute le fichier spécifié
en argument.
Cette documentation s'applique aussi à l'instruction de langage require.
Les fichiers sont inclus suivant le chemin du fichier fourni ; si aucun
n'est fourni, l'include_path sera vérifié. Si le fichier n'est pas
trouvé dans l' include_path, include vérifiera dans le dossier du script
appelant et dans le dossier de travail courant avant d'échouer.
L'instruction include enverra une erreur de type warning si elle ne peut
trouver le fichier; ce comportement est différent de require, qui
enverra une erreur de niveau fatal.
Pourquoi n'allez-vous pas lire les documentations de PHP sur le sujet :
http://fr2.php.net/manual/fr/function.include.php
Bonjour Monsieur
J'ai mieux que le PHP Manual, ( que j'ai déjà lu je m'empresse de
le dire ).
Le commencement de la page dont Monsieur Miakinen me donne l'url
( Université Paris V ) :
----------------------------------------------------------------------
require() n'est pas vraiment une fonction PHP : c'est plus une
instruction du langage. Elle ne fonctionne pas comme les fonctions
standards. Par exemple, require() est indépendante des structures de
contrôle (cela ne sert à rien de la placer dans une condition, elle
sera toujours exécutée). De plus, elle ne retourne aucune valeur. Lire
une valeur retournée par un require() retourne une erreur d'analyse.
Contrairement à include(), require() va toujours lire dans le
fichier cible, même si la ligne n'est jamais exécutée. Si vous
souhaitez une inclusion conditionnelle, utilisez include(). La
condition ne va jamais affecter require(). Cependant, si la ligne de
require() n'est jamais exécutée, le code du fichier ne le sera jamais
non plus.
Les boucles n'affectent pas le comportement de require(). Même si le
code contenu dans le fichier source est appelé dans la boucle,
require() n'est exécuté qu'une fois.
----------------------------------------------------------------------
Vous devriez pourtant faire confiance au manuel. Le texte en référence
me semble bien être un tissu d'âneries. Déjà écrire require() avec
parenthèses pour préciser que ce n'est "pas vraiment" une fonction,
alors que simplement *ce n'est pas* une fonction...
Tout le reste est soit incompréhensible soit faux. Ceci dit, je ne suis
pas expert PHP, je ne connais rien des très anciennes versions et un
truc doit m'échapper.
Jean Francois Ortolo :Le 29/05/2014 17:30, Otomatic a écrit :Jean Francois Ortolo
écrivait :Donc... La fonction require() permet une telle inclusion "statique",
c'est-à-dire à la compilation.
Désolé, mais les fonctions include() et require() sont strictement
identiques à une seul exception près au niveau de la gestion des
erreurs.
L'instruction de langage include inclut et exécute le fichier spécifié
en argument.
Cette documentation s'applique aussi à l'instruction de langage require.
Les fichiers sont inclus suivant le chemin du fichier fourni ; si aucun
n'est fourni, l'include_path sera vérifié. Si le fichier n'est pas
trouvé dans l' include_path, include vérifiera dans le dossier du script
appelant et dans le dossier de travail courant avant d'échouer.
L'instruction include enverra une erreur de type warning si elle ne peut
trouver le fichier; ce comportement est différent de require, qui
enverra une erreur de niveau fatal.
Pourquoi n'allez-vous pas lire les documentations de PHP sur le sujet :
http://fr2.php.net/manual/fr/function.include.php
Bonjour Monsieur
J'ai mieux que le PHP Manual, ( que j'ai déjà lu je m'empresse de
le dire ).
Le commencement de la page dont Monsieur Miakinen me donne l'url
( Université Paris V ) :
----------------------------------------------------------------------
require() n'est pas vraiment une fonction PHP : c'est plus une
instruction du langage. Elle ne fonctionne pas comme les fonctions
standards. Par exemple, require() est indépendante des structures de
contrôle (cela ne sert à rien de la placer dans une condition, elle
sera toujours exécutée). De plus, elle ne retourne aucune valeur. Lire
une valeur retournée par un require() retourne une erreur d'analyse.
Contrairement à include(), require() va toujours lire dans le
fichier cible, même si la ligne n'est jamais exécutée. Si vous
souhaitez une inclusion conditionnelle, utilisez include(). La
condition ne va jamais affecter require(). Cependant, si la ligne de
require() n'est jamais exécutée, le code du fichier ne le sera jamais
non plus.
Les boucles n'affectent pas le comportement de require(). Même si le
code contenu dans le fichier source est appelé dans la boucle,
require() n'est exécuté qu'une fois.
----------------------------------------------------------------------
Vous devriez pourtant faire confiance au manuel. Le texte en référence
me semble bien être un tissu d'âneries. Déjà écrire require() avec
parenthèses pour préciser que ce n'est "pas vraiment" une fonction,
alors que simplement *ce n'est pas* une fonction...
Tout le reste est soit incompréhensible soit faux. Ceci dit, je ne suis
pas expert PHP, je ne connais rien des très anciennes versions et un
truc doit m'échapper.
Le commencement de la page dont Monsieur Miakinen me donne l'url (
Université Paris V ) :
Le commencement de la page dont Monsieur Miakinen me donne l'url (
Université Paris V ) :
Le commencement de la page dont Monsieur Miakinen me donne l'url (
Université Paris V ) :
Jean Francois Ortolo
écrivait :Le commencement de la page dont Monsieur Miakinen me donne l'url (
Université Paris V ) :
Date de près de dix ans.
C'était peut-être (Et j'en doute fortement) vrai du temps de PHP 3.
- D'une part, je ne me base QUE sur les documentations officielles PHP
et non sur tout ce qu'on peut trouver comme cochoncetées sur tout un tas
de sites, même si ça provient d'une université.
- D'autre part, rien ne vous empêche d'effectuer vous-même des essais
pour confirmer ou infirmer ce que vous lisez ici ou là.
--------------------------------------
Essais effectués avec un script essais_include.php
<?php
$pour_test = 22;
echo "<p>Include et Require conditionnels if ".$pour_test." = > 12</p>n";
if($pour_test == 12) {
include('inc_toto_1.php');
require('inc_toto_1.php');
include('inc_toto_2.php');
require('inc_toto_2.php');
include('inc_toto_3.php');
require('inc_toto_3.php');
}
echo "<p>Fin test conditionnel</p>n";
echo "<p>Include et Require conditionnels if ".$pour_test." = > 22</p>n";
if($pour_test == 22) {
include('inc_toto_1.php');
require('inc_toto_1.php');
include('inc_toto_2.php');
require('inc_toto_2.php');
include('inc_toto_3.php');
require('inc_toto_3.php');
}
echo "<p>Fin test conditionnel</p>n";
?>
Les trois fichiers inc_toto_1, 2 et 3 contiennent :
<?php
$fichier = basename(__FILE__);
echo "<p>Fichier ".$fichier."</p>n";
?>
Voilà le résultat obtenu :
Include et Require conditionnels if 22 == 12
Fin test conditionnel
Include et Require conditionnels if 22 == 22
Fichier inc_toto_1.php
Fichier inc_toto_1.php
Fichier inc_toto_2.php
Fichier inc_toto_2.php
Fichier inc_toto_3.php
Fichier inc_toto_3.php
Fin test conditionnel
Exactement le même résultat avec PHP 5.3.28, PHP 5.4.29, PHP 5.5.13 et
PHP 5.6.b3
Donc, comme le dit si justement la documentation PHP, include et require
se comportent EXACTEMENT de la même manière sauf pour la gestion des
erreurs.
RTFM & CQFD
Jean Francois Ortolo <ortolo.jeanfrancois_nospam@free.fr.invalid>
écrivait :
Le commencement de la page dont Monsieur Miakinen me donne l'url (
Université Paris V ) :
Date de près de dix ans.
C'était peut-être (Et j'en doute fortement) vrai du temps de PHP 3.
- D'une part, je ne me base QUE sur les documentations officielles PHP
et non sur tout ce qu'on peut trouver comme cochoncetées sur tout un tas
de sites, même si ça provient d'une université.
- D'autre part, rien ne vous empêche d'effectuer vous-même des essais
pour confirmer ou infirmer ce que vous lisez ici ou là.
--------------------------------------
Essais effectués avec un script essais_include.php
<?php
$pour_test = 22;
echo "<p>Include et Require conditionnels if ".$pour_test." = > 12</p>n";
if($pour_test == 12) {
include('inc_toto_1.php');
require('inc_toto_1.php');
include('inc_toto_2.php');
require('inc_toto_2.php');
include('inc_toto_3.php');
require('inc_toto_3.php');
}
echo "<p>Fin test conditionnel</p>n";
echo "<p>Include et Require conditionnels if ".$pour_test." = > 22</p>n";
if($pour_test == 22) {
include('inc_toto_1.php');
require('inc_toto_1.php');
include('inc_toto_2.php');
require('inc_toto_2.php');
include('inc_toto_3.php');
require('inc_toto_3.php');
}
echo "<p>Fin test conditionnel</p>n";
?>
Les trois fichiers inc_toto_1, 2 et 3 contiennent :
<?php
$fichier = basename(__FILE__);
echo "<p>Fichier ".$fichier."</p>n";
?>
Voilà le résultat obtenu :
Include et Require conditionnels if 22 == 12
Fin test conditionnel
Include et Require conditionnels if 22 == 22
Fichier inc_toto_1.php
Fichier inc_toto_1.php
Fichier inc_toto_2.php
Fichier inc_toto_2.php
Fichier inc_toto_3.php
Fichier inc_toto_3.php
Fin test conditionnel
Exactement le même résultat avec PHP 5.3.28, PHP 5.4.29, PHP 5.5.13 et
PHP 5.6.b3
Donc, comme le dit si justement la documentation PHP, include et require
se comportent EXACTEMENT de la même manière sauf pour la gestion des
erreurs.
RTFM & CQFD
Jean Francois Ortolo
écrivait :Le commencement de la page dont Monsieur Miakinen me donne l'url (
Université Paris V ) :
Date de près de dix ans.
C'était peut-être (Et j'en doute fortement) vrai du temps de PHP 3.
- D'une part, je ne me base QUE sur les documentations officielles PHP
et non sur tout ce qu'on peut trouver comme cochoncetées sur tout un tas
de sites, même si ça provient d'une université.
- D'autre part, rien ne vous empêche d'effectuer vous-même des essais
pour confirmer ou infirmer ce que vous lisez ici ou là.
--------------------------------------
Essais effectués avec un script essais_include.php
<?php
$pour_test = 22;
echo "<p>Include et Require conditionnels if ".$pour_test." = > 12</p>n";
if($pour_test == 12) {
include('inc_toto_1.php');
require('inc_toto_1.php');
include('inc_toto_2.php');
require('inc_toto_2.php');
include('inc_toto_3.php');
require('inc_toto_3.php');
}
echo "<p>Fin test conditionnel</p>n";
echo "<p>Include et Require conditionnels if ".$pour_test." = > 22</p>n";
if($pour_test == 22) {
include('inc_toto_1.php');
require('inc_toto_1.php');
include('inc_toto_2.php');
require('inc_toto_2.php');
include('inc_toto_3.php');
require('inc_toto_3.php');
}
echo "<p>Fin test conditionnel</p>n";
?>
Les trois fichiers inc_toto_1, 2 et 3 contiennent :
<?php
$fichier = basename(__FILE__);
echo "<p>Fichier ".$fichier."</p>n";
?>
Voilà le résultat obtenu :
Include et Require conditionnels if 22 == 12
Fin test conditionnel
Include et Require conditionnels if 22 == 22
Fichier inc_toto_1.php
Fichier inc_toto_1.php
Fichier inc_toto_2.php
Fichier inc_toto_2.php
Fichier inc_toto_3.php
Fichier inc_toto_3.php
Fin test conditionnel
Exactement le même résultat avec PHP 5.3.28, PHP 5.4.29, PHP 5.5.13 et
PHP 5.6.b3
Donc, comme le dit si justement la documentation PHP, include et require
se comportent EXACTEMENT de la même manière sauf pour la gestion des
erreurs.
RTFM & CQFD