Em um projeto recente, a verificação do formulário requer um julgamento no intervalo de início e final: o horário final deve ser maior ou igual ao horário de início. Ou seja: o ano final deve ser maior que o ano inicial; Em seguida, para cada verificação, você pode usar a seguinte função para comparar.
Função Compare (BEGIN, END, ERRO) {
var begin = parseint (começo, 10);
var end = parseint (final, 10);
var diff = end - BEGIN;
if (diff <0) {
alerta (erro);
}outro{
retornar true;
}
}
Dessa forma, quando a verificação, desde que o resultado retorne verdadeiro, isso significa que ele passa. como:
var ano = compare (2001.2003, 'ano');
var mês = compare (1,2, 'mês');
var dia = compare (12,13, 'dia');
alerta (ano e mês && dia);
Altere os meses iniciais e de término e datas de partida e final acima. como:
var ano = compare (2001.2003, 'ano');
var mês = compare (3,2, 'mês');
var dia = compare (24,13, 'dia');
alerta (ano && Mês && dia);
Os resultados da execução são exibidos em sequência, "mês", "dia", "false"; é aprovado; o pré -requisito para a verificação diária é que a verificação do mês é aprovada. Após uma análise cuidadosa, decidi armazenar os três parâmetros da função acima em um modo monolítico, a saber::
{
Begin: 2001,
Fim: 2003,
Erro: "O período final deve ser maior que o período inicial"
}
No entanto, não quero definir os parâmetros da função. A resposta é sim. No início da função, primeiro determine o número de parâmetros. Como fazer processamento recursivo? Eu fiz o seguinte dentro da função:
var len = argumentos.Length;
if (len> 1) {
var args = array.prototype.slice.call (argumentos);
args.shift ();
}
Para argumentos, não podemos chamar o método Array.Shift () diretamente. Embora os argumentos tenham um atributo de comprimento, eles não são uma matriz, afinal, use o método da matriz.slice () para convertê -lo em uma matriz. Em relação aos argumentos, você pode aprender mais sobre isso on -line, para não entrar em detalhes aqui. Por que é processado apenas se Len é maior que 1? Porque quando o parâmetro é 1, não há necessidade de executar a próxima etapa de verificação. Quando o processamento recursivo será realizado? Se você pensar com cuidado, é necessário apenas se o valor inicial for igual ao valor final.
var diff = parseint (argumentos [0] .nd, 10) - parseint (argumentos [0] .Begin, 10);
if (diff <0) {
alerta (argumentos [0] .Error);
retornar falso;
} else if (diff == 0) {
retornar len> 1?
}outro{
retornar true;
}
No código acima, argumentos.Callee é a própria função.
A função de verificação foi concluída, mas deve -se notar que:
Embora o número de parâmetros não seja determinado, a ordem dos parâmetros ainda é importante, porque o resultado da verificação do parâmetro anterior determina se a verificação do próximo parâmetro continua;
O segundo parâmetro 10 da função parseInt () não deve ser ignorado. Se ignorado, quando um valor que começa com 0 (como 07, 08) é encontrado, ele será processado em octal.
Está aqui, olhe para os exemplos . Às vezes, não queremos exibir mensagens de erro no modo de alerta, podemos personalizar o manipulador para passá -lo como o último parâmetro. Então, no início da função, obtenha a função de processamento, como:
var func = argumentos [len - 1];
if (typeof func == 'function') {
func (argumentos [0]);
}
Então, a função de processamento final é assim:
função compare () {
var len = argumentos.Length;
var func = argumentos [len - 1];
if (len> 1) {
var args = array.prototype.slice.call (argumentos);
args.shift ();
}
var diff = parseint (argumentos [0] .nd, 10) - parseint (argumentos [0] .Begin, 10);
if (diff <0) {
(Typeof func == 'função')?
retornar falso;
} else if (diff == 0) {
retornar len> 1?
}outro{
retornar true;
}
}
função compare () {
var len = argumentos.Length;
if (len> 1) {
var args = array.prototype.slice.call (argumentos);
args.shift ();
}
var diff = parseint (argumentos [0] .nd, 10) - parseint (argumentos [0] .Begin, 10);
if (diff <0) {
alerta (argumentos [0] .Error);
retornar falso;
} else if (diff == 0) {
retornar len> 1?
}outro{
retornar true;
}
}