颤动: 查找两次约会之间的天数

可以使用 DateTime类提供的 difference方法

 //the birthday's date
final birthday = DateTime(1967, 10, 12);
final date2 = DateTime.now();
final difference = date2.difference(birthday).inDays;

更新

由于你们中的许多人报告说这个解决方案存在缺陷，为了避免更多的错误，我将在这里添加@MarcG 提出的正确解决方案，所有的荣誉归于他。

  int daysBetween(DateTime from, DateTime to) {
from = DateTime(from.year, from.month, from.day);
to = DateTime(to.year, to.month, to.day);
return (to.difference(from).inHours / 24).round();
}


//the birthday's date
final birthday = DateTime(1967, 10, 12);
final date2 = DateTime.now();
final difference = daysBetween(birthday, date2);

这是原来的答案与完整的解释: https://stackoverflow.com/a/67679455/666221

您可以使用 Datetime 类查找两年之间的差异，而无需使用 intl 格式化日期。

DateTime dob = DateTime.parse('1967-10-12');
Duration dur =  DateTime.now().difference(dob);
String differenceInYears = (dur.inDays/365).floor().toString();
return new Text(differenceInYears + ' years');

使用 DateTime 类查找两个日期之间的差异。

DateTime dateTimeCreatedAt = DateTime.parse('2019-9-11');
DateTime dateTimeNow = DateTime.now();
final differenceInDays = dateTimeNow.difference(dateTimeCreatedAt).inDays;
print('$differenceInDays');

或者

你可以使用 很快.Jiffy 是一个日期镖包，灵感来源于用于解析、操纵和格式化日期的 Momentjs。

例如: 1. 相对时间

Jiffy("2011-10-31", "yyyy-MM-dd").fromNow(); // 8 years ago
Jiffy("2012-06-20").fromNow(); // 7 years ago


var jiffy1 = Jiffy()
..startOf(Units.DAY);
jiffy1.fromNow(); // 19 hours ago


var jiffy2 = Jiffy()
..endOf(Units.DAY);
jiffy2.fromNow(); // in 5 hours


var jiffy3 = Jiffy()
..startOf(Units.HOUR);
jiffy3.fromNow();

2. 日期操作:

var jiffy1 = Jiffy()
..add(duration: Duration(days: 1));
jiffy1.yMMMMd; // October 20, 2019


var jiffy2 = Jiffy()
..subtract(days: 1);
jiffy2.yMMMMd; // October 18, 2019


//  You can chain methods by using Dart method cascading
var jiffy3 = Jiffy()
..add(hours: 3, days: 1)
..subtract(minutes: 30, months: 1);
jiffy3.yMMMMEEEEdjm; // Friday, September 20, 2019 9:50 PM


var jiffy4 = Jiffy()
..add(duration: Duration(days: 1, hours: 3))
..subtract(duration: Duration(minutes: 30));
jiffy4.format("dd/MM/yyy"); // 20/10/2019




// Months and year are added in respect to how many
// days there are in a months and if is a year is a leap year
Jiffy("2010/1/31", "yyyy-MM-dd"); // This is January 31
Jiffy([2010, 1, 31]).add(months: 1); // This is February 28

另一个也许更直观的选择是使用 Basics 软件包:

 // the birthday's date
final birthday = DateTime(1967, 10, 12);
final today = DateTime.now();
final difference = (today - birthday).inDays;

有关包的详细信息，请参阅: https://pub.dev/packages/basics

所有这些答案都遗漏了一个关键部分，那就是闰年。

下面是计算年龄的完美解决方案:

calculateAge(DateTime birthDate) {
DateTime currentDate = DateTime.now();
int age = currentDate.year - birthDate.year;
int month1 = currentDate.month;
int month2 = birthDate.month;
if (month2 > month1) {
age--;
} else if (month1 == month2) {
int day1 = currentDate.day;
int day2 = birthDate.day;
if (day2 > day1) {
age--;
}
}
return age;
}

日期时间延长

通过 extension课程，你可以:

int days = birthdate.daysSince;

示例 extension类:

extension DateTimeExt on DateTime {
int get daysSince => this.difference(DateTime.now()).inDays;
}

如果有人想找出秒，分钟，小时和天的不同形式。接下来是我的方法。

static String calculateTimeDifferenceBetween(
{@required DateTime startDate, @required DateTime endDate}) {
int seconds = endDate.difference(startDate).inSeconds;
if (seconds < 60)
return '$seconds second';
else if (seconds >= 60 && seconds < 3600)
return '${startDate.difference(endDate).inMinutes.abs()} minute';
else if (seconds >= 3600 && seconds < 86400)
return '${startDate.difference(endDate).inHours} hour';
else
return '${startDate.difference(endDate).inDays} day';
}

var start_date = "${DateTime.now()}";
var fulldate =start_date.split(" ")[0].split("-");
var year1 = int.parse(fulldate[0]);
var mon1 = int.parse(fulldate[1]);
var day1 = int.parse(fulldate[2]);
var date1 = (DateTime(year1,mon1,day1).millisecondsSinceEpoch);
var date2 = DateTime(2021,05,2).millisecondsSinceEpoch;
var Difference_In_Time = date2 - date1;
var Difference_In_Days = Difference_In_Time / (1000 * 3600 * 24);
print(Difference_In_Days); ```

小心选择答案的未来“错误”

在选定的答案中真正缺少的一点——大量奇怪的投票——是它将 计算两个日期之间的差额:

持续时间

这意味着，如果有小于24小时的差异，两个日期将被视为是相同的! ！这通常不是我们想要的行为。你可以通过稍微调整代码来解决这个问题，以便截断时钟:

Datetime from = DateTime(1987, 07, 11); // this one does not need to be converted, in this specific example, but we assume that the time was included in the datetime.
Datetime to = DateTime.now();


print(daysElapsedSince(from, to));


[...]


int daysElapsedSince(DateTime from, DateTime to) {
// get the difference in term of days, and not just a 24h difference
from = DateTime(from.year, from.month, from.day);
to = DateTime(to.year, to.month, to.day);
 

return to.difference(from).inDays;
}

因此，您可以检测 from是否在 to之前，因为它将返回一个正整数，表示在同一天发生的天数、负值和0的差值。

在 文件中指出这个函数返回什么，在许多情况下，如果按照原来选择的答案，它可能会导致一些难以调试的问题:

返回一个当从中减去其他 (来自)(到)时的持续时间差。

希望能有帮助。

接受的答案是错误的，不要使用它。

这是正确的:

int daysBetween(DateTime from, DateTime to) {
from = DateTime(from.year, from.month, from.day);
to = DateTime(to.year, to.month, to.day);
return (to.difference(from).inHours / 24).round();
}

测试:

DateTime date1 = DateTime.parse("2020-01-09 23:00:00.299871");
DateTime date2 = DateTime.parse("2020-01-10 00:00:00.299871");


expect(daysBetween(date1, date2), 1); // Works!

解释为什么公认的答案是错误的:

看看这个:

int daysBetween_wrong1(DateTime date1, DateTime date2) {
return date1.difference(date2).inDays;
}


DateTime date1 = DateTime.parse("2020-01-09 23:00:00.299871");
DateTime date2 = DateTime.parse("2020-01-10 00:00:00.299871");


// Should return 1, but returns 0.
expect(daysBetween_wrong1(date1, date2), 0);

注意: 由于夏令时的原因，你可以在某一天和第二天之间有23个小时的时差，即使你正常化为0:00。这就是为什么下面的内容也是不正确的:

// Fails, for example, when date2 was moved 1 hour before because of daylight savings.
int daysBetween_wrong2(DateTime date1, DateTime date2) {
from = DateTime(date1.year, date1.month, date1.day);
to = DateTime(date2.year, date2.month, date2.day);
return date2.difference(date1).inDays;
}

兰特: 如果你问我，飞镖 DateTime是非常糟糕的。它至少应该有像 daysBetween和时区处理等基本的东西。

更新: 包 https://pub.dev/packages/time_machine声称是 Noda Time 的一个端口。如果是这种情况，并且它被正确地移植(我还没有测试过它) ，那么这就是您可能应该使用的 Date/Time 包。

用 DateTime.difference天真地从一个 DateTime中减去另一个 DateTime是微妙的错误。正如 DateTime文件所解释的:

/// Returns the number of calendar days between [later] and [earlier], ignoring
/// time of day.
///
/// Returns a positive number if [later] occurs after [earlier].
int differenceInCalendarDays(DateTime later, DateTime earlier) {
// Normalize [DateTime] objects to UTC and to discard time information.
later = DateTime.utc(later.year, later.month, later.day);
earlier = DateTime.utc(earlier.year, earlier.month, earlier.day);


return later.difference(earlier).inDays;
}