Agregar días a la fecha de JavaScript

Cómo agregar días a la corriente Dateusando JavaScript. ¿JavaScript tiene una función integrada como .Net AddDay?

Puede crear uno con: -

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));

Esto se encarga de incrementar automáticamente el mes si es necesario. Por ejemplo:

8/31 + 1 día se convertirá en 9/1 .

El problema con el uso setDatedirecto es que es un mutador y es mejor evitar ese tipo de cosas. ECMA consideró adecuado tratarlo Datecomo una clase mutable en lugar de una estructura inmutable.

Respuesta correcta :

function addDays(date, days) {
  var result = new Date(date);
  result.setDate(result.getDate() + days);
  return result;
}

Respuesta incorrecta :

Esta respuesta a veces proporciona el resultado correcto, pero a menudo devuelve el año y mes incorrectos. El único momento en que esta respuesta funciona es cuando la fecha en la que está agregando días tiene el año y mes actual.

// Don't do it this way!
function addDaysWRONG(date, days) {
  var result = new Date();
  result.setDate(date.getDate() + days);
  return result;
}

Prueba / Ejemplo

Comprueba este 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);

Tenga cuidado, porque esto puede ser complicado. Al configurar "mañana", solo funciona porque su valor actual coincide con el año y el mes de "hoy". Sin embargo, establecer un número de fecha como "32" normalmente seguirá funcionando bien para pasar al próximo mes.

Mi solución simple es:

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

Esta solución no tiene problemas con el horario de verano. Además, uno puede agregar / sustituir cualquier compensación por años, meses, días, etc.

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

Es el código correcto.

Estas respuestas me parecen confusas, prefiero:

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

getTime () nos da milisegundos desde 1970, y 86400000 es la cantidad de milisegundos en un día. Por lo tanto, ms contiene milisegundos para la fecha deseada.

El uso del constructor de milisegundos da el objeto de fecha deseado.

Tratar

var someDate = new Date();
var duration = 2; //In Days
someDate.setTime(someDate.getTime() +  (duration * 24 * 60 * 60 * 1000));

Usar setDate () para agregar una fecha no resolverá su problema, intente agregar algunos días a un mes de febrero, si intenta agregarle nuevos días, no dará como resultado lo que esperaba.

Acabo de pasar años tratando de averiguar cuál era el acuerdo con el año sin agregar cuando seguimos los ejemplos principales a continuación.

Si desea simplemente agregar n días a la fecha que tiene, es mejor que simplemente vaya:

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

o la versión larga

var theDate = new Date(2013, 11, 15);
var myNewDate = new Date(theDate);
myNewDate.setDate(myNewDate.getDate() + 30);
console.log(myNewDate);

Esto de hoy / mañana es confuso. Al configurar la fecha actual en su nueva variable de fecha, desordenará el valor del año. Si trabaja desde la fecha original, no lo hará.

Si puedes, usa moment.js . JavaScript no tiene muy buenos métodos nativos de fecha / hora. El siguiente es un ejemplo de la sintaxis de Moment:

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>

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

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);

Creé estas extensiones anoche:
puede pasar valores positivos o negativos;

ejemplo:

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;
}

Sin usar la segunda variable, puede reemplazar 7 con sus próximos x días:

let d=new Date(new Date().getTime() + (7 * 24 * 60 * 60 * 1000));

restar 30 días de uso (24h = 86400000ms)

new Date(+yourDate - 30 *86400000)

var yourDate=new Date();
var d = new Date(+yourDate - 30 *86400000) 

console.log(d)

La solución más simple.

 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);

Gracias Jason por su respuesta que funciona como se esperaba, aquí hay una mezcla de su código y el práctico formato de AnthonyWJones:

Date.prototype.addDays = function(days){
    var ms = new Date().getTime() + (86400000 * days);
    var added = new Date(ms);
    return added;
}

Tarde a la fiesta, pero si la usas, jQueryentonces hay un excelente complemento llamado Momento:

http://momentjs.com/

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

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

¡Y muchas otras cosas buenas allí!

Editar: referencia de jQuery eliminada gracias al comentario de aikeru

Una solución diseñada para el operador de la tubería :

const addDays = days => date => {
  const result = new Date(date);

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

  return result;
};

Uso:

// Without the pipeline operator...
addDays(7)(new Date());

// And with the pipeline operator...
new Date() |> addDays(7);

Si necesita más funcionalidad, le sugiero que busque en la biblioteca de fecha-fns .

Lo sé, pero a veces me gusta esto:

function addDays(days) {
    return new Date(Date.now() + 864e5 * days);
}

Tuve problemas con el horario de verano con la solución propuesta.

Al usar getUTCDate/ en su setUTCDatelugar, resolví mi problema.

// 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;
}

Puede usar JavaScript, no se requiere jQuery:

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;

Prototipo genérico sin variables, se aplica a un valor de fecha existente:

Date.prototype.addDays = function (days) {
    return new Date(this.valueOf() + days * 864e5);
}

Los documentos de mozilla para setDate () no indican que manejará los escenarios de fin de mes. Ver https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date

Establece la fecha()

• Establece el día del mes (1-31) para una fecha específica de acuerdo con la hora local.

Es por eso que uso setTime () cuando necesito agregar días.

Tan simple como esto:

new Date((new Date()).getTime() + (60*60*24*1000));

Supongo que también daré una respuesta:
personalmente, me gusta intentar evitar la declaración de variables gratuita, las llamadas a métodos y las llamadas a constructores, ya que todos son caros en rendimiento. (dentro de lo razonable, por supuesto)
Iba a dejar esto como un comentario en la Respuesta dada por @AnthonyWJones, pero lo pensé mejor.

// 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;
};

Lo anterior respetará el horario de verano. Es decir, si agrega una cantidad de días que cruzan el horario de verano, la hora (hora) mostrada cambiará para reflejar eso.
Ejemplo:
2 de noviembre de 2014 02:00 fue el final del horario de verano.

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

Si está buscando retener el tiempo durante el horario de verano (por lo tanto, las 10:30 seguirán siendo las 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;
};

Entonces, ahora tienes ...

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 no tiene una función integrada, pero puede usar una línea de código simple

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

Yo uso algo como:

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

Funciona con el horario de verano:

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

Funciona con año nuevo:

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

Se puede parametrizar:

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);
}

Estoy usando la siguiente solución.

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 tiene un constructor que acepta un int. Este argumento representa milisegundos totales antes / después del 1 de enero de 1970. También tiene un método setTime que hace lo mismo sin crear un nuevo objeto Date.

Lo que hacemos aquí es convertir días a milisegundos y agregar este valor al valor proporcionado por getTime. Finalmente, damos el resultado al constructor Date (milisegundos) o al método setTime (milisegundos).

Editar: en lugar de setTime()(o setHours()) podría hacerlo de esta manera:

Date.prototype.addDays= function(d){
  this.setDate(this.getDate() + d);
  return this;
};

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

Antiguo:

En lugar de usar setTime()puedes usar setHours():

Date.prototype.addDays= function(d){
    this.setHours(this.getHours() + d * 24);
    return this;
};

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

Ver el JSFiddle ...

Código muy simple para agregar días de fecha en Java Script.

var d = new Date();
d.setDate(d.getDate() + prompt('how many days you want to add write here'));
alert(d);

Hay un método setDate y getDate , que le permite hacer algo como esto:

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

Si desea restar un número de días y formatear su fecha en un formato legible por humanos, debería considerar crear un DateHelperobjeto personalizado que se vea así:

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));

(ver también este violín )

Extender el prototipo en JavaScript puede no ser una buena idea , especialmente en bases de código profesionales.

Lo que quieres hacer es extender la Dateclase nativa :

class MyCustomDate extends Date {

  addDays(days) {
    const date = new MyCustomDate(this.valueOf());
    date.setDate(date.getDate() + days);
    return date;
  }
  
}

const today = new MyCustomDate();

const nextWeek = today.addDays(7)

console.log(nextWeek)

De esta manera, si algún día Javascript implementa un addDaysmétodo nativo , no romperá nada.