जावास्क्रिप्ट वर्ष की गणना दिन (1 - 366)

Question

1 - 366 से, वर्ष के दिन की गणना के लिए मैं जावास्क्रिप्ट का उपयोग कैसे करूं? उदाहरण के लिए:

• जनवरी 3 होना चाहिए 3 ।
• 1 फरवरी को 32 होनी चाहिए ।

Comments

var days = new Date().getFullYear() % 4 == 0 ? 366 : 365;

— एलेक्स टरपिन

लेकिन वास्तव में मुझे यकीन नहीं है कि आपका क्या मतलब है। आप बस वर्ष में दिनों की संख्या चाहते हैं? या दो तिथियों के बीच?

— एलेक्स टरपिन

fyi @ xeon06, लीप वर्ष की गणना 4 से mod'ing की तुलना में थोड़ी अधिक जटिल है। देखें: लीप वर्ष एल्गोरिथ्म

— मैट फेलजानी

@ Xeon06: यह केवल ज्यादातर समय सही है। से विकिपीडिया : वर्षों है कि समान रूप से 100 से विभाज्य हैं लीप वर्ष नहीं कर रहे हैं, जब तक कि वे भी समान रूप से 400 से विभाज्य है, जो मामले में वे कर रहे हैं लीप वर्ष।

— कैमरन

अच्छी तरह से मैं सही खड़ा हूँ। @ मिनिटेक को सही उत्तर लगता है।

— एलेक्स टर्पिन

Answer 1

ओपी के संपादन के बाद:

var now = new Date();
var start = new Date(now.getFullYear(), 0, 0);
var diff = now - start;
var oneDay = 1000 * 60 * 60 * 24;
var day = Math.floor(diff / oneDay);
console.log('Day of year: ' + day);

संपादित करें: उपरोक्त कोड तब विफल हो जाएगा जब nowमार्च 26 और अक्टूबर 29 के बीच की तारीख हो और now1 बजे से पहले का समय हो (जैसे 00:59:59)। यह कोड डेलाइट बचत समय को ध्यान में नहीं रखने के कारण है। आपको इसकी भरपाई करनी चाहिए :

var now = new Date();
var start = new Date(now.getFullYear(), 0, 0);
var diff = (now - start) + ((start.getTimezoneOffset() - now.getTimezoneOffset()) * 60 * 1000);
var oneDay = 1000 * 60 * 60 * 24;
var day = Math.floor(diff / oneDay);
console.log('Day of year: ' + day);

Comments

Math.floorलगातार मुझे अप्रैल में एक निश्चित दिन के बाद उम्मीद से 1 दिन कम का परिणाम दिया। Math.ceilउम्मीद के मुताबिक काम किया, लेकिन मैंने देखा है कि यह सलाह दी जाती है कि आप Math.roundया तो इस्तेमाल करें ।

— baacke

दिन घटक आधार -1 है। इस वर्ष की पहली जनवरी का प्रतिनिधित्व करने के लिए, आप इसका उपयोग करेंगे new Date(2014, 0, 1), न new Date(2014, 0, 0)कि आपके यहाँ। क्या वह जानबूझकर है? शायद यह है कि एक दिन के रूप में बंद होने के लिए क्या खाते new Date(2014, 0, 0)वापस आ जाएगा 12/31/2013।

— कर्क वॉक

शायद उपयोग करें .setUTCHoursऔर Date.UTC()अधिक विश्वसनीय समाधान के लिए।

— नॉयो

@AlexTurpin, @ T30: मुझे पता है कि यह थोड़ा पुराना है, लेकिन अगर आप सोच रहे थे ... मार्च में शुरू होने वाले डेलाइट सेविंग टाइम की वजह से यह समस्या है। ऐसा इसलिए है क्योंकि जब आप डीएसटी से पहले की तारीख की आधी रात और डीएसटी के बाद की तारीख की आधी रात का अंतर लेते हैं तो आपके पास 1000 * 60 * 24 (समान रूप से एक सेकंड के लिए बंद) द्वारा समान रूप से विभाज्य नहीं होंगे। । सबसे आसान समाधान ceilइसके बजाय उपयोग करना है floor, इससे आपको एक नंबरिंग सिस्टम मिलेगा जहाँ Jan 1st = 1. यदि आप Jan 1st = 0 चाहते हैं (जैसा floorकि आप देंगे), बस अपने अंतिम परिणाम से 1 घटाएं।

— वारेन आर।

टाइमज़ोन और दिन के उजाले की बचत को ध्यान में रखने के लिए, लाइन 3 से बदलें: var diff = now - start + (start.getTimezoneOffset() - now.getTimezoneOffset()) * 60 * 1000;

— मार्लोन

Answer 2

यह सभी देशों में डेलाइट सेविंग टाइम में बदलाव करता है (ऑस्ट्रेलिया में "दोपहर" ऊपर काम नहीं करता है):

Date.prototype.isLeapYear = function() {
    var year = this.getFullYear();
    if((year & 3) != 0) return false;
    return ((year % 100) != 0 || (year % 400) == 0);
};

// Get Day of Year
Date.prototype.getDOY = function() {
    var dayCount = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
    var mn = this.getMonth();
    var dn = this.getDate();
    var dayOfYear = dayCount[mn] + dn;
    if(mn > 1 && this.isLeapYear()) dayOfYear++;
    return dayOfYear;
};

Comments

इस बात से सहमत हैं कि स्वीकृत उत्तर में दिन की बचत संबंधी बग हैं। उपरोक्त समाधान बेहतर है और तेज है। यहाँ इसका एक रूपांतर है जिसका मैंने jsPerf jsperf.com/date-getdayofyear-perf

— श्याम हबरकड़ा

@ShyamHabarakada: आपके बेंचमार्क का कोड टूट गया है, getDay()इसे बदलने की आवश्यकता है getDate()। पूर्व सप्ताह का दिन लौटाता है (0 = रविवार।.6 = शनिवार), दिन नहीं।

— कोडमैनएक्स

Answer 3

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

function daysIntoYear(date){
    return (Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()) - Date.UTC(date.getFullYear(), 0, 0)) / 24 / 60 / 60 / 1000;
}

आप इसे निम्नलिखित के साथ जांच सकते हैं:

[new Date(2016,0,1), new Date(2016,1,1), new Date(2016,2,1), new Date(2016,5,1), new Date(2016,11,31)]
    .forEach(d => 
        console.log(`${d.toLocaleDateString()} is ${daysIntoYear(d)} days into the year`));

2016 में लीप वर्ष के लिए कौन सा आउटपुट ( http://www.epochconverter.com/days/2016 का उपयोग करके सत्यापित ):

1/1/2016 is 1 days into the year
2/1/2016 is 32 days into the year
3/1/2016 is 61 days into the year
6/1/2016 is 153 days into the year
12/31/2016 is 366 days into the year

Comments

यह ओवरफ्लो हो सकता है क्योंकि मिलीसेकंड की संख्या बहुत बड़ी है।

— knt5784

@ knt5784 गणित ओवरफ्लो करने में सक्षम हो सकता है, लेकिन उसका उदाहरण सबसे अच्छा संभव वास्तविक-विश्व मान दिखाता है कि यह ठीक काम कर रहा है, इसलिए जब तक कि पूर्णांक ओवरफ़्लो के साथ एक ब्राउज़र आधारित समस्या नहीं होती है, तब तक आपको इसका उपयोग करना चाहिए।

— प्रति फेग्रेल

मुझे व्यक्तिगत रूप से यह दृष्टिकोण पसंद है। बहुत क्लीनर (और बहुत चालाक!) डीएसटी मुद्दों से बचने का तरीका। अगर कोई सोच रहा है कि DOY से तारीख में कैसे परिवर्तित किया जाए, तो यह बहुत सरल है। मूल रूप से, आप सिर्फ जनवरी की एक तारीख बनाते हैं। उदाहरण के लिए, जनवरी 59 === 28 फरवरी। लीप दिन ठीक है। function doyToDate(doy, year) { return new Date(year, 0, doy); }

— किप

@ knt5784 इस कोड के साथ मिलीसेकंड अतिप्रवाह का कोई जोखिम नहीं है, कम से कम 200,000 वर्षों के लिए नहीं। तारीख द्वारा समर्थित सबसे बड़ी तारीख है new Date(8640000000000000), जो अब भी कम है Number.MAX_SAFE_INTEGER। : इस जवाब को देखने के stackoverflow.com/a/11526569/18511

— किप

Answer 4

Date.prototype.dayOfYear= function(){
    var j1= new Date(this);
    j1.setMonth(0, 0);
    return Math.round((this-j1)/8.64e7);
}

alert(new Date().dayOfYear())

Comments

यह एक प्रकार का वृक्ष नहीं होगा ... एक ऐसी वस्तु को संशोधित करना जो आपकी नहीं है, विशेष रूप से एक वैश्विक। यह अत्यधिक झुकाव वाले ग्रहों में भी विफल होगा जहां दिन के समय की बचत का समय 12 घंटे से अधिक है। लेकिन अधिक वास्तविक रूप से, यदि आप एक ब्राउज़र के लिए कोडिंग कर रहे हैं जो दिनांक ऑब्जेक्ट के टाइमज़ोन को बदलने की अनुमति देता है, तो j1 का टाइमज़ोन ऑस्ट्रेलिया हो सकता है और इस समय का अलास्का अलास्का हो सकता है, राउंडिंग को तोड़ सकता है।

— रे फॉस

Answer 5

सौभाग्य से यह प्रश्न निर्दिष्ट नहीं करता है कि क्या वर्तमान दिन की संख्या की आवश्यकता है, इस उत्तर के लिए कमरा छोड़ दें।
साथ ही कुछ उत्तरों (अन्य प्रश्नों पर भी) में लीप-वर्ष की समस्याएं थीं या दिनांक-ऑब्जेक्ट का उपयोग किया था। हालांकि Date object1 जनवरी 1970 के दोनों ओर जावास्क्रिप्ट के लगभग 285616 वर्ष (100,000,000 दिन) शामिल हैं, मैं विभिन्न ब्राउज़रों में सभी प्रकार की अप्रत्याशित तारीख विसंगतियों (सबसे विशेष रूप से 0 से 99 वर्ष) से तंग आ गया था । मैं भी उत्सुक था कि इसकी गणना कैसे की जाए।

इसलिए मैंने सही ( प्रोलेप्टिक ग्रेगोरियन / एस्ट्रोनॉमिकल / आईएसओ 8601: 2004 (खंड 4.3.2.1) की गणना करने के लिए एक सरल और सबसे ऊपर, छोटा एल्गोरिथ्म लिखा , इसलिए वर्ष मौजूद है और एक लीप वर्ष है और नकारात्मक वर्ष वर्ष के दिन का समर्थन करते हैं ) वर्ष , माह और दिन के आधार पर । ध्यान दें कि अंकन में, वर्ष 0 AD / BC मौजूद नहीं है: इसके बजाय वर्ष लीप-ईयर है! यदि आपको बीसी नोटेशन की आवश्यकता है, तो पहले (अन्यथा सकारात्मक) वर्ष-मूल्य का एक वर्ष पहले घटाएं !! 0
AD/BC1 BC

मैं (JavaScript) को संशोधित शॉर्ट सर्किट bitmask-सापेक्ष leapYear एल्गोरिथ्म और का एक सा वार देखने करने के लिए एक जादुई संख्या के साथ आया ऑफसेट (जो शामिल नहीं और जैन फ़रवरी, इस प्रकार 10 * 3 बिट्स की आवश्यकता होगी, (30 बिट्स से भी कम है 31 बिट्स, इसलिए हम सुरक्षित रूप से बिटशिफ्ट पर एक और चरित्र को बचा सकते हैं >>>))।

ध्यान दें कि न तो महीना या दिन हो सकता है 0। इसका मतलब है कि है कि आप बस के लिए इस समीकरण की जरूरत है वर्तमान दिन (इसे प्रयोग खिला .getMonth()) तुम सिर्फ हटाने की जरूरत --से --m।

ध्यान दें कि यह एक मान्य तिथि है (हालाँकि त्रुटि-जाँच अभी कुछ वर्ण अधिक है)।

function dayNo(y,m,d){
  return --m*31-(m>1?(1054267675>>m*3-6&7)-(y&3||!(y%25)&&y&15?0:1):0)+d;
}

<!-- some examples for the snippet -->
<input type=text value="(-)Y-M-D" onblur="
  var d=this.value.match(/(-?\d+)[^\d]+(\d\d?)[^\d]+(\d\d?)/)||[];
  this.nextSibling.innerHTML=' Day: ' + dayNo(+d[1], +d[2], +d[3]);
" /><span></span>

<br><hr><br>

<button onclick="
  var d=new Date();
  this.nextSibling.innerHTML=dayNo(d.getFullYear(), d.getMonth()+1, d.getDate()) + ' Day(s)';
">get current dayno:</button><span></span>

---

यहाँ सही श्रेणी-सत्यापन के साथ संस्करण है ।

function dayNo(y,m,d){
  return --m>=0 && m<12 && d>0 && d<29+(  
           4*(y=y&3||!(y%25)&&y&15?0:1)[phone]>>m*2&3  
         ) && m*31-(m>1?(1054267675>>m*3-6&7)-y:0)+d;
}

<!-- some examples for the snippet -->
<input type=text value="(-)Y-M-D" onblur="
  var d=this.value.match(/(-?\d+)[^\d]+(\d\d?)[^\d]+(\d\d?)/)||[];
  this.nextSibling.innerHTML=' Day: ' + dayNo(+d[1], +d[2], +d[3]);
" /><span></span>

फिर से, एक पंक्ति, लेकिन मैंने इसे पठनीयता (और निम्नलिखित स्पष्टीकरण) के लिए 3 लाइनों में विभाजित किया है।

पिछली पंक्ति उपरोक्त फ़ंक्शन के समान है, हालांकि (समान) लीपियर एल्गोरिथ्म को पिछले शॉर्ट-सर्किट अनुभाग (दिन-संख्या गणना से पहले) में ले जाया जाता है, क्योंकि यह भी जानना आवश्यक है कि एक महीने में कितने दिन होते हैं दिया (लीप) वर्ष।

मध्य रेखा किसी अन्य मैजिक नंबर का उपयोग करते हुए दिए गए (लीप) वर्ष में दिए गए महीने के लिए सही ऑफसेट संख्या (अधिकतम दिनों के लिए) की गणना करती है : चूंकि 31-28=3और 3केवल 2 बिट्स हैं, फिर 12*2=24बिट्स, हम सभी 12 महीनों को स्टोर कर सकते हैं। चूंकि इसके अलावा तेजी से घटाव हो सकता है, इसलिए हम ऑफसेट जोड़ते हैं (इसके बजाय इसे घटाना 31)। फरवरी के लिए एक लीप-ईयर निर्णय-शाखा से बचने के लिए, हम उस मैजिक लुकअप-नंबर को फ्लाई पर संशोधित करते हैं।

यह हमें (बहुत स्पष्ट) पहली पंक्ति के साथ छोड़ देता है: यह जाँचता है कि महीने और तारीख वैध सीमा के भीतर हैं और हमें falseसीमा त्रुटि पर एक वापसी मूल्य के साथ सुनिश्चित करता है (ध्यान दें कि यह फ़ंक्शन 0 भी वापस करने में सक्षम नहीं होना चाहिए, क्योंकि 1 जून 0000 अभी भी दिन 1. है), आसान त्रुटि-जाँच प्रदान करना if(r=dayNo(/*y, m, d*/)){}:।
तो इस तरह से (जहां माह और दिन नहीं हो सकता है इस्तेमाल किया 0), तो एक को बदल सकते हैं --m>=0 && m<12करने के लिए m>0 && --m<12(एक और चार बचत)।
कारण मैं इसे के मौजूदा रूप में टुकड़ा द्वारा लिखा गया है कि 0-आधारित महीने मूल्यों के लिए, एक बस को दूर करने की जरूरत है --से --m।

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

Comments

मैंने इसे उपयोग में आसानी के लिए एक तिथि समारोह में फेंक दिया। दी गई तारीख () विसंगतियां अभी भी एक मुद्दा है, लेकिन मैं वर्ष 2015+ का उपयोग कर रहा हूं इसलिए मुझे आशा है कि वे सुसंगत हैं। बेचारा JSHint आपके कोड hahah को मान्य करने की कोशिश में मर गया। Date.prototype.dayNo = function(){ var y = this.getFullYear(); var m = this.getMonth()+1; var d = this.getDate(); return --m*31-(m>1?(1054267675>>m*3-6&7)-(y&3||!(y%25)&&y&15?0:1):0)+d; };

— फ्रेशवॉल्क

ख़ुशी है की तुम्हे पसंद आया। इस एलगो को पूरी तरह से 2 ^ 31-1 साल (2147483647 से अधिक का परीक्षण किया गया है, कि 0. के दोनों तरफ जावास्क्रिप्ट की तिथि-वस्तु की 7500 गुना है) (यह 2 ^ 32 के लिए काम कर सकता है , लेकिन मैंने इसका परीक्षण नहीं किया है अभी तक)। इसके अलावा, आप मेरा उत्तर फिर से पढ़ सकता है: यदि आप बंद दाढ़ी कर सकते हैं +1से this.getMonth()+1अगर आप को दूर --से --m। संपादित करें , तो मैं (एक पुस्तकालय के लिए) Date.prototype.dayNo = function(){ var y=this.getFullYear(), m=this.getMonth(); return m*31-(m>1?(1054267675>>m*3-6&7)-(y&3||!(y%25)&&y&15?0:1):0)+this.getDate(); };

— करूंगा

मैंने वास्तव में बस यही किया था जब मैं इसे देख रहा था! मुझे एहसास हुआ कि मैं एक जोड़ रहा था तो इसे तुरंत घटाना। मुझे लगता है कि 2^31 - 2016अब से js तक के वर्षों में मिलने वाला समय शायद थोड़ा पुराना हो जाएगा।

— फ्रेशवॉक

@ फ्रेशवोक: lol, यही कारण है कि मैंने इसे 2 ^ 31 से आगे कभी नहीं परखा है :), लेकिन तब तक, यह कम से कम पूर्वानुमानित और सुसंगत परिणाम देगा। EDIT , सिर्फ़ सिद्धांत के लिए, धीमी पारंपरिक ऑल-मोडुलो एल्गो को खसखस ​​के लिए उपयोग करके, रेंज को 2 ^ 53 तक बढ़ाया जा सकता है। माह-लुकिंग एल्गो सीमित कारक नहीं है।

— 21

Answer 6

यदि आप पहिये का फिर से आविष्कार नहीं करना चाहते हैं, तो आप उत्कृष्ट दिनांक-fns (नोड.जेएस) पुस्तकालय का उपयोग कर सकते हैं :

var getDayOfYear = require('date-fns/get_day_of_year')

var dayOfYear = getDayOfYear(new Date(2017, 1, 1)) // 1st february => 32

Answer 7

ठीक है, अगर मैं आपको सही तरीके से समझता हूं, तो आप एक लीप वर्ष पर 366, 365 अन्यथा, सही चाहते हैं? एक वर्ष एक लीप वर्ष है यदि यह 4 से समान रूप से विभाज्य है लेकिन 100 से नहीं जब तक कि यह 400 से विभाज्य न हो:

function daysInYear(year) {
    if(year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)) {
        // Leap year
        return 366;
    } else {
        // Not a leap year
        return 365;
    }
}

---

अपडेट के बाद संपादित करें:

उस स्थिति में, मुझे नहीं लगता कि कोई अंतर्निहित पद्धति है; आपको यह करने की आवश्यकता होगी:

function daysInFebruary(year) {
    if(year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)) {
        // Leap year
        return 29;
    } else {
        // Not a leap year
        return 28;
    }
}

function dateToDay(date) {
    var feb = daysInFebruary(date.getFullYear());
    var aggregateMonths = [0, // January
                           31, // February
                           31 + feb, // March
                           31 + feb + 31, // April
                           31 + feb + 31 + 30, // May
                           31 + feb + 31 + 30 + 31, // June
                           31 + feb + 31 + 30 + 31 + 30, // July
                           31 + feb + 31 + 30 + 31 + 30 + 31, // August
                           31 + feb + 31 + 30 + 31 + 30 + 31 + 31, // September
                           31 + feb + 31 + 30 + 31 + 30 + 31 + 31 + 30, // October
                           31 + feb + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31, // November
                           31 + feb + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30, // December
                         ];
    return aggregateMonths[date.getMonth()] + date.getDate();
}

(हां, मैंने वास्तव में नकल या चिपकाने के बिना किया था। यदि मैं एक आसान तरीका है जो मैं पागल हो जाऊंगा)

Comments

मेरा आसान तरीका सिर्फ जादू की संख्या 1054267675 का उपयोग करना है और इसे एक दिन कॉल करना है, मैं आलसी के लिए यह सब टाइप करने का तरीका हूं:)

— गीतालैब

Answer 8

यह वर्ष में वर्तमान दिन को खोजने का एक सरल तरीका है, और इसमें बिना किसी समस्या के लीप वर्ष का हिसाब रखना चाहिए:

जावास्क्रिप्ट:

Math.round((new Date().setHours(23) - new Date(new Date().getYear()+1900, 0, 1, 0, 0, 0))/1000/60/60/24);

Google Apps स्क्रिप्ट में जावास्क्रिप्ट:

Math.round((new Date().setHours(23) - new Date(new Date().getYear(), 0, 1, 0, 0, 0))/1000/60/60/24);

इस कोड की प्राथमिक क्रिया उन मिलीसेकंड की संख्या को खोजना है जो वर्तमान वर्ष में समाप्त हो गए हैं और फिर इस संख्या को दिनों में परिवर्तित कर देते हैं। वर्तमान वर्ष में समाप्त हो चुके मिलीसेकंड की संख्या को चालू वर्ष के पहले दिन के दूसरे सेकंड के मिलीसेकंड की संख्या घटाकर पाया जा सकता है, जो मिलीसेकंड से new Date(new Date().getYear()+1900, 0, 1, 0, 0, 0)(जावास्क्रिप्ट) या new Date(new Date().getYear(), 0, 1, 0, 0, 0)(Google Apps स्क्रिप्ट) के साथ प्राप्त होता है। वर्तमान दिन के 23 वें घंटे के साथ, जो कि मिला new Date().setHours(23)। वर्तमान तिथि को 23 वें घंटे पर सेट करने का उद्देश्य यह सुनिश्चित करना है कि वर्ष का दिन सही तरीके से पूरा हो गया है Math.round()।

एक बार जब आपके पास चालू वर्ष के मिलीसेकंड की संख्या हो जाती है, तो आप इस समय को 1000 से विभाजित करके मिलीसेकंड में सेकंड में बदल सकते हैं, फिर 60 से विभाजित करके सेकंड में मिनट में बदल सकते हैं, फिर 60 से विभाजित करके मिनटों को घंटों में बदल सकते हैं। और अंत में 24 से विभाजित करके घंटे को दिनों में बदल सकते हैं।

नोट: इस पोस्ट को Google Apps स्क्रिप्ट में लागू जावास्क्रिप्ट और जावास्क्रिप्ट के बीच अंतर के लिए संपादित किया गया था। साथ ही, उत्तर के लिए अधिक संदर्भ जोड़ा गया था।

Comments

क्या आप कृपया यह कहकर थोड़ा और समझा सकते हैं कि यह काम कर रहा है?

— स्टीफन रिइंडल

हाँ! मुझे पहली बार में अधिक विवरण नहीं देने के लिए खेद है। "Math.round" कथन के अंदर की अभिव्यक्ति वर्ष के वर्तमान दिन के अंतिम घंटे के मिलीसेकंड से वर्ष के पहले दिन को घटाकर वर्तमान वर्ष में मिलीसेकंड की संख्या का पता लगाती है। मिलीसेकंड की संख्या को फिर सेकंड में बदलने के लिए 1000 से विभाजित किया जाता है, 60 को मिनट में परिवर्तित करने के लिए, 60 को घंटे में बदलने के लिए, और 24 को दिनों में बदलने के लिए। अभिव्यक्ति को "Math.round ()" फ़ंक्शन के भीतर लपेटा जाता है ताकि यह वर्ष के दिन के लिए पूर्णांक तक गोल हो जाए।

— लिज़ पेज-गोल्ड

मुझे यह भी जोड़ना चाहिए कि यह समाधान अनिवार्य रूप से "स्वीकृत" समाधान के समान है, सिवाय इसके कि यह कोड की एक पंक्ति में सब कुछ करता है।

— लिज़ पेज-गॉल्ड

डेलाइट सेविंग टाइम के लिए यह खाता कैसे है? कि इसे थोड़ा दूर फेंक नहीं होगा?

— डैन ओसवाल्ट

नहीं, दिन के समय की बचत का समय इस गणना को प्रभावित नहीं करेगा, क्योंकि दिन के समय की बचत का समय घंटों का है और यह कोड वर्ष में दिनों की संख्या की गणना कर रहा है। इसके अलावा, क्योंकि मैंने .setHoursपहली डेट ऑब्जेक्ट पर विधि का इस्तेमाल किया और दूसरी डेट ऑब्जेक्ट के साथ दिन का समय निर्दिष्ट किया, डेलाइट बचत समय से 1 घंटे का परिवर्तन इस गणना में उपयोग की गई दिनांक ऑब्जेक्ट्स के समय को प्रभावित नहीं करेगा।

— लिज पेज-गोल्ड

Answer 9

मुझे लगता है कि यह अधिक सीधा है:

var date365 = 0;

var currentDate = new Date();
var currentYear = currentDate.getFullYear();
var currentMonth = currentDate.getMonth(); 
var currentDay = currentDate.getDate(); 

var monthLength = [31,28,31,30,31,30,31,31,30,31,30,31];

var leapYear = new Date(currentYear, 1, 29); 
if (leapYear.getDate() == 29) { // If it's a leap year, changes 28 to 29
    monthLength[1] = 29;
}

for ( i=0; i < currentMonth; i++ ) { 
    date365 = date365 + monthLength[i];
}
date365 = date365 + currentDay; // Done!

Answer 10

यह विधि समय-समय पर जारी करने और दिन के उजाले के समय को ध्यान में रखती है

function dayofyear(d) {   // d is a Date object
    var yn = d.getFullYear();
    var mn = d.getMonth();
    var dn = d.getDate();
    var d1 = new Date(yn,0,1,12,0,0); // noon on Jan. 1
    var d2 = new Date(yn,mn,dn,12,0,0); // noon on input date
    var ddiff = Math.round((d2-d1)/864e5);
    return ddiff+1; 
}

( यहां से लिया गया )

आप भी देखिए ये फील

Comments

यह थोड़ा अक्षम है, लेकिन यह पूरी तरह से काम करता है। आप बस समय प्राप्त कर सकते हैं वस्तुओं और सेटडैट को दिन में बदल दें 1. दोनों जिनमें से पूरी तरह से समर्थित हैं। विचार आप अभ्यस्त timezones के आसपास घूम रहा है। यह भी मानता है कि दिन के उजाले की बचत का समय 12 घंटे से कम है ... जो पृथ्वी पर एक सुरक्षित धारणा है।

— रे फॉस

Answer 11

Math.round ((नई तिथि ()। setHours (23) - नई तिथि (नई तिथि) (। GetFullYear) (), 0, 1, 0, 0, 0)) / 1000/86400);

आगे उत्तर का अनुकूलन करता है।

इसके अलावा, सेटहॉर्स (23) या अंतिम-लेकिन-दो शून्य को बाद में एक और मूल्य पर बदलने से एक और टाइमज़ोन से संबंधित दिन का वर्ष प्रदान किया जा सकता है। उदाहरण के लिए, यूरोप से अमेरिका में स्थित एक संसाधन को पुनः प्राप्त करने के लिए।

Answer 12

Math.floor((Date.now() - Date.parse(new Date().getFullYear(), 0, 0)) / 86400000)

यह मेरा समाधान है

Comments

मैं पिछले साल के 31 दिसंबर को जनवरी 01 = डीओवाई 01 का उपयोग करता हूं। मैंने यह भी पाया कि 10 मार्च को 11 मार्च की तरह ही डीओवाई है क्योंकि एक 69 था और दूसरा 69.9, दोनों फ्लोरिंग 69 तक। मैथिंग करना। । मेरा मानना ​​है कि 10 मार्च या 11 मार्च को डेलाइट सेविंग टाइम स्विच है, जिसके कारण 11 मार्च को काफी 70 नहीं होना चाहिए।

— user3015682

Answer 13

मैंने एक ऐसा बनाया है जो पठनीय है और यह बहुत जल्दी से ट्रिक करेगा, साथ ही जेएस डेट ऑब्जेक्ट्स को असमान समय क्षेत्रों के साथ संभाल सकता है।

मैंने समय क्षेत्र, डीएसटी, लीप सेकंड और लीप वर्ष के लिए काफी कुछ परीक्षण मामलों को शामिल किया है।

UTC के विपरीत PS ECMA-262 लीप सेकंड को अनदेखा करता है। यदि आप इसे वास्तविक UTC का उपयोग करने वाली भाषा में परिवर्तित करना चाहते हैं, तो आप केवल 1 जोड़ सकते हैं oneDay।

// returns 1 - 366
findDayOfYear = function (date) {
  var oneDay = 1000 * 60 * 60 * 24; // A day in milliseconds
  var og = {                        // Saving original data
    ts: date.getTime(),
    dom: date.getDate(),            // We don't need to save hours/minutes because DST is never at 12am.
    month: date.getMonth()
  }
  date.setDate(1);                  // Sets Date of the Month to the 1st.
  date.setMonth(0);                 // Months are zero based in JS's Date object
  var start_ts = date.getTime();    // New Year's Midnight JS Timestamp
  var diff = og.ts - start_ts;

  date.setDate(og.dom);             // Revert back to original date object
  date.setMonth(og.month);          // This method does preserve timezone
  return Math.round(diff / oneDay) + 1; // Deals with DST globally. Ceil fails in Australia. Floor Fails in US.
}

// Tests
var pre_start_dst = new Date(2016, 2, 12);
var on_start_dst = new Date(2016, 2, 13);
var post_start_dst = new Date(2016, 2, 14);

var pre_end_dst_date = new Date(2016, 10, 5);
var on_end_dst_date = new Date(2016, 10, 6);
var post_end_dst_date = new Date(2016, 10, 7);

var pre_leap_second = new Date(2015, 5, 29);
var on_leap_second = new Date(2015, 5, 30);
var post_leap_second = new Date(2015, 6, 1);

// 2012 was a leap year with a leap second in june 30th
var leap_second_december31_premidnight = new Date(2012, 11, 31, 23, 59, 59, 999);

var january1 = new Date(2016, 0, 1);
var january31 = new Date(2016, 0, 31);

var december31 = new Date(2015, 11, 31);
var leap_december31 = new Date(2016, 11, 31);

alert( ""
  + "\nPre Start DST: " + findDayOfYear(pre_start_dst) + " === 72"
  + "\nOn Start DST: " + findDayOfYear(on_start_dst) + " === 73"
  + "\nPost Start DST: " + findDayOfYear(post_start_dst) + " === 74"
      
  + "\nPre Leap Second: " + findDayOfYear(pre_leap_second) + " === 180"
  + "\nOn Leap Second: " + findDayOfYear(on_leap_second) + " === 181"
  + "\nPost Leap Second: " + findDayOfYear(post_leap_second) + " === 182"
      
  + "\nPre End DST: " + findDayOfYear(pre_end_dst_date) + " === 310"
  + "\nOn End DST: " + findDayOfYear(on_end_dst_date) + " === 311"
  + "\nPost End DST: " + findDayOfYear(post_end_dst_date) + " === 312"
      
  + "\nJanuary 1st: " + findDayOfYear(january1) + " === 1"
  + "\nJanuary 31st: " + findDayOfYear(january31) + " === 31"
  + "\nNormal December 31st: " + findDayOfYear(december31) + " === 365"
  + "\nLeap December 31st: " + findDayOfYear(leap_december31) + " === 366"
  + "\nLast Second of Double Leap: " + findDayOfYear(leap_second_december31_premidnight) + " === 366"
);

Answer 14

मैं एक समाधान प्रदान करना चाहता हूं जो प्रत्येक पिछले महीने के दिनों को जोड़ते हुए गणना करता है:

function getDayOfYear(date) {
    var month = date.getMonth();
    var year = date.getFullYear();
    var days = date.getDate();
    for (var i = 0; i < month; i++) {
        days += new Date(year, i+1, 0).getDate();
    }
    return days;
}
var input = new Date(2017, 7, 5);
console.log(input);
console.log(getDayOfYear(input));

इस तरह आपको लीप वर्ष और डेलाइट सेविंग के विवरणों का प्रबंधन नहीं करना है।

Answer 15

UTC टाइमस्टैम्प का उपयोग कर एक विकल्प। जैसा कि अन्य ने उल्लेख किया है कि दिन 1 से संकेत दे रहा है कि एक माह 0. के बजाय 1 है। माह हालांकि 0 से शुरू होता है।

var now = Date.now();
var year =  new Date().getUTCFullYear();
var year_start = Date.UTC(year, 0, 1);
var day_length_in_ms = 1000*60*60*24;
var day_number = Math.floor((now - year_start)/day_length_in_ms)
console.log("Day of year " + day_number);

Answer 16

आप setDateफ़ंक्शन में दिनांक संख्या के रूप में पैरामीटर पास कर सकते हैं :

var targetDate = new Date();
targetDate.setDate(1);

// Now we can see the expected date as: Mon Jan 01 2018 01:43:24
console.log(targetDate);

targetDate.setDate(365);

// You can see: Mon Dec 31 2018 01:44:47
console.log(targetDate)

Answer 17

यह उन लोगों के लिए उपयोगी हो सकता है जिन्हें स्ट्रिंग के रूप में वर्ष के दिन की आवश्यकता होती है और उनके पास jQuery UI उपलब्ध होता है।

आप jQuery UI Datepicker का उपयोग कर सकते हैं:

day_of_year_string = $.datepicker.formatDate("o", new Date())

नीचे दिया गया यह उसी तरह काम करता है जैसे कि पहले से बताए गए कुछ उत्तर ((date_ms - first_date_of_year_ms) / ms_per_day ):

function getDayOfTheYearFromDate(d) {
    return Math.round((new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime() 
- new Date(d.getFullYear(), 0, 0).getTime()) / 86400000);
}

day_of_year_int = getDayOfTheYearFromDate(new Date())

Answer 18

हमारे बीच उन लोगों के लिए जो एक तेज वैकल्पिक समाधान चाहते हैं।

(function(){"use strict";
function daysIntoTheYear(dateInput){
    var fullYear = dateInput.getFullYear()|0;
	// "Leap Years are any year that can be exactly divided by 4 (2012, 2016, etc)
 	//	except if it can be exactly divided by 100, then it isn't (2100, 2200, etc)
 	//		except if it can be exactly divided by 400, then it is (2000, 2400)"
	// (https://www.mathsisfun.com/leap-years.html).
    var isLeapYear = ((fullYear & 3) | (fullYear/100 & 3)) === 0 ? 1 : 0;
	// (fullYear & 3) = (fullYear % 4), but faster
    //Alternative:var isLeapYear=(new Date(currentYear,1,29,12)).getDate()===29?1:0
    var fullMonth = dateInput.getMonth()|0;
    return ((
        // Calculate the day of the year in the Gregorian calendar
        // The code below works based upon the facts of signed right shifts
        //    • (x) >> n: shifts n and fills in the n highest bits with 0s 
        //    • (-x) >> n: shifts n and fills in the n highest bits with 1s
        // (This assumes that x is a positive integer)
        (31 & ((-fullMonth) >> 4)) + // January // (-11)>>4 = -1
        ((28 + isLeapYear) & ((1-fullMonth) >> 4)) + // February
        (31 & ((2-fullMonth) >> 4)) + // March
        (30 & ((3-fullMonth) >> 4)) + // April
        (31 & ((4-fullMonth) >> 4)) + // May
        (30 & ((5-fullMonth) >> 4)) + // June
        (31 & ((6-fullMonth) >> 4)) + // July
        (31 & ((7-fullMonth) >> 4)) + // August
        (30 & ((8-fullMonth) >> 4)) + // September
        (31 & ((9-fullMonth) >> 4)) + // October
        (30 & ((10-fullMonth) >> 4)) + // November
        // There are no months past December: the year rolls into the next.
        // Thus, fullMonth is 0-based, so it will never be 12 in Javascript

        (dateInput.getDate()|0) // get day of the month

    )&0xffff);
}
// Demonstration:
var date = new Date(2100, 0, 1)
for (var i=0; i<12; i=i+1|0, date.setMonth(date.getMonth()+1|0))
    console.log(date.getMonth()+":\tday "+daysIntoTheYear(date)+"\t"+date);
date = new Date(1900, 0, 1);
for (var i=0; i<12; i=i+1|0, date.setMonth(date.getMonth()+1|0))
    console.log(date.getMonth()+":\tday "+daysIntoTheYear(date)+"\t"+date);

// Performance Benchmark:
console.time("Speed of processing 65536 dates");
for (var i=0,month=date.getMonth()|0; i<65536; i=i+1|0)
    date.setMonth(month=month+1+(daysIntoTheYear(date)|0)|0);
console.timeEnd("Speed of processing 65536 dates");
})();

वर्ष के महीनों का आकार और जिस तरह से लीप इयर्स काम करते हैं वह हमारे समय को सूरज के साथ ट्रैक पर रखने में पूरी तरह से फिट बैठता है। हेक, यह इतनी अच्छी तरह से काम करता है कि हम कभी भी बस यहाँ और वहाँ मात्र सेकंड समायोजित करते हैं । लीप वर्षों की हमारी वर्तमान प्रणाली तब से प्रभावी है 24 फरवरी, 1582 और संभवतः भविष्य के लिए प्रभावी रहेगी।

DST, हालांकि, परिवर्तन के अधीन है। हो सकता है कि आज से 20 साल बाद, कुछ देश डीएसटी के लिए एक पूरे दिन या किसी अन्य चरम समय की भरपाई कर सकते हैं। एक संपूर्ण डीएसटी दिवस लगभग निश्चित रूप से कभी नहीं होगा, लेकिन डीएसटी अभी भी बहुत ऊपर से हवा और अनिर्णायक है। इस प्रकार, उपरोक्त समाधान बहुत तेज होने के अलावा भविष्य का प्रमाण है।

उपरोक्त कोड स्निपेट बहुत तेजी से चलता है। मेरा कंप्यूटर Chrome पर ~ 52ms में 65536 दिनांक संसाधित कर सकता है।

Answer 19

const dayOfYear = date => {
    const myDate = new Date(date);
    const year = myDate.getFullYear();
    const firstJan = new Date(year, 0, 1);
    const differenceInMillieSeconds = myDate - firstJan;
    return (differenceInMillieSeconds / (1000 * 60 * 60 * 24) + 1);
};

const result = dayOfYear("2019-2-01");
console.log(result);

Answer 20

यह एक समाधान है जो परेशान करने वाले दिनांक ऑब्जेक्ट और टाइमज़ोन मुद्दों से बचा जाता है, इसके लिए आवश्यक है कि आपकी इनपुट तिथि "yyyy-dd-mm" प्रारूप में हो। यदि आप प्रारूप बदलना चाहते हैं, तो date_str_to_parts फ़ंक्शन को संशोधित करें:

    function get_day_of_year(str_date){
    var date_parts = date_str_to_parts(str_date);
    var is_leap = (date_parts.year%4)==0;
    var acct_for_leap = (is_leap && date_parts.month>2);
    var day_of_year = 0;

    var ary_months = [
        0,
        31, //jan
        28, //feb(non leap)
        31, //march
        30, //april
        31, //may
        30, //june
        31, //july
        31, //aug
        30, //sep
        31, //oct
        30, //nov   
        31  //dec
        ];


    for(var i=1; i < date_parts.month; i++){
        day_of_year += ary_months[i];
    }

    day_of_year += date_parts.date;

    if( acct_for_leap ) day_of_year+=1;

    return day_of_year;

}

function date_str_to_parts(str_date){
    return {
        "year":parseInt(str_date.substr(0,4),10),
        "month":parseInt(str_date.substr(5,2),10),
        "date":parseInt(str_date.substr(8,2),10)
    }
}

Answer 21

गणित को डेट फ़ंक्शंस के साथ मिलाते समय यह मुझे हमेशा चिंतित करता है (कुछ लीप वर्ष अन्य विवरण को याद करना बहुत आसान है)। आप कहें:

var d = new Date();

मैं निम्नलिखित का उपयोग करने का सुझाव दूंगा, दिनों में बचाया जाएगा day:

for(var day = d.getDate(); d.getMonth(); day += d.getDate())
    d.setDate(0);

कोई कारण नहीं देख सकता है कि यह ठीक काम नहीं करेगा (और मैं कुछ पुनरावृत्तियों के बारे में इतना चिंतित नहीं होगा क्योंकि यह इतनी तीव्रता से उपयोग नहीं किया जाएगा)।

Answer 22

/ * इस SCRIPT का उपयोग करें * /

var today = new Date();
var first = new Date(today.getFullYear(), 0, 1);
var theDay = Math.round(((today - first) / 1000 / 60 / 60 / 24) + .5, 0);
alert("Today is the " + theDay + (theDay == 1 ? "st" : (theDay == 2 ? "nd" : (theDay == 3 ? "rd" : "th"))) + " day of the year");