Em um projeto recente, a validação do formulário exigiu o julgamento do intervalo de tempo de início e término: o horário de término deve ser maior ou igual ao horário de início. Ou seja: o ano final deve ser maior que o ano inicial; se forem iguais, compare o mês inicial e o mês final, se os meses inicial e final também forem iguais, compare as datas; Então, para cada verificação, você pode usar a seguinte função para comparar.
função comparar(início,fim,erro){
var início = parseInt(início,10);
var fim = parseInt(fim,10);
var diff = fim - início;
if(diferença < 0){
alerta(erro);
}outro{
retornar verdadeiro;
}
}
Desta forma, durante a verificação, desde que o resultado retorne verdadeiro, significa que foi aprovado. como:
var ano = comparar(2001,2003,'ano');
var mês = compare(1,2,'mês');
var dia = compare(12,13,'dia');
alert(ano && mês && dia); //O resultado é verdadeiro------"verdadeiro"
Modifique os meses inicial e final e as datas inicial e final acima. como:
var ano = comparar(2001,2003,'ano');
var mês = compare(3,2,'mês');
var dia = compare(24,13,'dia');
alert(ano && mês && dia); /O resultado é falso------"falso"
O resultado da execução exibe "mês", "dia" e "falso" em sequência, na verdade, quando os meses inicial e final estão incorretos, não precisamos verificar a data. O pré-requisito para verificação do mês é que o ano seja verificado; passa o pré-requisito para verificação do dia O mês é verificado. Após análise cuidadosa, decidi armazenar os três parâmetros da função acima no modo singleton, a saber:
{
começar: 2001,
fim: 2003,
erro: "O ano final deve ser maior que o ano inicial"
}
No entanto, não quero definir os parâmetros da função. A função pode verificar automaticamente com base nos parâmetros passados? A resposta é sim. No início da função, primeiro determine o número de parâmetros. Se for maior que 1, contém processamento recursivo. Como fazer processamento recursivo? Fiz o seguinte dentro da função:
var len = argumentos.comprimento;
if(len > 1){
var args = Array.prototype.slice.call(argumentos);
args.shift(); //Remova o primeiro parâmetro e use os parâmetros restantes para processamento recursivo
}
Para argumentos, não podemos chamar o método Array.shift() diretamente. Embora os argumentos tenham um atributo de comprimento, afinal não é um array, então use o método Array.slice() para convertê-lo em um array. Em relação aos argumentos, você pode obter mais informações online e não entrarei em detalhes aqui. Por que só é processado quando len é maior que 1? Porque quando o parâmetro é 1, não há necessidade de realizar a próxima etapa de verificação. Quando ocorre o processamento recursivo? Se você pensar bem, só será necessário quando o valor inicial e o valor final forem iguais. Compreendendo isso, podemos construir facilmente nossa função de verificação.
var diff = parseInt(argumentos[0].end,10) - parseInt(argumentos[0].begin,10);
if(diferença <0 ){
alerta(argumentos[0].erro);
retornar falso;
}senão se(diferença == 0){
retornar len > 1? argumentos.callee.apply(this,args): verdadeiro;
}outro{
retornar verdadeiro;
}
No código acima, argument.callee é a própria função. Quanto ao uso de apply, você pode encontrar informações relevantes na web.
Neste ponto, a função de verificação foi concluída, mas você precisa prestar atenção ao seguinte:
Por enquanto é isso, vejamos os exemplos . Às vezes, não queremos exibir informações de erro na forma de alerta. Podemos personalizar a função de processamento e passá-la como ú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 == 'função'){
func(argumentos[0]);
}
Então, a função de processamento final é assim:
função comparar(){
var len = argumentos.comprimento;
var func = argumentos[len - 1];
if(len > 1){
var args = Array.prototype.slice.call(argumentos);
args.shift(); //Remova o primeiro parâmetro e use os parâmetros restantes para processamento recursivo
}
var diff = parseInt(argumentos[0].end,10) - parseInt(argumentos[0].begin,10);
if(diferença <0 ){
(typeof func == 'função') ? func(argumentos[0].erro): alerta(argumentos[0].erro);
retornar falso;
}senão se(diferença == 0){
retornar len > 1? argumentos.callee.apply(this,args): verdadeiro;
}outro{
retornar verdadeiro;
}
}
função comparar(){
var len = argumentos.comprimento;
if(len > 1){
var args = Array.prototype.slice.call(argumentos);
args.shift(); //Remova o primeiro parâmetro e use os parâmetros restantes para processamento recursivo
}
var diff = parseInt(argumentos[0].end,10) - parseInt(argumentos[0].begin,10);
if(diferença <0 ){
alerta(argumentos[0].erro);
retornar falso;
}senão se(diferença == 0){
retornar len > 1? argumentos.callee.apply(this,args): verdadeiro;
}outro{
retornar verdadeiro;
}
}