Qfyilyi

You can create one with:-

Date.prototype.addDays = function(days) {

    var date = new Date(this.valueOf());

    date.setDate(date.getDate() + days);

    return date;

}



var date = new Date();



alert(date.addDays(5));

This takes care of automatically incrementing the month if necessary. For example:

8/31 + 1 day will become 9/1.

The problem with using setDate directly is that it's a mutator and that sort of thing is best avoided. ECMA saw fit to treat Date as a mutable class rather than an immutable structure.

Correct Answer:

function addDays(date, days) {

  var result = new Date(date);

  result.setDate(result.getDate() + days);

  return result;

}

Incorrect Answer:

This answer sometimes provides the correct result but very often returns the wrong year and month. The only time this answer works is when the date that you are adding days to happens to have the current year and month.

// Don't do it this way!

function addDaysWRONG(date, days) {

  var result = new Date();

  result.setDate(date.getDate() + days);

  return result;

}

Proof / Example

Check this JsFiddle

// Correct

function addDays(date, days) {

    var result = new Date(date);

    result.setDate(result.getDate() + days);

    return result;

}



// Bad Year/Month

function addDaysWRONG(date, days) {

    var result = new Date();

    result.setDate(date.getDate() + days);

    return result;

}



// Bad during DST

function addDaysDstFail(date, days) {

    var dayms = (days * 24 * 60 * 60 * 1000);

    return new Date(date.getTime() + dayms);    

}



// TEST

function formatDate(date) {

    return (date.getMonth() + 1) + '/' + date.getDate() + '/' + date.getFullYear();

}



$('tbody tr td:first-child').each(function () {

    var $in = $(this);

    var $out = $('<td/>').insertAfter($in).addClass("answer");

    var $outFail = $('<td/>').insertAfter($out);

    var $outDstFail = $('<td/>').insertAfter($outFail);

    var date = new Date($in.text());

    var correctDate = formatDate(addDays(date, 1));

    var failDate = formatDate(addDaysWRONG(date, 1));

    var failDstDate = formatDate(addDaysDstFail(date, 1));



    $out.text(correctDate);

    $outFail.text(failDate);

    $outDstFail.text(failDstDate);

    $outFail.addClass(correctDate == failDate ? "right" : "wrong");

    $outDstFail.addClass(correctDate == failDstDate ? "right" : "wrong");

});

body {

    font-size: 14px;

}



table {

    border-collapse:collapse;

}

table, td, th {

    border:1px solid black;

}

td {

    padding: 2px;

}



.wrong {

    color: red;

}

.right {

    color: green;

}

.answer {

    font-weight: bold;

}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>

<table>

    <tbody>

        <tr>

            <th colspan="4">DST Dates</th>

        </tr>

        <tr>

            <th>Input</th>

            <th>+1 Day</th>

            <th>+1 Day Fail</th>

            <th>+1 Day DST Fail</th>

        </tr>

        <tr><td>03/10/2013</td></tr>

        <tr><td>11/03/2013</td></tr>

        <tr><td>03/09/2014</td></tr>

        <tr><td>11/02/2014</td></tr>

        <tr><td>03/08/2015</td></tr>

        <tr><td>11/01/2015</td></tr>

        <tr>

            <th colspan="4">2013</th>

        </tr>

        <tr>

            <th>Input</th>

            <th>+1 Day</th>

            <th>+1 Day Fail</th>

            <th>+1 Day DST Fail</th>

        </tr>

        <tr><td>01/01/2013</td></tr>

        <tr><td>02/01/2013</td></tr>

        <tr><td>03/01/2013</td></tr>

        <tr><td>04/01/2013</td></tr>

        <tr><td>05/01/2013</td></tr>

        <tr><td>06/01/2013</td></tr>

        <tr><td>07/01/2013</td></tr>

        <tr><td>08/01/2013</td></tr>

        <tr><td>09/01/2013</td></tr>

        <tr><td>10/01/2013</td></tr>

        <tr><td>11/01/2013</td></tr>

        <tr><td>12/01/2013</td></tr>

        <tr>

            <th colspan="4">2014</th>

        </tr>

        <tr>

            <th>Input</th>

            <th>+1 Day</th>

            <th>+1 Day Fail</th>

            <th>+1 Day DST Fail</th>

        </tr>

        <tr><td>01/01/2014</td></tr>

        <tr><td>02/01/2014</td></tr>

        <tr><td>03/01/2014</td></tr>

        <tr><td>04/01/2014</td></tr>

        <tr><td>05/01/2014</td></tr>

        <tr><td>06/01/2014</td></tr>

        <tr><td>07/01/2014</td></tr>

        <tr><td>08/01/2014</td></tr>

        <tr><td>09/01/2014</td></tr>

        <tr><td>10/01/2014</td></tr>

        <tr><td>11/01/2014</td></tr>

        <tr><td>12/01/2014</td></tr>

        <tr>

            <th colspan="4">2015</th>

        </tr>

        <tr>

            <th>Input</th>

            <th>+1 Day</th>

            <th>+1 Day Fail</th>

            <th>+1 Day DST Fail</th>

        </tr>

        <tr><td>01/01/2015</td></tr>

        <tr><td>02/01/2015</td></tr>

        <tr><td>03/01/2015</td></tr>

        <tr><td>04/01/2015</td></tr>

        <tr><td>05/01/2015</td></tr>

        <tr><td>06/01/2015</td></tr>

        <tr><td>07/01/2015</td></tr>

        <tr><td>08/01/2015</td></tr>

        <tr><td>09/01/2015</td></tr>

        <tr><td>10/01/2015</td></tr>

        <tr><td>11/01/2015</td></tr>

        <tr><td>12/01/2015</td></tr>

    </tbody>

</table>

var today = new Date();

var tomorrow = new Date();

tomorrow.setDate(today.getDate()+1);

Be careful, because this can be tricky. When setting "tomorrow", it only works because it's current value matches the year and month for "today". However, setting to a date number like "32" normally will still work just fine to move it to the next month.

My simple solution is:

nextday=new Date(oldDate.getFullYear(),oldDate.getMonth(),oldDate.getDate()+1);

this solution does not have problem with daylight saving time. Also, one can add/sub any offset for years, months, days etc.

day=new Date(oldDate.getFullYear()-2,oldDate.getMonth()+22,oldDate.getDate()+61);

is correct code.

These answers seem confusing to me, I prefer:

var ms = new Date().getTime() + 86400000;

var tomorrow = new Date(ms);

getTime() gives us milliseconds since 1970, and 86400000 is the number of milliseconds in a day.
Hence, ms contains milliseconds for the desired date.

Using the millisecond constructor gives the desired date object.

Try

var someDate = new Date();

var duration = 2; //In Days

someDate.setTime(someDate.getTime() +  (duration * 24 * 60 * 60 * 1000));

Using setDate() to add a date wont solve your problem, try adding some days to a Feb month, if you try to add new days to it, it wont result in what you expected.

Just spent ages trying to work out what the deal was with the year not adding when following the lead examples below.

If you want to just simply add n days to the date you have you are best to just go:

myDate.setDate(myDate.getDate() + n);

or the longwinded version

var theDate = new Date(2013, 11, 15);

var myNewDate = new Date(theDate);

myNewDate.setDate(myNewDate.getDate() + 30);

console.log(myNewDate);

This today/tomorrow stuff is confusing. By setting the current date into your new date variable you will mess up the year value. if you work from the original date you won't.

If you can, use moment.js. JavaScript doesn't have very good native date/time methods. The following is an example Moment's syntax:

var nextWeek = moment().add(7, 'days');

alert(nextWeek);

<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.17.1/moment-with-locales.min.js"></script>

Reference: http://momentjs.com/docs/#/manipulating/add/

I created these extensions last night:

you can pass either positive or negative values;

example:

var someDate = new Date();

var expirationDate = someDate.addDays(10);

var previous = someDate.addDays(-5);





Date.prototype.addDays = function (num) {

    var value = this.valueOf();

    value += 86400000 * num;

    return new Date(value);

}



Date.prototype.addSeconds = function (num) {

    var value = this.valueOf();

    value += 1000 * num;

    return new Date(value);

}



Date.prototype.addMinutes = function (num) {

    var value = this.valueOf();

    value += 60000 * num;

    return new Date(value);

}



Date.prototype.addHours = function (num) {

    var value = this.valueOf();

    value += 3600000 * num;

    return new Date(value);

}



Date.prototype.addMonths = function (num) {

    var value = new Date(this.valueOf());



    var mo = this.getMonth();

    var yr = this.getYear();



    mo = (mo + num) % 12;

    if (0 > mo) {

        yr += (this.getMonth() + num - mo - 12) / 12;

        mo += 12;

    }

    else

        yr += ((this.getMonth() + num - mo) / 12);



    value.setMonth(mo);

    value.setYear(yr);

    return value;

}

int days = 1;

var newDate = new Date(Date.now() + days * 24*60*60*1000);

CodePen

var days = 2;

var newDate = new Date(Date.now() + days * 24*60*60*1000);



document.write('Today: <em>');

document.write(new Date());

document.write('</em><br/> New: <strong>');

document.write(newDate);

The simplest solution.

 Date.prototype.addDays = function(days) {

   this.setDate(this.getDate() + parseInt(days));

   return this;

 };



 // and then call



 var newDate = new Date().addDays(2); //+2 days

 console.log(newDate);



 // or



 var newDate1 = new Date().addDays(-2); //-2 days

 console.log(newDate1);

Late to the party, but if you use jQuery then there's an excellent plugin called Moment:

http://momentjs.com/

var myDateOfNowPlusThreeDays = moment().add(3, "days").toDate();

http://momentjs.com/docs/#/manipulating/

And lots of other good stuff in there!

Edit: jQuery reference removed thanks to aikeru's comment

Thanks Jason for your answer that works as expected, here is a mix from your code and the handy format of AnthonyWJones :

Date.prototype.addDays = function(days){

    var ms = new Date().getTime() + (86400000 * days);

    var added = new Date(ms);

    return added;

}

Old I know, but sometimes I like this:

function addDays(days) {

    return new Date(Date.now() + 864e5 * days);

}

The mozilla docs for setDate() don't indicate that it will handle end of month scenarios.
See https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date

setDate()

• Sets the day of the month (1-31) for a specified date according to local time.

That is why I use setTime() when I need to add days.

I guess I'll give an answer as well:

Personally, I like to attempt to avoid gratuitous variable declaration, method calls, and constructor calls, as they are all expensive on performance. (within reason, of course)

I was going to leave this as just comment under the Answer given by @AnthonyWJones but thought better of it.

// Prototype usage...

Date.prototype.addDays = Date.prototype.addDays || function( days ) {

    return this.setTime( 864E5 * days + this.valueOf() ) && this;

};



// Namespace usage...

namespace.addDaysToDate = function( date, days ) {

    return date.setTime( 864E5 * days + date.valueOf() ) && date;

};



// Basic Function declaration...

function addDaysToDate( date, days ) {

    return date.setTime( 864E5 * days + date.valueOf() ) && date;

};

The above will respect DST. Meaning if you add a number of days that cross DST, the displayed time (hour) will change to reflect that.

Example:

Nov 2, 2014 02:00 was the end of DST.

var dt = new Date( 2014, 10, 1, 10, 30, 0 );

console.log( dt );                  // Sat Nov 01 2014 10:30:00

console.log( dt.addDays( 10 ) );    // Tue Nov 11 2014 09:30:00

If you're looking to retain the time across DST (so 10:30 will still be 10:30)...

// Prototype usage...

Date.prototype.addDays = Date.prototype.addDays || function( days ) {

    return this.setDate( this.getDate() + days ) && this;

};



// Namespace usage...

namespace.addDaysToDate = function( date, days ) {

    return date.setDate( date.getDate() + days ) && date;

};



// Basic Function declaration...

function addDaysToDate( date, days ) {

    return date.setDate( date.getDate() + days ) && date;

};

So, now you have...

var dt = new Date( 2014, 10, 1, 10, 30, 0 );

console.log( dt );                  // Sat Nov 01 2014 10:30:00

console.log( dt.addDays( 10 ) );    // Tue Nov 11 2014 10:30:00

No, javascript has no a built in function, but
you can use a simple line of code

timeObject.setDate(timeObject.getDate() + countOfDays);

I had issues with daylight savings time with the proposed solution.

By using getUTCDate / setUTCDate instead, I solved my issue.

// Curried, so that I can create helper functions like `add1Day`

const addDays = num => date => {

  // Make a working copy so we don't mutate the supplied date.

  const d = new Date(date);



  d.setUTCDate(d.getUTCDate() + num);



  return d;

}

I use something like:

new Date(dateObject.getTime() + amountOfDays * 24 * 60 * 60 * 1000)

Works with day saving time:

new Date(new Date(2014, 2, 29, 20, 0, 0).getTime() + 1 * 24 * 60 * 60 * 1000)

Works with new year:

new Date(new Date(2014, 11, 31, 20, 0, 0).getTime() + 1 * 24 * 60 * 60 * 1000)

It can be parametrized:

function DateAdd(source, amount, step) {

  var factor = 1;

  if (step == "day") factor = 24 * 60 * 60 * 1000;

  else if (step == "hour") factor = 60 * 60 * 1000;

  ...

  new Date(source.getTime() + amount * factor);

}

I am using the following solution.

var msInDay = 86400000;

var daysToAdd = 5;

var now = new Date();

var milliseconds = now.getTime();

var newMillisecods = milliseconds + msInDay * daysToAdd;

var newDate = new Date(newMillisecods);

//or now.setTime(newMillisecods);

Date has a constructor that accepts an int. This argument represents total milliseconds before/after Jan 1, 1970. It also has a method setTime which does the same without creating a new Date object.

What we do here is convert days to milliseconds and add this value to the value provided by getTime. Finally, we give the result to Date(milliseconds) constructor or setTime(milliseconds) method.

Edit:
Instead of setTime() (or setHours()) you could do it this way:

Date.prototype.addDays= function(d){

  this.setDate(this.getDate() + d);

  return this;

};



var tomorrow = new Date().addDays(1);

Old:

Instead of using setTime() you can use setHours():

Date.prototype.addDays= function(d){

    this.setHours(this.getHours() + d * 24);

    return this;

};



var tomorrow = new Date().addDays(1);

See the JSFiddle...

Very simple code to add days in date in java script.

var d = new Date();

d.setDate(d.getDate() + prompt('how many days you want to add write here'));

alert(d);

Our team considers date-fns the best library in this space. It treats dates as immutable (Moment.js will probably never adopt immutability), it's faster, and can be loaded modularly.

const newDate = DateFns.addDays(oldDate, 2);

There's a setDate and a getDate method, which allow you to do something like this :

var newDate = aDate.setDate(aDate.getDate() + numberOfDays);

If you want to both subtract a number of days and format your date in a human readable format, you should consider creating a custom DateHelper object that looks something like this :

var DateHelper = {

    addDays : function(aDate, numberOfDays) {

        aDate.setDate(aDate.getDate() + numberOfDays); // Add numberOfDays

        return aDate;                                  // Return the date

    },

    format : function format(date) {

        return [

           ("0" + date.getDate()).slice(-2),           // Get day and pad it with zeroes

           ("0" + (date.getMonth()+1)).slice(-2),      // Get month and pad it with zeroes

           date.getFullYear()                          // Get full year

        ].join('/');                                   // Glue the pieces together

    }

}



// With this helper, you can now just use one line of readable code to :

// ---------------------------------------------------------------------

// 1. Get the current date

// 2. Add 20 days

// 3. Format it

// 4. Output it

// ---------------------------------------------------------------------

document.body.innerHTML = DateHelper.format(DateHelper.addDays(new Date(), 20));

(see also this Fiddle)

    //the_day is 2013-12-31

    var the_day = Date.UTC(2013, 11, 31); 

    // Now, the_day will be "1388448000000" in UTC+8; 

    var the_next_day = new Date(the_day + 24 * 60 * 60 * 1000);

    // Now, the_next_day will be "Wed Jan 01 2014 08:00:00 GMT+0800"

For those using Angular:

Just do:

$scope.booking.totTijd.setMinutes($scope.booking.totTijd.getMinutes()+15);

$scope.booking.totTijd.setDate($scope.booking.totTijd.getDate() + 1);

try this

function addDays(date,days) {        

      var one_day=1000*60*60*24; 

      return new Date(date.getTime()+(days*one_day)).toLocaleDateString(); 

    }

You can use JavaScript, no jQuery required:

var someDate = new Date();

var numberOfDaysToAdd = 6;

someDate.setDate(someDate.getDate() + numberOfDaysToAdd); 

Formatting to dd/mm/yyyy :



var dd = someDate.getDate();

var mm = someDate.getMonth() + 1;

var y = someDate.getFullYear();



var someFormattedDate = dd + '/'+ mm + '/'+ y;

You can create your custom helper function here

function plusToDate(currentDate, unit, howMuch) {



    var config = {

        second: 1000, // 1000 miliseconds

        minute: 60000,

        hour: 3600000,

        day: 86400000,

        week: 604800000,

        month: 2592000000, // Assuming 30 days in a month

        year: 31536000000 // Assuming 365 days in year

    };



    var now = new Date(currentDate);



    return new Date(now + config[unit] * howMuch);

}



var today = new Date();

var theDayAfterTommorow = plusToDate(today, 'day', 2);

By the way, this is generic solution for adding seconds or minutes or days whatever you want.

function addDays(n){

    var t = new Date();

    t.setDate(t.getDate() + n); 

    var month = "0"+(t.getMonth()+1);

    var date = "0"+t.getDate();

    month = month.slice(-2);

    date = date.slice(-2);

     var date = date +"/"+month +"/"+t.getFullYear();

    alert(date);

}



addDays(5);