Hay muchos componentes ASP que pueden generar miniaturas en Internet. Si su espacio virtual no admite registrar nuevos componentes, puede sentir que su sitio web ha perdido su brillo. ¿Conoces los pasos para generar miniaturas sin componentes? ¡Aprendamos sobre ello con el editor del nuevo canal de tecnología incorrecto!
Generar miniaturas sin componentes
Echemos un vistazo a lo básico primero. En primer lugar, sabemos que el siguiente código se muestra en la página:
SRC es la ruta de la imagen, el borde controla el ancho del borde de la imagen, el ancho es la longitud de la imagen y la altura es la altura de la imagen. La generación de miniaturas en realidad está ampliando el tamaño original. Pero en general, para minimizar la distorsión, escalaremos a escala. Por lo tanto, obtener la longitud y el ancho de la imagen se convierte en el foco de la generación de miniaturas.
Estos son los pasos para escribir una generación de miniatura sin componentes:
1. Obtenga el tamaño de la imagen sin componentes
Vi un artículo usando código ASCII para obtener tamaños de imagen sin componentes cuando aprendí ASP por primera vez. Más tarde lo probé y descubrí que cuando obtuve el tamaño de las imágenes similares a JPG, lo revisé en línea y descubrí que muchos sitios web reimpreso este programa, pero ninguno de ellos señaló los defectos de este programa, y mucho menos la solución a los defectos. Más tarde fui Google y finalmente encontré un artículo que introdujo el uso de ADODB.stream para obtener tamaños de imagen. Lo probé modificando el código dentro de acuerdo con el método introducido. El efecto es realmente bueno. Ahora lo sacaré y lo compartiré contigo:
Use ADODB.stream para obtener la clase común <% del tamaño de la imagen
'///////////// gps: obtener tamaño de imagen ////////////
'///////////////////////////
'////////// Citado por Leon (Xinqing) 11 de agosto de 2005 //////////////
GPS de clase
ASO oscuro
Sub class_initialize privado
Establecer aso = createObject ("ADODB.Stream")
aso.mode = 3
aso.type = 1
Aso. Abre
Final
Sub class_merminate privado
establecer aso = nada
Final
Función privada bin2str (bin)
Dim I, str
Para i = 1 a Lenb (bin)
CLOW = MidB (Bin, I, 1)
Si ASCB (CLOW) <128 entonces
Str = str & chr (ascb (clow))
Demás
I = i+1
Si i <= Lenb (bin) entonces str = str & chr (ascw (midb (bin, i, 1) y clow)))
final si
Próximo
Bin2str = str
Función final
Función privada num2str (num, base, lente)
'GPS (2005-8-11)
oscuro RET
ret = ""
Mientras (num> = base)
ret = (num mod base) y retir
num = (num - num modus base)/base
encaminarse a
Num2str = right (string (lente, "0") & num & ret, lente)
Función final
Función privada str2num (str, base)
'GPS (2005-8-11)
oscuro RET
ret = 0
para i = 1 a Len (Str)
Ret = Ret *Base + Cint (Mid (Str, I, 1))
próximo
Str2num = RET
Función final
Función privada binval (bin)
'GPS (2002-8-11)
oscuro RET
ret = 0
para i = Lenb (bin) a 1 paso -1
Ret = Ret *256 + ASCB (Midb (Bin, I, 1))
próximo
Binval = RET
Función final
Función privada binval2 (bin)
'GPS (2002-8-11)
oscuro RET
ret = 0
para i = 1 a Lenb (bin)
Ret = Ret *256 + ASCB (Midb (Bin, I, 1))
próximo
Binval2 = RET
Función final
'/// El siguiente es el código de llamada ///
Función getImageSize (FILEPEC)
'GPS (2002-8-11)
Dim ret (3)
Aso.LoadFromFile (Filespec)
bflag = aso.read (3)
Seleccione Caso Hex (Binval (BFLAG))
Caso "4E5089":
aso.read (15)
ret (0) = "PNG"
ret (1) = binval2 (aso.read (2))
aso.read (2)
ret (2) = binval2 (aso.read (2))
Caso "464947":
aso.read (3)
ret (0) = "gif"
ret (1) = binval (aso.read (2))
ret (2) = binval (aso.read (2))
Caso "535746":
aso.read (5)
bindata = aso.read (1)
sconv = num2str (ascb (bindata), 2,8)
nbits = str2num (izquierda (sconv, 5), 2)
SCONV = MID (SCONV, 6)
Mientras (Len (Sconv)
SCONV = SCONV & NUM2STR (ASCB (Bindata), 2,8)
encaminarse a
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)
Caso "ffd8ff":
hacer
do: p1 = binval (aso.read (1)): bucle mientras p1 = 255 y no Aso.eos
Si P1> 191 y P1 <196 entonces salga de lo más aso.read (binval2 (aso.read (2))-2)
do: p1 = binval (aso.read (1)): bucle mientras p1 <255 y no Aso.eos
bucle mientras es verdadero
aso.read (3)
ret (0) = "jpg"
ret (2) = binval2 (aso.read (2))
ret (1) = binval2 (aso.read (2))
Caso más:
Si se deja (bin2str (bflag), 2) = "bm" entonces
aso.read (15)
ret (0) = "BMP"
ret (1) = binval (aso.read (4))
ret (2) = binval (aso.read (4))
demás
ret (0) = ""
final si
final seleccionar
ret (3) = "width =" "" & ret (1) & "" "altura =" "" & ret (2) y "" "" ""
getImagesize = RET
Función final
Clase final
%>
Copie el código anterior para generar un archivo GPS.ASP, de modo que la clase general sin componente para obtener el tamaño de la imagen esté bien.
2. Obtenga la ruta de la imagen
Dado que más de una imagen y las imágenes deben almacenarse de manera clasificada, diseñamos un imgurl de campo que almacena la ruta relativa de la imagen en la base de datos. Ponemos todas las imágenes cargadas en una carpeta llamada imágenes (en cuanto a cómo cargar imágenes sin componentes, no diré mucho). Ahora diseñemos una página showimg.asp para mostrar miniaturas e información relacionada. El diseño específico es el siguiente:
imagen:
Formato de imagen:
Tamaño de la imagen:
Tamaño de la imagen:
Número de clics:
A continuación, obtenemos el camino absoluto a la imagen. El código es el siguiente:
<%
'///// Obtén la ruta absoluta de showimg.asp /////
Mañera oscura
Curfile = server.mappath (request.servervariables ("path_info"))
Dim CurfileName, nombre de archivo
'///// La ruta relativa de la imagen (almacenada en la base de datos)
cufilename = rs ("imgurl")
'///// Porque showimg.asp está en el mismo directorio que las imágenes, usamos Instrrev para obtener la ruta de las imágenes ////
FileName = Left (Curfile, Instrrev (Curfile, "/")) & Cufilename
'///// Crear entidad GPS /////
Dim getPicsize
Establecer getPicsize = nuevo GPS
Establecer fs = server.createObject ("scripting.filesystemObject")
'///// Obtén el tipo de imagen /////
Dim PicSuffixname
PicSuffixname = fsgetExtensionName (nombre de archivo)
Dim Pd '// Dimensión de imagen
Dim Pwidth, Pheight
Seleccione Case PicSuffixname
Caso "gif", "bmp", "jpg", "png":
'///// llame a la función getImageSize en la clase general GPS para obtener el tamaño de la imagen /////
PD = getPicsize.getImageSize (nombre de archivo)
Pwidth = pd (1) '// Obtener ancho de imagen
Pheight = pd (2) '// Obtener la altura de la imagen
Caso "SWF"
PD = getPicsize.getImageSize (nombre de archivo)
Pwidth = pd (1) '// Obtener ancho flash
Pheight = pd (2) '// Obtener altura flash
Caso
Final seleccionar
Establecer fs = nada
Establecer getPicsize = nada
%>
Copie el código anterior a *4) >>
¡Lo anterior está bien!
Por supuesto, algunas personas pueden decir que no tiene que usar Path_info para obtener el camino. Solo puede usar server.mappath () directamente. Jaja, todos tienen sus propias preferencias. La razón principal es que puedo usar Path_info para implementar algunas funciones de FSO, pero no lo he hecho con server.mappath (), así que he estado usando esto.
3. Defina el tamaño de la miniatura
Esta parte del código es diferente de la propia opinión. En primer lugar, necesitamos especificar el rango de tamaño de la pantalla en miniatura, por ejemplo: 300x260, el código se puede escribir así:
<%
Dim pxwidth, pxheight
Dim pp '// proporción
Si pwidth = 0 o pwidth = "" entonces
Pxwidth = 0
PxHeight = 0
Demás
PP = FormatNumber (PWidth/Pheight, 2) '// Relación agregada de ancho
Final si
Si pWidth> = Pheight entonces
Si pwidth> = 300 entonces
Pxwidth = 300
PxHeight = FormatNumber (300/pp, 0)
Demás
Pxwidth = pwidth
PxHeight = Pheight
Final si
Demás
Si Pheight> = 260 entonces
PxHeight = 260
Pxwidth = formatNumber (260*pp, 0)
Demás
Pxwidth = pwidth
PxHeight = Pheight
Final si
Final si
%>
Escriba el código anterior inmediatamente después del segundo paso. El código al llamar es el siguiente:
border = "0" ancho = <%= pxwidth%> altura = <%= pxheight%>>
En cuanto al formato de imagen, puede usar <%= picsuffixname%>, y el tamaño de la imagen se puede escribir como
<%
respuesta
%>
El tamaño de la imagen se puede lograr usando FSO.getFilesize (nombre de archivo), mientras que el número de clics se puede lograr simplemente usando las declaraciones SQL, por lo que la codificación específica ya no se describirá.
De esta manera, se escribirá un programa de miniatura sin componentes, que puede ser un poco sabio, pero siempre que pueda dominar el método, mejorará enormemente. >
El artículo anterior trata sobre el método de operación para generar miniaturas sin componentes. Creo que todos tienen un cierto entendimiento. Si desea saber más información técnica, ¡continúe prestando atención al nuevo canal de tecnología incorrecto!