| | auteur : Florian | Il est parfois utile de regrouper du code commun à plusieurs pages (ex: entête de document, barre de menu) ou bien des fonctions utiles à plusieurs scripts, plutôt que de réécrire ce code sur chaque page qui l'utilise. Cela permet une meilleure maintenance du code et une réutilisation éventuelle pour d'autres projets.
Les pages ASP utilisent pour cela une commande SSI (Server Side Include) qui n'est pas spécifique aux pages ASP.
Il s'agit de la commande INCLUDE qui accepte deux attributs : file ou virtual.
La syntaxe est la suivante : <!--#include file="fichier_a_inclure.ext"--> |
ou bien <!--#include virtual="/fichier_a_inclure.ext"--> |
La différence entre les deux méthodes tient au fait que file va inclure le fichier fichier_a_inclure.ext à partir du répertoire dans lequel on se trouve (celui du fichier qui comporte l'instruction include) alors que virtual va inclure ce même fichier depuis la racine WEB (ie le répertoire de base de votre application WEB).
Par exemple, si nous voulons inclure un fichier qui se trouve dans le sous-dossier includes du répertoire courant, qui est lui même un sous-dossier du répertoire de base, on pourra écrire de ces deux façons : <!--#include file="includes/fichier_a_inclure.ext"-->
<!--#include virtual="/sous-dossier/includes/fichier_a_inclure.ext"--> |
Notez, puisque nous parlons de pages ASP, que vous devez écrire cette instruction en dehors de tout code asp. Par exemple, ceci est faux <%
<!--#include file="includes/fichier_a_inclure.ext"-->
%> |
Ceci est juste <%
%>
<!--#include file="includes/fichier_a_inclure.ext"-->
<%
%> |
Cela tient au fait que la commande include n'est pas une instruction ASP mais SSI (que l'on retrouve par exemple dans les fichiers .shtm ou .shtml).
Par conséquent, si le code qui se trouve dans le fichier fichier_a_inclure.ext est du code ASP, ce code doit donc se trouver encadré par les balises ASP.
Notez enfin que l'extension du fichier a peu d'importance. Il est toutefois fortement conseillé de donner l'extension .asp à vos fichiers qui contiennent du code ASP sensible (comme votre chaine de connexion à votre base de données) car ainsi le code asp sera interpreté lors d'un appel direct du fichier dans le navigateur et donc invisible.
|
| | auteur : Florian | Oui et non.
Il est tout à fait possible de faire de l'inclusion dynamique, c'est à dire inclure un fichier en fonction de telle ou telle condition, mais il n'est pas possible d'utiliser pour cela l'instruction include directement.
C'est à dire que vous ne pouvez pas écrire <%
fichier = "fichier_a_inclure.ext"
%>
<!--#include file=<%=fichier%>--> |
Si vous voulez utiliser l'instruction include, il faut pour cela faire différents tests <%
Select Case (fichier)
Case "fichier_a_inclure_1"
%>
<!--#include file="includes/fichier_a_inclure_1.ext"-->
<%
Case "fichier_a_inclure_2"
%>
<!--#include file="includes/fichier_a_inclure_2.ext"-->
<%
Case "fichier_a_inclure_3"
%>
<!--#include file="includes/fichier_a_inclure_3.ext"-->
<%
Default
%>
<!--#include file="includes/fichier_a_inclure_default.ext"-->
<%
End Select
%> |
Une autre solution consiste à utiliser la méthode Execute de l'objet Server (ASP 3.0). <%
fichier = "fichier_a_inclure_executer.ext"
Server.Execute (fichier)
%> |
Le seul inconvénient de cette méthode est que les variables et fonctions définies dans le fichier appelant n'existent pas dans le fichier appelé et vice-versa.
Une dernière méthode consiste à utiliser le FileSystemObject.
Un petit exemple pour bien comprendre.
Deux fichiers : appelant.asp qui est le document à afficher et appele.asp le fichier à inclure.
appelant.asp
<%
testappelant = "valeur de testappelant dans appelant.asp"
fichier = "appele.asp"
Response.Write "dans appelant.asp : testappelant = " & testappelant & "<br>"
fichier = Server.MapPath(fichier)
Set fso = Server.CreateObject("Scripting.FileSystemObject")
Set f = fso.GetFile(fichier)
Set objcontenu = f.OpenAsTextStream(1)
code = objcontenu.ReadAll
code = Replace(code, "<"&"%", "")
code = Replace(code, "%"&">", "")
Execute code
Response.Write "dans appelant.asp : testappelant = " & testappelant & "<br>"
Response.Write "dans appelant.asp : testappele = " & testappele & "<br>"
proc_appele "hello world dans appelant.asp"
%> |
appele.asp
<%
Response.Write "dans appele.asp : testappelant = " & testappelant & "<br>"
Function proc_appele(texte)
Response.Write "texte dans la procédure proc_appele de appele.asp = " & texte & "<br>"
End Function
testappele = "valeur de testappele définie dans appele.asp"
Response.Write "dans appele.asp : testappele = " & testappele & "<br>"
proc_appele "hello world dans appele.asp"
testappelant = "valeur de testappelant modifiée dans appele.asp"
%> |
Ce qui va produire la sortie suivante lorsque l'on charge le fichier appelant.asp dans le navigateur
dans appelant.asp : testappelant = valeur de testappelant dans appelant.asp
dans appele.asp : testappelant = valeur de testappelant dans appelant.asp
dans appele.asp : testappele = valeur de testappele définie dans appele.asp
texte dans la procédure proc_appele de appele.asp = hello world dans appele.asp
dans appelant.asp : testappelant = valeur de testappelant modifiée dans appele.asp
dans appelant.asp : testappele = valeur de testappele définie dans appele.asp
texte dans la procédure proc_appele de appele.asp = hello world dans appelant.asp |
|
| | auteur : Jérôme | Alors, pour essayer de répondre précisément à cette question, il va déjà falloir définir ce qu'est une page.
Si on considère qu'une page, c'est le fichier qui est appelé dans la barre d'adresse, alors non, il n'est pas possible d'utiliser une fonction définie dans une autre page que celle actuellement dans le navigateur.
Maintenant, il est tout à fait possible que cette page soit en fait constituée de plusieurs petits bouts de script éparpillés à travers plusieurs fichiers. Dans ce cas effectivement, il s'agit d'inclure dans le script final (la page) tous ces fichiers pour reconstituer un script complet. Et c'est même généralement ce qu'il est conseillé de faire. Par exemple, une fonction qui va vérifier qu'une adresse email est valide, il y a 2 solutions : soit la définir dans le script final
unepage.asp
<%
function verifmail(mail)
end function
verifmail ("toto@toto.com")
%> |
Si on a besoin d'effectuer cette vérification sur une autre page, on va devoir redéfinir la fonction
uneautrepage.asp
<%
function verifmail(mail)
end function
verifmail ("titi@titi.com")
%> |
Si maintenant, on veut modifier le code de vérification de mail, il va falloir modifier la définition sur les 2 pages.
C'est donc pour ça que l'on fonctionne avec des fichiers séparés qui vont contenir les définitions de tes fonctions, comme ça il n'y aura qu'à inclure ces fichiers dans les pages dans lesquelles on aura besoin de telle ou telle fonction, et quand on modifie une fonction, on ne le fait qu'une fois : dans le fichier de sa définition.
L'extension que l'on donne à ce fichier séparé n'a strictement aucune importance. Par habitude, c'est l'extension .inc qui est donnée mais il est conseillé de lui donner la double extension .inc.asp, comme ça, même si ce fichier est appelé directement via la barre d'adresse, son contenu est interprété et invisible à l'utilisateur.
verifmail.inc.asp
<%
function verifmail(mail)
end function
%> |
page.asp
<!--#include file="verifmail.inc.asp" -->
<%
verifmail ("titi@titi.com")
%> |
|
Consultez les autres F.A.Q's  
|
