JS utilise des règles régulières pour déterminer la date de naissance

Cette fois, je vais vous présenter l'utilisation des expressions régulières par JS pour déterminer la date de naissance. Quelles sont les précautions à prendre pour utiliser les expressions régulières de JS pour déterminer la date de naissance ?

En bref

Dans la validation de formulaire, les expressions régulières sont souvent utilisées pour vérifier la date de naissance. Cet article divise la date de naissance en plusieurs parties et présente étape par étape le processus complet de mise en œuvre d'une vérification de la date de naissance. Je pense qu'après avoir compris le contenu de cet article, vous aurez une compréhension plus profonde et une plus grande confiance dans l'écriture d'expressions régulières.

Nous divisons une date de naissance sous la forme du 15/06/2018 en trois composantes : année, mois et jour, et écrivons respectivement les règles régulières correspondantes.

Expression régulière d'un an

Donnez d'abord la définition de la règle de l'expression régulière de l'année :

• L'année est composée de 4 chiffres

• N'accepte que les années commençant par 19 et 20

Selon les règles ci-dessus, il est facile d'écrire le expression régulière de l'année Formule :

var pattern = /^(19|20)\d{2}$/;
//输出 true
console.log(pattern.test("2008"));

où // les deux barres obliques et les caractères entre elles sont la définition des littéraux d'expression régulière ^ signifie correspondre au début de chaîne , $; signifie des caractères correspondants La fin de la chaîne ^(19|20) signifie correspondre à une chaîne commençant par 19 ou 20, une paire de parenthèses est utilisée pour combiner plusieurs éléments en une unité et d{2} signifie correspondre à n'importe quel nombre ASCII 2 ; fois, d, etc. La valeur est [0-9] et {2} signifie faire correspondre l'élément précédent 2 fois.

L'expression régulière ci-dessus peut correspondre aux années de 1900 à 2099. Si vous souhaitez limiter la plage des années, ajoutez les règles suivantes :

• L'année commence dans 1920

• L'année se termine en 2018

Selon les règles ci-dessus, modifiez l'expression régulière comme suit :

var pattern =/^(19[2-9]\d{1})|(20((0[0-9])|(1[0-8])))$/;
//输出 false
console.log(pattern.test("1916"));
//输出 true
console.log(pattern.test("2008"));
//输出 false
console.log(pattern.test("2022"));

Expression régulière de février

Donnez d'abord la définition de la règle de l'expression régulière du mois :

• Le mois peut être 1-12

• Si le mois est 1-9, vous pouvez ajouter 0 devant

Selon les règles ci-dessus, le Les règles régulières suivantes et les tests simples sont donnés :

var pattern = /^((0?[1-9])|(1[0-2]))$/;
//输出 false
console.log(pattern.test("19"));
//输出 true
console.log(pattern.test("02"));
//输出 true
console.log(pattern.test("2"));
//输出 true
console.log(pattern.test("11"));

3 Expression régulière de date

Donnez d'abord la définition de la règle de l'expression régulière de date :

• La date peut être de 1 à 31

• Si la date est de 1 à 9, vous pouvez ajouter 0 devant

Selon les règles ci-dessus, les règles régulières et les tests simples suivants sont donnés :

var pattern = /^((0?[1-9])|([1-2][0-9])|30|31)$/;
//输出 false
console.log(pattern.test("32"));
//输出 true
console.log(pattern.test("02"));
//输出 true
console.log(pattern.test("2"));

4 vérifications combinées

Sur la base de l'expression régulière ci-dessus de l'année, du mois et de la date, une expression régulière de la date de naissance est formée :

var pattern = /^((19[2-9]\d{1})|(20((0[0-9])|(1[0-8]))))\-((0?[1-9])|(1[0-2]))\-((0?[1-9])|([1-2][0-9])|30|31)$/;
//输出 true
console.log(pattern.test("1923-3-18"));
//输出 true
console.log(pattern.test("1923-4-31"));
//输出 true
console.log(pattern.test("1923-2-29"));
//输出 true
console.log(pattern.test("2016-2-29"));

Il ressort des résultats des tests ci-dessus que la vérification régulière ci-dessus est pas parfait, principalement en raison du nombre de jours en février, avril, juin, septembre et novembre.

5 Amélioration

Selon la question de l'étape 4, ajoutez les règles limitantes comme suit :

• Il n'y a pas de 31ème jour en avril, juin, septembre et novembre

• Février compte 28 jours dans les années ordinaires

• Février en compte 29 jours dans les années bissextiles

Jugement des années bissextiles dans les années ordinaires :

Une année qui est également divisible par 4 est une année bissextile, et une année qui n'est pas divisible à 4 ans est une année ordinaire. Mais s’il s’agit d’une centaine d’années complètes, ce n’est une année bissextile que si elle est divisible par 400, sinon c’est une année ordinaire.

Sur la base des nouvelles règles et instructions, les fonctions et tests réguliers suivants sont donnés :

var checkBirth = function (val) {
  var pattern = /^((?:19[2-9]\d{1})|(?:20(?:(?:0[0-9])|(?:1[0-8]))))\-((?:0?[1-9])|(?:1[0-2]))\-((?:0?[1-9])|(?:[1-2][0-9])|30|31)$/;
  var result = val.match(pattern);
  if(result != null) {
    var iYear = parseInt(result[1]);
    var month = result[2];
    var date = result[3];
    if(/^((0?[469])|11)$/.test(month) &&　date == '31') {
      return false;
    } else if(parseInt(month) == 2){
      if((iYear % 4 ==0 && iYear % 100 != 0) || (iYear % 400 == 0)) {
        if(date == '29') {
          return true;
        }
      }
      if(parseInt(date) > 28) {
        return false;
      }
    }
    return true;
  }
  return false;
}
//输出 true
console.log(checkBirth("1923-3-18"));
//输出 false 4月份没有31日
console.log(checkBirth("1923-4-31"));
//输出 false 平年
console.log(checkBirth("1923-2-29"));
//输出 true 闰年
console.log(checkBirth("2016-2-29"));

L'expression régulière ci-dessus utilise la méthode match() de String Le seul paramètre de ceci. La méthode est une expression régulière qui renvoie un tableau composé de résultats correspondants. Le premier élément du tableau est la chaîne correspondante et les éléments restants sont les sous-expressions entre parenthèses dans l'expression régulière. La forme (:?...) apparaît plusieurs fois. Cette méthode signifie que les éléments ne sont regroupés qu'en une seule unité, mais les caractères correspondant au groupe ne sont pas mémorisés. Cette méthode est utilisée pour extraire les éléments de l’année, du mois et du jour dans l’ordre de correspondance régulière pour une comparaison ultérieure.

根据上述分析与测试，我们不但实现了年月日的正则的一般判定，还实现了日期范围及2，4，6，9，11月等特殊月份天数的处理，测验结果达到了我们设定的目标。

根据上述讲解和分析，我们可以调整相应的限定规则，使其满足于特定场景下的项目需要。

延伸

根据 V2EX网友 xiangyuecn 的意见，上述checkBirth的逻辑代码太多，确实有点 low。现将上述代码更新如下：

var checkBirth = function (val) {
  var pattern = /^((19[2-9]\d{1})|(20((0[0-9])|(1[0-8]))))\-((0?[1-9])|(1[0-2]))\-((0?[1-9])|([1-2][0-9])|30|31)$/;
  if(pattern.test(val)) {
    var date = new Date(val);
    var month = val.substring(val.indexOf("-")+1,val.lastIndexOf("-"));
    return date && (date.getMonth()+1 == parseInt(month));
  }
  return false;
}

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

Angular集成三方UI框架、控件使用详解

JS常见函数使用详解

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!