我有一个包含天数的数组。每一天都是一个对象，例如:

{day_year: "2012", day_month: "08", day_number: "03", day_name: "mon"}

我还为每一天对象添加了时间戳属性，方法是:

function convertDays() {
    var max_i = days.length;
    for(var i = 0; i < max_i; i++) {
        var tar_i = days[i];
        tar_i.timestamp = new Date(tar_i.day_year, tar_i.day_month, tar_i.day_number);
    }
}

数组中的天数是任意的，因此没有真正的逻辑。

现在我想找到离任何给定日期最近的两天。因此，如果带有天数的数组包含

• 2012 年 8 月 2 日
• 2012 年 8 月 4 日
• 2012 年 8 月 23 日

我搜索 2012 年 8 月 11 日，我希望它返回 2012 年 8 月 4 日和 2012 年 8 月 23 日。

我试过使用另一个问题的答案，看起来像这样:

function findClosest(a, x) {
    var lo, hi;
    for(var i = a.length; i--;) {
        if(a[i] <= x && (lo === undefined || lo < a[i])) lo = a[i];
        if(a[i] >= x && (hi === undefined || hi > a[i])) hi = a[i];
    }
    return [lo, hi];
}

但是，这会返回 unidentified。

实现此目标的最有效(处理器/内存密集度最低的方法)是什么？

编辑:“但是，这些结果如何“奇怪”？您能否提供您的代码和数据的示例？”

我现在使用以下方法生成日期数组:

var full_day_array = [];
for(var i = 0; i < 10; i++) {
    var d = new Date();
    d.setDate(d.getDate() + i);
    full_day_array.push({day_year: d.getFullYear().toString(), day_month: (d.getMonth() + 1).toString(), day_number: d.getDate().toString()});
}

奇怪的是，使用下面的代码，这只适用于包含 10 个或更短日期的数组。每当我使用包含 11 个或更多日期的数组时，结果就会变得出乎意料。

例如:使用包含 15 个日期的数组，从 2012 年 8 月 6 日到 2012 年 8 月 21 日。如果我随后调用 findClosest(full_day_array, new Date("30/07/2012"); 你会期望它返回 {nextIndex: 0, prevIndex: -1}。但是，它返回 {nextIndex: 7, prevIndex: -1}。为什么？

function findClosest(objects, testDate) {
    var nextDateIndexesByDiff = [],
        prevDateIndexesByDiff = [];

    for(var i = 0; i < objects.length; i++) {
        var thisDateStr = [objects[i].day_month, objects[i].day_number, objects[i].day_year].join('/'),
            thisDate    = new Date(thisDateStr),
            curDiff     = testDate - thisDate;

        curDiff < 0
            ? nextDateIndexesByDiff.push([i, curDiff])
            : prevDateIndexesByDiff.push([i, curDiff]);
    }

    nextDateIndexesByDiff.sort(function(a, b) { return a[1] < b[1]; });
    prevDateIndexesByDiff.sort(function(a, b) { return a[1] > b[1]; });


    var nextIndex;
    var prevIndex;

    if(nextDateIndexesByDiff.length < 1) {
        nextIndex = -1;
    } else {
        nextIndex = nextDateIndexesByDiff[0][0];
    }
    if(prevDateIndexesByDiff.length < 1) {
        prevIndex = -1;
    } else {    
        prevIndex = prevDateIndexesByDiff[0][0];
    }
    return {nextIndex: nextIndex, prevIndex: prevIndex};
}

最佳答案

您可以轻松使用 sort function具有自定义比较器功能:

// assuming you have an array of Date objects - everything else is crap:
var arr = [new Date(2012, 7, 1), new Date(2012, 7, 4), new Date(2012, 7, 5), new Date(2013, 2, 20)];
var diffdate = new Date(2012, 7, 11);

arr.sort(function(a, b) {
    var distancea = Math.abs(diffdate - a);
    var distanceb = Math.abs(diffdate - b);
    return distancea - distanceb; // sort a before b when the distance is smaller
});

// result:
[2012-08-05, 2012-08-04, 2012-08-01, 2013-03-20]

要仅获取 diffdate 之前或之后的结果，您可以 filter数组:

var beforedates = arr.filter(function(d) {
    return d - diffdate < 0;
}),
    afterdates = arr.filter(function(d) {
    return d - diffdate > 0;
});

如果您的自定义数组包含 {the_date_object: new Date(...)} 对象，则需要调整排序算法

    var distancea = Math.abs(diffdate - a.the_date_object);
    var distanceb = Math.abs(diffdate - b.the_date_object);

关于javascript - 使用 JavaScript 在数组中查找最近的日期，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/11795266/