Adicionar dias à data do JavaScript

Como adicionar dias aos atuais Dateusando JavaScript. O JavaScript possui uma função incorporada como a .Net AddDay?

Você pode criar um com: -

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

Isso cuida de incrementar automaticamente o mês, se necessário. Por exemplo:

31/8 + 1 dia se tornará 9/1 .

O problema de usar setDatediretamente é que é um mutador e é melhor evitar esse tipo de coisa. A ECMA considerou adequado tratar Datecomo uma classe mutável e não como uma estrutura imutável.

Resposta correta :

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

Resposta incorreta :

Essa resposta às vezes fornece o resultado correto, mas muitas vezes retorna o ano e o mês incorretos. A única vez que essa resposta funciona é quando a data em que você está adicionando os dias tem o ano e o mês atuais.

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

Prova / Exemplo

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

Tenha cuidado, porque isso pode ser complicado. Ao definir "amanhã", funciona apenas porque o valor atual corresponde ao ano e mês para "hoje". No entanto, definir um número de data como "32" normalmente ainda funcionará bem para movê-lo para o próximo mês.

Minha solução simples é:

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

Esta solução não tem problemas com o horário de verão. Além disso, pode-se adicionar / subtrair qualquer deslocamento por anos, meses, dias etc.

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

é o código correto.

Essas respostas me parecem confusas, eu prefiro:

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

getTime () fornece milissegundos desde 1970 e 86400000 é o número de milissegundos em um dia. Portanto, ms contém milissegundos para a data desejada.

O uso do construtor de milissegundos fornece o objeto de data desejado.

Tentar

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

O uso de setDate () para adicionar uma data não resolverá seu problema. Tente adicionar alguns dias a um mês de fevereiro. Se você tentar adicionar novos dias, isso não resultará no que você esperava.

Passei anos tentando descobrir qual era o acordo que o ano não adicionava ao seguir os exemplos de liderança abaixo.

Se você quiser simplesmente adicionar n dias à data em que você tem, é melhor apenas ir:

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

ou a versão de vento longo

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

Esse material de hoje / amanhã é confuso. Ao definir a data atual em sua nova variável de data, você alterará o valor do ano. se você trabalha a partir da data original, não o fará.

Se você puder, use moment.js . O JavaScript não possui métodos de data / hora nativos muito bons. A seguir, é apresentado um exemplo da sintaxe do momento:

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>

Referência: 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);

Eu criei essas extensões na noite passada:
você pode passar valores positivos ou negativos;

exemplo:

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

Sem usar a segunda variável, você pode substituir 7 pelos seus próximos x dias:

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

para subtrair 30 dias de uso (24h = 86400000ms)

new Date(+yourDate - 30 *86400000)

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

console.log(d)

A solução mais simples.

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

Obrigado Jason pela resposta que funciona conforme o esperado, eis uma mistura do seu código e do prático formato de AnthonyWJones:

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

Tarde para a festa, mas se você usar jQuery, existe um excelente plugin chamado Moment:

http://momentjs.com/

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

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

E muitas outras coisas boas lá!

Edit: Referência do jQuery removida graças ao comentário de aikeru

Uma solução projetada para o operador de tubulação :

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

Se você precisar de mais funcionalidades, sugiro consultar a biblioteca date-fns .

Velho eu sei, mas às vezes gosto disso:

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

Eu tive problemas com o horário de verão com a solução proposta.

Usando getUTCDate/ em setUTCDatevez disso, resolvi meu 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;
}

Você pode usar JavaScript, não é necessário 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;

Protótipo genérico sem variáveis, aplica-se a um valor de Data existente:

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

Os documentos do mozilla para setDate () não indicam que ele manipulará cenários de final de mês. Consulte https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date

setDate ()

• Define o dia do mês (1 a 31) para uma data especificada, de acordo com a hora local.

É por isso que uso setTime () quando preciso adicionar dias.

Tão simples como isto:

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

Acho que vou dar uma resposta também:
Pessoalmente, gosto de tentar evitar declarações variáveis ​​gratuitas, chamadas de método e chamadas de construtor, pois elas são caras no desempenho. (dentro da razão, é claro),
eu deixaria isso como apenas um comentário na resposta dada por @AnthonyWJones, mas pensei melhor.

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

O acima irá respeitar o horário de verão. Ou seja, se você adicionar um número de dias que cruzam o horário de verão, o tempo (hora) exibido será alterado para refletir isso.
Exemplo:
2 de novembro de 2014 às 02:00 era o fim do horário de verão.

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

Se você deseja manter o tempo no horário de verão (as 10:30 ainda serão 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;
};

Então, agora você tem ...

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

Não, o javascript não possui uma função integrada, mas você pode usar uma linha de código simples

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

Eu uso algo como:

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

Funciona com horário de verão:

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

Funciona com o ano novo:

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

Pode ser parametrizado:

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

Estou usando a seguinte solução.

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 tem um construtor que aceita um int. Esse argumento representa o total de milissegundos antes / depois de 1º de janeiro de 1970. Ele também possui um método setTime que faz o mesmo sem criar um novo objeto Date.

O que fazemos aqui é converter dias em milissegundos e adicionar esse valor ao valor fornecido por getTime. Por fim, fornecemos o resultado ao construtor Date (milissegundos) ou ao método setTime (milissegundos).

Edit: Em vez de setTime()(ou setHours()), você poderia fazê-lo desta maneira:

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

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

Velho:

Em vez de usar, setTime()você pode usar setHours():

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

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

Veja o JSFiddle ...

Código muito simples para adicionar dias na data no script java.

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

Há um método setDate e getDate , que permitem fazer algo assim:

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

Se você deseja subtrair vários dias e formatar sua data em um formato legível por humanos, considere criar um DateHelperobjeto personalizado parecido com este:

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

(veja também este violino )

A extensão do protótipo em javascript pode não ser uma boa ideia , especialmente em bases de código profissionais.

O que você quer fazer é estender a Dateclasse 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)

Dessa forma, se um dia o Javascript implementar um addDaysmétodo nativo , você não quebrará nada.