Ce que j'ai écrit avant :
Tous ceux qui écrivent des programmes savent que lorsque vous développez progressivement les fonctions que vous souhaitez implémenter, la plupart du temps, ce que vous avez écrit le premier jour sera oublié le lendemain. Plusieurs fois, vous devez écrire des notes détaillées sur le développement du programme. Cela est particulièrement vrai dans le développement de systèmes ASP lorsque les fichiers et les fonctions sont complexes. Lorsque nous envisageons de modifier certaines fonctions du site Web, nous sentons que nous ne savons pas par où commencer ni ce qui, selon nous, doit être modifié. À ce stade, si vous avez appris un langage de programmation orienté objet, vous réfléchirez naturellement à la façon d'implémenter la fonction de code dans les modules. ASP n'est pas par nature une programmation orientée objet, mais VBSCRPIT6.0 fournit des classes. Réaliser l'encapsulation du code et implémenter le langage du module.
Tout d'abord, je veux écrire ici quelques concepts très officiels, qui visent à illustrer que l'orientation objet est un modèle très concret et substantiel, et que certaines personnes ne peuvent pas être effrayées lorsqu'elles voient l'objet.
Un objet est quelque chose qui peut être vu, ressenti, entendu, touché, goûté ou senti. Ici, nous le définissons ainsi : un objet est une entité autonome identifiée par un ensemble de propriétés et de comportements identifiables.
En programmation orientée objet (oop), les deux termes suivants sont utilisés.
Classe : Il s'agit du modèle d'un objet et définit les caractéristiques de l'objet.
Instance : Il s'agit d'un objet réel, avec lequel vous pouvez interagir.
Propriétés, méthodes et événements
En POO, les termes suivants décrivent les caractéristiques des objets :
Attribut : Il s'agit d'un classement qui décrit les attributs d'un objet.
Méthode : Il s’agit d’un verbe qui décrit ce qu’un objet peut faire ou ce qu’il est censé faire.
Événement : décrit l'opération effectuée par un objet en réponse à une action.
Les objets font partie de la programmation orientée objet et de la conception orientée objet. Ils présentent de très grands avantages. Beaucoup de gens pensent que c'est un sujet compliqué, mais en fait, c'est très simple et peut être expliqué en quatre termes simples : Abstraction, encapsulation, polymorphisme et héritage.
Abstraction : C'est une façon de cacher la complexité, le fonctionnement interne d'une classe, afin que l'utilisateur n'ait pas besoin de savoir comment cela fonctionne, juste comme ça. Si vous voulez regarder la télévision, vous n'avez pas besoin de savoir comment fonctionne la télévision. Il vous suffit d'allumer la télévision et de rechercher les chaînes. L'interrupteur marche/arrêt résume l'opération réelle. Dans l'exemple de chaîne, il y a un. méthode trim, qui peut supprimer Pour l'espace à la fin de la chaîne, vous n'avez pas non plus besoin de savoir comment elle accomplit cette tâche, il vous suffit de savoir qu'elle a cette fonction.
Encapsulation : chaque objet contient toutes les informations nécessaires pour effectuer des opérations. Cet objet est appelé encapsulation, donc l'objet ne s'appuie pas sur d'autres objets pour terminer ses opérations. Dans la méthode TOupper(), la chaîne n'a pas besoin d'obtenir d'informations d'autres objets. endroits pour terminer ses opérations. Tous les caractères sont convertis en majuscules.
Polymorphisme : ce terme est utilisé pour indiquer que différents objets peuvent effectuer la même action, mais via leur propre code d'implémentation. Le nom est le même, mais le code d'implémentation sous-jacent est différent.
Héritage : il définit la manière dont les classes sont liées les unes aux autres et partagent des caractéristiques. La façon dont fonctionne l'héritage consiste à définir des classes et des sous-classes, où la sous-classe hérite de toutes les caractéristiques de la classe parent. L'importance de l'héritage est qu'il force les classes de types similaires à le faire. avoir de la cohérence et permet le partage de code sans avoir à définir toutes les caractéristiques de la classe parent si l'on décide de créer une nouvelle classe.
Utiliser des classes en ASP pour atteindre la modularité
Laissez-moi vous expliquer en donnant quelques exemples simples. Notez que ce qui est souligné ici est une idée. Si vous pouvez utiliser une classe (classe de base) pour vous développer lorsque vous développez un site Web ASP, cela est très nécessaire (également très difficile).
Choisissons d’abord un exemple simple :
Nous souhaitons afficher les informations des utilisateurs du forum classique. Après avoir saisi l'identifiant de l'utilisateur, certaines informations de l'utilisateur peuvent être affichées. Vous pouvez le considérer de cette façon. Nous traitons l'utilisateur comme un objet. ID et sexe., Points, autorisations, la méthode d'implémentation consiste à afficher ces informations, ok, écrivez comme ceci :
Idée bleue de classe
Bname privé, bpoint, bsex, blevel
'........................
terminer le cours
Ici, nous déclarons d'abord une classe nommée blueidea, suivie de quelques variables privées pour stocker les propriétés de la classe blueidea. Ces variables ne sont pas accessibles depuis l'extérieur du code. Pour définir ces variables, utilisez l'instruction de propriété pour obtenir la. valeur. Payer indirectement aux variables privées.
'------------------------------------------------ - ---------------
Propriété Obtenir getname
getname = nomb
Propriété de fin
Propriété Let getname(nameid)
bname=nomid
Si nameid= Alors
bname=Aucun utilisateur enregistré
Fin si
Propriété de fin
'------------------------------------------------ - -----------------
Propriété Obtenir Getsex
getsex = bsex
Propriété de fin
Propriété Louer getsex(sexe)
bsex=killint(sexe,0,0)
Si bsex=0 Alors
bsex=homme
Autre
bsex = femme
Terminer si
Propriété de fin
'------------------------------------------------ - -----------------
Propriété Obtenir le point d'accès
getpoint=bpoint
Propriété de fin
Propriété Soit getpoint(point)
bpoint=killint(point,0,0)
Propriété de fin
'------------------------------------------------ - -----------------
Il existe ici une fonction killint pour déterminer la validité des données. Son prototype est :
Fonction privée killint (i, killstr, killsub)
Si ce n'est pas EstNumérique(i) Alors
je = killstr
SinonSi je<=0 Alors
je = killsub
Terminer si
killint=Int(Gauche(i,5))
Fonction de fin
Le fonctionnement de cette fonction est très clair et n'est plus compliqué.
Puisque nous devons juger le niveau de l'utilisateur à travers des points, une fonction privée est définie ici :
Fonction privée getlevel()
bpoint=killint(bpoint,0,0)
Si bpoint<500 Alors
blevel=membre junior
SinonSi bpoint>=500 Et bpoint<=100 Alors
blevel=Membre Premium
Autre
blevel=membre ultime
Fin si
Getlevel=blevel
Fonction de fin
Si l'on veut renvoyer les informations de l'utilisateur, il faut définir une fonction publique pour afficher les informations :
Fonction publique showuser()
réponse.write(<h5>Ce qui suit montre les informations de <font color=red>&bname&</font> :</h5>)
réponse.write(<h5>Sexe :<font color=red>&bsex&</font></h5>)
réponse.write(<h5>Points :<font color=red>&bpoint&</font></h5>)
obtenir le niveau
réponse.write(<h5>Niveau :<font color=red>&blevel&</font></h5>)
Fonction de fin
Fin du cours
Lorsque vous utilisez cette classe, utilisez-la comme ceci : (j'ai écrit un traitement de formulaire ici)
Définir blueideauser=nouvelle idée bleue
blueideauser.getname=Trim(requête(id))
blueideauser.getsex=requête(sexe)
blueideauser.getpoint=requête(point)
blueideauser.showuser
Si vous voulez voir l'effet, jetez un oeil ici : http://www.5do8.com/net/aspclass/class.asp
Classe qui contrôle la lecture des informations de la base de données :
Code source de référence
'Nom : ado_5do8
'Fonction : Lire diverses opérations de la base de données
'Village cultivé à la source http://www.5do8.com http://www.Blueidea.com-5do8
'Création : 5do8
'Contact:[email protected]
'Mise à jour : 13 novembre 2005
« Autorisation : les points du site Web Blue Ideal dépassent 3 000, tous les utilisateurs enregistrés du village de Gengyun
'Interface de la classe : ado_5do8.ConnectString=chemin absolu vers la base de données
'ado_5do8.rs_top nombre d'appels, nom de la table
Classe ado_5do8
Connexion privée, sqlstr, rs, iid, itable, isession
'sqlstr : adresse de la base de données, chemin absolu, privé
'conn : Ouvrir la connexion à la base de données, privée
'------------------------------------------------ - -----------------
rem élimine certains numéros indésirables
Fonction privée litière_in(r1,r2)
Si IsNumeric(r1) et IsNumeric(r2) Alors
Faible, faible
Si r1>r2 Alors
dimrr=r2
Autre
dimrr=r1
Fin si
Autre
dimrr=0
Terminer si
litière_in = dimrr
Fonction de fin
'------------------------------------------------ - ---------------
Fonction privée killint (i, killstr, killsub)
Si ce n'est pas EstNumérique(i) Alors
je = killstr
SinonSi je<=0 Alors
je = killsub
Terminer si
killint=Int(Gauche(i,5))
Fonction de fin
'------------------------------------------------ - ---------
sous-privé startconn()
En cas d'erreur, reprendre ensuite
Définir conn=server.CreateObject(adodb.connection)
strconn=Provider=Microsoft.Jet.OLEDB.4.0;Source de données= & Server.MapPath(sqlstr)
conn.open strconn
Si erreur alors
err.Effacer
SetConn=Rien
mess=Une erreur s'est produite et impossible de se connecter à la base de données
réponse.write(mess)
réponse.Fin
Autre
mess=Connecté à la base de données avec succès.......<br/>
réponse.write(mess)
Fin si
Fin du sous-marin
'------------------------------------------------ - ---------------
sous-privé closeconn()
connexion.fermer
Définir conn=Rien
réponse.write(<strong style='color:red'>Fermer la connexion</strong>...<hr/>)
Fin du sous-marin
'------------------------------------------------ - ---------------
Ferme-portes privés()
rs.fermer
Définir rs=Rien
réponse.write(<strong style='color:#085420'>Fermer la base de données RS</strong>.....<br/>)
Fin du sous-marin
'------------------------------------------------ - ---------------
Propriété Prendre possession
havese=isession
Propriété de fin
Propriété Louer(votresession)
isession=votresession
Si votre session = Alors
isession=nodef
Fin si
Propriété de fin
'------------------------------------------------ - ---------------
Fonction publique makesession (arraydata)
Si IsArray (arraydata) alors
makear = données de tableau
Autre
makear=Tableau(0,0,0,0)
Fin si
Si isession= Alors
isession=nodef
Terminer si
session(isession)=makear
Fonction de fin
'------------------------------------------------ - ---------------
Fonction privée getsession()
thisget=session(isession)
Si ce n'est pas IsArray (thisget) alors
thisget = Tableau (0,0,0,0)
Fin si
Getsession=thisget
Fin de fonction
'------------------------------------------------ - ---------------
Propriété GetConnectString
ConnectString = sqlstr
Propriété de fin
Propriété Let ConnectString(str)
sqlstr = chaîne
Propriété de fin
'------------------------------------------------ - ---------------
Propriété Obtenir getid
getid = iid
Propriété de fin
Propriété Let getid(id)
iid = identifiant
Propriété de fin
'------------------------------------------------ - ---------------
Propriété Devenir accessible
gettable = itable
Propriété de fin
Propriété Let gettable(table)
tableau = tableau
Propriété de fin
'------------------------------------------------ - ---------------
'------------------------------------------------ - -----------------
Fonction publique readarraysession (iStart, ipageno, irowid)
ID ligne=killint(Irowid,0,0)
start=killint(istart,0,0)
pageno=killint(ipageno,5,5)
data=getsession
iRows = UBound (données, 2)
iCols = UBound (données, 1)
réponse.write(<h5> nombre total obtenu :)
réponse.write(<b> &iRows+1&</b> messages</h5><hr/><ul style='width:100%;'>)
Si rowid = 0 alors
Si iRows > (ipageno + iStart) Alors
iStop = ipageno + iStart - 1
Autre
iStop = iRangées
Fin si
Pour iRowLoop = Démarrer jusqu'à iStop
Response.Write (<li style='padding:4px 0;'><a href=?k=read&rowid=&irowloop+1&>&data(1, iRowLoop) & </a><span style='padding:4px 0 4px 10px;background-color:#ccc; '>Plus lent, il n'est pas recommandé de cliquer--><a href=?k=list&id=&data(0,irowloop)&>mise à jour</a></span></li>)
Suivant
Response.Write </ul><div style='top:20px;background-color:#ccc;color:#020;font-weight:bold;bordr-top:2px solid #008;padding:10px 0;color: #b00'>Liste (<a href=default.asp>Retour au mode typique</a>) :
si Début > 0 alors
Response.Write <A HREF=?k=read&Start= & iStart-ipageno &&pageno= & ipageno & >Précédent</A>
finir si
si iStop < iRows alors
Response.Write <A HREF=?k=read&Start= & iStart+ipageno &&pageno= & ipageno & >Suivant</A>
finSi
réponse.write</div>
Autre
rowid=litter_in(rowid-1,iRows)
réponse.write(<div style='width:85%'><h4 style='text-align:center'><a href=?k=read&pageno=&pageno&&start=&start&>Liste de retour</a></h4></h2><hr/><h5>&server.htmlencode(data(1,rowid))&</h5><p >&server.htmlencode(data(2,rowid))&<h5>+-----&server.htmlencode(data(3,rowid))&)
réponse.write(<div>)
Terminer si
Fonction de fin
'------------------------------------------------ - ---------------
Fonction publique list_ids()
sql3=select * from &itable& où id=&iid&
démarrerconn()
Définir rs=conn.execute(sql3)
Si rs.eof et rs.bof Alors
données = Tableau (0,0,0,0)
Autre
data=Rs.GetRows()
Fin si
ferme-portes
connexion fermée
réponse.write(UBound(data)& :)
réponse.write(server.htmlencode(data(2,0)))
Fin de fonction
'------------------------------------------------ - ---------------
Fonction publique rs_top(num,table,whe)
démarrerconn()
sql=sélectionner le &num& supérieur * de la &table&
sql2=sélectionnez count(*) comme szd_count depuis &table& &whe&
Définir rs=conn.execute(sql2)
szd_count=rs(szd_count)
ferme-portes
Définir rs = Conn.Execute(sql)
estomper les données
Si Rs.Eof Alors
données = pas de données
Autre
data=Rs.GetRows()
Terminer si
ferme-portes
fermeture de connexion()
L'appel établit une session (données)
Fonction de fin
'++++++++++++++++++++++++++++++++++++++++++++++++++++ + ++++++++++
Fin du cours
Lors de l'utilisation :
Action faible
action=demande(k)
Si action = vue Alors
Afficher l'appelnouveau
SinonSi action=liste Alors
Liste d'appels()
SinonSi action=lire Alors
Appelez read()
Autre
Appeler()
Terminer si
Subff()
%>
<form style=border-top:2px solid #008;border-bottom:2px solid #008;margin:auto;background-color:#eee;padding:20px 5px;color:#008;font-weight:bold;>
<label>Quantité totale d'informations affichées :<input name=n type=text maxlength=4 size=10 />Nombre de pages par page :<input name=pagesize type=text maxlength=4 size=10 value=5/> <nom d'entrée =arrstart type=valeur cachée=0></label>
<h5 style=border-top:1px solid #000;padding:5px 0> Opération :<input name=k type=submit value=view /></h5>
</form> <%End sub%>
<%Sub viewnew()
f_num=killint(requête(n),1,1)
pagesize=killint(requête(pageno),5,5)
arrstart=killint(requête(début),0,0)
ID de ligne=killint(requête(ID de ligne),0,0)
Définir cs = nouveau ado_5do8
cs.ConnectString=data/a.mdb
cs.havese=shi
cs.rs_top f_num,site_szd,
cs.readarraysession arrstart, taille de page, ID de ligne
Fin du sous-marin
Sous-liste()
réponse.write(<h5><a href=default.asp>Retour au mode par défaut</a></h5>)
Des informations spécifiques sont affichées sous réponse.write :<hr/>
identifiant = demande (identifiant)
identifiant=killint(id,1,1)
Définir listid=new ado_5do8
listid.ConnectString=data/a.mdb
listid.getid=identifiant
listid.gettable=site_szd
listid.list_ids()
Fin du sous-marin
Sous-lecture()
réponse.write<div style='background-color:#ccc;padding:20px 0;color:080;font-weight:bold;border-bottom:2px solid #008'>L'analyse de la page est terminée. Pour mettre à jour, veuillez. sélectionnez <a href=default.asp>Retour au mode typique</a>Paramètres : Début, élément de démarrage, nombre d'éléments par page</div>
pagesize=killint(requête(pageno),5,5)
arrstart=killint(requête(début),0,0)
ID de ligne=killint(requête(ID de ligne),0,0)
Définir cs = nouveau ado_5do8
cs.havese=shi
cs.readarraysession arrstart,pagesize,rowid
Fin du sous-marin
Fonction killint(i,killstr,killsub)
Si ce n'est pas EstNumérique(i) Alors
je = killstr
SinonSi je<=0 Alors
je = killsub
Terminer si
killint=Int(Gauche(i,5))
Fonction de fin
%>