O editor compilou muitos exemplos de expressões regulares comumente usadas no JavaScript antes, e todas são usadas por si mesmas. Agora vou compartilhá -los com você.
A cópia do código é a seguinte:
/**
* Obtenha o comprimento do byte da corda
*/
função strlen (str)
{
var i;
var len;
len = 0;
para (i = 0; i <str.Length; i ++)
{
if (str.charcodeat (i)> 255) len+= 2; else len ++;
}
retornar Len;
}
/*
* Determine se é um número, retorne true, caso contrário, retorne falso
*/
função f_check_number (obj)
{
if (/^/d+$/.test(obj.value))
{
retornar true;
}
outro
{
f_alert (obj, "digite um número");
retornar falso;
}
}
/*
* Para determinar se é um número natural, retorne verdadeiro, retornar
*/
função f_check_naturalnumber (obj)
{
var s = obj.value;
if (/^[0-9]+$/. Teste (s) && (s> 0))
{
retornar true;
}
outro
{
F_ALERT (OBJ, "Por favor, digite um número natural");
retornar falso;
}
}
/*
* Para determinar se é um número inteiro, retorne verdadeiro, retorne False
*/
função f_check_integer (obj)
{
if (/^(/+|-)?/d+$/. test (obj.value)))
{
retornar true;
}
outro
{
F_ALERT (OBJ, "Por favor, digite um número inteiro");
retornar falso;
}
}
/*
* Para determinar se é um número real, retorne true, caso contrário, retorne falsa
*/
função f_check_float (obj)
{
if (/^(/+|-)?/d+($ | /./ d+$)/. teste (obj.value)))
{
retornar true;
}
outro
{
F_ALERT (OBJ, "Por favor, digite o número real");
retornar falso;
}
}
/*
* Verifique o comprimento e a precisão do número
*/
função f_check_double (obj) {
var numreg;
var valor = obj.value;
var strvaluetemp, strint, strdec;
var dtype = obj.eos_datatype;
var pos_dtype = dtype.substring (dtype.indexof ("(")+1, dtype.indexof (")")). split (",");
var len = pos_dtype [0], prec = Pos_dtype [1];
tentar
{
numreg =/[/-]/;
strvaluetemp = value.Replace (numreg, "");
numreg =/[/+]/;
strvaluetemp = strvaluetemp.replace (numreg, "");
// Inteiro
if (prec == 0) {
numreg =/[/.]/;
if (numreg.test (value) == true) {
f_alert (obj, "a entrada deve ser do tipo inteiro");
retornar falso;
}
}
if (strvaluetemp.indexof (".") <0) {
if (strvaluetemp.length> (len - prec)) {
f_alert (obj, "bits inteiros não podem exceder" + (len - prec) + "bits");
retornar falso;
}
}outro{
strint = strvaluetemp.substr (0, strvaluetemp.indexof ("."));
if (strint.length> (len - prec)) {
f_alert (obj, "bits inteiros não podem exceder" + (len - prec) + "bits");
retornar falso;
}
strdec = strvaluetemp.substr ((strvaluetemp.indexof (".")+1), strvaluetemp.length);
if (strdec.length> prec) {
f_alert (obj, "o dígito decimal não pode exceder" + prec + "bits");
retornar falso;
}
}
retornar true;
} catch (e) {
alert ("em f_check_double =" + e);
retornar falso;
}
}
/*
* Verifique o valor máximo mínimo do número
* Voltar para Bool
*/
função f_check_interval (obj)
{
var value = parsefloat (obj.value);
var dtype = obj.eos_datatype;
var pos_dtype = dtype.substring (dtype.indexof ("(")+1, dtype.indexof (")")). split (",");
var minlimit = POS_DTYPE [0];
var maxlimit = pos_dtype [1];
var minval = parsefloat (pos_dtype [0]);
var maxval = parsefloat (pos_dtype [1]);
if (isnan (valor))
{
f_alert (obj, "o valor deve ser um número");
retornar falso;
}
if ((isnan (minval) && (Minlimit! = "-")) || (isnan (maxval) && (maxlimit! = "+"))))))))
{
F_ALERT (OBJ, "O valor do limite deve ser um número ou -, +");
retornar falso;
}
if (miMlimit == "-" &&! isnan (maxval))
{
if (valor> maxval)
{
f_alert (obj, "valor não pode exceder" + maxval);
retornar falso;
}
}
if (! isnan (minval) && maxlimit == "+")
{
if (valor <minval)
{
F_ALERT (OBJ, "O valor não pode ser menor que" + minval);
retornar falso;
}
}
if (! isnan (minval) &&! isnan (maxval))
{
if (minval> maxval)
{
F_ALERT (OBJ, "Valor inicial" + minVal + "não pode ser maior que o Terminating Value" + Maxval);
}outro
{
if (! (valor <= maxval && value> = minval))
{
F_ALERT (OBJ, "O valor deve estar entre" + minval + "e" + maxval + "");
retornar falso;
}
}
}
retornar true;
}
/*
Objetivo: Verifique se a string de entrada é composta apenas de caracteres chineses
Se True for devolvido por verificação, caso contrário, Falso
*/
função f_check_zh (obj) {
if (/^/u4e00-/u9fa5 ]+$/.test(obj.value)) {
retornar true;
}
F_ALERT (OBJ, "Por favor, digite caracteres chineses");
retornar falso;
}
/*
* Determine se é uma letra inglesa em minúsculas. Se for sim, ele retornará verdadeiro, caso contrário, retornará falso
*/
função f_check_lowercase (obj)
{
if (/^[AZ]+$/. Teste (obj.value))
{
retornar true;
}
F_ALERT (OBJ, "Por favor, digite letras inglesas minúsculas");
retornar falso;
}
/*
* Determine se são letras inglesas capital, retorne verdadeiras, caso contrário, retorne falsa
*/
função f_check_uppercase (obj)
{
if (/^[AZ]+$/. Teste (obj.value))
{
retornar true;
}
F_ALERT (OBJ, "Por favor, digite letras maiúsculas");
retornar falso;
}
/*
* Para determinar se é uma carta em inglês, retorne verdadeiro, retornar
*/
função f_check_letter (obj)
{
if (/^[a-za-z]+$/. test (obj.value))
{
retornar true;
}
F_ALERT (OBJ, "Por favor, insira cartas em inglês");
retornar falso;
}
/*
Objetivo: Verifique se a sequência de entrada é composta apenas por caracteres, letras e números chineses.
digitar:
Valor: String
retornar:
Se True for devolvido por verificação, caso contrário, Falso
*/
função f_check_zhornumorlett (obj) {// julga se é composto por caracteres, letras e números chineses
var regus = "^[0-9a-za-z/u4e00-/u9fa5]+$";
var re = novo regexp (regum);
if (re.test (obj.value)) {
retornar true;
}
F_ALERT (OBJ, "Insira caracteres, letras ou números chineses");
retornar falso;
}
/*
Objetivo: Verifique o formato do endereço IP
Digite: tira: endereço IP
Retorno: Se True for retornado por verificação, caso contrário, False será retornado;
*/
função f_check_ip (obj)
{
var re =/^(/d+)/. (/d+)/. (/d+)/. (/d+) $/; // Endereço IP correspondente de expressão regular
if (re.test (obj.value))
{
if (regexp. $ 1 <= 255 && regexp. $ 1> = 0
&& regexp. $ 2 <= 255 && regexp. $ 2> = 0
&& regexp. $ 3 <= 255 && regexp. $ 3> = 0
&& regexp. $ 4 <= 255 && regexp. $ 4> = 0)
{
retornar true;
}
}
F_ALERT (OBJ, "Insira o endereço IP do computador legal");
retornar falso;
}
/*
Objetivo: Verifique se o valor do objeto de entrada atende ao formato do número da porta
Entrada: string stred string
Retorno: Se True for devolvido por verificação, caso contrário, Falso
*/
função f_check_port (obj)
{
if (! f_check_number (obj))
retornar falso;
if (obj.value <65536)
retornar true;
F_ALERT (OBJ, "Insira o endereço IP do computador legal e o número da porta");
retornar falso;
}
/*
Objetivo: Verifique se o valor do objeto de entrada atende ao formato URL
Entrada: string stred string
Retorno: Se True for devolvido por verificação, caso contrário, Falso
*/
função f_check_url (obj) {
var myreg = /^(http://chaugus
if (myreg.test (obj.value)) retorna true;
F_ALERT (OBJ, "Insira o endereço da Web legal");
retornar falso;
}
/*
Objetivo: Verifique se o valor do objeto de entrada está em conformidade com o formato de e-mail
Entrada: string stred string
Retorno: Se True for devolvido por verificação, caso contrário, Falso
*/
função f_check_email (obj) {
var myreg = /^([-_a-za-z0-9/. ]+)@ tiver
if (myreg.test (obj.value)) retorna true;
F_ALERT (OBJ, "Insira um endereço de email legal");
retornar falso;
}
/*
Requisitos: 1. O número do telefone celular é de 11 ou 12 dígitos. Se tiverem 12 dígitos, o primeiro dígito é 0
2. O primeiro e o segundo dígitos do número de telefone celular de 11 dígitos são "13"
Terceiro, o segundo e o terceiro dígitos do número de telefone celular de 12 dígitos são "13"
Objetivo: Verifique se o número do telefone celular é inserido corretamente
digitar:
s: string
retornar:
Se True for devolvido por verificação, caso contrário, Falso
*/
função f_check_mobile (obj) {
var regus =/(^[1] [3] [0-9] {9} $) | (^0 [1] [3] [0-9] {9} $)/;
var re = novo regexp (regum);
if (re.test (obj.value)) {
retornar true;
}
F_ALERT (OBJ, "Por favor, digite o número de telefone celular correto");
retornar falso;
}
/*
Requisitos: 1. O número de telefone consiste em números, "(", ")" e "--"
2. Os números de telefone são de 3 a 8 dígitos
3. Se o número de telefone contiver um código de área, o código da área será de três ou quatro dígitos.
4. Os códigos de área são separados de outras peças por "(", ")" ou "-"
Objetivo: Verifique se o número de telefone inserido está no formato correto
digitar:
strphone: string
retornar:
Se True for devolvido por verificação, caso contrário, Falso
*/
função f_check_phone (obj)
{
var regus =/(^([0] [1-9] {2,3} [-])?/d {3,8} (-/d {1,6})? $) | (^/([0] [1-9] {2,3}/)
var re = novo regexp (regum);
if (re.test (obj.value)) {
retornar true;
}
F_ALERT (OBJ, "Por favor, digite o número de telefone correto");
retornar falso;
}
/* Determine se é um código postal*/
função f_check_zipcode (obj)
{
if (! f_check_number (obj))
retornar falso;
if (obj.value.length! = 6)
{
F_ALERT (OBJ, "O comprimento do código postal deve ser de 6 dígitos");
retornar falso;
}
retornar true;
}
/*
ID do usuário, que pode ser uma combinação de números, letras e sublinhados.
O primeiro caractere não pode ser um número e o comprimento total não pode exceder 20.
*/
função f_check_userid (obj)
{
var userID = obj.value;
if (userId.length> 20)
{
F_ALERT (OBJ, "O comprimento do ID não pode ser maior que 20");
retornar falso;
}
if (! isnan (userid.charat (0)))
{
F_ALERT (OBJ, "O primeiro caractere de ID não pode ser um número");
retornar falso;
}
if (!/^/w {1,20} $/. test (userID))
{
F_ALERT (OBJ, "O ID só pode ser composto de números, letras e sublinhados");
retornar falso;
}
retornar true;
}
/*
Função: Verifique se o número de identificação é válido
Mensagem rápida: não inserido ou o número de identificação está incorreto!
Uso: f_check_idno (obj)
Retorno: Bool
*/
função f_check_idno (obj)
{
var acity = {11: "beijing", 12: "tianjin", 13: "hebei", 14: "shanxi", 15: "interno Mongólia ", 21:" Liaoning ", 22:" Jilin ", 23:" Heilongjiang ", 31:" Shanghai ", 32:" Jiangsu ", 33: "Zhejiang", 34: "Anhui", 35: "Fujian", 36: "Jiangxi", 37: "Shandong", 41: "Henan", 42: "Hubei", 43: "Hunan", 44: "Guangdong", 45: "Guangxi", 46: "Hainan", 50: "Chongqing", 51: "Sichuan", 52: "Guizhou", 53: "Yun Nan ", 54:" Tibete ", 61:" Shaanxi ", 62:" Gansu ", 63:" Qinghai ", 64:" Ningxia ", 65:" Xinjiang ", 71:" Taiwan ", 81:" Hong Kong ", 82:" Macao ", 91:" Foreign "};
var isum = 0;
var info = "";
var stridno = obj.value;
var iDCardLength = stridno.length;
if (!/^/d {17} (/d | x) $/i.test (stridno) &&!/^/d {15} $/i.test (stridno))
{
F_ALERT (OBJ, "Número de identificação ilegal");
retornar falso;
}
// Na operação subsequente, x é equivalente ao número 10, por isso é convertido em um
stridno = stridno.replace (/x $/i, "a");
if (acity [parseint (stridno.substr (0,2))] == null)
{
f_alert (obj, "área ilegal");
retornar falso;
}
if (iDCardLength == 18)
{
sbirthday = stridno.substr (6,4)+"-"+número (stridno.substr (10,2))+"-"+número (stridno.substr (12,2));
var d = nova data (sbirthday.replace (/-/g, "/")))
if (sbirthday!
{
F_ALERT (OBJ, "Aniversário ilegal");
retornar falso;
}
for (var i = 17; i> = 0; i -)
isum += (math.pow (2, i) % 11) * parseint (stridno.charat (17 - i), 11);
if (isum%11! = 1)
{
F_ALERT (OBJ, "Número de identificação ilegal");
retornar falso;
}
}
else if (iDCardLength == 15)
{
sbirthday = "19" + stridno.substr (6,2) + "-" + número (stridno.substr (8,2)) + "-" + número (stridno.substr (10,2));
var d = nova data (sbirthday.replace (/-/g, "/")))
var dd = d.getlyear (). ToString () + "-" + (d.getMonth () + 1) + "-" + d.getDate ();
if (sbirthday! = dd)
{
F_ALERT (OBJ, "Aniversário ilegal");
retornar falso;
}
}
retornar true;
}
/*
* Determine se a string atende à expressão regular especificada
*/
função f_check_formatstr (obj)
{
var str = obj.value;
var dtype = obj.eos_datatype;
var regus = dtype.substring (dtype.indexof ("(")+1, dtype.indexOf (")")); // Expressão regular especificada
var re = novo regexp (regum);
if (re.test (str))
retornar true;
F_ALERT (OBJ, "não atende aos requisitos de expressão regular especificados");
retornar falso;
}
/*
Função: Determine se é uma data (formato: AAAA ANO MM MÊS DD DD, AAA AA AYYY-MM-DD, AAA AA AA AA AA AA AA AYYYY/MM/DD, AAA AA AA AA AA AUMMMDD)
Dica: a data não inserida ou inserida está incorreta no formato!
Uso: f_check_date (obj)
Retorno: Bool
*/
função f_check_date (obj)
{
var date = Trim (obj.value);
var dtype = obj.eos_datatype;
var format = dtype.substring (dtype.indexof ("(")+1, dtype.indexof (")")); // formato de data
var ano, mês, dia, datepat, matchaRray;
if (/^(y {4}) (-| //) (m {1,2})/2 (d {1,2}) $/. test (formato))
datepat =/^(/d {4}) (-| //) (/d {1,2})/2 (/d {1,2}) $/;
caso contrário, if (/^(y {4}) (ano) (m {1,2}) (mês) (d {1,2}) (d {1,2}) (d) $/. test (formato))
datepat =/^(/d {4}) ano (/d {1,2}) mês (/d {1,2}) dia $/;
caso contrário, if (formato == "yyyymmdd")
datepat =/^(/d {4}) (/d {2}) (/d {2}) $/;
outro
{
f_alert (obj, "o formato de data está incorreto");
retornar falso;
}
MatchArray = date.match (datepat);
if (matchArray == null)
{
F_ALERT (OBJ, "O comprimento da data está incorreto ou há símbolos não numéricos na data");
retornar falso;
}
if (/^(y {4}) (-| //) (m {1,2})/2 (d {1,2}) $/. test (formato))
{
ano = matchArray [1];
mês = matchArray [3];
Dia = MatchArray [4];
} outro
{
ano = matchArray [1];
mês = matchArray [2];
Dia = MatchArray [3];
}
se (mês <1 || mês> 12)
{
f_alert (obj, "mês deve ser um número inteiro de 1 a 12");
retornar falso;
}
if (dia <1 || dia> 31)
{
F_ALERT (OBJ, "O número de dias por mês deve ser um número inteiro de 1 a 31");
retornar falso;
}
if ((mês == 4 || mês == 6 || mês == 9 || mês == 11) && dia == 31)
{
F_ALERT (OBJ, "O mês não existe no 31º");
retornar falso;
}
if (mês == 2)
{
var isleap = (ano % 4 == 0 && (ano % 100! = 0 || ano % 400 == 0));
se (dia> 29)
{
F_ALERT (OBJ, "fevereiro tem até 29 dias");
retornar falso;
}
if ((dia == 29) && (! isleap))
{
F_ALERT (OBJ, "Existem apenas 29 dias no ano bissexto");
retornar falso;
}
}
retornar true;
}
/*
Função: O formato de verificação é aa AAA ANO MM Mês DD DD HH Hora mm Minutos Ss Segundos, AAAA-MM-DD HH: MM: SS, AA YYYYY/MM/DD HH: MM: SS, Yyyymmdhhmms
Mensagem rápida: o formato de tempo não inserido ou inserido está incorreto
Uso: f_check_time (obj)
Retorno: Bool
*/
função f_check_time (obj)
{
var time = TRIM (obj.value);
var dtype = obj.eos_datatype;
var format = dtype.substring (dtype.indexof ("(")+1, dtype.indexof (")")); // formato de data
var datepat, matchArray, ano, mês, dia, hora, minuto, segundo;
if (/^(y {4}) (-| //) (m {1,2})/2 (d {1,2}) (hh: mm: ss) $/. test (formato))
datepat =/^(/d {4}) (-| //) (/d {1,2})/2 (/d {1,2}) (/d {1,2}): (/d {1,2}): (/d {1,2}): (/d {1,2}) $/;
caso contrário, if (/^(y {4}) (ano) (m {1,2}) (mês) (d {1,2}) (d {1,2}) (d) (hh hora, mm minuto, ss segundos) $/. test (formato))
datepat =/^(/d {4}) ano (/d {1,2}) mês (/d {1,2}) dia (/d {1,2}) hora (/d {1,2}) minuto (/d {1,2}) segundos $/;
caso contrário, if (formato == "yyyymmddhhmmss")
datepat =/^(/d {4}) (/d {2}) (/d {2}) (/d {2}) (/d {2}) (/d {2}) (/d {2}) (/d {2}) $/;
outro
{
f_alert (obj, "o formato de data está incorreto");
retornar falso;
}
MatchArray = time.match (datepat);
if (matchArray == null)
{
F_ALERT (OBJ, "O comprimento da data está incorreto ou há símbolos não numéricos na data");
retornar falso;
}
if (/^(y {4}) (-| //) (m {1,2})/2 (d {1,2}) (hh: mm: ss) $/. test (formato))
{
ano = matchArray [1];
mês = matchArray [3];
Dia = MatchArray [4];
hora = matchArray [5];
minuto = matchArray [6];
Segundo = MatchArray [7];
} outro
{
ano = matchArray [1];
mês = matchArray [2];
Dia = MatchArray [3];
hora = MatchArray [4];
minuto = matchArray [5];
Segundo = MatchArray [6];
}
se (mês <1 || mês> 12)
{
f_alert (obj, "mês deve ser um número inteiro de 1 a 12");
retornar falso;
}
if (dia <1 || dia> 31)
{
F_ALERT (OBJ, "O número de dias por mês deve ser um número inteiro de 1 a 31");
retornar falso;
}
if ((mês == 4 || mês == 6 || mês == 9 || mês == 11) && dia == 31)
{
F_ALERT (OBJ, "O mês não existe no 31º");
retornar falso;
}
if (mês == 2)
{
var isleap = (ano % 4 == 0 && (ano % 100! = 0 || ano % 400 == 0));
se (dia> 29)
{
F_ALERT (OBJ, "fevereiro tem até 29 dias");
retornar falso;
}
if ((dia == 29) && (! isleap))
{
F_ALERT (OBJ, "Existem apenas 29 dias no ano bissexto");
retornar falso;
}
}
se (hora <0 || hora> 23)
{
F_ALERT (OBJ, "As horas devem ser inteiros de 0 a 23");
retornar falso;
}
se (minuto <0 || minuto> 59)
{
F_ALERT (OBJ, "A pontuação deve ser um número inteiro de 0 a 59");
retornar falso;
}
se (segundo <0 || segundo> 59)
{
F_ALERT (OBJ, "Segundos devem ser inteiros de 0 a 59");
retornar falso;
}
retornar true;
}
/*Julgue se o objeto atual está visível*/
função isvisible (obj) {
var Visatt, Disat;
tentar{
Disatt = obj.style.display;
visatt = obj.style.visibility;
} catch (e) {}
if (Disatt == "Nenhum" || Visatt == "Hidden")
retornar falso;
retornar true;
}
/*Julgue se o objeto atual e seu objeto pai são visíveis*/
função checkprvis (obj) {
var pr = obj.parentNode;
fazer{
if (pr == indefinido || pr == "indefinido") retorna true;
outro{
if (! isVisible (pr)) retorna false;
}
} while (pr = pr.parentNode);
retornar true;
}
/* Uma caixa de diálogo de aviso aparece. Depois que o usuário clicar para confirmar, coloque o cursor na caixa de texto de erro e selecione o conteúdo original de entrada. */
função f_alert (obj, acertinfo)
{
var lege = obj.getAttribute ("eos_displayname");
if (legenda == null)
legenda = "";
alerta (legenda + ":" + alertinfo + "!");
obj.select ();
if (isVisible (obj) && checkprvis (obj))
obj.focus ();
}
/**
* Verifique se a string está vazia
*/
função isnull (str)
{
var i;
if (str.Length == 0)
retornar true;
para (i = 0; i <str.Length; i ++)
{
if (str.Charat (i)! = '')
retornar falso;
}
retornar true;
}
/**
* Verifique se a entrada da caixa de texto especificada é legal.
* Se o usuário inserir algo errado, uma caixa de diálogo prompt aparecerá.
* Ao mesmo tempo, concentre -se na caixa de texto e na frente da caixa de texto
* Um ícone de aviso aparecerá (ele será removido automaticamente após a entrada corretamente).
*/
Função Verificação de Tabela (objeto)
{
Var imagem;
var i;
comprimento var;
if (object.eos_maxsize + ""! = "indefinido") comprimento = object.eos_maxsize;
else comprimento = 0;
if (object.eos_isnull == "true" && isnull (object.value)) retorna true;
/* Verificação de comprimento*/
if (comprimento! = 0 && strlen (object.value)> parseint (comprimento)) {
f_alert (objeto, "comprimento máximo excedido" + comprimento);
retornar falso;
}
/* Verificação do tipo de dados*/
outro {
if (object.eos_datatype + ""! = "indefinido")
{
var dtype = object.eos_datatype;
var objName = object.name;
// Se o nome do tipo for seguido por colchetes, a string antes dos colchetes é considerada como o tipo de verificação
if (dtype.indexof ("(")! = -1)
dtype = dtype.substring (0, dtype.indexof ("("));
// Verifique de acordo com o tipo de verificação dos elementos da página
tentar{
if (avaliar ("f_check_" + dtype + "(objeto)")! = true)
retornar falso;
} catch (e) {return true;}
/* Se a primeira metade do nome existir em forma, e existem campos de formulário terminando com "min" e "max",
Em seguida, é considerado uma consulta por intervalo. Ou seja, o valor do campo de formulário que termina "min" deve ser menor ou igual ao valor do campo de formulário que termina "max". */
if (objName.substring ((objname.length-3), objname.length) == "min")
{
var objmaxName = objName.substring (0, (objName.length-3)) + "max";
if (document.getElementById (objmaxName)! = indefinido && document.getElementById (objmaxname)! = "indefinido")
{
if (checkInterValobjs (objeto, document.getElementById (objmaxName))! = true)
retornar falso;
}
}
}
}
retornar true;
}
/* Verifique a correção de todos os itens de entrada no formulário, geralmente usado para o evento onSubmit do formulário*/
Função CheckForm (MyForm)
{
var i;
for (i = 0; i <myform.elements.length; i ++)
{
/* Os atributos não customos são ignorados*/
if (myform.ents [i] .eos_displayName + "" == "indefinido") continue;
/* Cheque não vazio*/
if (myform.lements [i] .eos_isnull == "false" && isnull (myform.lements [i] .value)) {
f_alert (myform.lements [i], "não pode estar vazio");
retornar falso;
}
/* Verificação do tipo de dados*/
if (checkInput (myform.lements [i]) == false)
retornar falso;
}
retornar true;
}
/**
* Verifique o tamanho dos dados nos dois campos do formulário, atualmente apenas datas e números são permitidos.
* @param obj1 Campo de formulário de pequeno valor
* @param obj2 Campo de formulário de grande valor
*/
função checkIntervalobjs (obj1, obj2)
{
var cation1 = obj1.getAttribute ("eos_displayname");
var cation2 = obj2.getAttribute ("eos_displayname");
var val1 = parsefloat (obj1.value);
var val2 = parsefloat (obj2.value);
// atributos não-Custom são ignorados
if (obj1.eos_displayname + "" == "indefinido" || obj2.eos_displayname + "" "==" indefinido ") {
retornar falso;
}
// Comparação dos tipos de data
if (f_check_date (obj1) == true && f_check_date (obj2) == true) {
var dtype = obj1.eos_datatype;
var format = dtype.substring (dtype.indexof ("(")+1, dtype.indexof (")")); // formato de data
val1 = getDateByFormat (obj1.value, formato);
dtype = obj2.eos_datatype;
formato = dtype.substring (dtype.indexof ("(")+1, dtype.indexOf (")")); // formato de data
val2 = getDateByFormat (obj2.Value, formato);
if (val1> val2) {
obj2.Select ();
if (isVisible (obj) && checkprvis (obj))
obj2.focus ();
Alerta (Legenda1 + "A data de início não pode ser maior que a data final!");
retornar falso;
}
}
// Comparação de tipos numéricos
if ((isnan (val1) &&! isnull (val1)) || (isnan (val2) &&! isnull (val2))) {
Alerta (Legenda1 + "Se os valores de nem todos os números forem números, eles não podem ser comparados!");
retornar falso;
}
if (val1> val2) {
obj2.Select ();
if (isVisible (obj) && checkprvis (obj))
obj2.focus ();
alerta (Legenda1 + "O valor inicial de não pode ser maior que seu valor final!");
retornar falso;
}
retornar true;
}
/* Converta string até o objeto de data de acordo até o formato da data.
Formato: AAA YYYY, MM-MONTH, DD-DIA, HH-HOUR, MM-MINUTE, SS-SECOND.
(O formato deve ser escrito na íntegra, por exemplo: YY-MD, que não é permitido, caso contrário, o NULL será retornado; o formato não corresponde aos dados reais e também retornará nulo.)
Formato padrão: AAAA-MM-DD HH: MM: SS, AAAA-MM-DD. */
função getDateByFormat (str) {
var datereg, formato;
var y, m, d, h, m, s, yi, mi, di, hi, mi, si;
if ((argumentos [1] + "") == "indefinido") format = "yyyy-mm-dd hh: mm: ss";
else formato = argumentos [1];
yi = format.indexOf ("AAA");
Mi = format.indexof ("mm");
di = format.indexOf ("dd");
Oi = format.indexof ("hh");
mi = format.indexof ("mm");
si = format.indexOf ("ss");
if (yi == -1 || mi == -1 || di == -1) retorna nulo;
outro{
y = parseint (str.substring (yi, yi+4));
M = parseint (str.substring (mi, mi+2));
d = parseint (str.substring (di, di+2));
}
if (isnan (y) || isnan (m) || isnan (d)) retorna nulo;
if (hi == -1 || mi == -1 || si == -1) retorne nova data (y, m -1, d);
outro{
H = str.substring (oi, oi+4);
m = str.substring (mi, mi+2);
s = str.substring (Si, Si+2);
}
if (isnan (parseint (y)) || isnan (parseint (m)) || isnan (parseint (d))) retorna nova data (y, m-1, d);
caso contrário, retorne a nova data (y, m-1, d, h, m, s);
}
/*Ltrim (string): remova o espaço à esquerda*/
função ltrim (str) {
var whiteSpace = new String ("/t/n/r");
var s = new string (str);
if (whiteSpace.indexof (s.charat (0))! = -1) {
var j = 0, i = s.Length;
while (j <i && whitespace.indexof (s.charat (j))! = -1) {
j ++;
}
s = s.substring (j, i);
}
retorno s;
}
/*Rtrim (string): remova o espaço à direita*/
função rtrim (str) {
var whiteSpace = new String ("/t/n/r");
var s = new string (str);
if (whitespace.indexof (s.charat (s.length -1))! = -1) {
var i = s.length - 1;
while (i> = 0 && whitespace.indexOf (s.charat (i))! = -1) {
eu--;
}
s = s.substring (0, i+1);
}
retorno s;
}
/*TRIM (String): Remova os espaços em ambos os lados da corda*/
Função Trim (str) {
retornar rtrim (ltrim (str));
}