जावास्क्रिप्ट - 2 तिथियों के बीच तारीखों की सरणी प्राप्त करें

Question

var range = getDates(new Date(), new Date().addDays(7));

मैं "ऑब्जेक्ट" को दिनांक ऑब्जेक्ट्स की एक सरणी होना चाहता हूं, जो दो तिथियों के बीच प्रत्येक दिन के लिए एक है।

चाल यह है कि इसे महीने और साल की सीमाओं को भी संभालना चाहिए।

Answer 1

Date.prototype.addDays = function(days) {
    var date = new Date(this.valueOf());
    date.setDate(date.getDate() + days);
    return date;
}

function getDates(startDate, stopDate) {
    var dateArray = new Array();
    var currentDate = startDate;
    while (currentDate <= stopDate) {
        dateArray.push(new Date (currentDate));
        currentDate = currentDate.addDays(1);
    }
    return dateArray;
}

यहाँ एक कार्यात्मक डेमो है http://jsfiddle.net/jfhartsock/cM3ZU/

Comments

धन्यवाद जॉन। मैंने ज्यादातर आपका उपयोग किया, लेकिन आपके पास एक बायरफ बग है, जिसमें करंटडेट को सरणी पर धकेला नहीं जा सकता है या आप अंतिम तत्वों के रूप में, सभी तत्वों के साथ समाप्त हो जाएंगे। इसे बदल कर currentDate = new Date (currentDate) काम करता है।

— स्कॉट कर्लेनबैक

यह भविष्य की तारीख के लिए ठीक है, लेकिन जब मैं पिछली तारीख पर 30 दिनों की तरह काम कर रहा हूं, तो मुझे केवल समय प्राप्त करने के लिए उपरोक्त कोड को कहां बदलना चाहिए।

— वैभव कुलकर्णी

@vaibhavkulkarni आप केवल जोड़ () प्रोटोटाइप को उल्टा कर सकते हैं और जबकि लूप को संशोधित कर सकते हैं। इसके अलावा, टिप्पणियां एक नए प्रश्न को शुरू करने का स्थान नहीं हैं।

— जॉन हार्टसॉक

क्या हमें बेहतर समय निकालना चाहिए startDateऔर endDate? क्योंकि अगर startDateसमय बाद के समय से अधिक है stopDate, तो यह stopDateपरिणाम में शामिल नहीं होगा , है ना?

— Hp93

@ Hp93 निश्चित रूप से आपके बारे में बात नहीं कर रहा है। यदि आप मेरे द्वारा प्रदान की जाने वाली फिडेल चलाते हैं तो आप देखेंगे कि यह उस स्थिति को कवर करती है।

— जॉन हार्टसॉक

Answer 2

इसे आज़माएं, क्षण js को शामिल करना याद रखें,

function getDates(startDate, stopDate) {
    var dateArray = [];
    var currentDate = moment(startDate);
    var stopDate = moment(stopDate);
    while (currentDate <= stopDate) {
        dateArray.push( moment(currentDate).format('YYYY-MM-DD') )
        currentDate = moment(currentDate).add(1, 'days');
    }
    return dateArray;
}

Comments

बस एक मामूली सुधार: ऐरे बनाने के लिए आशुलिपि संकेतन की सिफारिश की गई है यहांvar dateArray = []; विवरण

— एड्रियन मोइसा

यह सरणियों को परिभाषित करने का नया तरीका है, और मुझे लगता है कि यह छोटा / क्लीनर है।

— मोहम्मद सेफ़र

महत्वपूर्ण फिक्स : var currentDate = moment(startDate);यदि आप एक ही पल में दो बार इस पद्धति का उपयोग कर रहे हैं। जेएस की तारीखों से आप हैरान हो जाएंगे कि यह पहली बार क्यों काम करता है। ऐसा इसलिए होता है क्योंकि javascripts ऑब्जेक्ट्स को संदर्भ से गुजरता है इसलिए फ़ंक्शन दो बार स्टार्टडेट का उपयोग करके समाप्त होता है (जो पहले से ही उत्परिवर्तित है)। उपरोक्त फ़िक्स को पैच करना सुनिश्चित करता है कि आप फ़ंक्शन स्कोप में नए और अनूठे पल js ऑब्जेक्ट्स के साथ घूम रहे हैं। इस बेला की

— एड्रियन मोइसा

Answer 3

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

एक लाइन:

var getDaysArray = function(s,e) {for(var a=[],d=new Date(s);d<=e;d.setDate(d.getDate()+1)){ a.push(new Date(d));}return a;};

दीर्घ संस्करण

var getDaysArray = function(start, end) {
    for(var arr=[],dt=new Date(start); dt<=end; dt.setDate(dt.getDate()+1)){
        arr.push(new Date(dt));
    }
    return arr;
};

बीच में सूची दिनांक:

var daylist = getDaysArray(new Date("2018-05-01"),new Date("2018-07-01"));
daylist.map((v)=>v.toISOString().slice(0,10)).join("")
/*
Output: 
    "2018-05-01
    2018-05-02
    2018-05-03
    ...
    2018-06-30
    2018-07-01"
*/

अब तक की अंतिम तिथि से दिन:

var daylist = getDaysArray(new Date("2018-05-01"),new Date());
daylist.map((v)=>v.toISOString().slice(0,10)).join("")

Comments

यदि आप उन सभी दिनों को प्राप्त करना चाहते हैं जो आप में निर्दिष्ट हैं getDaysArray? इसके बीच के दिन नहीं।

— जोन्जी

धन्यवाद! वास्तव में मैं क्या कोई निर्भरता के साथ की जरूरत है। :)

— mpsyp

यह फ़ंक्शन स्रोत इनपुट दिनांक में हेरफेर करता है। :) मैंने इसका परीक्षण किया।

— ताहेरी

@ HamedTaheri-हाँ, लेकिन है कि की एक प्रति बताए द्वारा ठीक किया जा सकता शुरू करने के लिए डीटी के बजाय शुरू में ही है, जैसे for (var arr=[], dt=new Date(start), ...)। ;-)

— RobG

अच्छा काम कर रहा है, लेकिन बहुत बुरा है (;;) लूप सॉफ्टवेयर रखरखाव के लिए इतना पठनीय नहीं है जब आप बहुत से अन्य लोगों के साथ काम कर रहे हों।

— विक्टर

Answer 4

मैं moment.js और Twix.js का उपयोग करता हूं, वे तारीख और समय के हेरफेर के लिए एक बहुत बड़ा समर्थन प्रदान करते हैं

var itr = moment.twix(new Date('2012-01-15'),new Date('2012-01-20')).iterate("days");
var range=[];
while(itr.hasNext()){
    range.push(itr.next().toDate())
}
console.log(range);

मेरे पास यह http://jsfiddle.net/Lkzg1bxb/ पर चल रहा है

Comments

मेरे पास इससे संबंधित सभी फाइलें हैं, लेकिन फिर भी यह त्रुटि को दर्शाता है TypeError: moment.twix एक फ़ंक्शन नहीं है

— vaibhav kulkarni

आपको पुस्तकालयों को शामिल करना पड़ सकता है। नोडज में यह पसंद आता है, var क्षण = आवश्यकता ('क्षण'); की आवश्यकता होती है ( 'TWIX');

— डॉ। बल ध्वनिराज

Answer 5

var boxingDay = new Date("12/26/2010");
var nextWeek  = boxingDay*1 + 7*24*3600*1000;

function getDates( d1, d2 ){
  var oneDay = 24*3600*1000;
  for (var d=[],ms=d1*1,last=d2*1;ms<last;ms+=oneDay){
    d.push( new Date(ms) );
  }
  return d;
}

getDates( boxingDay, nextWeek ).join("\n");
// Sun Dec 26 2010 00:00:00 GMT-0700 (Mountain Standard Time)
// Mon Dec 27 2010 00:00:00 GMT-0700 (Mountain Standard Time)
// Tue Dec 28 2010 00:00:00 GMT-0700 (Mountain Standard Time)
// Wed Dec 29 2010 00:00:00 GMT-0700 (Mountain Standard Time)
// Thu Dec 30 2010 00:00:00 GMT-0700 (Mountain Standard Time)
// Fri Dec 31 2010 00:00:00 GMT-0700 (Mountain Standard Time)
// Sat Jan 01 2011 00:00:00 GMT-0700 (Mountain Standard Time)

Comments

सुरक्षित होने के लिए, उपरोक्त के विपरीत, आपको दिन के समय में थोड़ी बचत से बचने के लिए दिन के मध्य में समय चुनना चाहिए।

— १३:१४ पर फ्रॉग्ज

काश, आप दिन के मध्य को भी कोड में बदल देते।

— मुर्गियां

Answer 6

function (startDate, endDate, addFn, interval) {

 addFn = addFn || Date.prototype.addDays;
 interval = interval || 1;

 var retVal = [];
 var current = new Date(startDate);

 while (current <= endDate) {
  retVal.push(new Date(current));
  current = addFn.call(current, interval);
 }

 return retVal;

}

Comments

यदि आप गलत क्रम में दिनांक प्रदान करते हैं, तो यह स्थिर हो जाएगा

— pie6k

Answer 7

यदि आप क्षण का उपयोग कर रहे हैं तो आप रेंज के लिए उनके "आधिकारिक प्लगइन" का उपयोग कर सकते हैं moment-rangeऔर फिर यह तुच्छ हो जाता है।

क्षण-सीमा नोड उदाहरण:

const Moment = require('moment');
const MomentRange = require('moment-range');
const moment = MomentRange.extendMoment(Moment);

const start = new Date("11/30/2018"), end = new Date("09/30/2019")
const range = moment.range(moment(start), moment(end));

console.log(Array.from(range.by('day')))

पल-सीमा ब्राउज़र उदाहरण:

window['moment-range'].extendMoment(moment);

const start = new Date("11/30/2018"), end = new Date("09/30/2019")
const range = moment.range(moment(start), moment(end));

console.log(Array.from(range.by('day')))

<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.22.2/moment.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/moment-range/4.0.1/moment-range.js"></script>

दिनांक fns उदाहरण:

यदि आप उपयोग कर रहे हैं date-fnsतो eachDayआपका मित्र है और आपको सबसे छोटा और सबसे संक्षिप्त उत्तर मिलता है:

console.log(dateFns.eachDay(
  new Date(2018, 11, 30),
  new Date(2019, 30, 09)
))

<script src="https://cdnjs.cloudflare.com/ajax/libs/date-fns/1.29.0/date_fns.min.js"></script>

Answer 8

बस इस सवाल का सामना करना पड़ा, ऐसा करने का सबसे आसान तरीका पल का उपयोग कर रहा है:

आपको पहले क्षण और क्षण-सीमा स्थापित करने की आवश्यकता है:

const Moment = require('moment');
const MomentRange = require('moment-range');
const moment = MomentRange.extendMoment(Moment);

const start = moment()
const end = moment().add(2, 'months')
const range = moment.range(start, end)
const arrayOfDates = Array.from(range.by('days'))
console.log(arrayOfDates)

Answer 9

मैं थोड़ी देर के लिए @ मोहम्मद सुरक्षित समाधान का उपयोग कर रहा हूं और मैंने कुछ सुधार किए हैं। अपने नियंत्रकों में काम करते समय तैयार तिथियों का उपयोग करना एक बुरा अभ्यास है। moment().format()केवल विचारों में प्रदर्शन प्रयोजनों के लिए उपयोग किया जाना चाहिए। यह भी याद रखें कि moment().clone()इनपुट मापदंडों से अलगाव सुनिश्चित करता है, जिसका अर्थ है कि इनपुट तिथियों में बदलाव नहीं किया गया है। मैं आपको तारीखों के साथ काम करते समय क्षणों का उपयोग करने के लिए दृढ़ता से प्रोत्साहित करता हूं।

उपयोग:

• के लिए मूल्यों के रूप में moment.js दिनांकों प्रदान करें startDate, endDateपैरामीटर
• intervalपैरामीटर वैकल्पिक है और 'दिन' के लिए चूक है। .add()विधि (क्षण.जै।) द्वारा अंतराल का प्रयोग करें । अधिक जानकारी यहाँ
• totalपैरामीटर उपयोगी है जब अंतराल को मिनटों में निर्दिष्ट करना। यह 1 को डिफॉल्ट करता है।

आह्वान:

var startDate = moment(),
    endDate = moment().add(1, 'days');

getDatesRangeArray(startDate, endDate, 'minutes', 30);

समारोह:

var getDatesRangeArray = function (startDate, endDate, interval, total) {
    var config = {
            interval: interval || 'days',
            total: total || 1
        },
        dateArray = [],
        currentDate = startDate.clone();

    while (currentDate < endDate) {
        dateArray.push(currentDate);
        currentDate = currentDate.clone().add(config.total, config.interval);
    }

    return dateArray;
};

Answer 10

ES6 का उपयोग करके आपके पास Array.from है जिसका अर्थ है कि आप एक बहुत ही सुंदर फ़ंक्शन लिख सकते हैं, जो गतिशील अंतराल (घंटे, दिन, महीने) के लिए अनुमति देता है।

function getDates(startDate, endDate, interval) {
const duration = endDate - startDate;
const steps = duration / interval;
return Array.from({length: steps+1}, (v,i) => new Date(startDate.valueOf() + (interval * i)));
}
const startDate = new Date(2017,12,30);
const endDate = new Date(2018,1,3);
const dayInterval = 1000 * 60 * 60 * 24; // 1 day
const halfDayInterval = 1000 * 60 * 60 * 12; // 1/2 day

console.log("Days", getDates(startDate, endDate, dayInterval));
console.log("Half Days", getDates(startDate, endDate, halfDayInterval));

Comments

"सुरुचिपूर्ण" आपकी बात पर निर्भर करता है। new Date(2017,12,30)30 जनवरी 2018 है, मेरे लिए तिथि सीमा 29 जनवरी 2018 से शुरू होती है। सभी दिन 8.64e7 एमएस (24 घंटे) नहीं हैं, जहां दिन के उजाले की बचत होती है। ;-)

— RobG

Answer 11

मैं हाल ही में क्षण के साथ काम कर रहा था।

function getDateRange(startDate, endDate, dateFormat) {
        var dates = [],
            end = moment(endDate),
            diff = endDate.diff(startDate, 'days');

        if(!startDate.isValid() || !endDate.isValid() || diff <= 0) {
            return;
        }

        for(var i = 0; i < diff; i++) {
            dates.push(end.subtract(1,'d').format(dateFormat));
        }

        return dates;
    };
    console.log(getDateRange(startDate, endDate, dateFormat));

परिणाम होगा:

["09/03/2015", "10/03/2015", "11/03/2015", "12/03/2015", "13/03/2015", "14/03/2015", "15/03/2015", "16/03/2015", "17/03/2015", "18/03/2015"]

Answer 12

var listDate = [];
var startDate ='2017-02-01';
var endDate = '2017-02-10';
var dateMove = new Date(startDate);
var strDate = startDate;

while (strDate < endDate){
  var strDate = dateMove.toISOString().slice(0,10);
  listDate.push(strDate);
  dateMove.setDate(dateMove.getDate()+1);
};
console.log(listDate);

//["2017-02-01", "2017-02-02", "2017-02-03", "2017-02-04", "2017-02-05", "2017-02-06", "2017-02-07", "2017-02-08", "2017-02-09", "2017-02-10"]

Comments

कृपया अपने उत्तर के बारे में अधिक विवरण और / या जानकारी जोड़ें और यह पूछे जाने वाली समस्या को कैसे हल करता है, ताकि अन्य लोग इसे आसानी से बिना स्पष्टीकरण के समझ सकें

— koceeng

मुझे लगता है कि यह किसी कारण से 2016-03-31 को छोड़ रहा है!

— वुडहेड92

जबकि लूप के अंदर आपको varपहले नहीं होना चाहिए strDate!

— बोरिस याकूबचिक

Answer 13

d3js बहुत सारे काम करता है और इसमें आसान तारीख में हेरफेर के लिए d3.time भी शामिल है

https://github.com/d3/d3-time

आपके विशिष्ट अनुरोध के लिए:

यु.टी. सी

var range = d3.utcDay.range(new Date(), d3.utcDay.offset(new Date(), 7));

या स्थानीय समय

var range = d3.timeDay.range(new Date(), d3.timeDay.offset(new Date(), 7));

रेंज एक ऐसी दिनांक ऑब्जेक्ट होगी, जो प्रत्येक दिन के लिए पहले संभावित मान पर आती है

आप अलग-अलग अंतराल पर समान परिणामों के लिए समय-समय, समय-समय, महीने आदि बदल सकते हैं

Answer 14

यहां एक लाइनर है जिसे किसी भी लाइब्रेरी की आवश्यकता नहीं है-यदि आप कोई अन्य फ़ंक्शन नहीं बनाना चाहते हैं। बस प्रारंभ (दो स्थानों में) को बदलें और अपने चर या तिथि मानों के साथ अंत करें (जो js दिनांक ऑब्जेक्ट हैं)। यदि आप चाहें तो निश्चित रूप से आप इसे एक फ़ंक्शन में लपेट सकते हैं

Array(Math.floor((endDate - startDate) / 86400000) + 1).fill().map((_, idx) => (new Date(startDate.getTime() + idx * 86400000)))

Comments

यह ध्यान में नहीं रखता है डेलाइट / स्टैंडर्ड सेविंग टाइम में बदलाव होता है .. कुछ दिन लंबे होते हैं और कुछ कम होते हैं

— माइक

Answer 15

मैं इस फ़ंक्शन का उपयोग करता हूं

function getDatesRange(startDate, stopDate) {
    const ONE_DAY = 24*3600*1000;
    var days= [];
    var currentDate = new Date(startDate);
    while (currentDate <= stopDate) {
        days.push(new Date (currentDate));
        currentDate = currentDate - 1 + 1 + ONE_DAY;
    }
    return days;
}

Answer 16

मैं सरल का उपयोग कर रहा हूँ, जबकि लूप के बीच की तारीखों की गणना करने के लिए

var start = new Date("01/05/2017");
var end = new Date("06/30/2017");
var newend = end.setDate(end.getDate()+1);
end = new Date(newend);
while(start < end){
   console.log(new Date(start).getTime() / 1000); // unix timestamp format
   console.log(start); // ISO Date format          
   var newDate = start.setDate(start.getDate() + 1);
   start = new Date(newDate);
}

Answer 17

नोट: मुझे पता है कि यह अनुरोधित समाधान से थोड़ा अलग है, लेकिन मुझे लगता है कि कई इसे उपयोगी पाएंगे।

आप दो तिथियों के बीच प्रत्येक "x" अंतराल (दिन, महीने, साल, आदि ...) जानना चाहते हैं तो moment.js और पल दूरी एक्सटेंशन पैकेज इस कार्यक्षमता को सक्षम करते हैं।

उदाहरण के लिए, दो तारीखों के बीच प्रत्येक 30 वें दिन को खोजने के लिए :

window['moment-range'].extendMoment(moment);

var dateString = "2018-05-12 17:32:34.874-08";
var start  = new Date(dateString);
var end    = new Date();
var range1 = moment.range(start, end);
var arrayOfIntervalDates = Array.from(range1.by('day', { step: 30 }));

arrayOfIntervalDates.map(function(intervalDate){
  console.log(intervalDate.format('YY-M-DD'))
});

Answer 18

1. वर्षों की एक सरणी उत्पन्न करें:

   const DAYS = () => {
    const days = []
    const dateStart = moment()
    const dateEnd = moment().add(30, ‘days')
    while (dateEnd.diff(dateStart, ‘days') >= 0) {
     days.push(dateStart.format(‘D'))
     dateStart.add(1, ‘days')
    }
    return days
   }
   console.log(DAYS())

2. महीने के लिए एक सरणियाँ बनाएं:

           const MONTHS = () => {
            const months = []
            const dateStart = moment()
            const dateEnd = moment().add(12, ‘month')
            while (dateEnd.diff(dateStart, ‘months') >= 0) {
             months.push(dateStart.format(‘M'))
             dateStart.add(1, ‘month')
            }
            return months
           }
           console.log(MONTHS())

3. दिनों के लिए एक सरणियाँ बनाएँ:

           const DAYS = () => {
            const days = []
            const dateStart = moment()
            const dateEnd = moment().add(30, ‘days')
            while (dateEnd.diff(dateStart, ‘days') >= 0) {
             days.push(dateStart.format(‘D'))
             dateStart.add(1, ‘days')
            }
            return days
           }
           console.log(DAYS())

Answer 19

आप इसे पल-पल का उपयोग करके आसानी से कर सकते हैं

अपनी निर्भरता में पल जोड़ें

npm i moment

फिर इसे अपनी फ़ाइल में आयात करें

var moment = require("moment");

फिर दो तिथियों के बीच सभी तिथियों की सूची प्राप्त करने के लिए निम्न कोड का उपयोग करें

let dates = [];
let currDate = moment.utc(new Date("06/30/2019")).startOf("day");
let lastDate = moment.utc(new Date("07/30/2019")).startOf("day");

do {
 dates.push(currDate.clone().toDate());
} while (currDate.add(1, "days").diff(lastDate) < 0);
dates.push(currDate.clone().toDate());

console.log(dates);

Answer 20

यह किसी की मदद कर सकता है,

आप इससे पंक्ति आउटपुट प्राप्त कर सकते हैं और पंक्ति_डेट ऑब्जेक्ट को स्वरूपित कर सकते हैं जैसा आप चाहते हैं।

var from_date = '2016-01-01';
var to_date = '2016-02-20';

var dates = getDates(from_date, to_date);

console.log(dates);

function getDates(from_date, to_date) {
  var current_date = new Date(from_date);
  var end_date     = new Date(to_date);

  var getTimeDiff = Math.abs(current_date.getTime() - end_date.getTime());
  var date_range = Math.ceil(getTimeDiff / (1000 * 3600 * 24)) + 1 ;

  var weekday = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"];
  var months = ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"];
  var dates = new Array();

  for (var i = 0; i <= date_range; i++) {
     var getDate, getMonth = '';

     if(current_date.getDate() < 10) { getDate = ('0'+ current_date.getDate());}
     else{getDate = current_date.getDate();}

    if(current_date.getMonth() < 9) { getMonth = ('0'+ (current_date.getMonth()+1));}
    else{getMonth = current_date.getMonth();}

    var row_date = {day: getDate, month: getMonth, year: current_date.getFullYear()};
    var fmt_date = {weekDay: weekday[current_date.getDay()], date: getDate, month: months[current_date.getMonth()]};
    var is_weekend = false;
    if (current_date.getDay() == 0 || current_date.getDay() == 6) {
        is_weekend = true;
    }
    dates.push({row_date: row_date, fmt_date: fmt_date, is_weekend: is_weekend});
    current_date.setDate(current_date.getDate() + 1);
 }
 return dates;
}

https://gist.github.com/pranid/3c78f36253cbbc6a41a859c5d718f362.js

Answer 21

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

const moment = require('moment');

// ...

/**
 * @param {string|import('moment').Moment} start
 * @param {string|import('moment').Moment} end
 * @returns {import('moment').Moment[]}
 */
const getDateRange = (start, end) => {
  const s = moment.isMoment(start) ? start : moment(start);
  const e = moment.isMoment(end) ? end : moment(end);
  return [...Array(1 + e.diff(s, 'days')).keys()].map(n => moment(s).add(n, 'days'));
};

Answer 22

@ सॉफ्टवेअर का समाधान, लेकिन फिर काम की तारीखों के विकल्प सहित

/**
 * Returns array of working days between two dates.
 *
 * @param {string} startDate
 *   The start date in yyyy-mm-dd format.
 * @param {string} endDate
 *   The end date in yyyy-mm-dd format.
 * @param {boolean} onlyWorkingDays
 *   If true only working days are returned. Default: false
 *
 * @return {array}
 *   Array of dates in yyyy-mm-dd string format.
 */
function getDates(startDate, stopDate, onlyWorkingDays) {
  let doWd = typeof onlyWorkingDays ==='undefined' ? false : onlyWorkingDays;

  let dateArray = [];  
  let dayNr;
  let runDateObj = moment(startDate);  
  let stopDateObj = moment(stopDate);

  while (runDateObj <= stopDateObj) {
    dayNr = runDateObj.day();
    if (!doWd || (dayNr>0 && dayNr<6)) {
     dateArray.push(moment(runDateObj).format('YYYY-MM-DD'));  
    }

    runDateObj = moment(runDateObj).add(1, 'days');
  }
  return dateArray;
}

Answer 23

समारोह:

  var dates = [],
      currentDate = startDate,
      addDays = function(days) {
        var date = new Date(this.valueOf());
        date.setDate(date.getDate() + days);
        return date;
      };
  while (currentDate <= endDate) {
    dates.push(currentDate);
    currentDate = addDays.call(currentDate, 1);
  }
  return dates;
};

उपयोग:

var dates = getDatesRange(new Date(2019,01,01), new Date(2019,01,25));                                                                                                           
dates.forEach(function(date) {
  console.log(date);
});

आशा है कि यह आपकी मदद करता है