Dodaj dni do daty JavaScript

Jak dodać dni do prądu Dateza pomocą JavaScript. Czy JavaScript ma wbudowaną funkcję taką jak .Net AddDay?

Możesz go utworzyć za pomocą:

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

W razie potrzeby zapewnia to automatyczne zwiększenie miesiąca. Na przykład:

8/31 + 1 dzień zmieni się na 9/1 .

Problem z setDatebezpośrednim używaniem polega na tym, że jest to mutator i tego rodzaju rzeczy najlepiej unikać. ECMA uznał za stosowne potraktować Dateraczej klasę zmienną niż niezmienną strukturę.

Prawidłowa odpowiedź :

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

Niepoprawna odpowiedź :

Ta odpowiedź czasami zapewnia poprawny wynik, ale bardzo często zwraca niewłaściwy rok i miesiąc. Ta odpowiedź działa tylko wtedy, gdy data, do której dodajesz dni, przypada na bieżący rok i miesiąc.

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

Dowód / przykład

Sprawdź to 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);

Uważaj, ponieważ może to być trudne. Ustawienie „jutro” działa tylko dlatego, że jego bieżąca wartość odpowiada rokowi i miesiącowi dla „dzisiaj”. Jednak ustawienie numeru daty, takiego jak „32”, normalnie nadal będzie działać dobrze, aby przenieść go na następny miesiąc.

Moje proste rozwiązanie to:

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

to rozwiązanie nie ma problemu z czasem letnim. Można również dodawać / subskrybować dowolne przesunięcie na lata, miesiące, dni itp.

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

jest poprawnym kodem.

Te odpowiedzi wydają mi się mylące, wolę:

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

getTime () daje nam milisekundy od 1970 roku, a 86400000 to liczba milisekund w ciągu dnia. Zatem ms zawiera milisekundy dla żądanej daty.

Użycie konstruktora milisekundowego daje pożądany obiekt daty.

Próbować

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

Za pomocą setDate (), aby dodać datę, nie rozwiążesz problemu, spróbuj dodać kilka dni do miesiąca lutego, jeśli spróbujesz dodać do niej nowe dni, nie da to tego, czego się spodziewałeś.

Po prostu spędziłem wieki, próbując ustalić, jaka była umowa z rokiem, nie dodając, postępując zgodnie z poniższymi przykładami wiodącymi.

Jeśli chcesz po prostu dodać n dni do swojej daty, najlepiej po prostu przejść:

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

lub wersja z długim wiatrem

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

To dziś / jutro jest mylące. Ustawiając bieżącą datę w nowej zmiennej daty, zepsujesz wartość roku. jeśli pracujesz od pierwotnej daty, nie będziesz.

Jeśli możesz, użyj moment.js . JavaScript nie ma bardzo dobrych metod natywnej daty / godziny. Oto przykładowa składnia 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>

Odniesienie: http://momentjs.com/docs/#/manipicing/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);

Te rozszerzenia utworzyłem ostatniej nocy:
możesz przekazać wartości dodatnie lub ujemne;

przykład:

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

Bez użycia drugiej zmiennej możesz zastąpić 7 następnymi x dniami:

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

odjąć 30 dni użytkowania (24h = 86400000 ms)

new Date(+yourDate - 30 *86400000)

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

console.log(d)

Najprostsze rozwiązanie.

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

Dziękuję Jasonowi za odpowiedź, która działa zgodnie z oczekiwaniami, oto mieszanka kodu i przydatnego formatu AnthonyWJones:

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

Późno do partii, ale jeśli używasz jQuerywtedy tam doskonały plugin o nazwie Moment:

http://momentjs.com/

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

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

I jest tam wiele innych dobrych rzeczy!

Edycja: odniesienie do jQuery zostało usunięte dzięki komentarzowi aikeru

Rozwiązanie zaprojektowane dla operatora rurociągu :

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

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

  return result;
};

Stosowanie:

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

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

Jeśli potrzebujesz więcej funkcji, sugeruję zajrzenie do biblioteki date-fns .

Stary, wiem, ale czasem mi się podoba:

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

Miałem problemy z czasem letnim związanym z proponowanym rozwiązaniem.

Używając getUTCDate/ setUTCDatezamiast, rozwiązałem swój problem.

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

Możesz używać JavaScript, nie wymaga 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;

Ogólny prototyp bez zmiennych, ma zastosowanie do istniejącej wartości daty:

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

Dokumenty mozilla dla setDate () nie wskazują, że będzie on obsługiwał scenariusze na koniec miesiąca. Zobacz https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date

ustawić datę()

• Ustawia dzień miesiąca (1-31) dla określonej daty zgodnie z czasem lokalnym.

Dlatego używam setTime (), kiedy muszę dodać dni.

Tak proste jak to:

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

Wydaje mi się, że dam również odpowiedź:
osobiście lubię próbować unikać nieuzasadnionej deklaracji zmiennych, wywołań metod i wywołań konstruktorów, ponieważ wszystkie one są drogie pod względem wydajności. (oczywiście w granicach rozsądku)
zamierzałem zostawić to jako komentarz pod odpowiedzią udzieloną przez @AnthonyWJones, ale lepiej się nad tym zastanowić.

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

Powyższe będzie przestrzegać DST. Oznacza to, że jeśli dodasz liczbę dni przekraczających czas letni, wyświetlany czas (godzina) zmieni się, aby to odzwierciedlić.
Przykład:
2 listopada 2014 02:00 był końcem czasu letniego.

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

Jeśli chcesz zachować czas w DST (więc 10:30 nadal będzie 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;
};

Więc teraz masz ...

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

Nie, javascript nie ma wbudowanej funkcji, ale możesz użyć prostej linii kodu

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

Używam czegoś takiego jak:

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

Działa z oszczędnością czasu:

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

Działa z nowym rokiem:

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

Można go sparametryzować:

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

Korzystam z następującego rozwiązania.

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 ma konstruktor, który akceptuje liczbę całkowitą. Ten argument reprezentuje całkowitą liczbę milisekund przed / po 1 stycznia 1970 r. Posiada również metodę setTime, która robi to samo bez tworzenia nowego obiektu Date.

To, co tutaj robimy, to konwersja dni na milisekundy i dodanie tej wartości do wartości podanej przez getTime. Na koniec podajemy wynik konstruktorowi Date (milisekundy) lub metodzie setTime (milisekundy).

Edycja: Zamiast setTime()(lub setHours()) możesz to zrobić w ten sposób:

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

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

Stary:

Zamiast używać setTime()możesz użyć setHours():

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

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

Zobacz JSFiddle ...

Bardzo prosty kod do dodawania dni w skrypcie Java.

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

Istnieje metoda setDate i getDate , które pozwalają zrobić coś takiego:

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

Jeśli chcesz odjąć liczbę dni i sformatować datę w formacie czytelnym dla człowieka, powinieneś rozważyć utworzenie niestandardowego DateHelperobiektu, który wygląda mniej więcej tak:

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

(zobacz także to skrzypce )

Rozszerzenie prototypu w javascript może nie być dobrym pomysłem , szczególnie w profesjonalnych kodach.

Co chcesz zrobić, to rozszerzyć Dateklasę natywną :

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)

W ten sposób, jeśli pewnego dnia JavaScript wdroży natywną addDaysmetodę, niczego nie zepsujesz.