J'aimerais obtenir un objet Date qui est 30 minutes plus tard qu'un autre objet Date. Comment faire avec JavaScript?

Utilisation d'une bibliothèque

Si vous faites beaucoup de travail sur les dates, vous voudrez peut-être regarder dans les bibliothèques de dates JavaScript comme Datejs ou Moment.js . Par exemple, avec Moment.js, c'est simplement:

var newDateObj = moment(oldDateObj).add(30, 'm').toDate();

Vanilla Javascript

C'est comme la réponse du chaos , mais en une seule ligne:

var newDateObj = new Date(oldDateObj.getTime() + diff*60000);

Quelle diffest la différence en minutes que vous voulez par rapport oldDateObjau temps. Cela peut même être négatif.

Ou comme fonction réutilisable, si vous devez le faire à plusieurs endroits:

function addMinutes(date, minutes) {
    return new Date(date.getTime() + minutes*60000);
}

^{Et juste au cas où cela ne serait pas évident, la raison pour laquelle nous multiplions les minutes 60000est de convertir les minutes en millisecondes.}

Soyez prudent avec Vanilla Javascript. Les dates sont difficiles!

Vous pensez peut-être que vous pouvez ajouter 24 heures à une date pour obtenir la date de demain, non? Faux!

addMinutes(myDate, 60*24); //DO NOT DO THIS

Il s'avère que si l'utilisateur observe l'heure d'été, une journée ne dure pas nécessairement 24 heures. Il y a un jour par an qui ne dure que 23 heures et un jour par an qui dure 25 heures. Par exemple, dans la plupart des États-Unis et du Canada, 24 heures après minuit, le 2 novembre 2014 est toujours le 2 novembre:

const NOV = 10; //because JS months are off by one...
addMinutes(new Date(2014, NOV, 2), 60*24); //In USA, prints 11pm on Nov 2, not 12am Nov 3!

C'est pourquoi utiliser l'une des bibliothèques susmentionnées est un pari plus sûr si vous devez faire beaucoup de travail avec cela.

Voici une version plus générique de cette fonction que j'ai écrite. Je recommanderais toujours d'utiliser une bibliothèque, mais cela peut être excessif / impossible pour votre projet. La syntaxe est modélisée d'après la fonction MySQL DATE_ADD .

/**
 * Adds time to a date. Modelled after MySQL DATE_ADD function.
 * Example: dateAdd(new Date(), 'minute', 30)  //returns 30 minutes from now.
 * https://stackoverflow.com/a/1214753/18511
 * 
 * @param date  Date to start with
 * @param interval  One of: year, quarter, month, week, day, hour, minute, second
 * @param units  Number of units of the given interval to add.
 */
function dateAdd(date, interval, units) {
  if(!(date instanceof Date))
    return undefined;
  var ret = new Date(date); //don't change original date
  var checkRollover = function() { if(ret.getDate() != date.getDate()) ret.setDate(0);};
  switch(String(interval).toLowerCase()) {
    case 'year'   :  ret.setFullYear(ret.getFullYear() + units); checkRollover();  break;
    case 'quarter':  ret.setMonth(ret.getMonth() + 3*units); checkRollover();  break;
    case 'month'  :  ret.setMonth(ret.getMonth() + units); checkRollover();  break;
    case 'week'   :  ret.setDate(ret.getDate() + 7*units);  break;
    case 'day'    :  ret.setDate(ret.getDate() + units);  break;
    case 'hour'   :  ret.setTime(ret.getTime() + units*3600000);  break;
    case 'minute' :  ret.setTime(ret.getTime() + units*60000);  break;
    case 'second' :  ret.setTime(ret.getTime() + units*1000);  break;
    default       :  ret = undefined;  break;
  }
  return ret;
}

Démonstration de jsFiddle .

var d1 = new Date ();
var d2 = new Date ( d1 );
d2.setMinutes ( d1.getMinutes() + 30 );
alert ( d2 );

Peut-être quelque chose comme ça?

var d = new Date();
var v = new Date();
v.setMinutes(d.getMinutes()+30);

console.log(v)

Je crée toujours 7 fonctions, pour travailler avec la date dans JS: addSeconds, addMinutes, addHours, addDays, addWeeks, addMonths, addYears.

Vous pouvez voir un exemple ici: http://jsfiddle.net/tiagoajacobi/YHA8x/

Comment utiliser:

var now = new Date();
console.log(now.addMinutes(30));
console.log(now.addWeeks(3));

Ce sont les fonctions:

        Date.prototype.addSeconds = function(seconds) {
            this.setSeconds(this.getSeconds() + seconds);
            return this;
        };

        Date.prototype.addMinutes = function(minutes) {
            this.setMinutes(this.getMinutes() + minutes);
            return this;
        };

        Date.prototype.addHours = function(hours) {
            this.setHours(this.getHours() + hours);
            return this;
        };

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

        Date.prototype.addWeeks = function(weeks) {
            this.addDays(weeks*7);
            return this;
        };

        Date.prototype.addMonths = function (months) {
            var dt = this.getDate();

            this.setMonth(this.getMonth() + months);
            var currDt = this.getDate();

            if (dt !== currDt) {  
                this.addDays(-currDt);
            }

            return this;
        };

        Date.prototype.addYears = function(years) {
            var dt = this.getDate();

            this.setFullYear(this.getFullYear() + years);

            var currDt = this.getDate();

            if (dt !== currDt) {  
                this.addDays(-currDt);
            }

            return this;
        };

La façon la plus simple de résoudre le problème est de reconnaître qu'en javascript, les dates ne sont que des chiffres. Cela commence 0ou 'Wed Dec 31 1969 18:00:00 GMT-0600 (CST). Chaque 1représente une milliseconde. Vous pouvez ajouter ou soustraire des millisecondes en obtenant la valeur et en instanciant une nouvelle date à l'aide de cette valeur. Vous pouvez le gérer assez facilement avec cet esprit.

const minutesToAdjust = 10;
const millisecondsPerMinute = 60000;
const originalDate = new Date('11/20/2017 10:00 AM');
const modifiedDate1 = new Date(originalDate.valueOf() - (minutesToAdjust * millisecondsPerMinute));
const modifiedDate2 = new Date(originalDate.valueOf() + (minutesToAdjust * millisecondsPerMinute));

console.log(originalDate); // Mon Nov 20 2017 10:00:00 GMT-0600 (CST)
console.log(modifiedDate1); // Mon Nov 20 2017 09:50:00 GMT-0600 (CST)
console.log(modifiedDate2); // Mon Nov 20 2017 10:10:00 GMT-0600 (CST)

C'est ce que je fais qui semble assez bien fonctionner:

Date.prototype.addMinutes = function(minutes) {
    var copiedDate = new Date(this.getTime());
    return new Date(copiedDate.getTime() + minutes * 60000);
}

Ensuite, vous pouvez simplement appeler cela comme ceci:

var now = new Date();
console.log(now.addMinutes(50));

Voici la version ES6 :

let getTimeAfter30Mins = () => {
  let timeAfter30Mins = new Date();
  timeAfter30Mins = new Date(timeAfter30Mins.setMinutes(timeAfter30Mins.getMinutes() + 30));
};

Appelez ça comme:

getTimeAfter30Mins();

Je pense que beaucoup de réponses ici manquent d'un composant créatif, très nécessaire pour les calculs de voyage dans le temps. Je présente ma solution pour une traduction temporelle de 30 minutes.

(jsfiddle ici )

function fluxCapacitor(n) {
    var delta,sigma=0,beta="ge";
    (function(K,z){

        (function(a,b,c){
            beta=beta+"tT";
            switch(b.shift()) {
                case'3':return z('0',a,c,b.shift(),1);
                case'0':return z('3',a,c,b.pop());
                case'5':return z('2',a,c,b[0],1);
                case'1':return z('4',a,c,b.shift());
                case'2':return z('5',a,c,b.pop());
                case'4':return z('1',a,c,b.pop(),1);
            }
        })(K.pop(),K.pop().split(''),K.pop());
    })(n.toString().split(':'),function(b,a,c,b1,gamma){
       delta=[c,b+b1,a];sigma+=gamma?3600000:0; 
       beta=beta+"im";
    });
    beta=beta+"e";
    return new Date (sigma+(new Date( delta.join(':')))[beta]());
}

Pour les paresseux comme moi:

Réponse de Kip (ci-dessus) en coffeescript, utilisant un "enum" et opérant sur le même objet:

Date.UNIT =
  YEAR: 0
  QUARTER: 1
  MONTH: 2
  WEEK: 3
  DAY: 4
  HOUR: 5
  MINUTE: 6
  SECOND: 7
Date::add = (unit, quantity) ->
  switch unit
    when Date.UNIT.YEAR then @setFullYear(@getFullYear() + quantity)
    when Date.UNIT.QUARTER then @setMonth(@getMonth() + (3 * quantity))
    when Date.UNIT.MONTH then @setMonth(@getMonth() + quantity)
    when Date.UNIT.WEEK then @setDate(@getDate() + (7 * quantity))
    when Date.UNIT.DAY then @setDate(@getDate() + quantity)
    when Date.UNIT.HOUR then @setTime(@getTime() + (3600000 * quantity))
    when Date.UNIT.MINUTE then @setTime(@getTime() + (60000 * quantity))
    when Date.UNIT.SECOND then @setTime(@getTime() + (1000 * quantity))
    else throw new Error "Unrecognized unit provided"
  @ # for chaining

Utilisez une bibliothèque existante connue pour gérer les bizarreries impliquées dans le traitement des calculs de temps. Mon préféré actuel est moment.js .

<script src="//cdnjs.cloudflare.com/ajax/libs/moment.js/2.13.0/moment.js"></script>
<script>
 var now = moment(); // get "now"
 console.log(now.toDate()); // show original date
 var thirty = moment(now).add(30,"minutes"); // clone "now" object and add 30 minutes, taking into account weirdness like crossing DST boundries or leap-days, -minutes, -seconds.
 console.log(thirty.toDate()); // show new date
</script>

Juste une autre option, que j'ai écrite:

Bibliothèque DP_DateExtensions

C'est exagéré si c'est tout le traitement de date dont vous avez besoin, mais il fera ce que vous voulez.

Prend en charge le formatage date / heure, les calculs de date (ajout / soustraction de parties de date), la comparaison de date, l'analyse de la date, etc. Il est généreusement ouvert.

Vous pouvez faire ceci:

let thirtyMinutes = 30 * 60 * 1000; // convert 30 minutes to milliseconds
let date1 = new Date();
let date2 = new Date(date1.getTime() + thirtyMinutes);
console.log(date1);
console.log(date2);

Voici mon one-liner:

console.log('time: ', new Date(new Date().valueOf() + 60000))

Vous devez obtenir la valeur de la date actuelle pour obtenir la date avec (ms) et y ajouter (30 * 60 * 1000). Vous avez maintenant (date actuelle + 30 min) avec ms

console.log('with ms', Date.now() + (30 * 60 * 1000))
console.log('new Date', new Date(Date.now() + (30 * 60 * 1000)))

Je sais que le sujet est bien trop ancien. Mais je suis à peu près sûr qu'il y a des développeurs qui en ont encore besoin, alors j'ai créé ce script simple pour vous. J'espère que ça vous plait!

function strtotime(date, addTime){
  let generatedTime=date.getTime();
  if(addTime.seconds) generatedTime+=1000*addTime.seconds; //check for additional seconds 
  if(addTime.minutes) generatedTime+=1000*60*addTime.minutes;//check for additional minutes 
  if(addTime.hours) generatedTime+=1000*60*60*addTime.hours;//check for additional hours 
  return new Date(generatedTime);
}

let futureDate = strtotime(new Date(), {
    hours: 1, //Adding one hour
    minutes: 45, //Adding fourty five minutes
    seconds: 0 //Adding 0 seconds return to not adding any second so  we can remove it.
});

<button onclick="alert(futureDate)">Travel to the future</button>