O chamado formulário complexo aqui se refere a um formulário que contém vários tipos de entrada diferentes, como caixas de listagem suspensa, texto de linha única, texto de várias linhas, valores numéricos, etc. Em situações em que tais formulários precisam frequentemente ser substituídos, é necessário um programa de geração dinâmica do formulário. Este artigo apresenta exatamente esse sistema, que usa um banco de dados para salvar dados de definição de formulário e usa scripts ASP para gerar dinamicamente códigos HTML de formulário e scripts para verificar entradas de formulário.
1. Defina a estrutura da tabela do banco de dados.
Muitas vezes você pode ver formulários como "Pesquisa Semanal" na Web. Este é um formulário que precisa ser atualizado com frequência. Se houver um programa que gere formulários dinamicamente e seus scripts de validação, a carga de trabalho de confecção desses formulários pode ser bastante reduzida.
No exemplo de geração e validação dinâmica de formulário deste artigo, usamos um banco de dados Access para armazenar as informações de definição sobre o formulário. Ao mesmo tempo, para simplificar, os dados inseridos pelo usuário no formulário também são salvos no mesmo banco de dados. . A definição de um formulário requer duas tabelas: a primeira tabela (Definições) é usada para definir os campos de entrada do formulário e a segunda tabela (Listas) salva informações adicionais sobre cada campo de entrada, como os itens de seleção da lista de seleção.
A tabela Definitons contém os seguintes campos:
FieldName - o nome da variável atribuída ao campo de entrada do formulário
Etiqueta - etiqueta de texto, o texto informativo exibido na frente do campo de entrada
Tipo - um único caractere, que representa a forma do campo de entrada do formulário e o tipo do valor de entrada, conforme segue:
(t) Caixa de entrada de texto, ou seja, < INPUT TYPE="TEXT" >.
(n) Uma caixa de entrada de texto, mas requer um valor numérico.
(m) Conteúdo da nota, usado para entrada de comentários ou outras grandes quantidades de texto, é uma caixa de edição de texto com várias linhas.
(b) Requer entrada de “sim” ou “não”. Nesta implementação, uma caixa de seleção será utilizada para obter esta entrada, sendo o rótulo de texto da caixa de seleção "Sim". Se o usuário selecionar, o valor de retorno será "on".
(r) Botão de opção.
(l) Caixa de listagem suspensa.
Min - válido apenas para valores de entrada numéricos, o valor mínimo é fornecido aqui. Neste exemplo há uma caixa de entrada numérica "Idade" com seu valor mínimo definido como 1.
Max – O valor deste campo é relativo ao formulário do campo de entrada. Para caixas de entrada numérica, representa o valor máximo permitido. Por exemplo, o valor máximo de "Idade" é 100. Para caixas de entrada de texto, Max representa o número máximo de caracteres permitidos. Para caixas de edição de texto multilinhas, Max representa o número de linhas de texto na área visível.
Obrigatório – Indica se a entrada é necessária. Se um valor deste tipo não for inserido, o validador de entrada reportará um erro. No formulário, os valores que devem ser inseridos são marcados com um asterisco, e o usuário é avisado em forma de nota de rodapé que tais valores devem ser inseridos.
O formulário de exemplo neste artigo é um questionário de programador ASP. A definição do formulário na tabela Definições é a seguinte:
FieldName Label Type Min Max Obrigatório
Nome Texto do nome (t) - 50 Sem
Idade Número de idade (n) 1 100 Sem
Sexo. Gênero único Botão de seleção (r) - - Sim
Texto do endereço de e-mail de e-mail (t) - - Sim
Caixa de lista suspensa de linguagem de programação de linguagem (l) - - Não
As listas são usadas para salvar algumas informações adicionais definidas no campo de entrada. Neste exemplo, “Sexo é usado para os dois valores de entrada” e “Idiomas”. A tabela Listas é muito simples e contém apenas os três campos a seguir:
FieldName - a qual campo de entrada do formulário o registro atual pertence
Valor - o valor da seleção
Label - o texto do prompt da seleção que o usuário vê
O campo de entrada "Sexo" só pode ser inserido a partir de Dois valores para escolher: "Masculino" ou "Feminino". "Linguagem" lista várias linguagens de programação que podem ser aplicadas ao ambiente ASP, incluindo: VBScript, JavaScript, C, Perl e "Outros".
A terceira tabela "Registros" salva o conteúdo enviado pelo usuário. Ela também contém três campos. Cada registro corresponde a um envio do usuário:
Registro - Tipo de observação, entrada do usuário salva na forma de uma string de consulta.
Criado – A data e hora em que o usuário enviou o formulário. RemoteIP - O endereço IP do remetente do formulário.
Em aplicações reais, pode ser necessário coletar mais informações sobre os usuários. Para simplificar, este exemplo registra apenas duas informações adicionais: horário de envio e endereço IP do usuário.
2. Preparação
Depois de concluir a definição da estrutura e do formulário de dados acima, você poderá escrever o script. A função do script é gerar formulários e processar formulários enviados pelo usuário.
Seja gerando ou processando um formulário, os três processos (tarefas) a seguir são essenciais: O primeiro é determinar o tipo de validação Ao gerar o formulário, o valor do tipo de validação é obtido por meio da string de consulta e quando o formulário é processado. , os campos ocultos do formulário são obtidos. Existem quatro tipos de métodos de verificação de formulário suportados pelo programa: sem verificação, verificação de JavaScript do lado do cliente, verificação de script ASP do lado do servidor e verificação do lado do cliente e do lado do servidor (os codinomes são de 0 a 3, respectivamente). Se nenhum método de autenticação válido for especificado na string de consulta, o quarto método de autenticação será padronizado. Este método de processamento de verificação nos permite aplicar com flexibilidade este sistema de geração e processamento de formulários. Quando o cliente proíbe o uso de verificação JavaScript, o processo de verificação só pode ser executado no lado do servidor. Aqui está o código para determinar o tipo de validação:
Verifique o tipo de validação.
Aqui está o trecho de cotação:
iValType = Request.QueryString("val")
Se IsNumeric(iValType) = False Então iValType = 3
Se iValType > 3 ou iValType < 0 Então iValType =3
A segunda tarefa é abrir uma conexão com o banco de dados e criar dois objetos de conjunto de registros: objeto RS, que é o principal objeto de conjunto de registros deste programa, usado para operar o objeto RSList, usado principalmente para ler dados da tabela Listas; O programa de amostra fornece dois métodos de conexão de banco de dados: usando ODBC DSN ou não usando ODBC DSN (ao usar DSN, você precisa criar um DSN chamado Dinâmico primeiro, e o código para usar DSN para conectar-se ao banco de dados foi comentado).
A terceira tarefa é gerar algum código HTML estático antes (e depois) de gerar (ou processar) o script do formulário, como <HEAD>< /HEAD>, e liberar o RS, RSList e outros objetos ocupados quando o script termina o recurso. .
Além do código que completa as tarefas acima, existem dois tipos de páginas que podem ser geradas pelos scripts ASP restantes no aplicativo de exemplo: o formulário de perguntas (veja a imagem acima) e a página de resultados que aparece após o formulário ser digitado. enviados (este último também é responsável por registrar os resultados enviados pelo usuário). A maneira mais simples de determinar qual parte do script será executada é verificar se o formulário foi enviado: em caso afirmativo, processe o formulário, caso contrário, gere o formulário.
Ele está gerando um formulário ou processando um formulário?
A seguir está um trecho de cotação:
Se Len(Request.Form) = 0 Então
'Gerar forma... ligeiramente...
Outro
'Processar o formulário... um pouco...
End If
3. Gerar o formulário dinamicamente
Ao gerar o formulário, o programa define os registros de acordo com cada campo de entrada na tabela Definitons e gera o código HTML e o código JavaScript do formulário correspondente por sua vez. A primeira coisa a ser gerada no código HTML é a tag de texto:
Aqui está o trecho da citação:
sHTML = sHTML & vbTab & "< TR >" & vbCrLf & vbTab & vbTab
sHTML = sHTML & "<TD VALIGN=" & Chr(34) & "TOP" & Chr(34)
sHTML = sHTML & " >" & vbCrLf & vbTab & vbTab & vbTab
sHTML = sHTML & "< B >" & RS.Fields("Rótulo")
O programa então verifica se o campo de entrada atual requer entrada. Se necessário, adicione um asterisco após o texto do rótulo (indicando que o valor deve ser inserido), e para o valor que deve ser inserido deve ser gerado o código JavaScript correspondente para verificá-lo. Para botões de opção ou listas de seleção, há uma verificação adicional de que o usuário realmente selecionou uma opção para todos os outros tipos de entrada, basta verificar se o valor de entrada não está vazio;
Após o rótulo de texto estão os elementos de entrada do formulário, e o código HTML para esses elementos é gerado com base nos tipos e atributos especificados na tabela Definições. A próxima etapa é gerar código JavaScript que executa tarefas de verificação do lado do cliente com base nos requisitos do valor de entrada. Para este exemplo, apenas os valores numéricos requerem verificação adicional para garantir que a entrada do usuário é de fato um número e que o valor numérico está entre os valores máximo e mínimo permitidos. Após gerar o código acima, você pode encerrar uma linha da tabela (ou seja, um campo de entrada) e continuar processando o próximo registro da tabela Definições. Depois que todos os registros do banco de dados forem processados, o próximo passo é adicionar o código HTML para o botão “Enviar” e o botão “Limpar”. Se você olhar de outro ângulo, a tarefa do programa aqui é gerar cada campo de entrada com base no registro do banco de dados. Cada campo de entrada ocupa uma linha da tabela e cada linha da tabela possui duas células: a primeira célula é usada para exibir. rótulos de texto e o segundo A unidade exibe o próprio elemento de entrada (consulte dForm.asp para obter o código).
Após a conclusão do processo acima, o código HTML do formulário e a função JavaScript de validação são salvos nas variáveis sHTML e sJavaScript respectivamente. Antes de gravar esse conteúdo na página, o programa verifica se o cliente requer validação de JavaScript. Se tal validação não for necessária, a variável sJavaScript é limpa:
Se iValType = 0 ou iValType = 2 Então sJavaScript = ""
Após gerar a tag BODY, o programa gera a seguinte função JavaScript:
A seguir está um fragmento de citação:
< IDIOMA DO SCRIPT = "JavaScript" >
< !--
função validar(OFormulário){
//Validação do formulário do cliente
< %=sJavaScript% >
retornar verdadeiro;
}
função CheckRadio(objRadio){
//Se um valor no botão de opção está selecionado
for(var n = 0; n < objRadio.length; n++){
if(objRadio[n].verificado){
retornar verdadeiro;
}
}
retornar falso;
}
functionListaVerificação(listaobj){
//Se um valor foi selecionado na lista de seleção
for(var n = 1; n < objList.length; n++){
if(objList.options[n].selected){
retornar verdadeiro;
}
}
retornar falso;
}
//-- >
</ /Roteiro>
Se o cliente não exigir validação de JavaScript, a função de validação ficará com uma instrução "return true". As duas últimas funções JavaScript estáticas (CheckRadio e CheckList) no código acima são usadas para validar os botões de opção e as caixas de listagem suspensa. A função de validação irá chamá-los quando esses dois campos de entrada precisarem ser validados.
Agora você pode começar a escrever o formulário na página:
< FORM ACTION="./dform.asp" METHOD="POST" NAME="MyForm" onSubmit="return activate(this)" >
Aqui, somente se a função de validação retornar true Só então execute a operação de envio do formulário. Portanto, quando a função de verificação JavaScript do lado do cliente estiver desativada, a função de validação retornará automaticamente verdadeiro.
A próxima coisa a adicionar é um campo oculto chamado val. Conforme mencionado anteriormente, este valor indica o modo de validação do formulário.
< INPUT TYPE="HIDDEN" NAME="val" VALUE="< %=iValType% >" >
Quando o usuário enviar o formulário, o script de processamento usará esse valor para determinar se deve executar a validação do lado do servidor.
Então a saída é a marca da tabela e o título da tabela. O título é salvo na variável sTitleLabel, cujo valor é inicializado quando o script inicia a execução:
Aqui está o trecho de citação:
< BORDA DA TABELA = "0" >
<TR>
< TD COLSPAN="2" ALIGN="CENTRO" >
< H2 >< %=sTitleLable% >< /H2 >
</TD>
</TR>
Como medida de melhoria, um campo FormID pode ser adicionado às tabelas Definições, Listas e Registros. FormID identifica exclusivamente um formulário, para que o programa possa definir vários formulários ao mesmo tempo e salvar os resultados da resposta do usuário de vários formulários. Quanto ao sTitleLabel acima, podemos usar outra tabela (como Forms) para salvá-lo.
Seguindo a marca e o título da tabela, o programa exibe o formulário HTML e o código para os botões "Enviar" e "Limpar". Depois disso, o programa verifica se a string sHTML contém "*". Em caso afirmativo, significa que há conteúdo que deve ser inserido no formulário. Neste momento, uma nota de rodapé é exibida para explicar o significado do asterisco.
Aqui está uma citação:
< %=sHTML% >
<TR>
< TD COLSPAN="2" ALIGN="CENTRO" >
< INPUT TYPE="ENVIAR" VALUE="Enviar formulário" > < INPUT TYPE="redefinir" VALUE="Limpar" >
</TD>
<%
'Se existe um campo de formulário que requer entrada, em caso afirmativo, produza a nota de rodapé do formulário para explicar o significado de '*'
Se InStr(sHTML,"*") Então
%>
</TR>
< TD COLSPAN="2" ALIGN="CENTRO" >
< FONT SIZE="2" >Nota: Os valores marcados com um asterisco são obrigatórios. < /FONT>
</TD>
</TR>
<%
Terminar se
%>
< /TABELA>
</ /FORM >
Até agora, a tarefa de geração de formulário foi concluída.
4. Processamento dos resultados do envio
As tarefas restantes do script ASP são o processamento do formulário no lado do servidor, incluindo validação, salvamento dos resultados no banco de dados e exibição da página "Sucesso/Falha no envio". Uma variável de string sBadForm é usada nesta parte do código de validação do formulário e o programa a utiliza para salvar informações de erro. Se sBadForm estiver vazio ao final do processo de verificação, significa que o formulário enviado pelo usuário é legal, caso contrário, o envio do formulário será rejeitado e sBadForm será retornado ao navegador;
Independentemente do modo de validação que seu formulário usa, é uma boa prática verificar HTTP_REFERER. Esta verificação evita roubo de script. Para verificar se um determinado POST vem de uma página ou script deste site, basta comparar duas variáveis do servidor:
Aqui está o trecho de citação:
Se InStr(Request.ServerVariables("HTTP_REFERER"), _
Request.ServerVariables("HTTP_HOST")) = 0 Então
sBadForm = "<LI>O formulário foi enviado de um local incorreto."
Terminar se
Se o campo oculto do formulário indicar que a verificação do lado do servidor deve ser realizada, o programa percorre os registros do banco de dados de definição do formulário e realiza as verificações correspondentes. O processo é muito semelhante à geração do formulário, exceto que desta vez o programa verifica o. formulário e adiciona informações de valor de entrada ilegais. Basta ir para sBadForm. Consulte dForm.asp para obter código específico.
O programa finalmente verifica se sBadForm está vazio. Se não estiver vazio, o envio do formulário será rejeitado e sBadForm será gravado no navegador. Se sBadForm estiver vazio, adicione um registro à tabela Records para salvar os dados do formulário. O campo oculto val precisa ser excluído antes de salvar o conteúdo do formulário. Este campo oculto é sempre o primeiro campo de entrada do formulário:
A seguir está um fragmento de citação:
Se Len(sBadForm) = 0 Então
RS.Abra "Registros", DB, 3, 2, &H0002
RS.AdicionarNovo
RS.Fields("Registro") = Mid(Request.Form, InStr(Request.Form, "&") + 1)
RS.Fields("Criado") = Agora()
RS.Fields("IPRemoto") = Request.ServerVariables("REMOTE_ADDR")
RS.Atualização
Response.Write("< H1 >Obrigado.</H1 >")
RS.Fechar
Outro
Response.Write("< H1 >Falha no envio do formulário. </H1 >")
Response.Write (vbCrLf e sBadForm)
Terminar se
Terminar se
É isso para o processamento de formulários do lado do servidor. Dependendo se existe um formulário enviado, podemos encapsular o código de geração de formulário anterior e o código de processamento de formulário aqui com uma instrução If, para que as duas partes do script compartilhem algum código comum, como o cabeçalho do documento HTML, a criação de objetos de banco de dados e a liberação de recursos.
No geral, dForm.asp possui apenas as funções básicas necessárias para geração e verificação dinâmica de formulários e ignora o tratamento de muitos problemas detalhados. Por exemplo, o problema de vários formulários mencionado anteriormente: adicionar uma tabela para gerenciar vários formulários permite que o script tenha a capacidade de gerenciar, gerar e processar formulários especificados. Outra falta evidente é a capacidade de adicionar, excluir e atualizar dados definidos no formulário, bem como o acesso aos dados de resultados enviados pelo usuário. Essa funcionalidade poderia ser implementada em um programa independente e, na maioria dos casos, poderia ser transformada em um programa. aplicação tradicional. (Aplicações sem estrutura B/S). Finalmente, os tipos de campos de entrada suportados pelo dForm.asp também são limitados. Na prática, pode haver outros requisitos de entrada de formulário, como uma caixa de entrada de endereço de email dedicada. No entanto, para sites que atualizam formulários com frequência, as funções de geração dinâmica de formulários e validação dinâmica discutidas neste artigo são realmente muito úteis.