以 YYYYMMDD 格式计算给定出生日期的年龄

Posted 2023-02-25

【中文标题】以 YYYYMMDD 格式计算给定出生日期的年龄

【英文标题】：Calculate age given the birth date in the format YYYYMMDD

【发布时间】：2011-05-02 21:07:08

【问题描述】：

如果出生日期格式为 YYYYMMDD，我如何计算年龄？是否可以使用Date() 函数？

我正在寻找比我现在使用的更好的解决方案：

var dob = '19800810';
var year = Number(dob.substr(0, 4));
var month = Number(dob.substr(4, 2)) - 1;
var day = Number(dob.substr(6, 2));
var today = new Date();
var age = today.getFullYear() - year;
if (today.getMonth() < month || (today.getMonth() == month && today.getDate() < day)) 
  age--;

alert(age);

【问题讨论】：

请注意您的格式，不要按照您的方式进行；只需使用代码 (010101) 按钮或 Ctrl-K 将代码缩进 4 个空格。

我做了，但它无法在 IE9 Beta 上运行，所以我不得不手动完成。

您的原始解决方案在计算年龄方面比当前答案更好。 Júlio Santos 的回答基本上是一样的。其他答案在许多情况下给出的结果不准确，并且可能不太直接或效率较低。

谢谢布洛克。我希望有一种比看起来有点粗糙的更优雅的方法。

@Francisc，这很粗糙，但如果 Date 对象封装它，它就必须这样做。人们可以写一些关于 JS 的 Date 处理的糟糕之处的书。 ...如果您可以忍受有时休息一天，那么近似值：AgeInYears = Math.floor ( (now_Date - DOB_Date) / 31556952000 ) 就很简单了。

【参考方案1】：

试试这个。

function getAge(dateString) 
    var today = new Date();
    var birthDate = new Date(dateString);
    var age = today.getFullYear() - birthDate.getFullYear();
    var m = today.getMonth() - birthDate.getMonth();
    if (m < 0 || (m === 0 && today.getDate() < birthDate.getDate())) 
        age--;
    
    return age;

我相信您的代码中唯一看起来很粗糙的是 substr 部分。

小提琴：http://jsfiddle.net/codeandcloud/n33RJ/

【讨论】：

你能举个使用例子吗？如果不修改函数以采用 3 个单独的参数，例如：getAge(y,m,d)，我无法让它工作。例如：jsbin.com/ehaqiw/1/edit

@RobG：当跳跃者“庆祝”时（该问题的常见答案实际上似乎是：“最接近实际日期的周末”）他们的生日不同 基于上下文，包括：地理区域（简单英语：where you live）、法律（不要低估那个）、宗教和个人偏好（包括群体行为）：一些原因：“我出生在二月”，其他原因：“我在 2 月 28 日之后出生”（最常见的是 3 月 1 日）en.wikipedia.org/wiki/February_29 对于以上所有情况，如果 3 月 1 日是闰年结果，那么这个算法是正确的

@RobG：“加 x 个月”的粪坑与人类的年龄概念无关。人类普遍的观念是，当日历具有相同的月份#和日期#（与开始日期相比）时，年龄（InYears）计数器每天都会增加（不考虑时间）：因此 2000-02-28 到 2001-02 -27 = 0 年，2000-02-28 到 2001-02-28 = 1 年。将“常识”扩展到跳跃：2000-02-29（ 2000-02-28 之后的一天）到 2001-02-28 = 零年。我的评论只是指出，如果人们期望/同意这种跳跃逻辑，则回答的算法总是给出“正确的”人类答案。

@RobG：我从未说过我或答案是普遍正确的（TM）。我包括了上下文/管辖权/观点的概念。我的两个 cmets 都清楚地包含一个大写的 IF （用于处理异常跳跃）。事实上，我的第一条评论准确地表达了我的意思，并且从未包含任何关于对错的判断。实际上，我的 cmets 澄清了从这个答案中可以期待什么和不期待什么（以及为什么）（正如你所说的“突出问题”）。 ps：2月31日？！？

@Dr.G：对我来说，它是 63。jsfiddle.net/codeandcloud/o86au3dn 请仔细检查您的代码

【参考方案2】：

我会追求可读性：

function _calculateAge(birthday)  // birthday is a date
    var ageDifMs = Date.now() - birthday.getTime();
    var ageDate = new Date(ageDifMs); // miliseconds from epoch
    return Math.abs(ageDate.getUTCFullYear() - 1970);

免责声明：这也存在精度问题，因此也不能完全信任。它可能会关闭几个小时、几年或夏令时（取决于时区）。

如果精度非常重要，我建议为此使用库。还有@Naveens post，可能是最准确的，因为它不依赖于一天中的时间。

---

【讨论】：

这对于 2000-02-29 到 2001-02-28 这样的日期返回 0 年，而它可能应该返回 1。

@RobG 从 2000 年 2 月 29 日到 2001 年 2 月 28 日，我认为从技术上讲还没有过去一年，这使您的答案无效。没有意义，2000-02-28 到 2001-02-28 是一年，所以 2000-02-29 到 2001-02-28，一定小于一年。

您没有详细说明“不精确”的含义，我认为其他信息可能会有所帮助。您可能会考虑修复问题或删除答案。

@RobG 实际上我做到了。我还指出了比我自己更好的解决方案。我的解决方案以一种易于阅读的方式解决了这个问题，精度问题很小，但在其目的范围内。

可爱的答案@AndréSnedeHansen 也很快，因为你没有我的答案中出现的那种疯狂的划分;-) +1 以提高可读性和速度。

【参考方案3】：

重要提示：此答案不能提供 100% 准确的答案，根据日期的不同，它会延迟大约 10-20 小时。

没有更好的解决方案（无论如何不在这些答案中）。 - 纳文

我当然无法抗拒接受挑战并制作比当前公认的解决方案更快更短的生日计算器的冲动。 我的解决方案的要点是，数学很快，所以我们使用美妙的数学而不是使用分支，而 javascript 提供的日期模型来计算解决方案

答案看起来像这样，比 naveen 的运行速度快约 65%，而且它更短：

function calcAge(dateString) 
  var birthday = +new Date(dateString);
  return ~~((Date.now() - birthday) / (31557600000));

幻数：31557600000 是 24 * 3600 * 365.25 * 1000 也就是一年的长度，一年的长度是365天6小时，也就是0.25天。最后我把结果告诉我们最后的年龄。

这里是基准测试：http://jsperf.com/birthday-calculation

要支持 OP 的数据格式，您可以替换 +new Date(dateString); +new Date(d.substr(0, 4), d.substr(4, 2)-1, d.substr(6, 2));

如果您能提出更好的解决方案，请分享！ :-)

【讨论】：

这是一个非常酷的解决方案。我看到的唯一问题是 dateString 参数正好适合 Date() 构造函数正确解析它。比如采用我在问题中给出的YYYYMMDD格式，就会失败。

这个答案有一个错误。将您的时钟设置为上午 12:01。在上午 12:01，如果您 calcAge('2012-03-27') （今天的日期），即使它应该等于 1，您也会得到零的答案。这个错误存在于整个上午 12:00 小时。这是由于一年中有 365.25 天的错误说法。它不是。我们处理的是日历年，而不是地球轨道的长度（更准确地说是 365.256363 天）。一年有 365 天，闰年有 366 天。除此之外，在这样的事情上表现毫无意义。可维护性更为重要。

感谢您的解决方案 Kristoffer。我能问一下 +new 与 new 相比，以及返回中的两个波浪号 (~) 有什么作用吗？

@FrankJensen 嗨弗兰克，我也很好奇，找到了这个答案：double tilde converts float to integer Greetings

@FrankJensen 本质上是波浪号反转数字（二进制​​值），同时将浮点数转换为整数（下限），因此，两个波浪号为您提供四舍五入的数字。 new Date() 前面的 + 将对象转换为日期对象的整数表示，这也可以与数字字符串一起使用，例如 +'21' === 21

【参考方案4】：

使用 ES6 清洁单线解决方案：

const getAge = birthDate => Math.floor((new Date() - new Date(birthDate).getTime()) / 3.15576e+10)

// today is 2018-06-13
getAge('1994-06-14') // 23
getAge('1994-06-13') // 24

我使用 365.25 天（由于闰年为 0.25 天）的年份，分别为 3.15576e+10 毫秒（365.25 * 24 * 60 * 60 * 1000）。

它有几个小时的余量，因此取决于用例，它可能不是最佳选择。

【讨论】：

非常整洁 - 你能详细说明 3.15576e+10 的含义吗？

是的，最好在函数前添加以下行：const yearInMs = 3.15576e+10 // Using a year of 365.25 days (because leap years)

效果很好，但有几小时的误差。明天转18 的用户实际上是18 today。我知道我不应该提及图书馆，但 Day.js 就像魔术一样工作。

const NUMBER_OF_MILI_SECONDS_IN_YEAR = 31536000000;返回 Math.floor( (CurrentDate - BirthDay.getTime()) / NUMBER_OF_MILI_SECONDS_IN_YEAR );

【参考方案5】：

用momentjs：

/* The difference, in years, between NOW and 2012-05-07 */
moment().diff(moment('20120507', 'YYYYMMDD'), 'years')

【讨论】：

@RicardoPontual 这需要momentjs，所以不是最好的答案。

@itzmukeshy7 确实，要成为最好的答案，它至少应该需要 jQuery ;)

@thomaux 这完全取决于开发环境！

@itzmukeshy7 放松，这是个玩笑；）见：meta.stackexchange.com/a/19492/173875

@thomaux 我知道这是个玩笑；）

【参考方案6】：

前段时间我为此目的做了一个函数：

function getAge(birthDate) 
  var now = new Date();

  function isLeap(year) 
    return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
  

  // days since the birthdate    
  var days = Math.floor((now.getTime() - birthDate.getTime())/1000/60/60/24);
  var age = 0;
  // iterate the years
  for (var y = birthDate.getFullYear(); y <= now.getFullYear(); y++)
    var daysInYear = isLeap(y) ? 366 : 365;
    if (days >= daysInYear)
      days -= daysInYear;
      age++;
      // increment the age only if there are available enough days for the year.
    
  
  return age;

它需要一个Date对象作为输入，所以需要解析'YYYYMMDD'格式化的日期字符串：

var birthDateStr = '19840831',
    parts = birthDateStr.match(/(\d4)(\d2)(\d2)/),
    dateObj = new Date(parts[1], parts[2]-1, parts[3]); // months 0-based!

getAge(dateObj); // 26

【讨论】：

啊，是的，我错过了闰年。谢谢。

这会为选择的日期组合提供无效值！例如，如果 birthDate 是 1980 年 1 月 5 日，当前日期是 2005 年 1 月 4 日，那么函数将错误地将 age 报告为 25。 .. 正确的值是 24。

@BrockAdams 为什么会这样？我现在有这个问题。谢谢。

@VisionIncision，因为它不能正确处理边缘条件。信不信由你，问题中的代码是最好的方法——尽管看起来后来的答案之一可能更合适地重新包装了它。

CMS 嗨 :-) 我写了这个问题 (***.com/questions/16435981/…)，有人告诉我，如果我想要 100% 准确的答案，我应该每年检查一次 - 如果是闰年，然后计算最后一个分数。 （见古法的回答）。你的功能（它的一部分）做到了。但是我怎样才能用它来计算 100% 准确的年龄呢？ DOB 很少从 1/1/yyyy 开始......所以我如何使用你的 func 来计算确切的年龄？

【参考方案7】：

这是我的解决方案，只需传入一个可解析的日期：

function getAge(birth) 
  ageMS = Date.parse(Date()) - Date.parse(birth);
  age = new Date();
  age.setTime(ageMS);
  ageYear = age.getFullYear() - 1970;

  return ageYear;

  // ageMonth = age.getMonth(); // Accurate calculation of the month part of the age
  // ageDay = age.getDate();    // Approximate calculation of the day part of the age

【参考方案8】：

替代解决方案，因为为什么不：

function calculateAgeInYears (date) 
    var now = new Date();
    var current_year = now.getFullYear();
    var year_diff = current_year - date.getFullYear();
    var birthday_this_year = new Date(current_year, date.getMonth(), date.getDate());
    var has_had_birthday_this_year = (now >= birthday_this_year);

    return has_had_birthday_this_year
        ? year_diff
        : year_diff - 1;

【讨论】：

这是真正的最佳答案，不是最佳答案，只是因为 var 名称太长:)

【参考方案9】：

function age()

    var birthdate = $j('#birthDate').val(); // in   "mm/dd/yyyy" format
    var senddate = $j('#expireDate').val(); // in   "mm/dd/yyyy" format
    var x = birthdate.split("/");    
    var y = senddate.split("/");
    var bdays = x[1];
    var bmonths = x[0];
    var byear = x[2];
    //alert(bdays);
    var sdays = y[1];
    var smonths = y[0];
    var syear = y[2];
    //alert(sdays);

    if(sdays < bdays)
    
        sdays = parseInt(sdays) + 30;
        smonths = parseInt(smonths) - 1;
        //alert(sdays);
        var fdays = sdays - bdays;
        //alert(fdays);
    
    else
        var fdays = sdays - bdays;
    

    if(smonths < bmonths)
    
        smonths = parseInt(smonths) + 12;
        syear = syear - 1;
        var fmonths = smonths - bmonths;
    
    else
    
        var fmonths = smonths - bmonths;
    

    var fyear = syear - byear;
    document.getElementById('patientAge').value = fyear+' years '+fmonths+' months '+fdays+' days';

【讨论】：

感谢很容易找到年月日的年龄

【参考方案10】：

我认为可能就是这样：

function age(dateString)
    let birth = new Date(dateString);
    let now = new Date();
    let beforeBirth = ((() => birth.setDate(now.getDate());birth.setMonth(now.getMonth()); return birth.getTime())() < birth.getTime()) ? 0 : 1;
    return now.getFullYear() - birth.getFullYear() - beforeBirth;


age('09/20/1981');
//35

也适用于时间戳

age(403501000000)
//34

【讨论】：

此代码将计算一个人全年的年龄相同。在您的示例中，如果今天是 '09/19/2018'，则代码将给出 37，但年龄（生日前一天）将是 36...

【参考方案11】：

为了测试生日是否已经过去，我定义了一个辅助函数Date.prototype.getDoY，它有效地返回了一年中的天数。剩下的就不用说了。

Date.prototype.getDoY = function() 
    var onejan = new Date(this.getFullYear(), 0, 1);
    return Math.floor(((this - onejan) / 86400000) + 1);
;

function getAge(birthDate) 
    function isLeap(year) 
        return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
    

    var now = new Date(),
        age = now.getFullYear() - birthDate.getFullYear(),
        doyNow = now.getDoY(),
        doyBirth = birthDate.getDoY();

    // normalize day-of-year in leap years
    if (isLeap(now.getFullYear()) && doyNow > 58 && doyBirth > 59)
        doyNow--;

    if (isLeap(birthDate.getFullYear()) && doyNow > 58 && doyBirth > 59)
        doyBirth--;

    if (doyNow <= doyBirth)
        age--;  // birthday not yet passed this year, so -1

    return age;
;

var myBirth = new Date(2001, 6, 4);
console.log(getAge(myBirth));

【讨论】：

对于 2 月 28 日之后的生日，闰年的结果不准确。它会使这些人衰老 1 天。 EG：对于 DoB = 2001/07/04，此函数将返回 7 年，即 2008/07/03。

@Brock：谢谢。如果我没记错的话，我已经纠正了这个错误的行为。

是的，我想你可能有（没有经过严格测试，只是分析过）。但是，请注意，新的解决方案并不比 OP 的解决方案更简单和优雅（不算这个解决方案被正确封装在一个函数中）。 ... OP 的解决方案更易于理解（因此更易于审计、测试或修改）。有时简单明了是最好的，IMO。

@Brock：我完全同意：我必须考虑这个函数的作用，这绝不是一件好事。

“if (doyNow

【参考方案12】：

我只需要为自己编写这个函数 - 公认的答案相当不错，但 IMO 可以使用一些清理方法。这需要一个用于 dob 的 unix 时间戳，因为这是我的要求，但可以很快适应使用字符串：

var getAge = function(dob) 
    var measureDays = function(dateObj) 
            return 31*dateObj.getMonth()+dateObj.getDate();
        ,
        d = new Date(dob*1000),
        now = new Date();

    return now.getFullYear() - d.getFullYear() - (measureDays(now) < measureDays(d));

请注意，我在 measureDays 函数中使用了 31 的平面值。所有计算关心的是“一年中的一天”是时间戳的单调递增度量。

如果使用 javascript 时间戳或字符串，显然您需要删除 1000 的因子。

【讨论】：

n 未定义。我想你的意思是 now.getFullYear()

【参考方案13】：

这对我来说是最优雅的方式：

const getAge = (birthDateString) => 
  const today = new Date();
  const birthDate = new Date(birthDateString);

  const yearsDifference = today.getFullYear() - birthDate.getFullYear();

  if (
    today.getMonth() < birthDate.getMonth() ||
    (today.getMonth() === birthDate.getMonth() && today.getDate() < birthDate.getDate())
  ) 
    return yearsDifference - 1;
  

  return yearsDifference;
;

console.log(getAge('2018-03-12'));

【讨论】：

这是对我来说最有意义的版本。

【参考方案14】：

function getAge(dateString) 

    var dates = dateString.split("-");
    var d = new Date();

    var userday = dates[0];
    var usermonth = dates[1];
    var useryear = dates[2];

    var curday = d.getDate();
    var curmonth = d.getMonth()+1;
    var curyear = d.getFullYear();

    var age = curyear - useryear;

    if((curmonth < usermonth) || ( (curmonth == usermonth) && curday < userday   ))

        age--;

    

    return age;

获取输入欧洲日期的年龄：

getAge('16-03-1989')

【讨论】：

感谢***.com/a/13367162/1055987good catch 的建议。

【参考方案15】：

这个问题已经超过 10 年了，没有人回答他们已经有 YYYYMMDD 格式的出生日期的提示？

如果您有 YYYYMMDD 格式的过去日期和当前日期，您可以非常快速地计算它们之间的年数，如下所示：

var pastDate = '20101030';
var currentDate = '20210622';
var years = Math.floor( ( currentDate - pastDate ) * 0.0001 );
// 10 (10.9592)

您可以像这样将当前日期格式化为YYYYMMDD：

var now = new Date();

var currentDate = [
    now.getFullYear(),
    ('0' + (now.getMonth() + 1) ).slice(-2),
    ('0' + now.getDate() ).slice(-2),
].join('');

【参考方案16】：

我检查了之前显示的示例，但它们并非在所有情况下都有效，因此我制作了自己的脚本。我对此进行了测试，并且效果很好。

function getAge(birth) 
   var today = new Date();
   var curr_date = today.getDate();
   var curr_month = today.getMonth() + 1;
   var curr_year = today.getFullYear();

   var pieces = birth.split('/');
   var birth_date = pieces[0];
   var birth_month = pieces[1];
   var birth_year = pieces[2];

   if (curr_month == birth_month && curr_date >= birth_date) return parseInt(curr_year-birth_year);
   if (curr_month == birth_month && curr_date < birth_date) return parseInt(curr_year-birth_year-1);
   if (curr_month > birth_month) return parseInt(curr_year-birth_year);
   if (curr_month < birth_month) return parseInt(curr_year-birth_year-1);


var age = getAge('18/01/2011');
alert(age);

【讨论】：

2000-02-29 到 2001-02-28 应该是一年吗？如果是这样，那么上面的内容并不完美。 :-)

【参考方案17】：

Get the age (years, months and days) from the date of birth with javascript

函数calcularEdad（年月日）

function calcularEdad(fecha) 
        // Si la fecha es correcta, calculamos la edad

        if (typeof fecha != "string" && fecha && esNumero(fecha.getTime())) 
            fecha = formatDate(fecha, "yyyy-MM-dd");
        

        var values = fecha.split("-");
        var dia = values[2];
        var mes = values[1];
        var ano = values[0];

        // cogemos los valores actuales
        var fecha_hoy = new Date();
        var ahora_ano = fecha_hoy.getYear();
        var ahora_mes = fecha_hoy.getMonth() + 1;
        var ahora_dia = fecha_hoy.getDate();

        // realizamos el calculo
        var edad = (ahora_ano + 1900) - ano;
        if (ahora_mes < mes) 
            edad--;
        
        if ((mes == ahora_mes) && (ahora_dia < dia)) 
            edad--;
        
        if (edad > 1900) 
            edad -= 1900;
        

        // calculamos los meses
        var meses = 0;

        if (ahora_mes > mes && dia > ahora_dia)
            meses = ahora_mes - mes - 1;
        else if (ahora_mes > mes)
            meses = ahora_mes - mes
        if (ahora_mes < mes && dia < ahora_dia)
            meses = 12 - (mes - ahora_mes);
        else if (ahora_mes < mes)
            meses = 12 - (mes - ahora_mes + 1);
        if (ahora_mes == mes && dia > ahora_dia)
            meses = 11;

        // calculamos los dias
        var dias = 0;
        if (ahora_dia > dia)
            dias = ahora_dia - dia;
        if (ahora_dia < dia) 
            ultimoDiaMes = new Date(ahora_ano, ahora_mes - 1, 0);
            dias = ultimoDiaMes.getDate() - (dia - ahora_dia);
        

        return edad + " años, " + meses + " meses y " + dias + " días";
    

函数 esNumero

function esNumero(strNumber) 
    if (strNumber == null) return false;
    if (strNumber == undefined) return false;
    if (typeof strNumber === "number" && !isNaN(strNumber)) return true;
    if (strNumber == "") return false;
    if (strNumber === "") return false;
    var psInt, psFloat;
    psInt = parseInt(strNumber);
    psFloat = parseFloat(strNumber);
    return !isNaN(strNumber) && !isNaN(psFloat);

【参考方案18】：

moment.js 的另一种可能的解决方案：

var moment = require('moment');
var startDate = new Date();
var endDate = new Date();
endDate.setDate(endDate.getFullYear() + 5); // Add 5 years to second date
console.log(moment.duration(endDate - startDate).years()); // This should returns 5

【参考方案19】：

我有点晚了，但我发现这是计算出生日期的最简单方法。

希望这会有所帮助。

function init() 
  writeYears("myage", 0, Age());



function Age() 
  var birthday = new Date(1997, 02, 01), //Year, month-1 , day.
    today = new Date(),
    one_year = 1000 * 60 * 60 * 24 * 365;
  return Math.floor((today.getTime() - birthday.getTime()) / one_year);


function writeYears(id, current, maximum) 
  document.getElementById(id).innerhtml = current;

  if (current < maximum) 
    setTimeout(function() 
      writeYears(id, ++current, maximum);
    , Math.sin(current / maximum) * 200);
  

init()

<span id="myage"></span>

【讨论】：

我很喜欢，点赞。它与众不同，而且效果很好。

我给你做了一个sn-p。删除了 jQuery 和不相关的验证码。计算已关闭。如果我去年输入明天的日期，我仍然会得到 age=1

【参考方案20】：

非常适合我，伙计们。

getAge(birthday) 
    const millis = Date.now() - Date.parse(birthday);
    return new Date(millis).getFullYear() - 1970;

【讨论】：

我今天在 2020 年 2 月 16 日尝试了这个，明天的日期是去年的 console.log(getAge("2020-02-17"))，它返回 1

对我来说很好，可能存在与 Date 对象相关的时区差异。如果您需要准确的年龄，请使用具有正确时区配置的 DayJs 或 Moment。

【参考方案21】：

我知道这是一个非常古老的线程，但我想放入我编写的这个实现，用于查找我认为更准确的年龄。

var getAge = function(year,month,date)
    var today = new Date();
    var dob = new Date();
    dob.setFullYear(year);
    dob.setMonth(month-1);
    dob.setDate(date);
    var timeDiff = today.valueOf() - dob.valueOf();
    var milliInDay = 24*60*60*1000;
    var noOfDays = timeDiff / milliInDay;
    var daysInYear = 365.242;
    return  ( noOfDays / daysInYear ) ;

当然，您可以对其进行调整以适应其他获取参数的格式。希望这对寻找更好解决方案的人有所帮助。

【参考方案22】：

我使用逻辑而不是数学来使用这种方法。 它精确而快速。 参数是人生日的年月日。 它以整数形式返回人的年龄。

function calculateAge(year, month, day) 
        var currentDate = new Date();
        var currentYear = currentDate.getFullYear();
        var currentMonth = currentDate.getUTCMonth() + 1;
        var currentDay = currentDate.getUTCDate();
        // You need to treat the cases where the year, month or day hasn't arrived yet.
        var age = currentYear - year;
        if (currentMonth > month) 
            return age;
         else 
            if (currentDay >= day) 
                return age;
             else 
                age--;
                return age;
            
        
    

【讨论】：

按 OP 输入的字符串或日期对象

【参考方案23】：

采用 naveen 和原始 OP 的帖子，我最终得到了一个可重用的方法存根，它接受字符串和/或 JS Date 对象。

我将其命名为gregorianAge()，因为该计算准确地给出了我们使用公历表示年龄的方式。即如果月份和日期在出生年份的月份和日期之前，则不计算结束年份。

/**
 * Calculates human age in years given a birth day. Optionally ageAtDate
 * can be provided to calculate age at a specific date
 *
 * @param string|Date Object birthDate
 * @param string|Date Object ageAtDate optional
 * @returns integer Age between birthday and a given date or today
 */
function gregorianAge(birthDate, ageAtDate) 
  // convert birthDate to date object if already not
  if (Object.prototype.toString.call(birthDate) !== '[object Date]')
    birthDate = new Date(birthDate);

  // use today's date if ageAtDate is not provided
  if (typeof ageAtDate == "undefined")
    ageAtDate = new Date();

  // convert ageAtDate to date object if already not
  else if (Object.prototype.toString.call(ageAtDate) !== '[object Date]')
    ageAtDate = new Date(ageAtDate);

  // if conversion to date object fails return null
  if (ageAtDate == null || birthDate == null)
    return null;


  var _m = ageAtDate.getMonth() - birthDate.getMonth();

  // answer: ageAt year minus birth year less one (1) if month and day of
  // ageAt year is before month and day of birth year
  return (ageAtDate.getFullYear()) - birthDate.getFullYear() 
  - ((_m < 0 || (_m === 0 && ageAtDate.getDate() < birthDate.getDate())) ? 1 : 0)


// Below is for the attached snippet

function showAge() 
  $('#age').text(gregorianAge($('#dob').val()))


$(function() 
  $(".datepicker").datepicker();
  showAge();
);

<link rel="stylesheet" href="//code.jquery.com/ui/1.11.4/themes/smoothness/jquery-ui.css">
<script src="//code.jquery.com/jquery-1.10.2.js"></script>
<script src="//code.jquery.com/ui/1.11.4/jquery-ui.js"></script>

DOB:
<input name="dob" value="12/31/1970" id="dob" class="datepicker" onChange="showAge()" /> AGE: <span id="age"><span>

【参考方案24】：

另外两个选项：

// Int Age to Date as string YYY-mm-dd
function age_to_date(age)

    try 
        var d = new Date();
        var new_d = '';
        d.setFullYear(d.getFullYear() - Math.abs(age));
        new_d = d.getFullYear() + '-' + d.getMonth() + '-' + d.getDate();

        return new_d;
     catch(err) 
        console.log(err.message);
    

// Date string (YYY-mm-dd) to Int age (years old)
function date_to_age(date)

    try 
        var today = new Date();
        var d = new Date(date);

        var year = today.getFullYear() - d.getFullYear();
        var month = today.getMonth() - d.getMonth();
        var day = today.getDate() - d.getDate();
        var carry = 0;

        if (year < 0)
            return 0;
        if (month <= 0 && day <= 0)
            carry -= 1;

        var age = parseInt(year);
        age += carry;

        return Math.abs(age);
     catch(err) 
        console.log(err.message);
    

【参考方案25】：

我对之前的一个答案做了一些更新。

var calculateAge = function(dob) 
    var days = function(date) 
            return 31*date.getMonth() + date.getDate();
        ,
        d = new Date(dob*1000),
        now = new Date();

    return now.getFullYear() - d.getFullYear() - ( measureDays(now) < measureDays(d));

希望对你有帮助：D

【参考方案26】：

这里有一个简单的计算年龄的方法：

//dob date dd/mm/yy 
var d = 01/01/1990


//today
//date today string format 
var today = new Date(); // i.e wed 04 may 2016 15:12:09 GMT
//todays year
var todayYear = today.getFullYear();
// today month
var todayMonth = today.getMonth();
//today date
var todayDate = today.getDate();

//dob
//dob parsed as date format   
var dob = new Date(d);
// dob year
var dobYear = dob.getFullYear();
// dob month
var dobMonth = dob.getMonth();
//dob date
var dobDate = dob.getDate();

var yearsDiff = todayYear - dobYear ;
var age;

if ( todayMonth < dobMonth ) 
  
  age = yearsDiff - 1; 
 
else if ( todayMonth > dobMonth ) 
 
  age = yearsDiff ; 
 

else //if today month = dob month
  if ( todayDate < dobDate ) 
  
   age = yearsDiff - 1;
  
    else 
    
     age = yearsDiff;
    
 

【参考方案27】：

var now = DateTime.Now;
var age = DateTime.Now.Year - dob.Year;
if (now.Month < dob.Month || now.Month == dob.Month && now.Day < dob.Day) age--;

【讨论】：

现在和出生年份之间有一个简单的年份差异。然后如果今天比生日早，它会减去一年（想想看，你的年龄在这一年中上升，在你的生日）

【参考方案28】：

您可以在表单中使用它来限制年龄 -

function dobvalidator(birthDateString)
    strs = birthDateString.split("-");
    var dd = strs[0];
    var mm = strs[1];
    var yy = strs[2];

    var d = new Date();
    var ds = d.getDate();
    var ms = d.getMonth();
    var ys = d.getFullYear();
    var accepted_age = 18;

    var days = ((accepted_age * 12) * 30) + (ms * 30) + ds;
    var age = (((ys - yy) * 12) * 30) + ((12 - mm) * 30) + parseInt(30 - dd);

    if((days - age) <= '0')
        console.log((days - age));
        alert('You are at-least ' + accepted_age);
    else
        console.log((days - age));
        alert('You are not at-least ' + accepted_age);
    

【参考方案29】：

这是我的修改：

  function calculate_age(date) 
     var today = new Date();
     var today_month = today.getMonth() + 1; //STRANGE NUMBERING //January is 0!
     var age = today.getYear() - date.getYear();

     if ((today_month > date.getMonth() || ((today_month == date.getMonth()) && (today.getDate() < date.getDate())))) 
       age--;
     

    return age;
  ;

【参考方案30】：

我相信有时可读性在这种情况下更为重要。除非我们验证 1000 个字段，否则这应该足够准确和快速：

function is18orOlder(dateString) 
  const dob = new Date(dateString);
  const dobPlus18 = new Date(dob.getFullYear() + 18, dob.getMonth(), dob.getDate());
  
  return dobPlus18 .valueOf() <= Date.now();


// Testing:
console.log(is18orOlder('01/01/1910')); // true
console.log(is18orOlder('01/01/2050')); // false

// When I'm posting this on 10/02/2020, so:
console.log(is18orOlder('10/08/2002')); // true
console.log(is18orOlder('10/19/2002'))  // false

我喜欢这种方法，而不是使用一个常数来表示一年中有多少毫秒，然后再搞乱闰年等。只是让内置的 Date 来完成这项工作。

更新，发布此 sn-p，因为可能会发现它很有用。由于我在输入字段上强制使用掩码，因此具有mm/dd/yyyy 的格式并且已经验证日期是否有效，就我而言，这也适用于验证 18 年以上：

 function is18orOlder(dateString) 
   const [month, date, year] = value.split('/');
   return new Date(+year + 13, +month, +date).valueOf() <= Date.now();