YYYYMMDD प्रारूप में दी गई जन्म तिथि की गणना करें

Question

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);

Comments

कृपया अपनी फ़ॉर्मेटिंग का ध्यान रखें, इसे वैसे ही न करें जैसे आपने किया था; कोड (010101) बटन या Ctrl-K का उपयोग करके 4 स्थानों के साथ अपने कोड को इंडेंट करें।

— मार्सेल कोर्पेल

मैंने किया लेकिन यह IE9 बीटा पर काम करने में विफल रहता है इसलिए मुझे इसे हाथ से करना पड़ा।

— फ्रांसिस

वर्तमान उत्तरों की तुलना में उम्र की गणना करने पर आपका मूल समाधान बेहतर है। जुएलियो सांतोस का जवाब अनिवार्य रूप से एक ही बात है। अन्य उत्तर कई शर्तों के तहत गलत परिणाम देते हैं, और कम सीधे या कम कुशल हो सकते हैं।

— ब्रॉक एडम्स

थैंक यू ब्रॉक। मैं उम्मीद कर रहा था कि ऐसा करने का एक और अधिक सुरुचिपूर्ण तरीका है जो थोड़ा कच्चा लगता है।

— फ्रांसिस्क

@ क्रैंकस्क, यह क्रूड है, लेकिन Dateअगर यह इसे एनकैप्सुलेट करता है तो ऑब्जेक्ट को क्या करना होगा। लोग जेएस की Dateहैंडलिंग की चूसना के बारे में किताबें लिख सकते थे । ... यदि आप कभी-कभी एक दिन के साथ बंद हो सकते हैं, तो अनुमान: लगभग AgeInYears = Math.floor ( (now_Date - DOB_Date) / 31556952000 )उतना ही सरल है जितना आप प्राप्त कर सकते हैं।

— ब्रॉक एडम्स

Answer 1

मैं पठनीयता के लिए जाऊंगा:

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, शायद सबसे सटीक है, क्योंकि यह दिन के समय पर निर्भर नहीं करता है।

---

बेंचमार्क: http://jsperf.com/birthday-calacle/15

Comments

यह 2000-02-29 से 2001-02-28 की तारीखों के लिए 0 साल का है जब यह शायद वापस आ जाना चाहिए।

— RobG

@RobG मुझे नहीं लगता कि एक पूरा साल तकनीकी रूप से 2000-02-29 से 2001-02-28 तक बीत गया है, जिससे आपका उत्तर अमान्य हो जाएगा। यह समझ में नहीं आता है, 2000-02-28 से 2001-02-28 एक वर्ष है, इसलिए 2000-02-29 से 2001-02-28 तक एक वर्ष से कम होना चाहिए।

— एंड्रे स्नेड कोक

आपने इस बात पर विस्तार नहीं दिया कि "सटीक नहीं" का क्या मतलब है, मुझे लगा कि अतिरिक्त जानकारी मददगार हो सकती है। आप समस्याओं को ठीक करने या उत्तर को हटाने पर विचार कर सकते हैं।

— रोबग

@RobG वास्तव में मैंने किया था। मैंने खुद से बेहतर समाधान की ओर भी इशारा किया। मेरा हल मामूली सटीक मुद्दों के साथ, फैशन को पढ़ने में आसान में समस्या को हल करता है, लेकिन इसके उद्देश्य की सीमा के भीतर।

— एंड्रे स्नेड कोक

लवली जवाब @ AndréSnedeHansen और तेज़ भी, क्योंकि आपके पास वह पागल विभाजन नहीं है जैसा कि मेरे उत्तर में मौजूद है; पठनीयता और गति के लिए ;-) +1।

— क्रिस्टोफर डॉल्फ

Answer 2

इसे इस्तेमाल करे।

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/

Comments

क्या आप एक उपयोग उदाहरण दे सकते हैं? मैं इसे 3 अलग-अलग तर्क लेने के लिए फ़ंक्शन को संशोधित किए बिना काम करने के लिए नहीं प्राप्त कर सका, जैसे: getAge (y, m, d)। उदाहरण के लिए: jsbin.com/ehaqiw/1/edit

— EDT

कई अन्य लोगों की तरह, यह सोचता है कि 2000-02-29 से 2001-02-28 शून्य वर्ष है, जब यह सबसे अधिक संभावना 1 होना चाहिए (2001-03-01 से 1 वर्ष 1 दिन होना चाहिए)।

— रॉबग

@RobG: जब लीपलिंग 'मनाते हैं' (उस प्रश्न का सामान्य उत्तर केवल वास्तव में प्रतीत होता है: 'वास्तविक तिथि के सबसे निकट का सप्ताहांत') उनके जन्म-दिवस के संदर्भ के आधार पर भिन्न होते हैं: भौगोलिक क्षेत्र (सरल अंग्रेजी: जहाँ आप रहते हैं ), एलएडब्ल्यू (उस एक को कम मत समझो), धर्म और व्यक्तिगत पसंद (समूह-व्यवहार सहित): कुछ कारण: "मैं फरवरी में पैदा हुआ हूं", अन्य कारण: "मैं 28 फरवरी के दिन के बाद पैदा हुआ हूं" (जो कि आमतौर पर 1 मार्च से अधिक होता है) en.wikipedia.org/wiki/Febdays_29 उपरोक्त सभी के लिए यह सही है कि यदि 1 मार्च को खतना परिणाम एक की जरूरत है

— GitaarLAB

@RobG: 'प्लस x माह (s)' का सेसपिट वर्षों में उम्र की मानव धारणा के लिए अप्रासंगिक है। आम मानव धारणा यह है कि उम्र (InYears) -काउंटर में हर दिन (समय की अवहेलना) बढ़ जाती है जब कैलेंडर में एक ही महीना # और दिन # (शुरुआत की तारीख की तुलना में) होता है: ताकि 2000-02-28 से 2001-02 तक -27 = 0 वर्ष और 2000-02-28 से 2001-02-28 = 1 वर्ष। उत्तोलन के लिए उस 'सामान्य ज्ञान' का विस्तार: 2000-02-29 ( 2000-02-28 के बाद का दिन ) से 2001-02-28 = शून्य वर्ष । मेरी टिप्पणी में केवल इतना कहा गया है कि उत्तर दिया गया अहंकार हमेशा 'सही' मानव उत्तर देता है यदि कोई इस तर्क को छपाने के लिए सहमत / सहमत होता है।

— गीतालीलाब

@ रोब: मैंने कभी नहीं कहा या उत्तर सार्वभौमिक रूप से सही था (टीएम)। मैंने संदर्भों / क्षेत्राधिकार / विचारों की धारणा को शामिल किया। मेरी दोनों टिप्पणियों में स्पष्ट रूप से एक अपरकेस IF (अपवाद छलांगों को संभालने के लिए) शामिल है। वास्तव में, मेरी पहली टिप्पणी में वही कहा गया था जो मेरे कहने का मतलब था और इसमें कभी भी सही या गलत के संबंध में कोई निर्णय शामिल नहीं था। वास्तव में मेरी टिप्पणियाँ स्पष्ट करती हैं कि इस उत्तर से क्या (और क्यों नहीं) उम्मीद की जाए (जैसा कि आप इसे 'मुद्दों पर प्रकाश डालते हैं')। Ps: 31 फरवरी?

— गीतालीलाब

Answer 3

महत्वपूर्ण: यह उत्तर 100% सटीक उत्तर प्रदान नहीं करता है, यह तारीख के आधार पर लगभग 10-20 घंटों तक बंद रहता है।

कोई बेहतर समाधान नहीं हैं (इन उत्तरों में वैसे भी नहीं)। - नवीन

मैं निश्चित रूप से चुनौती को स्वीकार करने और वर्तमान स्वीकृत समाधान की तुलना में तेज़ और कम जन्मदिन का कैलकुलेटर बनाने का आग्रह नहीं कर सकता। मेरे समाधान के लिए मुख्य बिंदु यह है कि गणित तेज है, इसलिए ब्रांचिंग का उपयोग करने के बजाय, और तारीख मॉडल जावास्क्रिप्ट एक समाधान की गणना करने के लिए प्रदान करता है जिसे हम अद्भुत गणित का उपयोग करते हैं

जवाब इस तरह दिखता है, और ~ 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-calacle

ओपी के डेटा प्रारूप का समर्थन करने के लिए आप के +new Date(dateString);
साथ बदल सकते हैं+new Date(d.substr(0, 4), d.substr(4, 2)-1, d.substr(6, 2));

यदि आप एक बेहतर समाधान के साथ आ सकते हैं तो कृपया साझा करें! :-)

Comments

यह एक बहुत अच्छा समाधान है। एकमात्र समस्या जो मुझे इसके साथ दिखाई देती है, वह है dateStringडेट () कंस्ट्रक्टर को सही तरीके से पार्स करने के लिए बस सही होना। उदाहरण के लिए, YYYYMMDDमैंने प्रश्न में जो प्रारूप दिया था, उसे लेना विफल हो जाएगा।

— फ्रांसिस्क

इस उत्तर में एक बग है। अपनी घड़ी को 12:01 बजे तक सेट करें। 12:01 बजे, यदि आप कैल्सेग करते हैं ('2012-03-27') (आज की तारीख) तो आपको शून्य का उत्तर मिलेगा, भले ही यह बराबर 1 होना चाहिए। यह बग पूरे 12:00 बजे घंटे के लिए मौजूद है। यह गलत कथन के कारण है कि एक वर्ष में 365.25 दिन होते हैं। ऐसा नहीं होता। हम कैलेंडर वर्षों के साथ काम कर रहे हैं, न कि पृथ्वी की कक्षा की लंबाई (जो कि अधिक सटीक रूप से 365.256363 दिन है)। एक वर्ष में 365 दिन होते हैं, एक लीप वर्ष को छोड़कर जिसमें 366 दिन होते हैं। इसके अलावा, कुछ इस तरह का प्रदर्शन अर्थहीन है। स्थिरता कहीं अधिक महत्वपूर्ण है।

— एरिक ब्रैंडेल

आपके समाधान के लिए धन्यवाद क्रिस्टोफर। क्या मैं पूछ सकता हूं कि सिर्फ नए की तुलना में नया क्या करता है, और वापसी में दो टिल्ड (~) भी?

— फ्रैंक जेन्सेन

@FrankJensen हाय फ्रैंक, मैं भी उत्सुक था और इस जवाब को मिला: डबल टिल्ड ने फ्लोट को पूर्णांक ग्रीटिंग्स में बदल दिया

— स्टेनो

@FrankJensen अनिवार्य रूप से टिल्ड नंबर (बाइनरी वैल्यू) को तैरते हुए पूर्णांक (पूर्णांक) में परिवर्तित करता है, इसलिए, दो टिल्ड आपको गोल संख्या देता है। नई दिनांक के सामने + (दिनांक ऑब्जेक्ट के पूर्णांक प्रतिनिधित्व के लिए वस्तु को रूपांतरित करता है, इसका उपयोग उदाहरण के लिए संख्याओं के तार के साथ भी किया जा सकता है + '21 '=== 21

— क्रिस्टोफर डॉर्फ

Answer 4

क्षणिकाओं के साथ:

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

Comments

@RicardoPontual को इसके लिए क्षणिका की आवश्यकता होती है, इसलिए यह सर्वश्रेष्ठ उत्तर नहीं हो सकता है।

— itzmukeshy7

@ itzmukeshy7 वास्तव में, सबसे अच्छा होने के लिए एक उत्तर के लिए, इसे कम से कम jQuery की आवश्यकता होनी चाहिए;)

— थोमक्स

@thomaux यह पूरी तरह से विकास के माहौल पर निर्भर करता है!

— itzmukeshy7 13

@ itzmukeshy7 आराम करो, यह एक मजाक है;) देखें: meta.stackexchange.com/a/19492/173875

— thomaux

@thomaux मुझे पता था कि यह एक मजाक है;)

— itzmukeshy7

Answer 5

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) हैं।

Comments

सुंदर बहुत साफ - क्या आप विस्तृत कर सकते हैं कि 3.15576e + 10 का क्या मतलब है?

— १२:०६

हां, फंक्शन से पहले निम्न लाइन जोड़ना अच्छा होगा:const yearInMs = 3.15576e+10 // Using a year of 365.25 days (because leap years)

— लुकास जोंन जूल

Answer 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;
}

यह इनपुट के रूप में एक दिनांक ऑब्जेक्ट लेता है, इसलिए आपको '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

Comments

आह हाँ, मैं छलांग वर्ष याद किया। धन्यवाद।

— फ्रांसिस

यह चुनिंदा दिनांक संयोजनों के लिए अमान्य मान देता है! उदाहरण के लिए, यदि birthDateहै जनवरी 5 वीं, 1980 , और आज की तारीख है जनवरी 4 थी, 2005 है, तो समारोह ग़लती से रिपोर्ट करेंगे age25 के रूप में ... सही मान 24. किया जा रहा है

— ब्रॉक एडम्स

@BrockAdams यह क्यों है? मुझे इस समय यह समस्या हो रही है। धन्यवाद।

— जैक एच

@VisionInaches, क्योंकि यह बढ़त की स्थिति को ठीक से नहीं संभालता है। मानो या न मानो, सवाल से कोड सबसे अच्छा तरीका है - हालांकि ऐसा लगता है कि बाद के जवाबों में से एक ने इसे अधिक उपयुक्त तरीके से पुनर्प्राप्त किया हो सकता है।

— ब्रॉक एडम्स

सीएमएस हाय :-) मैंने यह सवाल लिखा था ( stackoverflow.com/questions/16435981/… ) और मुझे बताया गया था कि अगर मुझे 100% सटीक उत्तर चाहिए तो मुझे हर साल जांच करनी चाहिए - अगर यह एक लीप ईयर है, और फिर अंतिम अंश। (देखें गुफ़ा का जवाब)। आपका कार्य (इसका हिस्सा) ऐसा करता है । लेकिन मैं इसका उपयोग कैसे कर सकता हूं ताकि उम्र को 100% सही किया जा सके? DOB शायद ही कभी 1/1 / yyyy से शुरू होता है ..... तो मैं सटीक आयु को शांत करने के लिए आपके फंक का उपयोग कैसे कर सकता हूं?

— रॉय नमिर

Answer 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
}

Answer 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;
}

Answer 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';
}

Comments

वर्षों और दिनों में उम्र का पता लगाने के लिए आसान धन्यवाद

— सुमित कुमार गुप्ता

Answer 10

यह परीक्षण करने के लिए कि जन्मदिन पहले से ही पारित हो गया है या नहीं, मैं एक सहायक फ़ंक्शन को परिभाषित करता हूं 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));

Comments

यह 28 फरवरी के बाद जन्मदिन के लिए, लीप-इयर्स में गलत परिणाम देता है। यह ऐसे लोगों की उम्र 1 दिन है। उदा: DoB = 2001/07/04 के लिए , यह फ़ंक्शन 2008/07/03 को 7 साल वापस आ जाएगा ।

— ब्रॉक एडम्स

@Brock: धन्यवाद। अगर मुझसे गलती नहीं हुई है, तो मैंने इस गलत व्यवहार को सुधार लिया है।

— मार्सेल कोर्पेल

हां, मुझे लगता है कि आपके पास (सख्ती से परीक्षण नहीं किया गया है, बस विश्लेषण किया गया है)। लेकिन, ध्यान दें कि नया समाधान सरल नहीं है और ओपी के समाधान की तुलना में अधिक सुरुचिपूर्ण नहीं है (गिनती नहीं है कि यह एक फ़ंक्शन में ठीक से समझाया गया है)। ... ओपी के समाधान को समझना आसान है (इस तरह ऑडिट करना, परीक्षण करना या संशोधित करना)। कभी-कभी सरल और सीधा सबसे अच्छा है, आईएमओ।

— ब्रॉक एडम्स

@Brock: मैं पूरी तरह से सहमत हूँ: मुझे यह सोचना होगा कि यह कार्य क्या करता है और यह कभी भी अच्छी बात नहीं है।

— मार्सेल कोर्पेल

"अगर (doyNow <doyBirth)" नहीं होना चाहिए तो "if (doyNow <= doyBirth)"? मेरे सभी परीक्षणों में, दिन एक के बाद एक बंद हो गए और उन्होंने इसे ठीक कर दिया।

— टेड कुलप

Answer 11

मुझे लगता है कि ऐसा हो सकता है:

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

Comments

यह कोड पूरे वर्ष एक ही उम्र वाले व्यक्ति की गणना करेगा। आपके उदाहरण में, अगर आज '09 / 19/2018 'कोड 37 देता, लेकिन उम्र (जन्मदिन से एक दिन पहले) 36 होगी ...

— स्टीव गॉसेन्स

Answer 12

मुझे सिर्फ अपने लिए यह फ़ंक्शन लिखना था - स्वीकृत उत्तर काफी अच्छा है लेकिन IMO कुछ सफाई का उपयोग कर सकता है। यह dob के लिए एक यूनिक्स टाइमस्टैम्प लेता है क्योंकि यह मेरी आवश्यकता थी लेकिन एक स्ट्रिंग का उपयोग करने के लिए जल्दी से अनुकूलित किया जा सकता है:

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));
}

ध्यान दें, मैंने अपने मापक फ़ंक्शन में 31 के फ्लैट मूल्य का उपयोग किया है। सभी गणना के बारे में परवाह है कि "दिन के वर्ष" टाइमस्टैम्प के एक नीरस रूप से बढ़ते हुए उपाय हैं।

यदि एक जावास्क्रिप्ट टाइमस्टैम्प या स्ट्रिंग का उपयोग कर रहे हैं, तो जाहिर है कि आप 1000 के कारक को हटाना चाहेंगे।

Comments

n अपरिभाषित है। मुझे लगता है कि आप अब मतलब है। मत भूलना। ()

— लैरी बैटल

Answer 13

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')

Comments

आपके सुझाव के लिए धन्यवाद stackoverflow.com/a/13367162/1055987 अच्छी पकड़।

— JFK

Answer 14

पल के साथ एक और संभव समाधान। 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

Answer 15

मैंने पहले दिखाए गए उदाहरणों की जाँच की है और उन्होंने सभी मामलों में काम नहीं किया है, और इस वजह से मैंने अपनी खुद की एक स्क्रिप्ट बनाई है। मैंने इसका परीक्षण किया, और यह पूरी तरह से काम करता है।

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);

Comments

2000-02-29 से 2001-02-28 एक वर्ष होना चाहिए? यदि ऐसा है, तो ऊपर सही नहीं है। :-)

— रोबग

Answer 16

यह मेरे लिए सबसे सुंदर तरीका है:

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'));

Answer 17

जावास्क्रिप्ट के साथ जन्म की तारीख से उम्र (वर्ष, महीने और दिन) प्राप्त करें

कार्यकुशलता (वर्ष, महीने और दिन)

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);
}

Answer 18

मेरे लिए सही काम करता है, दोस्तों।

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

Answer 19

मुझे पता है कि यह एक बहुत पुराना धागा है लेकिन मैं इस कार्यान्वयन में लगाना चाहता था जो मैंने उस उम्र को खोजने के लिए लिखा था जिसे मैं मानता हूं कि यह अधिक सटीक है।

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 ) ;
}

निश्चित रूप से आप पैरामीटर प्राप्त करने के अन्य प्रारूपों में फिट होने के लिए इसे अनुकूलित कर सकते हैं। आशा है कि यह किसी को बेहतर समाधान की तलाश में मदद करता है।

Answer 20

मैंने गणित के बजाय तर्क का उपयोग करते हुए इस दृष्टिकोण का उपयोग किया। यह सटीक और त्वरित है। पैरामीटर व्यक्ति के जन्मदिन का वर्ष, महीना और दिन हैं। यह व्यक्ति की आयु को पूर्णांक के रूप में लौटाता है।

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;
            }
        }
    }

Comments

तार या ओपी के अनुसार इनपुट के लिए दिनांक ऑब्जेक्ट

— नाज़िम

Answer 21

नवीन के और मूल ओपी के पदों को अपनाने से मैं एक पुन: प्रयोज्य विधि के साथ समाप्त हो गया, जो दोनों तार और / या जेएस दिनांक वस्तुओं को स्वीकार करता है।

मैंने इसे नाम दिया 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>

Answer 22

दो और विकल्प:

// 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);
    }
}

Answer 23

मैंने पिछले एक उत्तर के लिए कुछ अपडेट किया है।

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));
}

मुझे आशा है कि मदद करता है: डी

Answer 24

यहाँ उम्र की गणना का एक सरल तरीका है:

//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;
    }
 }

Answer 25

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--;

Comments

यह अब और जन्म के वर्ष के बीच एक साधारण वर्ष का अंतर करता है। तब यह एक साल घटाता है अगर आज जन्मदिन की तुलना में वर्ष में पहले है (इसके बारे में सोचो, आपकी उम्र वर्ष के दौरान बढ़ जाती है, आपके जन्मदिन पर)

— स्टीव गोस्सेंस

Answer 26

आप अपने फॉर्म में उम्र प्रतिबंध के लिए इसका उपयोग कर सकते हैं -

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);
    }
}

Answer 27

मुझे थोड़ी देर हो गई है लेकिन मैंने जन्म तिथि की गणना करने का सबसे सरल तरीका पाया।

$(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 );
    }
}

HTML टैग:

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

उम्मीद है कि इससे मदद मिलेगी।

Answer 28

यहाँ सबसे सरल, सबसे सटीक समाधान है जो मैं आ सकता था:

Date.prototype.getAge = function (date) {
    if (!date) date = new Date();
    return ~~((date.getFullYear() + date.getMonth() / 100
    + date.getDate() / 10000) - (this.getFullYear() + 
    this.getMonth() / 100 + this.getDate() / 10000));
}

और यहां एक नमूना है जो एक वर्ष में फ़रवरी 29 -> फ़रवरी 28 पर विचार करेगा।

Date.prototype.getAge = function (date) {
    if (!date) date = new Date();
    var feb = (date.getMonth() == 1 || this.getMonth() == 1);
    return ~~((date.getFullYear() + date.getMonth() / 100 + 
        (feb && date.getDate() == 29 ? 28 : date.getDate())
        / 10000) - (this.getFullYear() + this.getMonth() / 100 + 
        (feb && this.getDate() == 29 ? 28 : this.getDate()) 
        / 10000));
}

यह नकारात्मक उम्र के साथ भी काम करता है!

Comments

अन्य सभी की तरह, यह सोचता है कि 2000-02-29 से 2001-02-28 शून्य वर्ष है।

— रोबग

मैंने लीप ईयर एज मामले को समायोजित करने के लिए अपना जवाब अपडेट कर दिया है। धन्यवाद @RobG

— wizulus

Answer 29

अभी तक एक और समाधान:

/**
 * Calculate age by birth date.
 *
 * @param int birthYear Year as YYYY.
 * @param int birthMonth Month as number from 1 to 12.
 * @param int birthDay Day as number from 1 to 31.
 * @return int
 */
function getAge(birthYear, birthMonth, birthDay) {
  var today = new Date();
  var birthDate = new Date(birthYear, birthMonth-1, birthDay);
  var age = today.getFullYear() - birthDate.getFullYear();
  var m = today.getMonth() - birthDate.getMonth();
  if (m < 0 || (m === 0 && today.getDate() < birthDate.getDate())) {
    age--;
  }
  return age;
}

Answer 30

साथ momentjs "fromNow" विधि, यह स्वरूपित तारीख, यानी साथ काम करने के लिए आप की अनुमति देता है: 1968/03/15

var dob = document.getElementByID("dob"); var age = moment(dob.value).fromNow(true).replace(" years", "");

//fromNow(true) => suffix "ago" is not displayed //but we still have to get rid of "years";

एक प्रोटोटाइप संस्करण के रूप में

String.prototype.getAge = function() {
return moment(this.valueOf()).fromNow(true).replace(" years", "");

}