Fügen Sie dem JavaScript-Datum Tage hinzu

So fügen Sie Datemit JavaScript Tage zum aktuellen hinzu . Hat JavaScript eine eingebaute Funktion wie die von .Net AddDay?

Sie können eine erstellen mit: -

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

Dadurch wird der Monat bei Bedarf automatisch erhöht. Zum Beispiel:

8/31 + 1 Tag wird 9/1 .

Das Problem bei der setDatedirekten Verwendung ist, dass es sich um einen Mutator handelt und dass solche Dinge am besten vermieden werden. ECMA hielt es für angebracht, Dateeher als veränderliche Klasse als als unveränderliche Struktur zu behandeln.

Richtige Antwort :

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

Falsche Antwort :

Diese Antwort liefert manchmal das richtige Ergebnis, gibt aber sehr oft das falsche Jahr und den falschen Monat zurück. Diese Antwort funktioniert nur dann, wenn das Datum, zu dem Sie Tage hinzufügen, zufällig das aktuelle Jahr und den aktuellen Monat enthält.

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

Beweis / Beispiel

Überprüfen Sie diese 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);

Seien Sie vorsichtig, da dies schwierig sein kann. Wenn Sie "morgen" einstellen, funktioniert dies nur, weil der aktuelle Wert mit dem Jahr und dem Monat für "heute" übereinstimmt. Die Einstellung auf eine Datumsnummer wie "32" funktioniert jedoch normalerweise immer noch einwandfrei, um sie auf den nächsten Monat zu verschieben.

Meine einfache Lösung ist:

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

Diese Lösung hat kein Problem mit der Sommerzeit. Man kann auch jeden Offset für Jahre, Monate, Tage usw. hinzufügen / unterschreiben.

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

ist der richtige Code.

Diese Antworten erscheinen mir verwirrend, ich bevorzuge:

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

getTime () gibt uns Millisekunden seit 1970 an, und 86400000 ist die Anzahl der Millisekunden pro Tag. Daher enthält ms Millisekunden für das gewünschte Datum.

Die Verwendung des Millisekundenkonstruktors ergibt das gewünschte Datumsobjekt.

Versuchen

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

Wenn Sie setDate () zum Hinzufügen eines Datums verwenden, wird Ihr Problem nicht gelöst. Versuchen Sie, einem Februar-Monat einige Tage hinzuzufügen. Wenn Sie versuchen, neue Tage hinzuzufügen, führt dies nicht zu den erwarteten Ergebnissen.

Ich habe nur ewig versucht, herauszufinden, was der Deal mit dem Jahr war, das nicht hinzugefügt wurde, wenn ich den folgenden Beispielen folge.

Wenn Sie dem Datum, das Sie haben, einfach n Tage hinzufügen möchten, gehen Sie am besten einfach:

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

oder die langatmige Version

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

Das heute / morgen Zeug ist verwirrend. Indem Sie das aktuelle Datum in Ihre neue Datumsvariable einstellen, wird der Jahreswert durcheinander gebracht. Wenn Sie ab dem ursprünglichen Datum arbeiten, werden Sie nicht.

Wenn Sie können, verwenden Sie moment.js . JavaScript verfügt nicht über sehr gute native Datums- / Zeitmethoden. Das Folgende ist ein Beispiel für die Syntax von 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>

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

Ich habe diese Erweiterungen letzte Nacht erstellt:
Sie können entweder positive oder negative Werte übergeben.

Beispiel:

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

Ohne die zweite Variable zu verwenden, können Sie 7 durch Ihre nächsten x Tage ersetzen:

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

zu subtrahieren 30 Tagen verbrauchen (24h = 86400000ms)

new Date(+yourDate - 30 *86400000)

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

console.log(d)

Die einfachste Lösung.

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

Vielen Dank an Jason für Ihre Antwort, die wie erwartet funktioniert. Hier ist eine Mischung aus Ihrem Code und dem praktischen Format von AnthonyWJones:

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

Spät zur Party, aber wenn Sie verwenden jQuerydann ist es ein ausgezeichnetes Plugin namens Moment:

http://momentjs.com/

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

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

Und viele andere gute Sachen drin!

Bearbeiten: jQuery-Referenz dank Aikerus Kommentar entfernt

Eine Lösung für den Pipeline-Betreiber :

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

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

  return result;
};

Verwendungszweck:

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

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

Wenn Sie mehr Funktionen benötigen, empfehle ich Ihnen, in die date-fns- Bibliothek zu schauen .

Alt weiß ich, aber manchmal mag ich das:

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

Ich hatte Probleme mit der Sommerzeit mit der vorgeschlagenen Lösung.

Mit getUTCDate/ setUTCDatestattdessen habe ich mein Problem gelöst.

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

Sie können JavaScript verwenden, keine jQuery erforderlich:

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;

Generischer Prototyp ohne Variablen, gilt für einen vorhandenen Datumswert:

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

Die Mozilla-Dokumente für setDate () geben nicht an, dass sie Szenarien zum Monatsende verarbeiten. Siehe https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date

Datum einstellen()

• Legt den Tag des Monats (1-31) für ein bestimmtes Datum entsprechend der Ortszeit fest.

Deshalb verwende ich setTime (), wenn ich Tage hinzufügen muss.

So einfach ist das:

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

Ich denke, ich werde auch eine Antwort geben:
Ich persönlich versuche gerne, unbegründete Variablendeklarationen, Methodenaufrufe und Konstruktoraufrufe zu vermeiden, da sie alle teuer für die Leistung sind. (im Rahmen der Vernunft natürlich)
Ich wollte dies als Kommentar unter der Antwort von @AnthonyWJones belassen, dachte aber besser darüber nach.

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

Das oben Gesagte respektiert die Sommerzeit. Wenn Sie also eine Anzahl von Tagen hinzufügen, die die Sommerzeit überschreiten, ändert sich die angezeigte Zeit (Stunde) entsprechend.
Beispiel:
2. November 2014 02:00 war das Ende der Sommerzeit.

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

Wenn Sie die Zeit während der Sommerzeit beibehalten möchten (10:30 ist also immer noch 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;
};

Also, jetzt hast du ...

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

Nein, Javascript hat keine eingebaute Funktion, aber Sie können eine einfache Codezeile verwenden

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

Ich benutze so etwas wie:

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

Funktioniert mit Tagessparzeit:

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

Arbeitet mit Neujahr:

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

Es kann parametrisiert werden:

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

Ich verwende die folgende Lösung.

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 hat einen Konstruktor, der ein int akzeptiert. Dieses Argument repräsentiert die Gesamtzahl der Millisekunden vor / nach dem 1. Januar 1970. Es verfügt auch über eine Methode setTime, die dasselbe tut, ohne ein neues Date-Objekt zu erstellen.

Wir konvertieren hier Tage in Millisekunden und addieren diesen Wert zu dem von getTime bereitgestellten Wert. Schließlich geben wir das Ergebnis an den Konstruktor Date (Millisekunden) oder an die Methode setTime (Millisekunden) weiter.

Bearbeiten: Anstelle von setTime()(oder setHours()) können Sie dies folgendermaßen tun:

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

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

Alt:

Anstatt zu verwenden setTime(), können Sie verwenden setHours():

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

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

Siehe die JSFiddle ...

Sehr einfacher Code zum Hinzufügen von Datumstagen in Java-Skript.

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

Es gibt eine setDate- und eine getDate- Methode, mit denen Sie Folgendes tun können:

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

Wenn Sie sowohl eine Anzahl von Tagen subtrahieren als auch Ihr Datum in einem für Menschen lesbaren Format formatieren möchten, sollten Sie ein benutzerdefiniertes DateHelperObjekt erstellen , das ungefähr so ​​aussieht:

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

(siehe auch diese Geige )

Das Erweitern des Prototyps in Javascript ist möglicherweise keine gute Idee , insbesondere in professionellen Codebasen.

Was Sie tun möchten, ist die native DateKlasse zu erweitern:

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)

Auf diese Weise werden addDaysSie nichts kaputt machen , wenn Javascript eines Tages eine native Methode implementiert .