à l'Aide d'une Bibliothèque

si vous faites beaucoup de travail de date, vous pouvez vouloir regarder dans les bibliothèques de date JavaScript comme Datejs ou Moment.js . Par exemple, avec le Moment.js, c'est tout simplement:

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

Vanilla Javascript

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

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

où diff est la différence en minutes que vous voulez de l'Heure de oldDateObj . Il peut même être négatif.

ou comme une fonction réutilisable, si vous avez besoin de le faire en plusieurs endroits:

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

soyez prudent avec le Javascript vanille. Les Dates Sont Dures!

vous pourriez penser 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, si l'utilisateur observe l'heure d'été, un jour n'est pas nécessairement de 24 heures. Il y a un jour par année qui ne dure que 23 heures, et un jour par année 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 Nov 2:

addMinutes(new Date('2014-11-02'), 60*24); //In USA, prints 11pm on Nov 2, not 12am Nov 3!

C'est pourquoi utiliser l'une des bibliothèques mentionnées ci-dessus 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 quand même l'utilisation d'une bibliothèque, mais cela peut être exagéré/impossible pour votre projet. La syntaxe est inspirée de 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) {
  var ret = new Date(date); //don't change original date
  var checkRollover = function() { if(ret.getDate() != date.getDate()) ret.setDate(0);};
  switch(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;
}

Travail jsFiddle démo .

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

var newDateObj = new Date();
newDateObj.setTime(oldDateObj.getTime() + (30 * 60 * 1000));

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

peut-être quelque chose comme ça?

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

je crée toujours 7 fonctions, pour travailler avec la date en JS: addsecondes, addMinutes, addHours, addDays, addWeeks, add months, add years.

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

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

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

alors vous pouvez appeler ça comme ça:

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

la façon la plus facile de résoudre est de reconnaître que dans les dates javascript ne sont que des nombres. Il commence par 0 ou 'Wed Dec 31 1969 18:00:00 GMT-0600 (CST) . Chaque 1 représente une milliseconde. Vous pouvez ajouter ou soustraire des millisecondes en obtenant la valeur et en instanciant une nouvelle date en utilisant cette valeur. Tu peux gérer ça 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)

Voici la ES6 version:

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'une composante créative, très nécessaire pour les calculs de voyage dans le temps. Je vous 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]());
}

juste une autre option, que j'ai écrit:

DP_DateExtensions Library

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, le calcul de date (ajouter/soustraire des parties de date), la comparaison de date, l'analyse de date, etc. Il est généreusement open source.

pour les paresseux comme moi:

de Kip réponse (à partir de ci-dessus) en coffeescript, à l'aide d'un "enum", et d'exploitation 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

utiliser 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>