Im Internet gibt es viele ASP-Komponenten, die Miniaturansichten generieren. Wenn Ihr virtueller Bereich die Registrierung neuer Komponenten nicht unterstützt, haben Sie möglicherweise das Gefühl, dass Ihre Website ihren Glanz verloren hat. Ich bin nicht sehr talentiert, daher habe ich Online-Ressourcen kombiniert, um ein komponentenfreies Programm zur Erstellung von Miniaturansichten zu schreiben, das nur als Referenz dient.
Werfen wir zunächst einen Blick auf die Grundlagen. Zunächst wissen wir, dass der Code zum Anzeigen von Bildern auf der Seite wie folgt lautet:
<img src=pic.gif border=0 width=300 height=260>
src ist der Bildpfad, border steuert die Kantenbreite des Bildes, width ist die Länge des Bildes und height ist die Höhe des Bildes. Bei der Erstellung von Miniaturansichten wird tatsächlich auf die Originalgröße skaliert. Aber im Allgemeinen skalieren wir proportional, um Verzerrungen zu minimieren. Daher ist das Ermitteln der Längen- und Breitenabmessungen des Bildes zum Schwerpunkt bei der Erstellung von Miniaturansichten geworden.
Hier sind die Schritte zum Schreiben einer komponentenfreien Miniaturbildgenerierung:
1. Bildgröße ohne Komponenten ermitteln
Vor nicht allzu langer Zeit, als ich ASP zum ersten Mal lernte, sah ich einen Artikel, in dem ASCII-Code verwendet wurde, um die Bildgröße ohne Komponenten zu ermitteln. Später habe ich es versucht und festgestellt, dass die Größe von JPG-Bildern nicht korrekt angezeigt werden konnte. Ich habe online nachgesehen und festgestellt, dass viele Websites dieses Programm nachgedruckt haben, aber niemand hat auf die Mängel dieses Programms hingewiesen, geschweige denn die Mängel behoben gelöst. Später habe ich erneut gegoogelt und schließlich einen Artikel gefunden, in dem die Verwendung von ADODB.stream zum Erhalten der Bildgröße vorgestellt wurde. Ich habe den darin enthaltenen Code geändert und ausprobiert. Jetzt werde ich ihn teilen mit dir. :
Verwenden Sie ADODB.stream, um die allgemeine Klasse der Bildgröße abzurufen
<%
'///////////// GPS: Bildgröße abrufen ///////////////
'//////////////Verwenden Sie ADODB.stream, um die Bildgröße zu erhalten///////////////
'/////////Zitiert von Leon (心清) 11. August 2005//////////
Klasse GPS
Dimmen usw
Private Sub Class_Initialize
Setze aso=CreateObject(Adodb.Stream)
aso.Mode=3
aso.Type=1
usw.Öffnen
Sub beenden
Private Unterklasse_Terminate
setze aso=nichts
Sub beenden
Private Funktion Bin2Str(Bin)
Dim I, Str
Für I=1 bis LenB(Bin)
clow=MidB(Bin,I,1)
wenn AscB(clow)<128 dann
Str = Str & Chr(ASCB(clow))
Anders
I=I+1
wenn I <= LenB(Bin) dann Str = Str & Chr(ASCW(MidB(Bin,I,1)&clow))
endIf
Nächste
Bin2Str = Str
Funktion beenden
Private Funktion Num2Str(num,base,lens)
'GPS (2005-8-11)
schwach ret
ret =
while(num>=base)
ret = (num mod base) & ret
num = (num - num mod base)/base
wenden
Num2Str = right(string(lens,0) & num & ret,lens)
Funktion beenden
Private Funktion Str2Num(str,base)
'GPS (2005-8-11)
schwach ret
ret = 0
für i=1 bis len(str)
ret = ret *base + cint(mid(str,i,1))
nächste
Str2Num=ret
Funktion beenden
Private Funktion BinVal(bin)
'GPS (2002-8-11)
schwach ret
ret = 0
für i = lenb(bin) zu 1 Schritt -1
ret = ret *256 + ascb(midb(bin,i,1))
nächste
BinVal=ret
Funktion beenden
Private Funktion BinVal2(bin)
'GPS (2002-8-11)
schwach ret
ret = 0
für i = 1 bis lenb(bin)
ret = ret *256 + ascb(midb(bin,i,1))
nächste
BinVal2=ret
Funktion beenden
'///Das Folgende ist der aufrufende Code///
Funktion getImageSize(filespec)
'GPS (2002-8-11)
dim ret(3)
aso.LoadFromFile(filespec)
bFlag=aso.read(3)
select case hex(binVal(bFlag))
Fall 4E5089:
aso.read(15)
ret(0)=PNG
ret(1)=BinVal2(aso.read(2))
aso.read(2)
ret(2)=BinVal2(aso.read(2))
Fall 464947:
aso.read(3)
ret(0)=GIF
ret(1)=BinVal(aso.read(2))
ret(2)=BinVal(aso.read(2))
Fall 535746:
aso.read(5)
binData=aso.Read(1)
sConv=Num2Str(ascb(binData),2,8)
nBits=Str2Num(left(sConv,5),2)
sConv=mid(sConv,6)
while(len(sConv)<nBits*4)
binData=aso.Read(1)
sConv=sConv&Num2Str(ascb(binData),2,8)
wenden
ret(0)=SWF
ret(1)=int(abs(Str2Num(mid(sConv,1*nBits+1,nBits),2)-Str2Num(mid(sConv,0*nBits+1,nBits),2))/20)
ret(2)=int(abs(Str2Num(mid(sConv,3*nBits+1,nBits),2)-Str2Num(mid(sConv,2*nBits+1,nBits),2))/20)
Gehäuse FFD8FF:
Tun
do: p1=binVal(aso.Read(1)): Schleife während p1=255 und nicht aso.EOS
Wenn p1>191 und p1<196, dann beenden, sonst tun aso.read(binval2(aso.Read(2))-2)
do:p1=binVal(aso.Read(1)):loop while p1<255 and not aso.EOS
Schleife während true
aso.Read(3)
ret(0)=JPG
ret(2)=binval2(aso.Read(2))
ret(1)=binval2(aso.Read(2))
Fall anders:
wenn left(Bin2Str(bFlag),2)=BM dann
aso.Lesen(15)
ret(0)=BMP
ret(1)=binval(aso.Read(4))
ret(2)=binval(aso.Read(4))
anders
ret(0)=
Ende wenn
Ende auswählen
ret(3)=width= & ret(1) & height=
& ret(2) &
getimagesize=ret
Funktion beenden
Unterricht beenden
%>
Kopieren Sie den obigen Code, um die Datei GPS.asp zu generieren, sodass die allgemeine Klasse zum Erhalten der Bildgröße ohne Komponenten in Ordnung ist.
2. Rufen Sie den Bildpfad ab
Da es mehr als ein Bild gibt und die Bilder in Kategorien gespeichert werden müssen, haben wir in der Datenbank ein Feld ImgURL entworfen, um den relativen Pfad des Bildes zu speichern. Wir legen alle hochgeladenen Bilder in einem Ordner namens „images“ ab (ich werde nicht mehr darüber sagen, wie man Bilder ohne Komponenten hochlädt). Jetzt entwerfen wir zunächst eine ShowImg.asp-Seite, um Miniaturansichten und zugehörige Informationen anzuzeigen. Das konkrete Design ist wie folgt:
Bild:
Bildformat:
Bildgröße:
Bildgröße:
Anzahl der Klicks:
Als nächstes erhalten wir den absoluten Pfad des Bildes. Der Code lautet wie folgt:
<%
'/////Erhalten Sie den absoluten Pfad von ShowImg.asp/////
CurFile dimmen
curFile=Server.mappath(Request.servervariables(PATH_INFO))
Curfilename,Dateiname dimmen
'/////Relativer Pfad zum Bild (in der Datenbank gespeichert)
cufilename=rs(ImgURL)
'/////Da sich ShowImg.asp im selben Verzeichnis wie Bilder befindet, verwenden wir instrrev, um den Pfad der Bilder abzurufen/////
filename=left(curFile,instrrev(curFile,/))&cufilename
'/////GPS-Klasseneinheit erstellen/////
GetPicSize dimmen
Legen Sie GetPicSize=new GPS fest
Setze fs=Server.CreateObject(Scripting.FileSystemObject)
'/////Bildtyp abrufen/////
Dimmen Sie PicSuffixName
PicSuffixName=fs.GetExtensionName(Dateiname)
Dim PD '//Bilddimension
Dimmen Sie PWidth, PHeight
Wählen Sie Case PicSuffixName aus
Fall gif,bmp,jpg,png:
'/////Rufen Sie die GetImageSize-Funktion in der allgemeinen GPS-Klasse auf, um die Bildgröße zu erhalten/////
PD=GetPicSize.GetImageSize(Dateiname)
PWidth=PD(1) '//Bildbreite abrufen
PHeight=PD(2) '//Bildhöhe abrufen
Fall swf
PD=GetPicSize.GetImageSize(Dateiname)
PWidth=PD(1) '//Flash-Breite abrufen
PHeight=PD(2) '//Blitzhöhe abrufen
Fall anders
Endauswahl
Setze fs=Nothing
Setzen Sie GetPicSize=Nothing
%>
Kopieren Sie den obigen Code an den Anfang von <body> und es ist OK!
Natürlich werden einige Leute sagen, dass Sie PATH_INFO nicht verwenden müssen, um den Pfad zu erhalten. Haha, jeder hat seine eigenen Vorlieben Ich habe festgestellt, dass einige Funktionen von FSO und die Verwendung von server .mappath() nicht funktionierten, also habe ich dies weiterhin verwendet.
3. Definieren Sie die Miniaturbildgröße
Dieser Teil des Codes liegt im Auge des Betrachters, und der Weise erkennt Weisheit. Zuerst müssen wir den Größenbereich der Miniaturansicht angeben, zum Beispiel: 300X260. Der Code kann wie folgt geschrieben werden:
<%
Dimmen Sie PXWidth, PXHeight
Dim Pp '//Proportion
Wenn PWidth=0 oder PWidth= dann
PXWidth=0
PXHeight=0
Anders
Pp=FormatNumber(PWidth/PHeight,2) '//Seitenverhältnis
Ende wenn
Wenn PWidth>=PHeight, dann
Wenn PWidth>=300, dann
PXWidth=300
PXHeight=FormatNumber(300/Pp,0)
Anders
PXWidth=PWidth
PXHeight=PHeight
Ende wenn
Anders
Wenn PHeight>=260, dann
PXHeight=260
PXWidth=FormatNumber(260*Pp,0)
Anders
PXWidth=PWidth
PXHeight=PHeight
Ende wenn
Ende wenn
%>
Schreiben Sie einfach den obigen Code direkt nach dem zweiten Schritt. Der Code beim Aufruf lautet wie folgt:
<img src=<%=curfilename%> border=0 width=<%=PXWidth%>
height=<%=PXHeight%>>
Das Bildformat können Sie mit <%=PicSuffixName%> abrufen, und die Bildgröße kann als geschrieben werden
<%
Antwort.write PXWidth&X&PXHeight
%>
Die Bildgröße kann mit FSO.GetFileSize(filename) realisiert werden, die Anzahl der Klicks kann einfach mit SQL-Anweisungen realisiert werden. Die spezifische Codierung wird nicht noch einmal beschrieben.
Auf diese Weise wurde ein komponentenfreies Programm zur Erstellung von Miniaturansichten geschrieben. Es mag etwas entlehnt sein, aber solange jeder die Methode beherrschen kann, wird es meiner Meinung nach erheblich verbessert.