L'éditeur a compilé de nombreux exemples d'expressions régulières couramment utilisées dans JavaScript auparavant, et elles sont toutes utilisées par elles-mêmes. Maintenant, je vais les partager avec vous.
La copie de code est la suivante:
/ **
* Obtenez la longueur d'octet de la chaîne
* /
fonction strlen (str)
{
var i;
var len;
len = 0;
pour (i = 0; i <str.length; i ++)
{
if (str.charcodeat (i)> 255) len + = 2; else len ++;
}
retour Len;
}
/ *
* Déterminez s'il s'agit d'un nombre, renvoyez vrai, sinon renvoyez false
* /
fonction f_check_number (obj)
{
if (/^/d+$/.test(obj.value))
{
Retour Vrai;
}
autre
{
f_alert (obj, "veuillez entrer un nombre");
retourne false;
}
}
/ *
* Pour déterminer s'il s'agit d'un nombre naturel, revenez vrai, sinon retournez faux
* /
fonction f_check_naturalNumber (obj)
{
var s = obj.value;
if (/ ^ [0-9] + $ /. test (s) && (s> 0))
{
Retour Vrai;
}
autre
{
f_alert (obj, "Veuillez entrer un nombre naturel");
retourne false;
}
}
/ *
* Pour déterminer s'il s'agit d'un entier, retournez vrai, sinon renvoyez false
* /
fonction f_check_integer (obj)
{
if (/ ^ (/ + | -)? / d + $ /. test (obj.value))
{
Retour Vrai;
}
autre
{
f_alert (obj, "Veuillez entrer un entier");
retourne false;
}
}
/ *
* Pour déterminer s'il s'agit d'un nombre réel, revenez vrai, sinon renvoyez false
* /
fonction f_check_float (obj)
{
if (/ ^ (/ + | -)? / d + ($ | /./ d + $) /. test (obj.value)))
{
Retour Vrai;
}
autre
{
f_alert (obj, "Veuillez entrer le numéro réel");
retourne false;
}
}
/ *
* Vérifiez la longueur et la précision du numéro
* /
fonction f_check_double (obj) {
var numreg;
VAR VALEUR = 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], pré = pos_dtype [1];
essayer
{
numreg = / [/ -] /;
strvaluetemp = value.replace (numreg, "");
numreg = / [/ +] /;
strvaluetemp = strvaluetemp.replace (numreg, "");
//Entier
if (pré == 0) {
numreg = / [/.] /;
if (numreg.test (valeur) == true) {
f_alert (obj, "l'entrée doit être de type entier");
retourne false;
}
}
if (strvaluetemp.indexof (".") <0) {
if (strvaluetemp.length> (len - pré) {
F_ALERT (OBJ, "Les bits entiers ne peuvent pas dépasser" + (Len - Prec) + "bits");
retourne false;
}
}autre{
strint = strvaluetemp.substr (0, strvaluetemp.indexof ("."));
if (strint.length> (len - pré)) {
F_ALERT (OBJ, "Les bits entiers ne peuvent pas dépasser" + (Len - Prec) + "bits");
retourne false;
}
strDec = strvaluetemp.substr ((strvaluetemp.indexof (".") + 1), strvaluetemp.length);
if (strdec.length> prec) {
f_alert (obj, "Le chiffre décimal ne peut pas dépasser" + pré + "bits");
retourne false;
}
}
Retour Vrai;
} catch (e) {
alert ("dans f_check_double =" + e);
retourne false;
}
}
/ *
* Vérifiez la valeur maximale minimale du nombre
* Retour à bool
* /
fonction f_check_interval (obj)
{
var valeur = 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 (valeur))
{
f_alert (obj, "la valeur doit être un nombre");
retourne false;
}
if ((Isnan (minval) && (minlimit! = "-")) || (isnan (maxval) && (maxlimit! = "+")))))
{
f_alert (obj, "La valeur limite doit être un nombre ou -, +");
retourne false;
}
if (minlimit == "-" &&! Isnan (maxval)))
{
if (valeur> maxval)
{
f_alert (obj, "la valeur ne peut pas dépasser" + maxval);
retourne false;
}
}
if (! Isnan (minval) && maxlimit == "+")
{
if (valeur <minval)
{
f_alert (obj, "la valeur ne peut pas être inférieure à" + minval);
retourne false;
}
}
if (! Isnan (minval) &&! Isnan (maxval)))
{
if (minval> maxval)
{
F_ALERT (OBJ, "Démarrer la valeur" + Minval + "ne peut pas être supérieur à la valeur de terminaison" + maxval);
}autre
{
if (! (valeur <= maxval && valeur> = minval)))
{
f_alert (obj, "La valeur doit être entre" + minval + "et" + maxval + "");
retourne false;
}
}
}
Retour Vrai;
}
/ *
Objectif: Vérifiez si la chaîne d'entrée est composée uniquement de caractères chinois
Si le vrai est renvoyé par vérification, sinon faux
* /
fonction f_check_zh (obj) {
if (/^@/u4e00-/u9fa5
Retour Vrai;
}
f_alert (obj, "Veuillez entrer les caractères chinois");
retourne false;
}
/ *
* Déterminez s'il s'agit d'une lettre d'anglais minuscule. Si c'est oui, il reviendra vrai, sinon il reviendra faux
* /
fonction f_check_lowercase (obj)
{
if (/ ^ [az] + $ /. test (obj.value)))
{
Retour Vrai;
}
f_alert (obj, "Veuillez entrer en minuscules lettres anglaises");
retourne false;
}
/ *
* Déterminez s'il s'agit de lettres d'anglais capital, de retour vrai, sinon retourne false
* /
fonction f_check_uppercase (obj)
{
if (/ ^ [az] + $ /. test (obj.value)))
{
Retour Vrai;
}
f_alert (obj, "veuillez entrer en majuscules");
retourne false;
}
/ *
* Pour déterminer s'il s'agit d'une lettre anglaise, revenez vrai, sinon retournez false
* /
fonction f_check_letter (obj)
{
if (/ ^ [a-za-z] + $ /. test (obj.value)))
{
Retour Vrai;
}
f_alert (obj, "s'il vous plaît entrez des lettres anglaises");
retourne false;
}
/ *
Objectif: Vérifiez si la chaîne d'entrée est composée uniquement de caractères chinois, de lettres et de chiffres.
entrer:
valeur: chaîne
retour:
Si le vrai est renvoyé par vérification, sinon faux
* /
fonction f_check_zhornumorlett (obj) {// juger s'il est composé de caractères, de lettres et de chiffres chinois
var regu = "^ [0-9a-za-z / u4e00- / u9fa5] + $";
var re = new regexp (regu);
if (re.test (obj.value)) {
Retour Vrai;
}
f_alert (obj, "Veuillez entrer des caractères, des lettres ou des numéros chinois");
retourne false;
}
/ *
Objectif: Vérifiez le format de l'adresse IP
Entrez: Strip: Adresse IP
Retour: si le vrai est renvoyé par vérification, sinon false est renvoyé;
* /
fonction f_check_ip (obj)
{
var re = / ^ (/ d +) /. (/ d +) /. (/ d +) /. (/ d +) $ /; // Expression régulière correspondant à l'adresse IP
if (re.test (obj.value))
{
if (regexp. $ $ <= 255 && regexp. $ $> = 0
&& regexp. $ $ <= 255 && regexp. $ 2> = 0
&& regexp. $ $ <= 255 && regexp. $ $> = 0
&& regexp. $ $ <= 255 && regexp. $ $> = 0)
{
Retour Vrai;
}
}
f_alert (obj, "Veuillez saisir l'adresse IP d'ordinateur légal");
retourne false;
}
/ *
Objectif: Vérifiez si la valeur de l'objet d'entrée répond au format de numéro de port
Entrée: la chaîne entrée STR
Retour: si le vrai est renvoyé par vérification, sinon faux
* /
fonction f_check_port (obj)
{
if (! f_check_number (obj))
retourne false;
if (obj.value <65536)
Retour Vrai;
F_ALERT (OBJ, "Veuillez saisir l'adresse IP et le numéro de port de l'ordinateur légal");
retourne false;
}
/ *
Objectif: Vérifiez si la valeur de l'objet d'entrée répond au format URL
Entrée: la chaîne entrée STR
Retour: si le vrai est renvoyé par vérification, sinon faux
* /
fonction f_check_url (obj) {
var myreg = /^((http:@/
if (myreg.test (obj.value)) renvoie true;
f_alert (obj, "Veuillez saisir l'adresse Web légale");
retourne false;
}
/ *
Objectif: Vérifiez si la valeur de l'objet d'entrée est conforme au format électronique
Entrée: la chaîne entrée STR
Retour: si le vrai est renvoyé par vérification, sinon faux
* /
fonction f_check_email (obj) {
var myreg = /^(@-_a-za-z0-9/.
if (myreg.test (obj.value)) renvoie true;
f_alert (obj, "Veuillez saisir une adresse e-mail légale");
retourne false;
}
/ *
Exigences: 1. Le numéro de téléphone mobile est de 11 ou 12 chiffres. S'il est à 12 chiffres, alors le premier chiffre est 0
2. Les premier et deuxième chiffres du numéro de téléphone mobile à 11 chiffres sont "13"
Troisièmement, les deuxième et troisième chiffres du numéro de téléphone mobile à 12 chiffres sont "13"
Objectif: Vérifiez si le numéro de téléphone mobile est entré correctement
entrer:
s: chaîne
retour:
Si le vrai est renvoyé par vérification, sinon faux
* /
fonction f_check_mobile (obj) {
var regu = / (^ [1] [3] [0-9] {9} $) | (^ 0 [1] [3] [0-9] {9} $) /;
var re = new regexp (regu);
if (re.test (obj.value)) {
Retour Vrai;
}
f_alert (obj, "Veuillez saisir le numéro de téléphone mobile correct");
retourne false;
}
/ *
Exigences: 1. Le numéro de téléphone se compose de numéros, "(", ")" et "-"
2. Les numéros de téléphone sont de 3 à 8 chiffres
3. Si le numéro de téléphone contient un code régional, le code régional est de trois ou quatre chiffres.
4. Les codes de zone sont séparés des autres parties par "(", ")" ou "-"
Objectif: Vérifiez si le numéro de téléphone entré est en format correct
entrer:
Strphone: chaîne
retour:
Si le vrai est renvoyé par vérification, sinon faux
* /
fonction f_check_phone (obj)
{
var regu = / (^ ([0] [1-9] {2,3} [-])? / d {3,8} (- / d {1,6})? $) | (^ / ([0] [1-9] {2,3} /) / d {3,8} (/ (/ d {1,6} /))? $) | (^
var re = new regexp (regu);
if (re.test (obj.value)) {
Retour Vrai;
}
f_alert (obj, "Veuillez saisir le numéro de téléphone correct");
retourne false;
}
/ * Déterminez s'il s'agit d'un code postal * /
fonction f_check_zipcode (obj)
{
if (! f_check_number (obj))
retourne false;
if (obj.value.length! = 6)
{
f_alert (obj, "La longueur du code postal doit être à 6 chiffres");
retourne false;
}
Retour Vrai;
}
/ *
ID utilisateur, qui peut être une combinaison de nombres, de lettres et de soulignements.
Le premier caractère ne peut pas être un nombre et la longueur totale ne peut pas dépasser 20.
* /
fonction f_check_userid (obj)
{
var userId = obj.value;
if (userId.length> 20)
{
f_alert (obj, "la longueur d'ID ne peut pas être supérieure à 20");
retourne false;
}
if (! Isnan (userid.charat (0)))
{
f_alert (obj, "Le premier caractère d'Id ne peut pas être un nombre");
retourne false;
}
if (! / ^ / w {1,20} $ /. Test (userId))
{
f_alert (obj, "id ne peut être composé que de nombres, de lettres et de soulignements");
retourne false;
}
Retour Vrai;
}
/ *
Fonction: Vérifiez si le numéro d'identification est valide
Message rapide: non entré ou le numéro d'identification est incorrect!
Utilisation: f_check_idno (obj)
Retour: bool
* /
fonction f_check_idno (obj)
{
var acity = {11: "Beijing", 12: "Tianjin", 13: "Hebei", 14: "Shanxi", 15: "Intérieur Mongolie ", 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:" Tibet ", 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, "numéro d'identification illégal");
retourne false;
}
// Dans l'opération suivante, X est équivalent au numéro 10, il est donc converti en un
stridno = stridno.replace (/ x $ / i, "a");
if (acity [parseInt (stridno.substr (0,2))] == null)
{
f_alert (obj, "zone illégale");
retourne false;
}
if (idcardLength == 18)
{
sbirthday = stridno.substr (6,4) + "-" + nombre (stridno.substr (10,2)) + "-" + nombre (stridno.suStr (12,2));
var d = nouvelle date (sbirthday.replace (/ - / g, "/"))
if (sbirthday! = (d.getlyear () + "-" + (d.getMonth () + 1) + "-" + d.getDate ()))
{
f_alert (obj, "anniversaire illégal");
retourne false;
}
pour (var i = 17; i> = 0; i -)
ISUM + = (math.pow (2, i)% 11) * paSeInt (stridno.charat (17 - i), 11);
si (ISUM% 11! = 1)
{
f_alert (obj, "numéro d'identification illégal");
retourne false;
}
}
else if (idcardLength == 15)
{
sbirthday = "19" + stridno.substr (6,2) + "-" + nombre (stridno.substr (8,2)) + "-" + nombre (stridno.substr (10,2));
var d = nouvelle date (sbirthday.replace (/ - / g, "/"))
var dd = d.getlyar (). toString () + "-" + (d.getMonth () + 1) + "-" + d.getDate ();
if (sbirthday! = dd)
{
f_alert (obj, "anniversaire illégal");
retourne false;
}
}
Retour Vrai;
}
/ *
* Déterminez si la chaîne répond à l'expression régulière spécifiée
* /
Fonction f_check_formatstr (obj)
{
var str = obj.value;
var dtype = obj.eos_datatype;
var regu = dtype.substring (dtype.indexof ("(") + 1, dtype.indexof (")")); // Expression régulière spécifiée
var re = new regexp (regu);
if (re.test (str))
Retour Vrai;
f_alert (obj, "ne répond pas aux exigences d'expression régulières spécifiées");
retourne false;
}
/ *
Fonction: Déterminez s'il s'agit d'une date (Format: Yyyy Year Mm Moids DD Date, Yyyy-mm-dd, yyyyy / mm / dd, yyyymmdd)
Conseil: la date non entrée ou entrée est incorrecte au format!
Utilisation: f_check_date (obj)
Retour: bool
* /
fonction f_check_date (obj)
{
Var Date = Trim (obj.Value);
var dtype = obj.eos_datatype;
var format = dtype.substring (dtype.indexof ("(") + 1, dtype.indexof (")")); // Format de date
Var Année, mois, jour, datepat, matchArray;
if (/ ^ (y {4}) (- | //) (m {1,2}) / 2 (d {1,2}) $ /. Test (format))
datepat = / ^ (/ d {4}) (- | //) (/ d {1,2}) / 2 (/ d {1,2}) $ /;
else if (/ ^ (y {4}) (année) (m {1,2}) (mois) (d {1,2}) (d {1,2}) (d) $ /. test (format)))
datepat = / ^ (/ d {4}) année (/ d {1,2}) mois (/ d {1,2}) jour $ /;
else if (format == "yyyymmdd")
datepat = / ^ (/ d {4}) (/ d {2}) (/ d {2}) $ /;
autre
{
F_ALERT (OBJ, "Le format de date est incorrect");
retourne false;
}
MatchArray = Date.match (datepat);
if (matchArray == null)
{
f_alert (obj, "La longueur de date est incorrecte, ou il existe des symboles non numériques dans la date");
retourne false;
}
if (/ ^ (y {4}) (- | //) (m {1,2}) / 2 (d {1,2}) $ /. Test (format))
{
année = matchArray [1];
mois = matchArray [3];
jour = matchArray [4];
} autre
{
année = matchArray [1];
mois = matchArray [2];
jour = matchArray [3];
}
if (mois <1 || mois> 12)
{
f_alert (obj, "Le mois devrait être un entier de 1 à 12");
retourne false;
}
if (jour <1 || jour> 31)
{
F_ALERT (OBJ, "Le nombre de jours par mois devrait être un entier de 1 à 31");
retourne false;
}
if ((mois == 4 || mois == 6 || mois == 9 || mois == 11) && day == 31)
{
f_alert (obj, "Le mois n'existe pas le 31");
retourne false;
}
si (mois == 2)
{
var isleap = (année% 4 == 0 && (année% 100! = 0 || an% 400 == 0));
si (jour> 29)
{
f_alert (obj, "février a jusqu'à 29 jours");
retourne false;
}
if ((day == 29) && (! Isleap))
{
F_ALERT (OBJ, "Il n'y a que 29 jours en saut");
retourne false;
}
}
Retour Vrai;
}
/ *
Fonction: Le format de vérification est yyyy année mm mois dd jour hh heure mm minutes ss
Message rapide: le format de temps non entré ou entré est incorrect
Utilisation: f_check_time (obj)
Retour: bool
* /
fonction f_check_time (obj)
{
var time = trim (obj.value);
var dtype = obj.eos_datatype;
var format = dtype.substring (dtype.indexof ("(") + 1, dtype.indexof (")")); // Format de date
var datepat, matcharray, année, mois, jour, heure, minute, deuxième;
if (/ ^ (y {4}) (- | //) (m {1,2}) / 2 (d {1,2}) (hh: mm: ss) $ /. test (format))
datepat = / ^ (/ d {4}) (- | //) (/ d {1,2}) / 2 (/ d {1,2}) (/ d {1,2}): (/ d {1,2}): (/ d {1,2}): (/ d {1,2}) $ /;
else if (/ ^ (y {4}) (année) (m {1,2}) (mois) (d {1,2}) (d {1,2}) (d) (hh heure, mm minute, ss secondes) $ /. Test (format)))
datepat = / ^ (/ d {4}) année (/ d {1,2}) mois (/ d {1,2}) jour (/ d {1,2}) heure (/ d {1,2}) minute (/ d {1,2}) secondes $ /;
else if (format == "yyyymmddhhmms")
datepat = / ^ (/ d {4}) (/ d {2}) (/ d {2}) (/ d {2}) (/ d {2}) (/ d {2}) (/ d {2}) (/ d {2}) $ /;
autre
{
F_ALERT (OBJ, "Le format de date est incorrect");
retourne false;
}
matchArray = time.match (datepat);
if (matchArray == null)
{
f_alert (obj, "La longueur de date est incorrecte, ou il existe des symboles non numériques dans la date");
retourne false;
}
if (/ ^ (y {4}) (- | //) (m {1,2}) / 2 (d {1,2}) (hh: mm: ss) $ /. test (format))
{
année = matchArray [1];
mois = matchArray [3];
jour = matchArray [4];
heure = matchArray [5];
minute = matchArray [6];
second = matchArray [7];
} autre
{
année = matchArray [1];
mois = matchArray [2];
jour = matchArray [3];
heure = matchArray [4];
minute = matchArray [5];
second = matchArray [6];
}
if (mois <1 || mois> 12)
{
f_alert (obj, "Le mois devrait être un entier de 1 à 12");
retourne false;
}
if (jour <1 || jour> 31)
{
F_ALERT (OBJ, "Le nombre de jours par mois devrait être un entier de 1 à 31");
retourne false;
}
if ((mois == 4 || mois == 6 || mois == 9 || mois == 11) && day == 31)
{
f_alert (obj, "Le mois n'existe pas le 31");
retourne false;
}
si (mois == 2)
{
var isleap = (année% 4 == 0 && (année% 100! = 0 || an% 400 == 0));
si (jour> 29)
{
f_alert (obj, "février a jusqu'à 29 jours");
retourne false;
}
if ((day == 29) && (! Isleap))
{
F_ALERT (OBJ, "Il n'y a que 29 jours en saut");
retourne false;
}
}
if (heure <0 || heure> 23)
{
f_alert (obj, "les heures doivent être des entiers de 0 à 23");
retourne false;
}
if (minute <0 || minute> 59)
{
f_alert (obj, "Le score doit être un entier de 0 à 59");
retourne false;
}
if (deuxième <0 || seconde> 59)
{
f_alert (obj, "Les secondes devraient être des entiers de 0 à 59");
retourne false;
}
Retour Vrai;
}
/ * Juger si l'objet actuel est visible * /
fonction est visible (obj) {
Var Visatt, Disatt;
essayer{
Disatt = obj.style.display;
visatt = obj.style.visibilité;
} catch (e) {}
if (Disatt == "Aucun" || Visatt == "Hidden")
retourne false;
Retour Vrai;
}
/ * Juger si l'objet actuel et son objet parent sont visibles * /
Fonction CheckPrVis (obj) {
var pr = obj.parentNode;
faire{
if (pr == Undefined || pr == "Undefined") return true;
autre{
if (! isVisible (pr)) renvoie false;
}
} while (pr = pr.parentNode);
Retour Vrai;
}
/ * Une boîte de dialogue d'avertissement apparaît. Une fois que l'utilisateur a cliqué pour confirmer, placez le curseur sur la zone de texte d'erreur et sélectionnez le contenu d'entrée d'origine. * /
fonction f_alert (obj, acertinfo)
{
var Légende = obj.getAttribute ("eos_displayName");
if (légende == null)
Légende = "";
alert (légende + ":" + alertinfo + "!");
obj.select ();
if (isVisible (obj) && checkPrvis (obj))
obj.focus ();
}
/ **
* Vérifiez si la chaîne est vide
* /
fonction isNull (str)
{
var i;
if (str.length == 0)
Retour Vrai;
pour (i = 0; i <str.length; i ++)
{
if (str.charat (i)! = '')
retourne false;
}
Retour Vrai;
}
/ **
* Vérifiez si l'entrée de la zone de texte spécifiée est légale.
* Si l'utilisateur entre quelque chose de mal, une boîte de dialogue invite apparaîtra.
* En même temps, concentrez-vous sur la zone de texte et devant la zone de texte
* Une icône d'avertissement apparaîtra (elle sera automatiquement supprimée après l'entrée correctement).
* /
Fonction CheckInput (objet)
{
var image;
var i;
longueur var;
if (object.eos_maxsize + ""! = "Undefined") Longueur = object.eos_maxsize;
else longueur = 0;
if (object.eos_isnull == "true" && isNull (object.value)) return true;
/ * Chèque de longueur * /
if (length! = 0 && strlen (object.value)> parseInt (longueur)) {
f_alert (objet, "longueur maximale dépassée" + longueur);
retourne false;
}
/ * Vérification du type de données * /
autre {
if (object.eos_datatype + ""! = "Undefined")
{
var dtype = object.eos_datatype;
var objname = object.name;
// Si le nom de type est suivi des supports, la chaîne avant les supports est considérée comme le type de chèque
if (dtype.indexof ("(")! = -1)
dtype = dType.SubString (0, dtype.indexof ("("));
// Vérifiez en fonction du type de vérification des éléments de page
essayer{
if (eval ("f_check_" + dtype + "(objet)")! = true)
retourne false;
} catch (e) {return true;}
/ * Si la première moitié du nom existe en forme, et il y a les deux champs de forme se terminant par "min" et "max",
Ensuite, il est considéré comme une requête par intervalle. C'est-à-dire que la valeur du champ de formulaire se terminant "min" doit être inférieure ou égale à la valeur du champ de formulaire terminant "Max". * /
if (objname.substring ((objname.length-3), objname.length) == "min")
{
var objMaxName = objname.substring (0, (objname.length-3)) + "max";
if (document.getElementById (objMaxName)! = Undefined && document.getElementByid (objMaxName)! = "Undefined")
{
if (checkIntervalObjs (objet, document.getElementById (objMaxName))! = true)
retourne false;
}
}
}
}
Retour Vrai;
}
/ * Vérifiez l'exactitude de tous les éléments d'entrée du formulaire, généralement utilisés pour l'événement onSubmit du formulaire * /
Fonction CheckForm (MyForm)
{
var i;
for (i = 0; i <myform.elements.length; i ++)
{
/ * Les attributs non personnalisés sont ignorés * /
if (myform.ments [i] .eos_displayName + "" == "Undefined") continue;
/ * Chèque non vide * /
if (myform.elements [i] .eos_isnull == "false" && isNull (myform.elements [i] .value)) {
f_alert (myform.elements [i], "ne peut pas être vide");
retourne false;
}
/ * Vérification du type de données * /
if (checkInput (myform.elements [i]) == false)
retourne false;
}
Retour Vrai;
}
/ **
* Vérifiez la taille des données dans les deux champs de formulaire, les dates et les nombres sont actuellement autorisés.
* @param obj1 champ de formulaire de petite valeur
* @param obj2 champ de formulaire de grande valeur
* /
Fonction CheckIntervalObjs (Obj1, Obj2)
{
var légende1 = obj1.getAttribute ("eos_displayName");
var Légende2 = obj2.getAttribute ("eos_displayName");
var val1 = parsefloat (obj1.value);
var val2 = parsefloat (obj2.value);
// Les attributs non personnalisés sont ignorés
if (obj1.eos_displayname + "" == "Undefined" || obj2.eos_displayName + "" == "Undefined") {
retourne false;
}
// Comparaison des types de dates
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 (")")); // Format de date
val1 = getDateByFormat (obj1.value, format);
dtype = obj2.eos_datatype;
format = dtype.substring (dtype.indexof ("(") + 1, dtype.indexof (")")); // Format de date
val2 = getDateByFormat (obj2.value, format);
if (val1> val2) {
obj2.select ();
if (isVisible (obj) && checkPrvis (obj))
obj2.focus ();
alerte (Légende1 + "La date de début ne peut pas être supérieure à sa date de fin!");
retourne false;
}
}
// Comparaison des types numériques
if ((Isnan (Val1) &&! Isnull (Val1)) || (Isnan (Val2) &&! Isnull (Val2))) {
alerte (légende1 + "Si les valeurs de tous les nombres ne sont pas des nombres, ils ne peuvent pas être comparés!");
retourne false;
}
if (val1> val2) {
obj2.select ();
if (isVisible (obj) && checkPrvis (obj))
obj2.focus ();
alert (Légende1 + "La valeur de départ de ne peut pas être supérieure à sa valeur finale!");
retourne false;
}
Retour Vrai;
}
/ * Convertir la chaîne à l'objet Date en fonction du format de date.
Format: Yyyy-Year, MM-Month, DD-Day, HH-Hour, MM-Minute, SS-Second.
(Le format doit être écrit en entier, par exemple: YY-MD, qui n'est pas autorisé, sinon NULL sera renvoyé; le format ne correspond pas aux données réelles et renvoie également NULL.)
Format par défaut: yyyy-mm-dd hh: mm: ss, yyyy-mm-dd. * /
fonction getDateByFormat (str) {
var datoreg, format;
var y, m, d, h, m, s, yi, mi, di, hi, mi, si;
if ((arguments [1] + "") == "Undefined") format = "yyyy-mm-dd hh: mm: ss";
else format = arguments [1];
yi = format.indexof ("yyyy");
Mi = format.indexof ("mm");
di = format.indexof ("dd");
Hi = format.indexof ("hh");
mi = format.indexof ("mm");
si = format.indexof ("ss");
if (yi == -1 || mi == -1 || di == -1) renvoie null;
autre{
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)) renvoie null;
if (hi == -1 || mi == -1 || si == -1) renvoie la nouvelle date (y, m-1, d);
autre{
H = str.substring (hi, hi + 4);
m = str.substring (mi, mi + 2);
S = str.substring (Si, Si + 2);
}
if (isnan (parseInt (y)) || ISnan (parseInt (m)) || ISnan (parseInt (d))) renvoie la nouvelle date (y, m-1, d);
sinon retourner la nouvelle date (y, m-1, d, h, m, s);
}
/ * Ltrim (String): Retirez l'espace à gauche * /
fonction 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);
}
retour s;
}
/ * Rtrim (chaîne): supprimez l'espace à droite * /
fonction 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) {
je--;
}
S = S.Substring (0, i + 1);
}
retour s;
}
/ * Trim (String): Retirez les espaces des deux côtés de la chaîne * /
Fonction Trim (str) {
return rtrim (ltrim (str));
}