Existem muitos componentes ASP que podem gerar miniaturas na Internet. Se o seu espaço virtual não suportar o registro de novos componentes, você poderá sentir que seu site perdeu o brilho. Você conhece as etapas para gerar miniaturas sem componentes? Vamos aprender sobre isso com o editor do New Technology Channel errado!
Gerar miniaturas sem componentes
Vamos dar uma olhada no básico primeiro. Primeiro de tudo, sabemos que o código a seguir é exibido na página:
SRC é o caminho da imagem, a borda controla a largura da borda da imagem, a largura é o comprimento da imagem e a altura é a altura da imagem. A geração de miniaturas está realmente escalando no tamanho original. Mas, geralmente, para minimizar a distorção, escalaremos em escala. Portanto, obter o comprimento e a largura da figura se torna o foco da geração de miniaturas.
Aqui estão as etapas para escrever uma geração de miniatura sem componentes:
1. Obtenha o tamanho da imagem sem componentes
Vi um artigo usando o código ASCII para obter tamanhos de imagem sem componentes quando aprendi o ASP pela primeira vez. Mais tarde, tentei e descobri que, quando recebi o tamanho de imagens do tipo JPG, verifiquei on-line e descobri que muitos sites reimprimiam esse programa, mas nenhum deles apontou as falhas deste programa, muito menos a solução para as falhas. Mais tarde, fui pesquisado no Google e finalmente encontrei um artigo introduzindo o uso do Adodb.stream para obter tamanhos de imagem. Eu tentei modificar o código dentro de acordo com o método introduzido. O efeito é realmente bom. Agora vou retirá -lo e compartilhar com você:
Use Adodb.stream para obter a classe comum <% do tamanho da imagem
'////////////// GPS: obtenha tamanho de imagem //////////////
'///////////////////////////////////
'/////////// citado por Leon (xinqing) 11 de agosto de 2005 //////////////////
GPS da classe
Dim Aso
Sub -Class_initialize privado
Definir Aso = CreateObject ("Adodb.stream")
ASO.MODE = 3
ASO.TYPE = 1
ASO.OPEN
Final sub
Sub -Class_terminado privado
Definir aso = nada
Final sub
Função privada bin2str (lixo)
Dim i, str
Para i = 1 a lenb (bin)
Clow = MIDB (bin, i, 1)
Se ASCB (Clow) <128 então
Str = str & ch (ASCB (Clow))
Outro
I = i+1
Se i <= lenb (bin) então str = str & ch (ascw (midb (bin, i, 1) e coro
final se
Próximo
Bin2str = str
Função final
Função privada num2str (num, base, lente)
'GPS (2005-8-11)
Dim ret
ret = ""
While (num> = base)
RET = (Num Mod Base) e RET
num = (num - num mod base)/base
Wend
Num2str = direita (string (lente, "0") e num & ret, lente)
Função final
Função privada str2num (str, base)
'GPS (2005-8-11)
Dim ret
ret = 0
para i = 1 a len (str)
ret = ret *base + cint (mid (str, i, 1))
próximo
Str2num = ret
Função final
Função privada Binval (BIN)
'GPS (2002-8-11)
Dim ret
ret = 0
para i = lenb (bin) a 1 etapa -1
ret = ret *256 + ASCB (midb (bin, i, 1))
próximo
Binval = ret
Função final
Função privada binval2 (lixo)
'GPS (2002-8-11)
Dim ret
ret = 0
para i = 1 a lenb (bin)
ret = ret *256 + ASCB (midb (bin, i, 1))
próximo
Binval2 = ret
Função final
'/// a seguir é o código de chamada ///
Function getImagesize (FileSec)
'GPS (2002-8-11)
Dim ret (3)
ASO.LOADFROMFILE (FILESC)
bflag = aso.read (3)
Selecione Case 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 (esquerda (sconv, 5), 2)
SCONV = MID (SCONV, 6)
enquanto (Len (SCONV)
sconv = sconv & num2str (ascb (bindata), 2,8)
Wend
ret (0) = "SWF"
ret (1) = int (abs (str2num (médio (sconv, 1*nbits+1, nbits), 2) -Str2num (mid (sconv, 0*nbits+1, nbits), 2))/20)
ret (2) = int (abs (str2num (médio (sconv, 3*nbits+1, nbits), 2) -Str2num (mid (sconv, 2*nbits+1, nbits), 2))/20)
caso "ffd8ff":
fazer
do: p1 = binval (aso.read (1)): loop while p1 = 255 e não aso.eos
Se P1> 191 e P1 <196, então a saída do outro
do: p1 = binval (aso.read (1)): loop while p1 <255 e não aso.eos
loop enquanto verdadeiro
ASO.read (3)
ret (0) = "jpg"
ret (2) = binval2 (aso.read (2))
ret (1) = binval2 (aso.read (2))
Caso mais:
se esquerdo (bin2str (bflag), 2) = "bm" então
Aso.read (15)
ret (0) = "bmp"
ret (1) = binval (aso.read (4))
ret (2) = binval (aso.read (4))
outro
ret (0) = ""
final se
final Selecione
ret (3) = "width =" "" e ret (1) e "" altura = "" "e ret (2) e" "" "" ""
getImagesize = ret
Função final
Classe final
%>
Copie o código acima para gerar um arquivo GPS.asp, para que a classe geral sem componente para obter o tamanho da imagem seja OK.
2. Obtenha o caminho da imagem
Como mais de uma imagem e as imagens precisam ser armazenadas de maneira classificada, projetamos um campo de campo que armazena o caminho relativo da imagem no banco de dados. Colocamos todas as imagens enviadas em uma pasta chamada imagens (como para como fazer upload de imagens sem componentes, não direi muito). Agora, vamos projetar uma página showimg.asp para exibir miniaturas e informações relacionadas. O design específico é o seguinte:
foto:
Formato de imagem:
Tamanho da imagem:
Tamanho da imagem:
Número de cliques:
Abaixo, temos o caminho absoluto para a imagem. O código é o seguinte:
<%
'///// Obtenha o caminho absoluto de showimg.asp /////
Celudo escuro
Curfile = server.mappath (request.servervariables ("path_info")))
Dim Curfilename, nome do arquivo
'///// o caminho relativo da imagem (armazenado no banco de dados)
Cufilename = rs ("imgurl")
'///// porque o showimg.asp está no mesmo diretório que as imagens, usamos o Instrrev para obter o caminho das imagens /////
FILENAME = esquerda (Curfile, Instrrev (Curfile, "/")) & CuFileName
'///// crie entidade GPS //////
Dim getPicsize
Definir getPicsize = novo GPS
Definir fs = server.createObject ("scripting.filesystemobject")
'///// obtenha o tipo de imagem /////
Dim picsuffixName
PicsuffixName = fs.geTextensionName (nome do arquivo)
Dimensão de imagem pd '//
Dim pwidth, pheight
Selecione PicsuffixName de casos
Case "gif", "bmp", "jpg", "png":
'///// Ligue para a função getImagesize na classe geral GPS para obter o tamanho da imagem /////
Pd = getpicsize.getImagesize (nome do arquivo)
Pwidth = pd (1) '// Obtenha largura de imagem
Pheight = pd (2) '// obtenha altura da imagem
Caso "swf"
Pd = getpicsize.getImagesize (nome do arquivo)
Pwidth = pd (1) '// Obtenha a largura do flash
Pheight = pd (2) '// Obtenha altura do flash
Caso mais
Final Selecione
Defina FS = nada
Definir getPicsize = nada
%>
Copie o código acima para *4) >>
O acima está ok!
Obviamente, algumas pessoas podem dizer que você não precisa usar o path_info para conseguir o caminho. Você pode apenas usar o server.mappath () diretamente. Haha, todo mundo tem suas próprias preferências. O principal motivo é que eu posso usar o PATH_INFO para implementar algumas funções do FSO, mas não o fiz com o Server.mappath (), então tenho usado isso.
3. Defina o tamanho da miniatura
Esta parte do código é diferente da própria opinião. Primeiro de tudo, precisamos especificar a faixa de tamanho da exibição de miniaturas, por exemplo: 300x260, o código pode ser escrito assim:
<%
Dim PxWidth, PxHeight
Dim pp '// proporção
Se pwidth = 0 ou pwidth = "" então
Pxwidth = 0
PxHeight = 0
Outro
Pp = formatNumber (pwidth/pheight, 2) '// relação add-width
Final se
Se pwidth> = pheight então
Se pwidth> = 300 então
Pxwidth = 300
PxHeight = formatNumber (300/pp, 0)
Outro
Pxwidth = pwidth
PxHeight = pheight
Final se
Outro
Se pHeight> = 260 então
PxHeight = 260
Pxwidth = formatNumber (260*pp, 0)
Outro
Pxwidth = pwidth
PxHeight = pheight
Final se
Final se
%>
Escreva o código acima imediatamente após a segunda etapa. O código quando chama é o seguinte:
Border = "0" largura = <%= pxWidth%> Height = <%= pxHeight%>>
Quanto ao formato de imagem, você pode usar <%= picsuffixname%>, e o tamanho da imagem pode ser escrito como
<%
Response.Write PxWidth & "X" & PxHeight
%>
O tamanho da imagem pode ser alcançado usando o FSO.getFilesize (nome do arquivo), enquanto o número de cliques pode ser alcançado simplesmente usando instruções SQL, portanto a codificação específica não será mais descrita.
Dessa forma, será escrito um programa de miniatura sem componentes, que pode ser um pouco sábio, mas, desde que você possa dominar o método, ele será bastante aprimorado. >
O artigo acima é sobre o método de operação de gerar miniaturas sem componentes. Eu acredito que todo mundo tem um certo entendimento. Se você quiser saber mais informações técnicas, continue prestando atenção ao novo canal de tecnologia errada!