Display relative time in hour, day, month and year
I wrote a function
toBeautyString(epoch) : String
which given a epoch , return a string which will display the relative time from now in hour and minute
For instance:
// epoch: 1346140800 -> Tue, 28 Aug 2012 05:00:00 GMT
// and now: 1346313600 -> Thu, 30 Aug 2012 08:00:00 GMT
toBeautyString(1346140800)
-> "2 days and 3 hours ago"
I want now to extend this function to month and year, so it will be able to print:
2 years, 1 month, 3 days and 1 hour ago
Only with epoch without any external libraries. The purpose of this function is to give to the user a better way to visualize the time in the past.
I found this: Calculate relative time in C# but the granularity is not enough.
function toBeautyString(epochNow, epochNow){
var secDiff = Math.abs(epochNow - epochNow);
var milliInDay = 1000 * 60 * 60 * 24;
var milliInHour = 1000 * 60 * 60;
var nbDays = Math.round(secDiff/milliInDay);
var nbHour = Math.round(secDiff/milliInHour);
var relativeHour = (nbDays === 0) ? nbHour : nbHour-(nbDays*24);
relativeHour %= 24;
if(nbHour === 0){
nbDays += 1;
}else if(nbHour === (nbDays-1)*24){
nbDays -= 1;
}
var dayS = (nbDays > 1) ? "days" : "day";
var hourS = (relativeHour > 1) ? "hours" : "hour";
var fullString = "";
if(nbDays > 0){
fullString += nbDays + " " + dayS;
if(relativeHour > 0)
fullString += " ";
}
if(relativeHour > 0){
fullString += relativeHour + " " + hourS;
}
if(epochDate > epochNow){
return "Will be in " + fullString;
}else if ((epochDate === epochNow)
|| (relativeHour === 0 && nbDays === 0)){
return "Now";
}else{
return fullString + " ago";
}
}
It's helpful to recognize this as two distinct problems: 1) slicing the time into individual chunks of varying units; 2) formatting the chunks and joining them together with your choice of commas, conjunctions, etc. That way, you keep your text formatting logic separate from your time calculation logic.
#converts a time amount into a collection of time amounts of varying size.
#`increments` is a list that expresses the ratio of successive time units
#ex. If you want to split a time into days, hours, minutes, and seconds,
#increments should be [24,60,60]
#because there are 24 hours in a day, 60 minutes in an hour, etc.
#as an example, divideTime(100000, [24,60,60]) returns [1,3,46,40],
#which is equivalent to 1 day, 3 hours, 46 minutes, 40 seconds
def divideTime(amount, increments):
#base case: there's no increments, so no conversion is necessary
if len(increments) == 0:
return [amount]
#in all other cases, we slice a bit off of `amount`,
#give it to the smallest increment,
#convert the rest of `amount` into the next largest unit,
#and solve the rest with a recursive call.
else:
conversionRate = increments[-1]
smallestIncrement = amount % conversionRate
rest = divideTime(amount / conversionRate, increments[:-1])
return rest + [smallestIncrement]
def beautifulTime(amount):
names = ["year", "month", "day", "hour", "minute", "second"]
increments = [12, 30, 24, 60, 60]
ret = []
times = divideTime(amount, increments)
for i in range(len(names)):
time = times[i]
name = names[i]
#don't display the unit if the time is zero
#e.g. we prefer "1 year 1 second" to
#"1 year 0 months 0 days 0 hours 0 minutes 1 second"
if time == 0:
continue
#pluralize name if appropriate
if time != 1:
name = name + "s"
ret.append(str(time) + " " + name)
#there's only one unit worth mentioning, so just return it
if len(ret) == 1:
return ret[0]
#when there are two units, we don't need a comma
if len(ret) == 2:
return "{0} and {1}".format(ret[0], ret[1])
#for all other cases, we want a comma and an "and" before the last unit
ret[-1] = "and " + ret[-1]
return ", ".join(ret)
print beautifulTime(100000000)
#output: 3 years, 2 months, 17 days, 9 hours, 46 minutes, and 40 seconds
This solution is somewhat inaccurate with regards to real-life years because it assumes a year is made up of 12 months, each 30 days long. This is a necessary abstraction, or otherwise you'd have to factor in varying month lengths and leap days and daylight savings time, etc etc etc. With this method, you'll lose about 3.75 days per year, which isn't so bad if you're only using it to visualize the magnitude of time spans.
您可以使用.NET时间库中的类DateDiff来显示相对时间：
// ----------------------------------------------------------------------
public void DateDiffSample( DateTime epoch )
{
DateDiff dateDiff = new DateDiff( DateTime.Now, epoch );
Console.WriteLine( "{0} ago", dateDiff.GetDescription( 4 ) );
// > 1 Year 4 Months 12 Days 12 Hours ago
} // DateDiffSample
As exhaustively discussed in other answers, your code can't easily be extended because of the variable month lengths. So one simply can't assume the month to be 30 days.
In order to have a human-readable difference, you must subtract from the human-readable dates.
I'd do it like this (JavaScript, to match the question):
function toBeautyString(then) {
var nowdate = new Date();
var thendate = new Date(then * 1000);
//finding the human-readable components of the date.
var y = nowdate.getFullYear() - thendate.getFullYear();
var m = nowdate.getMonth() - thendate.getMonth();
var d = nowdate.getDate() - thendate.getDate();
var h = nowdate.getHours() - thendate.getHours();
var mm = nowdate.getMinutes() - thendate.getMinutes();
var s = nowdate.getSeconds() - thendate.getSeconds();
//back to second grade math, now we must now 'borrow'.
if(s < 0) {
s += 60;
mm--;
}
if(mm < 0) {
mm += 60;
h--;
}
if(h < 0) {
h += 24;
d--;
}
if(d < 0) {
//here's where we take into account variable month lengths.
var a = thendate.getMonth();
var b;
if(a <= 6) {
if(a == 1) b = 28;
else if(a % 2 == 0) b = 31;
else b = 30;
}
else if(b % 2 == 0) b = 30;
else b = 31;
d += b;
m--;
}
if(m < 0) {
m += 12;
y--;
}
//return "y years, m months, d days, h hours, mm minutes and s seconds ago."
}
The code works by subtracting from the human-readable dates (obtained using the in-built javascript commands). The only work left is to ensure that any borrowing over proceeds smoothly. This is easy, except in the case where you're borrowing from the months, because months have variable length.
Say you're subtracting 25th February from 12th April.
Before borrowing takes place, m = 2 and d = -13 . Now, when you borrow from m , m = 1 , but you need to ensure that d increases by 28, as you are borrowing across February. The final result is 1 month, 15 days ago.
If you were subtracting 25th July from 12th September, the result would be 1 month, 18 days ago.
The only thing the code above does not provide for is leap years. This is easily extendable: you simply need to take into account the year and adjust by the one necessary if you're borrowing over February.
链接地址: http://www.djcxy.com/p/63064.html上一篇: EF4代码优先+ SQL Server CE：自动保存双向引用
下一篇: 以小时，天，月和年显示相对时间