Gostaria de obter um objeto Date 30 minutos mais tarde que outro objeto Date. Como faço com JavaScript?

Usando uma biblioteca

Se você trabalha muito com datas, pode procurar em bibliotecas de datas JavaScript, como Datejs ou Moment.js . Por exemplo, com Moment.js, isso é simplesmente:

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

Javascript de baunilha

É como a resposta do caos , mas em uma linha:

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

Onde diffestá a diferença em minutos que você deseja do oldDateObjtempo. Pode até ser negativo.

Ou como uma função reutilizável, se você precisar fazer isso em vários locais:

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

^{E, caso isso não seja óbvio, a razão pela qual multiplicamos minutos 60000é converter minutos em milissegundos.}

Cuidado com o Vanilla Javascript. As datas são difíceis!

Você pode adicionar 24 horas a uma data para obter a data de amanhã, certo? Errado!

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

Acontece que, se o usuário observar o horário de verão, o dia não será necessariamente de 24 horas. Há um dia por ano com apenas 23 horas e um dia por ano com 25 horas. Por exemplo, na maioria dos Estados Unidos e Canadá, 24 horas após a meia-noite de 2 de novembro de 2014, ainda é 2 de novembro:

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!

É por isso que usar uma das bibliotecas mencionadas acima é uma aposta mais segura se você tiver que trabalhar muito com isso.

Abaixo está uma versão mais genérica dessa função que escrevi. Eu ainda recomendo usar uma biblioteca, mas isso pode ser um exagero / impossível para o seu projeto. A sintaxe é modelada após a função 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;
}

Trabalhando com a demonstração do jsFiddle .

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

Talvez algo assim?

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

console.log(v)

Eu sempre crio 7 funções, para trabalhar com a data em JS: addSeconds, addMinutes, addHours, addDays, addWeeks, addMonths, addYears.

Você pode ver um exemplo aqui: http://jsfiddle.net/tiagoajacobi/YHA8x/

Como usar:

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

Estas são as funções:

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

A maneira mais fácil de resolver é reconhecer que em datas javascript são apenas números. Começa 0ou 'Wed Dec 31 1969 18:00:00 GMT-0600 (CST). Cada 1um representa um milissegundo. Você pode adicionar ou subtrair milissegundos obtendo o valor e instanciando uma nova data usando esse valor. Você pode gerenciar isso com bastante facilidade com essa mente.

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)

É isso que faço, que parece funcionar muito bem:

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

Então você pode chamar assim:

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

Aqui está a versão do ES6 :

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

Chame assim:

getTimeAfter30Mins();

Sinto que muitas das respostas aqui carecem de um componente criativo, muito necessário para os cálculos de viagens no tempo. Apresento minha solução para uma tradução temporal de 30 minutos.

(jsfiddle aqui )

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

Para os preguiçosos como eu:

A resposta de Kip (de cima) em coffeescript, usando um "enum" e operando no mesmo objeto:

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

Use uma biblioteca existente conhecida para lidar com as peculiaridades envolvidas no tratamento de cálculos de tempo. Meu favorito atual é 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>

Apenas outra opção, que escrevi:

Biblioteca DP_DateExtensions

É um exagero se esse for o processamento de todas as datas necessárias, mas ele fará o que você deseja.

Suporta formatação de data / hora, matemática da data (adicionar / subtrair partes da data), comparação de datas, análise de datas, etc. É de código aberto.

Você poderia fazer isso:

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

Aqui está o meu one-liner:

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

Você deve obter o valor da data atual para obter a data com (ms) e adicionar (30 * 60 * 1000) a ela. Agora você tem (data atual + 30 min) com ms

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

Eu sei que o tópico é muito antigo. Mas tenho certeza de que alguns desenvolvedores ainda precisam disso, então fiz esse script simples para você. Espero que você goste!

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>