Ajouter des jours à la date JavaScript

Comment ajouter des jours au courant en Dateutilisant JavaScript. JavaScript a-t-il une fonction intégrée comme .Net AddDay?

Vous pouvez en créer un avec: -

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

Cela prend soin d'incrémenter automatiquement le mois si nécessaire. Par exemple:

8/31 + 1 jour deviendra 9/1 .

Le problème avec l'utilisation setDatedirecte est qu'il s'agit d'un mutateur et qu'il vaut mieux éviter ce genre de chose. L'ECMA a jugé bon de traiter Datecomme une classe mutable plutôt que comme une structure immuable.

Bonne réponse :

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

Réponse incorrecte :

Cette réponse fournit parfois le résultat correct mais renvoie très souvent la mauvaise année et le mauvais mois. La seule fois où cette réponse fonctionne, c'est lorsque la date à laquelle vous ajoutez des jours se trouve avoir l'année et le mois en cours.

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

Preuve / exemple

Vérifiez ce 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);

Soyez prudent, car cela peut être délicat. Lorsque vous définissez "demain", cela ne fonctionne que parce que sa valeur actuelle correspond à l'année et au mois pour "aujourd'hui". Cependant, la définition d'un numéro de date tel que "32" fonctionnera normalement très bien pour le déplacer vers le mois suivant.

Ma solution simple est:

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

cette solution n'a pas de problème avec l'heure d'été. En outre, on peut ajouter / sous-compenser n'importe quel décalage pendant des années, des mois, des jours, etc.

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

est le bon code.

Ces réponses me paraissent déroutantes, je préfère:

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

getTime () nous donne des millisecondes depuis 1970, et 86400000 est le nombre de millisecondes par jour. Par conséquent, ms contient des millisecondes pour la date souhaitée.

L'utilisation du constructeur en millisecondes donne l'objet de date souhaité.

Essayer

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

L'utilisation de setDate () pour ajouter une date ne résoudra pas votre problème, essayez d'ajouter quelques jours à un mois de février, si vous essayez d'ajouter de nouveaux jours, cela n'entraînera pas ce que vous attendiez.

Je viens de passer des heures à essayer de comprendre ce que l'accord avec l'année n'a pas ajouté en suivant les exemples principaux ci-dessous.

Si vous voulez simplement ajouter n jours à la date que vous avez, il vaut mieux y aller:

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

ou la version longue

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

Ce truc aujourd'hui / demain est déroutant. En définissant la date actuelle dans votre nouvelle variable de date, vous gâcherez la valeur de l'année. si vous travaillez à partir de la date d'origine, vous ne le ferez pas.

Si vous le pouvez, utilisez moment.js . JavaScript n'a pas de très bonnes méthodes de date / heure natives. Voici un exemple de syntaxe 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>

Référence: 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);

J'ai créé ces extensions hier soir:
vous pouvez passer des valeurs positives ou négatives;

exemple:

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

Sans utiliser la deuxième variable, vous pouvez remplacer 7 par vos x prochains jours:

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

soustraire 30 jours d'utilisation (24h = 86400000ms)

new Date(+yourDate - 30 *86400000)

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

console.log(d)

La solution la plus 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);

Merci Jason pour votre réponse qui fonctionne comme prévu, voici un mélange de votre code et du format pratique d'AnthonyWJones:

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

Tard dans la soirée, mais si vous l'utilisez, jQueryil existe un excellent plugin appelé Moment:

http://momentjs.com/

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

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

Et plein d'autres bonnes choses là-dedans!

Edit: référence jQuery supprimée grâce au commentaire d'Aikeru

Une solution conçue pour l' exploitant du pipeline :

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

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

  return result;
};

Usage:

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

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

Si vous avez besoin de plus de fonctionnalités, je vous suggère de regarder dans les date-fns bibliothèque .

Vieux je sais, mais parfois j'aime ça:

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

J'ai eu des problèmes avec l'heure d'été avec la solution proposée.

En utilisant getUTCDate/ à la setUTCDateplace, j'ai résolu mon problème.

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

Vous pouvez utiliser JavaScript, aucune jQuery requise:

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;

Prototype générique sans variable, il s'applique sur une valeur Date existante:

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

Les documents mozilla pour setDate () n'indiquent pas qu'il gérera les scénarios de fin de mois. Voir https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date

régler la date()

• Définit le jour du mois (1-31) pour une date spécifiée en fonction de l'heure locale.

C'est pourquoi j'utilise setTime () lorsque j'ai besoin d'ajouter des jours.

Aussi simple que cela:

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

Je suppose que je donnerai également une réponse:
Personnellement, j'aime essayer d'éviter la déclaration de variable gratuite, les appels de méthode et les appels de constructeur, car ils sont tous coûteux en performances. (dans des limites raisonnables, bien sûr)
J'allais laisser cela comme un simple commentaire sous la réponse donnée par @AnthonyWJones, mais j'y pensais mieux.

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

Ce qui précède respectera l'heure d'été. Cela signifie que si vous ajoutez un nombre de jours qui traversent l'heure d'été, l'heure affichée (heure) changera pour refléter cela.
Exemple:
le 2 novembre 2014, 02:00 était la fin de l'heure d'été.

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 vous cherchez à conserver l'heure sur l'heure d'été (10h30 sera donc toujours 10h30) ...

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

Alors maintenant, vous avez ...

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

Non, javascript n'a pas de fonction intégrée, mais vous pouvez utiliser une simple ligne de code

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

J'utilise quelque chose comme:

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

Fonctionne avec gain de temps:

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

Fonctionne avec la nouvelle année:

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

Il peut être paramétré:

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

J'utilise la solution suivante.

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 a un constructeur qui accepte un int. Cet argument représente le total des millisecondes avant / après le 1er janvier 1970. Il a également une méthode setTime qui fait de même sans créer un nouvel objet Date.

Ce que nous faisons ici est de convertir les jours en millisecondes et d'ajouter cette valeur à la valeur fournie par getTime. Enfin, nous donnons le résultat au constructeur Date (millisecondes) ou à la méthode setTime (millisecondes).

Edit: Au lieu de setTime()(ou setHours()) vous pouvez le faire de cette façon:

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

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

Vieux:

Au lieu d'utiliser, setTime()vous pouvez utiliser setHours():

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

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

Voir le JSFiddle ...

Code très simple pour ajouter des jours en date dans le script java.

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

Il existe une méthode setDate et une méthode getDate , qui vous permettent de faire quelque chose comme ceci:

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

Si vous souhaitez à la fois soustraire un nombre de jours et formater votre date dans un format lisible par l'homme, vous devriez envisager de créer un DateHelperobjet personnalisé qui ressemble à ceci:

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

(voir aussi ce violon )

L'extension du prototype en javascript peut ne pas être une bonne idée , en particulier dans les bases de code professionnelles.

Ce que vous voulez faire, c'est étendre la Dateclasse native :

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 cette façon, si un jour Javascript implémente une addDaysméthode native , vous ne casserez rien.