Date math in Linux shell script?

In a former job I once wrote scripts that did date arithmetic entirely in Korn shell, and I expect the method would translate into other shell languages as well. I no longer have access to the scripts and no convenient access to a Unix/Linux system to reconstruct them, but I will describe the method and leave the details up to the reader. This requires an understanding of certain facts about Unix (about shells, actually) and the "date" command.

First, the "date" command computes the human-readable date output based on the timezone specified in the environment (something like TZ= or TIMEZONE=). You can see which your system uses by looking in /etc/TIMEZONE or the like.

Second, the TZ= (or whatever) variable supports different formats for the timezone, including the ability to specify positive or negative offsets from some timezone (something like EDT-1 or GMT+6).

Third, you may already have realized that if the displacement is a multiple of 24 hours, then the date can be shifted by that number of days.

Next, it is very easy to specify a change in a command's environment only for the duration of the command. When used with the "date" command, this allows you to change the timezone of the date returned; for example, "TZ=$TZ-2 date" (or the like; ignore the quotes) will show you the date and time two hours displaced.

Finally, shells can do arithmetic. Dumb old shells use the "expr" command, newer ones do it directly. I like the Korn shell method. So to pull it all together, if you treat the following as metacode and not gospel, something like this should work for you:

OFFSET_DATE=$(TZ=$TZ+$((TZ * 24)) date)

Of course you can use the entire range of "date" command options to pull out any particular item of a date you wish. And if you really like a challenge, you can even control the date shift down to the minute or second, allowing you to force outputs for some particular time of day, say noon for example. Have fun and happy scripting!

Sorry, that example should have been:

OFFSET_DATE=$(TZ=$TZ+$((DAYS * 24)) date)

The offset can be positive or negative. The $(...) is command substitution and the $((...)) is arithmetic substitution. You may have to quote the asterisk.

Try running these, see what you get:
date -d "-1 day"
date -d "+1 day"
date -d "1 year"

Thanks, Peter, but realize that what you're referencing isn't a flag that's available in all versions of Unix / Linux...

The following code will convert any given date to any offset using only GNU compliant ksh (e.g. bash) script tools.

Note: This is not 100% Unix portable since it only works if the date supports the non-RFC compliant “–d” option. GNU does (i.e. Linux) but I doubt it will work on older HP-UX or Solaris systems (but hey, try it and see -- ymmv)

The basic algorithm uses the fact that the ‘date’ command can output the “seconds since epoch” as well as be provided a date other than “now” with the –d option (see above disclaimer). So, if we give it a specific date, and request the output in %s we get the “seconds since the epoch” for the date we’ve supplied. Now, we apply our offset (+ or -) and resubmit the date command with the modified epoch time.

----- Start of Script -----

#!/bin/bash

# The date we want to convert
# can be any valid date format - I like this one myself
ORIGINAL_DATE="20060401"

# provide the original date instead of "now" and ask for "seconds since epoch"
ORIGINAL_EPOCH=$(date -d "${ORIGINAL_DATE}" "+%s")

# Now apply our offset, in this example we subtract 1 day
# Remember that $((.)) does arithmetic in bash (aka ksh)
# and can be nested. *hug gnu*
NEW_EPOCH=$((${ORIGINAL_EPOCH} - $((60 * 60 * 24))))

# We now have our target date in EPOCH format, we need to get it back to our
# original format.
NEW_DATE=$(date -d "1970-01-01 ${NEW_EPOCH} sec" "+%Y%m%d")

# And there we have it! $NEW_DATE contains "20060331"

# For those that like a tidyier script (like me)
# here's a sample of the above in one line.
NEW_DATE=$(date -d "1970-01-01 $(($(date -d "${ORIGINAL_DATE}" "+%s") - $((60 * 60 * 24)))) sec" "+%Y%m%d")

echo "ORIGINAL_DATE = $ORIGINAL_DATE"
echo "NEW_DATE = $NEW_DATE"

----- End of Script -----

prints out:

ORIGINAL_DATE = 20060401
NEW_DATE = 20060331

There you have it. Enjoy!

This site is very Good.
Plz let me know what is epoch time in Linux

Epoch time is the amount of time since a fixed point in the history of Unix itself, and that's what's displayed when you specify the '-r' flag to date followed by a number of seconds offset. For example:

$ date -r 0
Wed Dec 31 17:00:00 MST 1969

Zero seconds after the epoch time is the date and time shown above, basically 0:00:00 GMT on 31 December 1969.

Why that time and date? Just ... because. :-)

A few more, for fun:

$ date -r 999999999
Sat Sep 8 19:46:39 MDT 2001
$ date -r 1999999999
Tue May 17 21:33:19 MDT 2033

#!/bin/bash
# function to reproduce UNIX time() value
second()
{
set -- $(TZ=GMT date '+%Y %m %d %H %M %S')
local y=$1 m=1$2 d=1$3 H=1$4 M=1$5 S=1$6
((m-=103, d-=101, H-=100, M-=100, S-=100, m<0 && (m+=12, --y)))
((d+=(m*153 + 2)/5+y*365+y/4-y/100+y/400-719468))
echo $((d*86400+H*3600+M*60+S))
}

In the above example of date operation using EPOCH, the resultant date will be set as per GMT time zone. e.g. if we use epoch value, it will return seconds since 1970, Jan 01 GMT value. now if my machine time zone is different than GMT i.e. IST(+0530), then to set correct time I have to add addition seconds for that particular time zone. Is there any command which can convert or give extra seconds that I need to add or subtract to get actual time? Thanks...

Hey guys, what about this ;-) ?

----------------------------------------------
#!/bin/bash
# Call me this way: epochtodate EPOCH FORMAT
# Where EPOCH is an epoch-formatted date
# and FORMAT is the +%... date format.
# If FORMAT="", then +%c
# Quote space-containing FORMAT.

dateformat=$2
[ -z "$dateformat" ] && dateformat="+%c"
date -d "1970-01-01 $1 sec" "$dateformat"

-------------------------------------------------
: w epochtodate

> epochtodate 1167001200

But why 1 hour late?

Regarding all questions about why the time is off by hour(s): date assumes the input is in the local timezone, however epoch time is given in GMT.
The fix is extremely simple. Assuming your epoch value is stored in $time

#First, we get our local timezone offset, i.e. +0130
mytz="`date +%z`"
#Then we dissect, using the +/- in the adjustment to the epoch, and then the 01 and 30 pieces multiplied by 3600 and 60 seconds respectively to come up with the proper offset in seconds.
let time${mytz:0:1}=3600*${mytz:1:2}+60*${mytz:3:2}

A shell only possibility for calculating dates in the future or the past.

date --date @$(($(date +%s)-(3600*24*2))) +%Y/%m/%d

Tested with bash and zsh.

Thanx peter for the info ... the command date -d "-1 day" .. was really helpful

Here is something I found that gets the job done. Using some shell commands in Linux or Unix to write a script that calculated the previous or future date or any date for that matter using the "date" and "cal" command.

Taking in account that the previous date to the first of any month is the last day of the previous month. "cal" does a good enough job to give you the days of any month for any year since Jan 1 1970.

I used the following command in my scripts to get the dates I need to use in variables:

Get the current numerical day
DAY=`date +%d`
Get the current numerical month
MTH=`date +%m`
Get the current numerical year
YEAR=`date +%Y`
Get the previous numerical date (or replace 1 with the number of day to count back)
DAYLESS="$((`date +%d`-1))"
Get the previous numerical month (or replace 1 with the number of months to count back)
MTHLESS="$((`date +%m`-1))"

Get the last numerical date of the previous month
MTHEND="$((`cal $MTHLESS $YEAR|wc -w`-9))"

Hugh: Your "cal" trick is nice but your math for the previous day and month breaks pretty badly around Jan 1st. I'd suggest using the TZ trick to set DAYLESS and YEAR properly for the target date and then you can use cal to count the number of days in that month.

I think any algorithm that does arithmetic on the epoch time will have problems crossing daylight savings boundary as days on these boundaries are not 24 hours (in terms of number of seconds from 2am to 2am). The TZ trick might also have issues with daylight savings. So you might want to use Hugh's code, fixed up to handle month boundaries as suggested by Kevin.

Oops! In my previous post I meant to say that the "Modification" and "Change" date time stamps change when new content is echoed to the end of the file. It is the "Access" date that remains unchanged. Nevertheless, if one wanted to measure "Access" time they could do it easily with the "stat" command.

http://www.askdavetaylor.com/date_math_in_linux_shell_script.html

Ok, I guess this really never got posted then...
I found an EASIER SOLUTION. =)

Though I would like to do "Date math in Linux shell script", my application is simply to test which file is newer than another based on "Access date". Note that there bash has the "-nt" newer than conditional test for files (e.g. file1 -nt file2), but the bash man page says that is according to the modification date. [del] --When I append a line to a file (e.g. cat "# my final comment" >> file2) and run the "stat" command, I see that only the "Access date" has changed - not the modification date.--[/del] correction: The "Modification" and "Change" dates are updated!

Fortunately, there is an option in the "stat" command to return the MAC timestamps of a file in epoch time where Access/Modify/Change are given in format %X/%Y/%Z.

Usage:
$ stat -c %X file2
1200496284

Now you can easily perform mathematical operations in seconds and date time stamp comparisons (e.g. is file1 > 10 secs newer than file2?) without ANY parsing and extra computation! I'm not sure that the "stat" command is standard on every Unix/BSD/Linux platform - but it should be available as a package!

Thanks a lot! I try them, Peter's one is fine.