Javascript - 获取两个日期之间的日期数组答案

【问题标题】：Javascript - get array of dates between 2 datesJavascript - 获取两个日期之间的日期数组
【发布时间】：2011-05-23 18:01:57
【问题描述】：

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

我希望“范围”是一个日期对象数组，两个日期之间的每一天都有一个。

诀窍在于它还应该处理月份和年份的界限。

【问题讨论】：

标签： javascript node.js date datetime date-range

【解决方案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;
}

这是一个函数demo http://jsfiddle.net/jfhartsock/cM3ZU/

【讨论】：

谢谢约翰。我主要使用你的，但是你有一个 byRef 错误，因为 currentDate 不能被推送到数组上，否则你最终会得到一个包含 n 个元素的数组，所有这些都是最后一个日期。将其更改为 currentDate = new Date(currentDate) 有效。
这对于未来的日期很好，但是当我在过去的日期工作时，比如 30 天前，我应该在哪里更改上面的代码以只获取日期而不是时间。
@vaibhavkulkarni 您可以简单地反转 addays() 原型并修改 while 循环。此外，cmets 不是提出新问题的地方。
我们是否应该更好地从startDate 和endDate 中删除时间？因为如果startDate的时间晚于stopDate的时间，那么结果中就不会包含stopDate，对吧？
@Hp93 不确定您在说什么。如果你运行我提供的小提琴，你会发现它涵盖了这种情况。

【解决方案2】：

我看了上面所有的。最后自己写了。 你不需要 momentjs 来做这个。 原生 for 循环就足够了，而且最有意义，因为存在 for 循环来计算范围内的值。

一个班轮：

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

【讨论】：

此函数操作源输入日期。 :) 我测试过了。
@HamedTaheri——是的，但这可以通过将 start 的副本分配给 dt 而不是 start 来解决本身，例如for (var arr=[], dt=new Date(start), ...)。 ;-)
当日期跨度发生时间变化时（例如从夏令时/DST 切换到标准时间），这将无法按预期工作。你最终会错过最后一天。可以通过专门设置时间来防止。
像魅力一样工作！不过，我会再做一个补充。 dt<=end 到 dt<=new Date(end)
它会为您返回 [] 吗？ ...您必须输入日期对象，例如比如new Date("2021-03-01") 不只是"2021-03-01" :-) 一开始我错过了这个

【解决方案3】：

试试这个，记得包含moment 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;
}

【讨论】：

只是一个小改进：推荐用于创建数组的简写符号var dateArray = []; 详情here
这是定义数组的新方法，我想它更短/更干净。
重要修复：var currentDate = moment(startDate); 如果您在同一个 moment.js 日期使用此方法两次，您会感到困惑，为什么它只是第一次起作用。发生这种情况是因为 javascripts 通过引用传递对象，因此函数最终使用 startDate 两次（它已经发生了变异）。修补上述修复可确保您在函数范围内使用新的和唯一的时刻 js 对象。检查这个fiddle
值得注意的是，不再推荐使用moment.js。该项目的开发已停止，但仍将进行维护，但维护人员建议寻找替代方案。
只是添加一个注释，当指定时间和日期时，这将无法正常工作。例如getDates('2021-01-01 23:00:00','2021-01-04 22:00:00')返回["2021-01-01", "2021-01-02", "2021-01-03"]，这不包括2021-01-04

【解决方案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/ 上运行这个

【讨论】：

我已经下载了与之相关的所有文件，但仍然显示错误 TypeError: moment.twix is not a function
您可能必须包含这些库。在 nodejs 中， var moment = require('moment');要求（'twix'）;
我认为您可以使用toArray() 而不是iterate() 来简化此操作：moment.twix(new Date('2012-01-15'),new Date('2012-01-20')).toArray("days"); isaaccambron.com/twix.js/docs.html#toarray

【解决方案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)

【讨论】：

为安全起见，与上述情况不同，您通常应选择一天中的时间，以避免因夏令时而略有变化。
我希望您也可以在代码中添加一天中的更改。

【解决方案6】：

如果您正在使用 moment，那么您可以使用他们的“官方插件”来获取范围 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')))

moment-range 浏览器示例：

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

&lt;script src="https://cdnjs.cloudflare.com/ajax/libs/date-fns/1.29.0/date_fns.min.js"&gt;&lt;/script&gt;

【讨论】：

date fns 从 // v2.0.0 开始有一个重大变化现在是 eachDayOfInterval( { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) })

【解决方案7】：

我在使用上面的答案时遇到了麻烦。由于当地夏令时 (DST) 导致的时区偏移，日期范围缺少单日。我使用 UTC 日期实现了一个版本来解决这个问题：

function dateRange(startDate, endDate, steps = 1) {
  const dateArray = [];
  let currentDate = new Date(startDate);

  while (currentDate <= new Date(endDate)) {
    dateArray.push(new Date(currentDate));
    // Use UTC date to prevent problems with time zones and DST
    currentDate.setUTCDate(currentDate.getUTCDate() + steps);
  }

  return dateArray;
}

const dates = dateRange('2020-09-27', '2020-10-28');
console.log(dates);

注意：是否应用某个时区或 DST，完全取决于您的locale。覆盖这通常不是一个好主意。使用UTC dates 可以缓解大部分时间相关的问题。

奖励：您可以使用可选的steps 参数设置要创建时间戳的时间间隔。如果您想将每周时间戳设置为 steps 到 7。

【讨论】：

谢谢你。它超级有用。在推入数组之前，我最终转换为 ISO 字符串。我可以看到自己将来会经常使用它。
这个是老大
新日期(currentDate).toString();可能会有所帮助。

【解决方案8】：

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;

}

【讨论】：

如果您以错误的顺序提供日期，这将冻结

【解决方案9】：

刚刚遇到这个问题，最简单的方法是使用时刻：

你需要先安装moment和moment-range：

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)

【讨论】：

【解决方案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));

【讨论】：

“优雅”取决于您的观点。 new Date(2017,12,30) 是 2018 年 1 月 30 日，对我来说，日期范围从 2018 年 1 月 29 日开始。并非所有的日子都是 8.64e7 毫秒（24 小时）长，可以观察到夏令时。 ;-)

【解决方案11】：

我最近在使用moment.js，以下是成功的方法..

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

【讨论】：

【解决方案12】：

我使用@Mohammed Safeer 解决方案已经有一段时间了，我做了一些改进。在控制器中工作时使用格式化日期是一种不好的做法。 moment().format() 应仅用于视图中的显示目的。还要记住moment().clone() 确保与输入参数分离，这意味着输入日期不会改变。我强烈建议您在处理日期时使用 moment.js。

用法：

提供 moment.js 日期作为 startDate、endDate 参数的值
interval 参数是可选的，默认为“天”。使用 .add() 方法 (moment.js) 支持的间隔。 More details here
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;
};

【讨论】：

【解决方案13】：

我正在使用简单的 while 循环来计算日期之间的时间

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

【讨论】：

完美运行

【解决方案14】：

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

【讨论】：

请添加更多描述和/或有关您的答案以及它如何解决所问问题的信息，以便其他人可以轻松理解它而无需要求澄清
我发现由于某种原因跳过了 2016-03-31！
在 while 循环中 strDate 之前不应该有 var！
对我来说就像魅力:)

【解决方案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;
}

【讨论】：

【解决方案16】：

你可以使用momentJS轻松做到这一点

为你的依赖添加时刻

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

【讨论】：

【解决方案17】：

d3js 提供了很多方便的功能，包括d3.time 方便日期操作

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

针对您的具体要求：

UTC

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

range 将是一个日期对象数组，它们位于每天的第一个可能值上

您可以将 timeDay 更改为 timeHour、timeMonth 等，以获得不同时间间隔的相同结果

【讨论】：

【解决方案18】：

这是一个不需要任何库的单行程序，以防您不想创建另一个函数。只需用您的变量或日期值替换 startDate （在两个地方）和 endDate （它们是 js 日期对象）。当然，如果您愿意，可以将其包装在一个函数中

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

【讨论】：

这没有考虑夏令时/标准节约时间的变化。有些日子更长，有些日子更短

【解决方案19】：

这就是我喜欢的方式

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

【讨论】：

【解决方案20】：

注意： 我知道这与请求的解决方案略有不同，但我认为很多人会发现它很有用。

如果您想查找两个日期之间的每个“x”间隔（天、月、年等），moment.js 和 moment-range 扩展包启用此功能。

例如，查找两个日期之间的每 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'))
});

【讨论】：

【解决方案21】：

@softvar 的解决方案，但随后包括工作日期选项

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

【讨论】：

【解决方案22】：

生成一个年份数组：

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

为月份生成一个数组：

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

为几天生成一个数组：

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

【讨论】：

【解决方案23】：

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

【讨论】：

好伙伴！仅供参考，您必须使用/安装 DayJs 依赖项。我在末尾添加了一个 .reverse() 以按升序获取日期！
谢谢，May 和 ThisIsMyName。我想知道其他人是如何做到这一点的。我所做的唯一真正的编辑是针对 ES6：[...Array(7)].map((_, i) => startOfWeek.add(i, 'day'))，其中 startOfWeek 是一个 dayjs 对象，例如dates.get(date).startOf('week').subtract(-1, 'week')

【解决方案24】：

这是另一个使用 date-fns 库的几行解决方案：

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

&lt;script src="https://cdnjs.cloudflare.com/ajax/libs/date-fns/1.30.1/date_fns.js"&gt;&lt;/script&gt;

【讨论】：

【解决方案25】：

这可能对某人有帮助，

您可以从中获取行输出并根据需要格式化 row_date 对象。

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

【讨论】：

【解决方案26】：

这是一个罐装方法，它将接受 Moment 日期或字符串或混合作为输入，并生成一个日期数组作为 Moment 日期。如果您不希望 Moment 日期作为输出，请更改 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'));
};

【讨论】：

【解决方案27】：

功能：

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

希望对你有帮助

【讨论】：

【解决方案28】：

使用 lodash 和矩：

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

【讨论】：

【解决方案29】：

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

【讨论】：

【解决方案30】：

不是最短，但简单、不可变且没有依赖关系

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

【讨论】：