Calculez l'âge en fonction de la date de naissance au format AAAAMMJJ
Comment puis-je calculer un âge en années, étant donné une date de naissance au format AAAAMMJJ? Est-il possible d'utiliser la fonction Date()?
Je cherche une meilleure solution que celle que j'utilise actuellement:
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);J'irais pour la lisibilité:
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);
}
Disclaimer: Cela a aussi des problèmes de précision, donc on ne peut pas non plus faire confiance à tout cela. Il peut s’éteindre de quelques heures, certaines années ou pendant l’heure avancée (en fonction du fuseau horaire).
Au lieu de cela, je recommanderais d'utiliser une bibliothèque pour cela, si la précision est très importante. Aussi @Naveens post , est probablement le plus précis, car il ne dépend pas de l'heure.
Benchmarks: http://jsperf.com/birthday-calculation/15
Essaye ça.
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;
}
Je crois que la seule chose qui paraissait grossière dans votre code était la partie substr.
Important: Cette réponse ne fournit pas une réponse précise à 100%, elle est décalée d’environ 10 à 20 heures en fonction de la date.
Il n'y a pas de meilleures solutions (pas dans ces réponses de toute façon). - Naveen
Bien sûr, je ne pouvais pas résister à l'envie de relever le défi et de créer un calculateur d'anniversaire plus rapide et plus court que la solution actuellement acceptée .. Le point principal de ma solution est que les mathématiques sont rapides, alors au lieu d'utiliser des branches, et le modèle de date javascript fournit pour calculer une solution, nous utilisons les mathématiques merveilleuses
La réponse ressemble à ceci: elle est environ 65% plus rapide que celle de Naveen et elle est beaucoup plus courte:
function calcAge(dateString) {
var birthday = +new Date(dateString);
return ~~((Date.now() - birthday) / (31557600000));
}
Le nombre magique: 31557600000 est 24 * 3600 * 365.25 * 1000 Ce qui est la durée d'une année, la durée d'une année est de 365 jours et 6 heures soit 0,25 jour. En fin de compte, le résultat final nous donne l’âge final.
Voici les points de repère: http://jsperf.com/birthday-calculation
Pour prendre en charge le format de données OP, vous pouvez remplacer +new Date(dateString);
avec +new Date(d.substr(0, 4), d.substr(4, 2)-1, d.substr(6, 2));
Si vous pouvez trouver une meilleure solution, partagez-la! :-)
Avec momentjs:
/* The difference, in years, between NOW and 2012-05-07 */
moment().diff(moment('20120507', 'YYYYMMDD'), 'years')
Il y a quelque temps, j'ai créé une fonction dans ce but:
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;
}
Il faut un objet Date en entrée, vous devez donc analyser la chaîne de date formatée 'YYYYMMDD':
var birthDateStr = '19840831',
parts = birthDateStr.match(/(\d{4})(\d{2})(\d{2})/),
dateObj = new Date(parts[1], parts[2]-1, parts[3]); // months 0-based!
getAge(dateObj); // 26
Voici ma solution, il suffit de passer une date analysable:
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
}
Clean one-liner solution ES6 écrit:
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
Utilisation d'une année de 365,25 jours (parce que les années bissextiles)
Pour vérifier si l'anniversaire est déjà passé ou non, je définis une fonction d'assistance Date.prototype.getDoY, qui renvoie effectivement le numéro du jour de l'année. Le reste est assez explicite.
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));
Solution alternative, car pourquoi pas:
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;
}
Je pense que cela pourrait être simplement comme ça:
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
Fonctionne aussi avec un horodatage
age(403501000000)
//34
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;
}
Pour obtenir l'âge auquel la date européenne est entrée:
getAge('16-03-1989')
Je devais juste écrire cette fonction pour moi-même - la réponse acceptée est assez bonne mais l’OMI pourrait utiliser un peu de nettoyage. Cela nécessite un horodatage unix pour dob car c’était ce que je souhaitais mais que je pourrais rapidement adapter pour utiliser une chaîne:
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));
}
Notez que j'ai utilisé une valeur plate de 31 dans ma fonction measureDays. Tout ce qui compte dans le calcul, c’est que le "jour de l’année" soit une mesure monotone de plus en plus longue de l’horodatage.
Si vous utilisez un horodatage ou une chaîne javascript, vous souhaiterez évidemment supprimer le facteur 1000.
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';
}
Une solution supplémentaire avec 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
J'ai vérifié les exemples montrés précédemment et ils ne fonctionnaient pas dans tous les cas, et à cause de cela, j'ai créé mon propre script. J'ai testé cela et cela fonctionne parfaitement.
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);
Obtenez l'âge (années, mois et jours) à partir de la date de naissance avec javascript
Fonction calcularEdad (années, mois et jours)
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";
}
Fonction 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);
}
En adoptant les publications de naveen et de OP d'origine, je me suis retrouvé avec un module de remplacement réutilisable qui accepte les chaînes et/ou les objets JS Date.
Je l'ai nommée gregorianAge() car ce calcul donne exactement comment nous désignons l'âge à l'aide du calendrier grégorien. c'est-à-dire sans compter l'année de fin si le mois et le jour se situent avant le mois et le jour de l'année de naissance.
/**
* 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>Je suis un peu trop tard, mais j’ai trouvé que c’était le moyen le plus simple de calculer une date de naissance.
$(document).ready(init);
function init()
{
writeYears("myage", 0, Age());
$(".captcha").click(function()
{
reloadCaptcha();
});
}
function Age()
{
var birthday = new Date(1997, 02, 01), //Year, month, 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 );
}
}
La balise HTML:
<span id="myage"></span>
Espérons que cela aidera.
Ça me convient parfaitement, les gars.
getAge(birthday) {
const millis = Date.now() - Date.parse(birthday);
return new Date(millis).getFullYear() - 1970;
}
C'est la manière la plus élégante pour moi:
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'));Vous pouvez utiliser ceci pour la restriction d'âge dans votre formulaire -
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);
}
}
voici un moyen simple de calculer l'âge:
//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;
}
}
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--;
J'ai déjà mis à jour une réponse précédente.
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));
}
J'espère que ça aide: D
Deux autres options:
// 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);
}
}
J'ai utilisé cette approche en utilisant la logique au lieu du calcul ..__ C'est précis et rapide . Les paramètres sont l'année, le mois et le jour de l'anniversaire de la personne . Il retourne son âge en entier.
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;
}
}
}
Je sais que c'est un très vieux fil, mais je voulais intégrer cette mise en œuvre que j'ai écrite pour trouver l'âge que je crois beaucoup plus précis.
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 ) ;
}
Bien sûr, vous pouvez l’adapter à d’autres formats pour obtenir les paramètres. J'espère que cela aidera quelqu'un à la recherche d'une meilleure solution.