Javascript – krijg een reeks datums tussen 2 datums

Antwoord 14, autoriteit 2%

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"]

Antwoord 15

Ik gebruik deze functie

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

Antwoord 16

Je kunt het gemakkelijk doen met momentJS

Voeg een moment toe aan uw afhankelijkheden

npm i moment

Importeer dat dan in je bestand

var moment = require("moment");

Gebruik vervolgens de volgende code om de lijst met alle datums tussen twee datums te krijgen

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

Antwoord 17

d3jsbiedt veel handige functies en bevat d3.timevoor gemakkelijke datummanipulaties

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

Voor uw specifieke verzoek:

Utc

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

of lokale tijd

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

bereik is een reeks datumobjecten die voor elke dag op de eerst mogelijke waarde vallen

u kunt timeDay wijzigen in timeHour, timeMonth enz. voor dezelfde resultaten met verschillende tussenpozen

Antwoord 18

Hier is een one-liner die geen bibliotheken nodig heeft voor het geval je geen andere functie wilt creëren. Vervang gewoon startDate (op twee plaatsen) en endDate (dit zijn js-datumobjecten) door uw variabelen of datumwaarden. Natuurlijk kun je het in een functie verpakken als je dat liever hebt

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

Antwoord 19

Zo doe ik het graag

// hours * minutes * seconds * milliseconds
const DAY_IN_MS = 24 * 60 * 60 * 1000
/**
 * Get range of dates 
 * @param {Date} startDate 
 * @param {Number} numOfDays 
 * @returns {array}
 */
const dateRange = (startDate, numOfDays) => {
    const startDateMs = startDate.getTime()
    // get array of days and map it to Date object
    return [...Array(numOfDays).keys()].map(i => new Date(startDateMs + i * DAY_IN_MS))
}

Antwoord 20

Opmerking:ik ben me ervan bewust dat dit iets anders is dan de gevraagde oplossing, maar ik denk dat velen het nuttig zullen vinden.

Als je elke “x”-interval (dagen, maanden, jaren, enz…) tussen twee datums wilt vinden, moment .jsen de moment-rangeextensiepakketten maken deze functionaliteit mogelijk.

Bijvoorbeeld om elke 30e dag tussen twee datums te vinden:

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

Antwoord 21

@softvar’s oplossing, maar dan inclusief optie voor werkdatums

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

Antwoord 22

1. Genereer een reeks jaren:

   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. Genereer een array voor de maand:

          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. Genereer een array voor dagen:

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

Antwoord 23

Array(7).fill().map((_,i) => dayjs().subtract(i, "day").format("YYYY-MM-DD"));

Antwoord 24

Dat is nog een paar regels oplossing die date-fns bibliotheek gebruikt:

const { format, differenceInDays, addDays } = dateFns;
const getRangeDates = (startDate, endDate) => {
  const days = differenceInDays(endDate, startDate);
  console.log([...Array(days + 1).keys()].map((i) => format(addDays(startDate, i), 'YYYY-MM-DD')));
};
getRangeDates('2021-06-01', '2021-06-05');

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

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

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

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

const startDate = moment();
_.range(0, 7).map((d) => startDate.clone().add(d, 'day').toDate())

getDates = (from, to) => {
    const cFrom = new Date(from);
    const cTo = new Date(to);
    let daysArr = [new Date(cFrom)];
    let tempDate = cFrom;
    while (tempDate < cTo) {
        tempDate.setUTCDate(tempDate.getUTCDate() + 1);
        daysArr.push(new Date(tempDate));
    }
    return daysArr;
}

function datesArray(start, end) {
    let result = [], current = new Date(start);
    while (current <= end)
        result.push(current) && (current = new Date(current)) && current.setDate(current.getDate() + 1);
    return result;
}

function datesArray(start, end) {
    let result = [], current = new Date(start);
    while (current <= end)
        result.push(current) && (current = new Date(current)) && current.setDate(current.getDate() + 1);
    return result;
 }
//  Usage
const test = datesArray(
  new Date('2020-02-26'), 
  new Date('2020-03-05')
 );
for (let i = 0; i < test.length; i ++ ) {
    console.log(
      test[i].toISOString().slice(0,10)
    );
}