Ce cours va vous faire découvrir l’outil dont vous avez besoin pour la creation de votre site web.
Active Server Pages [ASP] est un ensemble de logiciels développés par Microsoft et utilisés dans la programmation web. La dernière version livrée par Microsoft date de l’an 2000.
| Présentation des ASP Démarrer avec Active Serve Pages Comment écrire vos scripts ASP ? Les fonctions ASP de WebExpert Le modèle objet d’Active Server Pages Descriptif ADO |
Comment connecter une base de données Access ? |
| Introduction |
| Active Server Pages (ASP) est un environnement d’écriture de scripts côté serveur, que nous pouvons utiliser pour la création de pages Web dynamiques ou la conception de puissantes applications Web. Les pages ASP sont des fichiers contenant des balises HTML, du texte et des commandes de script. Les pages ASP peuvent appeler des composants ActiveX pour effectuer des tâches, comme la connexion à une base de données par exemple. Grâce à ASP, nous sommes en mesure d’ajouter un contenu interactif à nos pages Web ou de concevoir des applications Web utilisant les pages HTML comme interface avec le client. |
| Les fonctions principales |
| Les scripts côté serveur : nous pouvons incorporer dans une page HTML des scripts qui seront exécutés sur le serveur et non par le navigateur. Étant donné que les scripts s’exécutent sur le serveur plutôt que sur la machine client, votre serveur Web effectue tout le travail lié à la génération des pages Web envoyées aux navigateurs. Il nous importe donc peu de savoir si un navigateur peut traiter ou non vos scripts : votre serveur Web effectue tout le travail de traitement du script et de transmission du HTML standard au navigateur. Les scripts serveur ne peuvent être copiés car seul le résultat du script est envoyé au navigateur. Les utilisateurs ne peuvent voir les commandes de script ayant servi à créer la page qu’ils consultent.La connectivité aux bases de données : les scripts côté serveur et ADO (Active Data Object) permettent de créer facilement de puissantes fonctions de gestion de base de données à intégrer dans vos sites Internet.
La gestion d’état d’application : nous pouvons gérer et suivre l’état des applications au niveau utilisateur, application et serveur grâce aux objets intégrés. Les Actives Server Components : nous pouvons instancier et utiliser des composants programmables à l’aide d’outils (Visual Basic, C, Java…) Les ASP fonctionnent avec les serveurs Web suivants :
Nous pouvons utiliser les scripts côté serveur pour créer allègrement des contenus dynamiques qui réagissent, par exemple, aux requêtes basées sur des informations fournies par les utilisateurs, les profils personnels ou la logique conditionnelle. Avec les scripts côté serveur, la même page Web peut être personnalisée différemment à chaque téléchargement. Vous pouvez aussi utiliser les scripts côté serveur pour générer dynamiquement une interactivité côté client. Par exemple, vous pouvez détecter si le navigateur de votre utilisateur gère le JavaScript, afin de rediriger ce dernier vers des pages prenant en charge ce langage de script. Jusqu’à ce jour, la programmation CGI (Common Gateway Interface) a été abondamment utilisée pour insuffler une intelligence serveur aux applications Internet, mais les programmes CGI sont souvent complexes et rigides. Avec les ASP, l’expérience de la programmation avec Basic ou JavaScript peut être exploitée pour créer plus rapidement des applications productives pour Internet. Ceci dit, nous pouvons utiliser n’importe quel langage de script pour lequel nous disposons d’un moteur de script respectant la norme de script ActiveX. |
| Qu’est-ce qu’une page ASP ? |
| Une page ASP (Active Server Pages) est un document HTML contenant une logique de script côté serveur. |
DEMARRER AVEC ACTIVE SERVER PAGES
| Introduction |
Il n’est pas nécessaire d’avoir une configuration puissante pour utiliser et faire fonctionner les ASP.Minimum requis:
|
| Mise en route |
Voici énumérées les différentes étapes pour la mise en place de pages ASP en mode local :
|
| Votre première page ASP |
| Voici le classique Hello World à la façon ASP 🙂 Vous noterez les balises qui délimitent les scripts écrits en ASP <% et %> et appelées « délimiteurs ». <HTML> <% For i = 3 To 6 %> </BODY> Enregistrons la page avec l’extension .asp (ex: hello.asp) dans le répertoire « test » puis tapons dans la barre d’adresse du navigateur http://serveur/test/hello.asp (il faut remplacer « serveur » par le nom trouvé précédemment) afin de voir le résultat 🙂 |
COMMENT ECRIRE VOS SCRIPTS ASP ?
| La « bonne façon » de faire… |
| Il existe sur le marché des outils de développement visuel pour créer des pages ASP avec une très grande facilité. Ces outils de développement permettent aux novices de concevoir des applications Internet en quelques clics de souris. Ceux-ci libèrent les programmeurs débutants du fardeau de la vraie programmation, mais cela porte atteinte à leur créativité et affaiblit la capacité du développeur à écrire du « bon code », à débuguer le code difficile, et plus généralement diminue la compréhension globale de ce que signifie le code. Afin d’éviter cela, la seule solution est de ne pas se servir de tels outils de développement, à moins que vous soyez certain à 100% de pouvoir écrire la même application en utilisant uniquement Notepad. Si vous êtes sur le point de créer votre première page ASP, résistez à la tentation d’utiliser de tels outils. WebExpert est, à n’en point douter, un outil de développement idéal, parfaitement adapté à l’écriture de scripts ASP tout en facilitant la tâche des développeurs débutants et/ou professionnels. |
LES FONCTIONS ASP DE WEBEXPERT
| Le générateur de script ASP |
| Vous découvrez dans ce tutoriel que la structure ASP possède des objets (et des méthodes, évènements et propriétés associées). Vous retrouvez cette dernière dans son intégralité au sein du générateur de script ASP de WebExpert !
Le générateur accomplit pleinement la fonction pour laquelle il a été conçu, à savoir la création assistée de codes ASP. De plus ce dernier fait office de bibliographie complète !
Pour générer un script ASP: 1. Dans la page ASP, positionnez-vous à l’endroit où vous désirez insérer le script. 2. Dans l’onglet Spécialisés, cliquez sur le bouton Insérer une commande ASP. 3. La fenêtre visible ci-dessus s’affiche. Dans la zone Aller à, déroulez la liste pour choisir le type du script ; vous pouvez également utiliser la zone inférieure de la fenêtre. 4. La zone inférieure de la fenêtre s’actualise en fonction du type de script que vous avez sélectionné. Double-cliquez sur l’icône pour choisir une commande. Une boîte de dialogue apparaît vous permettant d’identifier le script en cours d’élaboration. Une fois la commande complétée, WebExpert insère la commande au point d’insertion. Exemple pratique Vous allez créer une instance de l’objet Connection, en affectant une référence d’objet à une variable : 1- Cliquez sur le dossier Database. 2- Dans la fenêtre de droite, cliquez sur Create connection.
Le constructeur d’expressions apparaît alors :
Vous allez insérer en Nom de l’objet Conn Ce qui donne sur votre page : <HEAD> <%Set Conn = Server.CreateObject(« ADODB.Connection »)%> </BODY> L’instance de l’objet Connection est implémentée par le composant Active Database qui a pour identifiant (progID) ADODB. Vous utilisez maintenant la méthode Open de l’objet Connection, afin d’ouvrir notre connexion à la source de données dans le but de manipuler les éléments (ajouts, suppression, modification) présents dans celle-ci.
Double cliquez sur Open connection. La fenêtre du Constructeur d’expressions fait son apparition. Vous entrez alors le Nom de l’objet qui est Conn et la chaîne de connexion Carnet.
La chaîne de connexion est le paramètre désignant le DSN (Data Source Name), autrement dit, le nom de la source de données ou une série de paramètre=valeur séparés par des points-virgules, dans notre exemple Carnet. Votre page se présente maintenant ainsi : <HEAD> <%Set Conn = Server.CreateObject(« ADODB.Connection »)%> </BODY> La connexion ainsi établie, vous pouvez l’utiliser… L’utilisation du générateur de script est donc aisée. Vous pouvez désormais poursuivre la construction de votre script, afin de lire des enregistrements présents dans votre base de données, par exemple à l’aide de la méthode Execute. Bon code ! |
| Introduction |
| La structure ASP possède des objets (et des méthodes, évènements et propriétés associés) qui fournissent des informations sur le serveur Internet et son environnement, facilitant le traitement et la gestion des formulaires, apportant ainsi un système souple de stockage des données. Nous pouvons incorporer toutes ces possibilités dans une application Internet bien conçue, robuste, facile à développer et à maintenir, et réellement très évolutive.
Active Server Pages dispose de cinq objets intégrés :
Ces objets possèdent des éléments de méthode, évènements et propriétés typiquement orientés objets. Quand un groupe de propriétés, s’apparentant à un objet, peut être classé comme une seule unité, cela s’appelle une collection. Les objets Request et Response ont des collections alors que les autres objets ont des propriétés ou, dans le cas de l’objet Application, seulement des évènements et des méthodes. |
| Objet Server |
Les méthodes et propriétés de l’objet Server permettent d’établir une interaction avec le serveur Web. L’objet Server possède une propriété ScriptTimeout afin d’éviter la saturation du système ainsi que les quatre méthodes suivantes :
Les méthodes et propriétés sont peu nombreuses dans l’objet Server, mais elles sont très utiles. L’objet Server permet, en effet, l’utilisation de composants ActiveX côté serveur dans les applications Internet. La méthode CreateObject de l’objet Server est vraisemblablement la méthode la plus importante de tout objet ASP intégré. En spécifiant l’identifiant (progID) d’un composant serveur, nous créons une instance de ce composant et lui assignons une variable objet. Nous pouvons créer des objets pour tout composant COM de notre système, mais non créer des instanciations des objets intégrés à ASP. Nous ne pouvons pas, par exemple, créer un objet Session avec cette syntaxe. Cependant, il est possible d’exploiter les cinq composants ActiveX côté serveur fournis avec les Active Server Pages que sont les composants Advertisement Rotator, Browser Capabilities, Database Access, Content Linking et TextStream. |
| Objet Application |
L’objet Application permet de partager des informations entre les utilisateurs de notre application. Lock et Unlock sont les deux méthodes de l’objet Application. La syntaxe de l’affectation d’une valeur à une variable dans l’objet Application est la suivante : Application(« nom_variable ») = variable Nous référençons la valeur de la variable de cette manière : MaVariable = Application(« nom_variable ») |
| Objet Session |
| Alors que l’objet Application stocke des valeurs et références des objets (connexions aux bases de données par exemple) de façon globale (valables pour toute l’application et disponibles dans toutes les pages), l’objet Session permet de partager les données entre les pages mais en aucun cas entre les clients. Ceci permet de résoudre le problème de persistance d’état souvent rencontré au cours du développement de sites Internet. Ce problème apparaissant lorsque nous avons besoin de suivre le parcours d’un utilisateur d’une page Internet à une autre, dans le cadre d’une application de boutique virtuelle, par exemple car la nature même du protocole HTTP, ignore les états. L’objet Session possède les propriétés SessionID,Timeout, la méthode Abandon ainsi que deux événements (OnStart et OnEnd). La syntaxe de l’affectation d’une valeur à une variable dans l’objet Session est la suivante : Session(« nom_variable ») = variable Nous référençons la valeur de la variable comme ceci : MaVariable = Session(« nom_variable ») |
| Objet Request |
L’objet Request reçoit les informations envoyées par le navigateur à l’aide d’une requête HTTP. Cinq types de variables peuvent être transmises à notre application à l’aide de l’objet Request. Chaque type possède sa propre collection dans l’objet Request :
Nous pouvons accéder aux variables en référençant l’objet Request, ensuite la collection, et enfin la variable souhaitée. Le nom de la collection est facultatif pour lire la valeur d’une variable. Si nous omettons le nom de la collection, la recherche de la variable demandée sera effectuée dans toutes les collections dans l’ordre ci-dessus. La syntaxe : Request[.Collection](variable) |
| Objet Response |
L’objet Response est utilisé pour renvoyer les informations au navigateur. Il dispose de méthodes et propriétés pour créer et modifier les informations retournées au navigateur ainsi que pour rediriger une requête vers une autre page. Alors que l’objet Request prend en compte ce qui est envoyé au serveur, l’objet Response se charge de ce qui est renvoyé par le serveur. Sa seule collection est la collection Cookies qui permet de définir des valeurs de cookies à l’inverse de la collection Cookies dans l’objet Request, utilisée pour lire les valeurs de cookies. L’objet Response dispose de plusieurs propriétés et méthodes. L’application la plus courante de l’objet Response est l’envoi d’une chaîne à afficher dans le navigateur. Il suffit de placer un signe égal (=) devant les informations à envoyer ou d’utiliser la syntaxe Response.Write, comme le montre les exemples ci-dessous. Premier exemple : <% For intLoop = 1 to 10 %> Deuxième exemple : <% For intLoop = 1 to 10 %> |
| Introduction |
| Nous donnons ci-après le détail du modèle objet en ASP. Les cinq objets intrinsèques des ASP : Server – Application – Session – Request – Response |
| Server | ||||||||||||||
Méthodes
Propriété
|
| Application | ||||||||||||||||||
Méthodes
Collections
Evénements
|
| Session | ||||||||||||||||||||||||||
Méthode
Propriétés
Evénements
Collections
|
| Request | ||||||||||||||||||||
Méthode
Collections
Propriété
|
| Response | ||||||||||||||||||||||||||||||||||||||||
Méthodes
Propriétés
Collection
|
| Intoduction |
| Ci-dessous, un descriptif de ADO. Vous trouverez les objets : Command, Connection, Error, Field, Parameter, Property, et Recordset, et également les collections Errors, Fields et Properties. |
| L’objet Command | ||||||||||||||||||||||
Méthodes
Propriétés
|
| L’objet Connection | ||||||||||||||||||||||||||||||||||||||||||
Méthodes
Propriétés
|
| L’objet Error | ||||||||||||||||
Propriétés
|
| L’objet Field | ||||||||||||||||||||||||||||||
Méthodes
Propriétés
|
| L’objet Parameter | ||||||||||||||||||
Propriétés
|
| L’objet Property | ||||||||||
Propriétés
|
| L’objet Recordset | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Méthodes
Propriétés
|
| La collection Errors | ||||||||||
Méthode
Propriétés
|
| La collection Fields | ||||||||||
Méthode
Propriétés
|
| La collection Parameters | ||||||||||||||
Méthodes
Propriétés
|
| La collection Properties | ||||||||||
Méthode
Propriétés
|
| La connexion à une base de données |
| La connexion à une base de données n’est pas très complexe. Il nous suffit de créer une instance de l’objet Connection, en affectant une référence d’objet à une variable (Set est utilisé pour cela) :
Set conn = Server.CreateObject (« ADODB.Connection ») L’instance de l’objet Connection est implémentée par le composant Active Database qui a pour identifiant (progID) ADODB. |
| Ouverture de la connexion |
| A lui seul, l’instance de l’objet Connection ne sert à rien tant que nous n’avons pas ouvert notre connexion à la source de données afin de manipuler les éléments (ajouts, suppression, modification) présents dans celle-ci. Pour ce faire nous utilisons la méthode Open de l’objet Connection. connection.Open ChaîneDeConnection, Nom_Utilisateur, MotDePasse ChaîneDeConnection est le paramètre désignant le DSN (Data Source Name) autrement dit, le nom de la source de donnée ou une série de paramètre=valeur séparés par des points virgules. Voici un exemple d’ouverture de connection utilisant un DSN appelé carnet : Set conn = Server.CreateObjet (« ADODB.Connection ») Pour des raisons de sécurité, il est possible d’employer un nom d’utilisateur et un mot de passe dans la chaîne de connexion, ceci dit ce n’est pas une obligation. Exemple d’ouverture de connection utilisant une chaîne de connexion : Set conn = Server.CreateObjet (« ADODB.Connection ») La connexion ainsi établie, nous pouvons l’utiliser… |
| Exécution de commandes sur la connexion | |||||||||||||||
| Pour modifier des enregistrements présents dans une base de données nous utilisons la méthode Execute. Cette instruction exécute une chaîne pouvant contenir : 1) Une requête SQL. * Une procédure stockée est une procédure existante dans un SGBD et contenant une ou plusieurs instructions SQL, ce qui présente l’avantage de manipuler les données en toute simplicité en utilisant uniquement le nom de la procédure. Supposons que la base Carnet contient une table nommée « contacts » et un seul champ nommé « Nom » (nous ne pouvons pas faire plus simple ;-)) Nous supprimons l’enregistrement « Albert » Exemple utilisant une chaîne SQL : Set conn = Server.CreateObjet (« ADODB.Connection ») Exemple utilisant une procédure stockée (DeleteJean, par exemple) : Set conn = Server.CreateObjet (« ADODB.Connection ») Dans le cas de figure où une base de données SQL Server (par exemple) serait utilisée, la chaîne de l’instruction Execute serait différente car celle-ci doit correspondre à la syntaxe du fournisseur et non à d’ADO. Exemple avec une base SQL Server : Set conn = Server.CreateObjet (« ADODB.Connection ») Il est possible d’améliorer l’exécution des commandes en spécifiant des paramètres optionnels… Connection.Execute TexteCommande, NbreEnregistrementModifiés, Options Le paramètre TexteCommande nous permet d’accélérer le processus dans sa globalité, en spécifiant au paramètre Options une des valeurs notifiées dans le tableau ci- dessous : Le paramètre Options spécifie le type d’instruction à exécuter. Le paramètre NbreEnregistrementModifiés est utilisé (en donnant à celui-ci un nom de variable) afin de permettre à ADO d’y mettre le nombre d’enregistrements modifiés par la requête (ou par la procédure stockée). Un petit exemple : Sans spécifier de paramètre : Set conn = Server.CreateObjet (« ADODB.Connection ») En spécifiant les paramètres optionnels
NomVar est le nom que nous avons donné à une variable contenant le nombre d’enregistrement modifiés. Set conn = Server.CreateObjet (« ADODB.Connection ») La valeur 1 correspond donc à la constante adCmdText. Il est à noter qu’il est tout à fait possible d’indiquer le nom des constantes à la place de leurs valeurs, ce qui donnera: Set conn = Server.CreateObjet (« ADODB.Connection ») Attention! Car pour ce faire, il nous faut inclure dans notre page un fichier de définition nommé Adovbs.inc (présent dans le tutoriel :)) fourni avec ASP et installé par défaut dans le répertoire ASPSamp\Samples. <!— #include file= »Adovbs.inc »–> Nous aborderons l’instruction #include plus loin dans ce tutoriel… |
| Fermeture de la connexion |
| A la fin de traitements sur une base de données, il nous faut toujours fermer la connexion avec l’instruction Close, puis (bien que ASP s’en charge automatiquement si ce n’est pas spécifié) libérer les ressources avec l’instruction Nothing.
Ce qui nous donne: conn.Close |
| Récupérer un Recordset |
| Afin de renvoyer, par l’intermédiaire d’ADO, des données ayant pour but de renseigner des valeurs dans la page, nous devons définir un objet Recordset qui contiendra les résultats. Nous pouvons avantageusement comparer un recordset à une table contenant des lignes (enregistrements) et colonnes (champs de données). Aussi, nous pouvons stocker les résultats d’une requête dans l’objet Recordset et nous pouvons renseigner les paramètres entre parenthèses. Set recordset = connection.Execute (TexteCommande, NbEnregModifiés, Options) |
| Création d’un Recordset à partir d’une requête |
| Supposons que la base carnet contienne une table nommée contacts et un seul champ nommé Nom. Pour des raisons de simplicités nous spécifions uniquement TexteCommande. Nous sélectionnons l’enregistrement « Albert » : Set conn = Server.CreateObjet (« ADODB.Connection ») Il est possible de préciser la nature de la requête SQL par exemple ou le nombre d’enregistrements modifiés en indiquant un nom de variable en paramètre NbEnreModifiés et indiquer également la valeur donné à Options : NomVar est le nom que nous avons donné à une variable. Set conn = Server.CreateObjet (« ADODB.Connection ») Il est à noter qu’il est également possible de créer un recordset directement à partir d’une table de données, cependant cette « pratique » ne permet pas de mise à jour directe de cette dernière : Set conn = Server.CreateObjet (« ADODB.Connection ») |
| Une autre façon de créer un Recordset | ||||||||||||
| Dans le cas où un seul accès à la base de données est prévue, nous pouvons faire l’impasse sur l’objet Connection par exemple et créer directement notre recordset grâce à la méthode Server.CreateObjet. La syntaxe dans ce cas est la suivante : Curseur.open Source, Connexion, TypeCurseur, TypeVerrou, Options
* ** *** NB: Pour utiliser le nom des constantes ci-dessus à la place de leur valeur nous devons inclure Adovbs.inc |
| Fermeture du Recordset |
rs.Close Set rs = Nothing |
| Introduction |
Nous allons apprendre maintenant à connecter une base de données Access 97 à un site Web. Pour cela, nous supposons que vous disposez :
|
| Création de la base | |||||
Nous allons créer une base très simple qui comprendra une seule table. Elle devra gérer un stock vestimentaire.
Afin de pouvoir utiliser la base dans notre exemple, remplissez-la de quelques articles. Important : Evitez de donner le même nom à un champ et à une table. Evitez aussi les accents, les majuscules et les pluriels. Pensez que cela vous donnera plus de travail par la suite ! |
| Déclaration de la base |
Voilà, votre base est prête, et correctement interfacée avec votre système. |
| La page ASP |
| <html> <body> <% ‘ nous créons la connexion à la base avec l’objet Connection set conn=server.createobject(« adodb.connection ») conn.open « nom de votre base » ‘ nous créons un Recordset et exécutons la requête SQL set rs=conn.execute(« select * from vetement ») howmanyfields=rs.fields.count -1 %> <table border=2> <tr> <% ‘ nous affichons for i=0 to howmanyfields %> <td><b><%=rs(i).name %></b></td> <% next %> </tr> <% ‘ nous affichons tous les enregistrements de la base do while not rs.eof %> <tr> <% for i = 0 to howmanyfields%> <td valign=top><% = rs.fields(i).value %></td> <% next %> </tr> <% rs.movenext loop conn.close %> </table> </body> </html> |
STRUCTURED QUERY LANGUAGE (SQL)
| Introduction |
| Le langage SQL est compris par toutes les bases de données actuelles. Celui-ci permet d’effectuer des requêtes multiples sur les SGBD (Système de Gestion de Base de Données). C’est un langage assez simple qui rend cependant possible l’accomplissement des actions complexes. |
| Sélectionner des enregistrements | ||||||||||||||
| L’instruction SELECT est employée pour rechercher des enregistrements, selon des critères spécifiques. Nous faisons usage de celle-si avec FROM pour spécifier le nom de la table concernée.
WHERE , LIKE sont utilisés dans la perspective d’une condition. SELECT champ1,champ2 FROM latable WHERE « condition » champ1 et champ2 sont les noms des champs latable : nom de la table dans laquelle nous souhaitons extraire les données WHERE est optionnel et indique une condition : cela peut être une clause de type égalité, supérieur ou autre. L’instruction LIKE s’emploie avec WHERE pour rechercher des enregistrements comprenant une chaîne. Elle utilise le signe % L’exemple ci-dessous recherche les adresses qui commencent par W dans la table contact SELECT adresse FROM contact WHERE adresse LIKE ‘W%’ NB : pour sélectionner tous les champs d’une table dans la requête nous utilisons * SELECT * FROM contact Nous pouvons aussi spécifier un ordre de tri grâce à ORDER BY Cet exemple sélectionne les adresses et les classe alphabétiquement par leur nom SELECT * FROM contact ORDER BY adresse NB : Il faut ajouter ASC pour un tri ascendant ou DSC pour un tri descendant. Opérateurs disponibles pour la condition WHERE :
|
| Ajouter des enregistrements |
| La commande INSERT INTO est utilisée pour ajouter des enregistrements dans une base de données. Celle-ci s’emploie avec VALUES pour inclure les données.
INSERT INTO nomtable (champ1,champ2,champn) VALUES (val1,val2,valn) nomtable : nom de la table où nous allons ajouter les enregistrements champn : champs de la table pour lesquel nous allons ajouter les valeurs valn : valeurs qui vont être ajoutées dans les champs Exemple : INSERT INTO contact (nom,prenom,ville) VALUES (‘Mocq’,David’,’Paris’) Remarque importante : les valeurs chaîne doivent être entre guillemets ‘ (simple quote) |
| Mettre à jour des enregistrements |
| L’instruction UPDATE sert à mettre à jour des enregistrements. Elle s’utilise en association avec SET et un opérateur. Nous faisons aussi usage de l WHERE (syntaxe vue précédemment) :
UPDATE nomtable SET champ1operateur valeur,champn OPERATEUR valeurn WHERE champx OPERATEUR valx nomtable : nom de la table dans laquelle va s’effectuer la mise à jour d’un (ou plusieurs) enregistrement(s) champ représente le ou les champs de la table champx=valx représente la condition de mise à jour opérateur Exemple ayant pour but de remplacer la valeur actuelle du champ nom par la valeur Mocq pour l’enregistrement où l’ID (numéro identificateur) est 33 : UPDATE nom SET nom=’Mocq’ WHERE id=33 nom : nom de la table NB : Attention! Les valeurs chaîne doivent être entre guillemets ‘ (simple quote) |
| Créer une table | ||||||||||
| L’instruction CREATE TABLE sert à créer une table, et également les champs de cette dernière.
CREATE TABLE nomtable (champ1 type(contrainte),champn type(contrainte)) nomtable : nom de la table à créer champ1 : nom du champ à créer type : type de champ dont les valeurs possibles sont définies ci-dessous :
Exemple : CREATE TABLE client (nom varchar(60),prénom varchar(60),codepostal number(5)) client : nom de la table créée nom : chaîne de caractères avec un maximum de 60 prenom : chaîne de caractères avec un maximum de 60 codepostal : champ numérique à 5 chiffres NB : Les contraintes , c’est-à-dire les valeurs entre parenthèses après le type de champ, sont optionnelles. |
| Supprimer des enregistrements |
| La fonction DELETE est utilisée dans le but de supprimer des enregistrements dans une table. Elle s’emploie avec l’ instruction FROM et accepte la condition WHERE.
DELETE FROM nomtable WHERE champn operateur valeurn nomdetable : nom de la table où nous allons effacer les enregistrements champn operateur valeurn : représente la condition de suppression Exemple : DELETE FROM contact WHERE nom=’Dupond’ Ici, nous effaçons de la table contact l’enregistrement pour lequel le champ nom a la valeur Dupond. NB : Les valeurs doivent être entre guillemets ‘ (single quote) |
| Introduction |
| L’objet Dictionary se présente comme un tableau à deux dimensions, qui associe la clé et sa valeu :, les données en mémoire sont par conséquent identifiées avec une clé. Pour accéder aux données de l’objet Dictionary, nous nous servons de ses méthodes et propriétés. |
| Les propriétés de l’objet DICTIONARY |
| Au nombre de quatre, celles-ci permettent d’obtenir le nombre de paires nom-valeur, d’obtenir ou de définir la valeur à partir du nom d’une clé existante, de créer une nouvelle paire nom-valeur ou enfin de modifier le mode de comparaison pour les clés.
La propriété CompareMode : Cette propriété est employée afin de définir (ou obtenir) le mode de comparaison de chaîne utilisé pour les recherches dans les clés. Il peut s’agir d’une comparaison tenant compte de la casse ou non (respect des majuscules/minuscules). La valeur de la propriété CompareMode ne peut être définie que pour un objet ne possédant encore aucune entrée. Cette propriété n’est actuellement prise en charge que dans VBScript. Mais vous devrez créer explicitement les constantes si vous souhaitez vous servir des constantes nommées. Par défaut CompareMode vaut vbBinaryCompare (comparaison binaire). Nous pouvons aussi utiliser une comparaison textuelle en attribuant VbTextCompare à CompareMode. La propriété Count : Cette propriété (en lecture seule) retourne le nombre de paires nom-valeur stockées dans l’objet Dictionary. La propriété Item : Défini ou récupère la valeur correspondante à une clé donnée. objDict.Item(clé)[ = valeur] clé : nom de clé identifiant la valeur que nous souhaitons définir ou récupérer. La propriété Key : Cette propriété est utilisée dans le but de redéfinir le nom de la clé pour une paire nom-valeur existante, ou bien à créer une nouvelle paire nom-valeur (mais dont l’élément est vide). objDict.Key(clé) = Nom clé : ce paramètre spécifie la clé avec son nom actuel |
| Les méthodes de l’objet DICTIONARY |
| L’objet Dictionary possède six méthodes, permettant ainsi d’ajouter, de supprimer ou de récupérer des paires nom-valeur ainsi que de vérifier l’existence d’une clé.
La méthode Add : Cette méthode ajoute une paire nom valeur à un objet Dictionary. objDict.Add nom, valeur Nom : nom de clé qui identifie la valeur La méthode Exists : Cette méthode sert à vérifier l’existence d’une clé dans un objet Dictionary. Elle retourne true lorsque la clé existe, false sinon. [bExiste = ]objDict.Exists(clé) clé = ce paramètre spécifie le nom de la clé recherchée. La méthode Items : Cette méthode retourne un tableau contenant tous les éléments de l’objet Dictionary. [arElmts = ]objDict.Items La méthode Keys : Cette méthode retourne un tableau contenant toutes les clés de l’objet Dictionary. [arClés = ]objDict.Keys La méthode Remove : Cette méthode permet de supprimer une paire nom-valeur dans un objet Dictionary. objDict.Remove NomClef NomClef : ce paramètre spécifie un nom de clé qui identifie la paire nom-valeur à supprimer. La méthode RemoveAll : Cette méthode efface tout le contenu d’un objet Dictionary en supprimant toutes les paires nom-valeur. objDict.RemoveAll |
| Exemple |
Création des paires nom-valeur Dim objMyData Set objMyData = CreateObject(« Scripting.Dictionary ») objMyData.Comparemode = 0 objMyData.Add « Pantalon », « Vert » objMyData.Add « Chemise », « Rouge » Récupérer les paires nom-valeur response.write=objMyData.item (« Chemise ») Vérification et modification des paires nom-valeur if objMyData.Exists(« Chemise ») then objMyData.Key(« Chemise ») = « Pull » ‘La clé Chemise est remplacée par la clé Pull Affichage de toutes les paires nom-valeur Response.Write « Listing des clés : » dim arKeys, i arKeys = objMyData.keys For i = 0 to objMyData.Count -1 Response.Write » <p>Clé : » & arKeys(i) & » Valeur : » & objMyData.Item(arKeys(i)) |
| Introduction |
Querystring est utilisé lorsque nous souhaitons transmettre les informations recueillies d’une page à une autre. Il est également tout à fait possible de sauvegarder ces dernières dans une variable Session. |
| Utilisation |
| QueryString permet de retrouver les valeurs attribuées en fin de chaîne URL. Ces dernières sont visibles dans la barre d’adresse de votre navigateur lorsque nous cliquons sur le lien.
Nous attribuons une ou plusieurs valeurs à la fin d’un lien, à l’aide de ? : <A HREF= »query.asp?nomvaleur=valeur »>valeur</A> En cas de multiples valeurs à utiliser, l’on se sert de & <A HREF= »query.asp?nomvaleur=valeur&valeur2=valeur2″>valeur</A> Puis les valeurs sont récupérées avec Request.querystring : <% =request.querystring(« nomvaleur ») %> NB :Nous pouvons évidemment stocker cette valeur avec l’objet Session : <% Session(« valeur »)=Request.QueryString(« nomvaleur ») %> |
| Exemple |
| Le code de la première page à sauvegarder sous pagea.asp :
<html> <head> <title>Test QueryString</title> </head> <body> <br> Où habitez-vous ? <A HREF= »pageb.asp?ville=paris>Paris</A> <A HREF= »pageb.asp?ville=versailles>Versailles</A> <A HREF= »pageb.asp?ville=marseille>Marseille</A> <A HREF= »pageb.asp?ville=toulouse>Toulouse</A> </body> </html> Et le code de la deuxième page à sauvegarder sous pageb.asp : <html> <head> <title>Test QueryString</title> </head> <body> <br> Vous habitez <% =request.querystring(« ville ») %> |
| Introduction |
| Un cookie est une variable qui est stockée sur la machine de l’utilisateur, et se présente la plupart du temps sous la forme d’un petit fichier qui stocke un certain nombre d’informations (comme par exemple le nom du visiteur, ses préférences, etc.).
La manipulation des cookies est simple avec ASP. Pour lire les Cookies de l’utilisateur, nous utilisons la collection Cookies de l’objet Request. Pour définir un cookie, nous utilisons la collection Cookies de l’objet Response. |
| Enregistrer les données | ||||||||||||
| Pour affecter une valeur à un cookie, nous utilisons l’objet Response
Response.Cookies(cookie)[(Key)|.attribute]=value Le paramètre attribute spécifie des informations sur le cookie Attributs des cookies :
Par exemple, le code suivant écrit une valeur dans le cookie Utilisateur, celui-ci ne possède qu’une seule valeur, Ad : <% Response.Cookies (« Utilisateur »)= »Ad » %> Il est également possible d’assigner une clé à une valeur, mais il faut pour cela créer un Dictionnaire : un cookie avec un tableau de clefs correspondant chacune à une valeur. L’exemple suivant écrit deux valeurs dans le dictionnaire Voiture : <% Response.Cookies (« Voiture ») (« couleur ») = « Rouge » (« ligne ») = « Tourisme » Response.Cookies (« Voiture ») %> |
| Lire les données |
| Pour lire les cookies présents sur la machine de l’utilisateur, il faut faire appel à la collection Cookies de l’objet Request.
Request.Cookies(cookie)[(key)|.attribute] Chaque valeur ayant un nom (une clef), nous pouvons lire le contenu d’un cookie pour savoir s’il contient plus d’une clef en lisant la propriété HasKeys du cookie. Etant donné que la propriété sera vraie ou fausse, nous pouvons donc utiliser If…Then…Else. <% If Request.Cookies(« MonCookie »).Haskeys then %> MonCookie dispose des valeurs suivantes : <P><% For each key in Request.Cookies(« MonCookie ») %> <% = key %> <% Request.Cookies (« MonCookie ») (key) %> <% Next %> <% Else %> La valeur de mon cookie est<% =Request.Cookies (« MonCookie ») %> <% End If %> |
| Introduction |
| L’objet Session permet de partager les données entre les pages, non entre les clients. Chaque client accédant à une page est doté d’un objet Session. Par défaut, la durée de vie de cet objet est de 20 mn ; par conséquent, une session est créée automatiquement dès le premier accès d’un client, puis détruite au bout de ce laps de temps.
Le client se voit donc attribuer un identifiant de session (SessionID) par le serveur (n’est disponible qu’en lecture seule), afin de l’identifier tout au long de son parcours sur un site Internet. Remarque importante : la SessionID est stockée sous forme de cookie ; par conséquent si le navigateur de l’utilisateur ne supporte pas ces derniers ASP, il n’a pas la possibilité de créer celui-ci. |
| L’objet Session | ||||||||||||||||||||
| L’objet Session possède une méthode, des propriétés et des collections.
Méthode
Propriétés
Collections
|
| Exemple |
| Une petite application en deux pages asp déterminant l’accès à une page…
Première page à sauvegarder sous session.asp <html> Deuxième page à sauvegarder sous sortie.asp <% |
| Introduction |
| Inclure des SSI est une pratique souvent employée et utile pour simplifier la gestion d’un site, tant au niveau de son fonctionnement qu’au niveau de la facilité de mise à jour. Les SSI sont réalisés avant le traitement de l’interpréteur ASP ; par conséquent, il n’est pas possible de coder la décision d’utiliser telle ou telle « inclusion », car elles sont toutes incluses automatiquement. |
| Adresse physique et virtuelle d’un fichier |
| L’instruction #include vous permet de spécifier le chemin physique ou virtuel (alias) d’un fichier. Pour un fichier se trouvant par exemple dans le répertoire c:\InetPub : Chemin physique <!— #include file= »c:\InetPub\nom_fichier.txt » –> Chemin virtuel On peut aussi utiliser un chemin relatif Il est possible d’utiliser des SSI au format texte (comme ci-dessus) dans une page mais également des formats tels que .htm, .html, .asp, .inc .inc est un format spécialement indiqué par Microsoft pour les #include ; en tout cas, c’était la politique de départ, car la firme suggère plutôt maintenant le format .asp L’avantage de l’utilisation de .inc est que les fichiers se chargent plus rapidement, mais présentent comme défaut le fait qu’il est très facile de télécharger ces fichiers par un internaute connaissant la localisation sur le serveur de ceux-ci. |
| Exemple |
| Vous vous souvenez de votre première page ASP (Hello World) ?… Vous allez maintenant obtenir exactement le même résultat, mais cette fois-ci, en utilisant l’instruction #include :
Enregistrez la page hello2.asp ci-dessous dans le répertoire « test » <HTML> <!— #include file= »script.inc » –> </BODY> Enregistrez maintenant le code suivant sous le nom script.inc (par exemple) dans le même répertoire (test) : <% For i = 3 To 6 %> Voyez maintenant le résultat dans votre navigateur 🙂 NB : comme indiqué dans la partie « Démarrer avec les Active Server Pages », indiquez la bonne URL dans la barre de votre navigateur (http://serveur/test/hello2.asp). |
| Introduction |
| La création de nombres aléatoires peut être utile pour afficher, par exemple, de multiples messages d’accueil et bien d’autres choses (comme des tirages au sort…). |
| Utilisation et exemple |
| Randomize est un générateur de nombres aléatoires. Celui-ci s’utilise avec la fonction RND. Cette dernière va permettre de fixer des limites. C’est-à-dire que vous pouvez choisir la plage de nombres tirés au hasard. Par exemple : choisir un nombre au hasard entre 0 et 10 ou entre 0 et 19998, etc.
L’exemple suivant va « sortir » un chiffre au hasard parmi 9. Selon le résultat, il va afficher une citation. La fonction Int doit être utilisée afin d’afficher les entiers. Vous pouvez sauvegarder la page sous le nom de cita.asp par exemple 🙂 <html> <head> <title>Une citation aléatoire</title> </head> <Body> <p>Voici une citation au hasard. Rechargez la page afin d’en découvrir une autre… <p> <% Randomize ‘Appel au générateur intchoice=Int(Rnd*9) ‘Tirage aléatoire Select Case intchoice ‘ Sélection parmi les choix suivants Case 0%>Tant va la cruche à l’eau qu’à la fin elle se casse (La Fontaine) <%Case 1%> Tout flatteur vit aux dépens de celui qui l’écoute (La Fontaine) <%Case 2%>Rien n’est plus semblable à l’identique que ce qui est pareil au même (Pierre Dac) <%Case 3%> Je veux bien être embêté par les femmes, mais pas tout le temps par la même – Capus- <%Case 4%> Si les femmes étaient bonnes, Dieu en aurait une (Coluche) <% End Select %> ‘ Fin de selection </Body> |