Partial answer:

To round down to nearest moment minute:

var m = moment();
m.startOf('minute');

However, the equivalent for rounding up, endOf, doesn't quite give the expected result.

The roundTo feature could make it into a future release.

Examples:

moment().roundTo('minute', 15); // output: 12:45
moment().roundTo('minute', 15, 'down'); // output: 12:30

To round up, you need to add a minute and then round it down. To round down, just use the startOf method.

Note the use of a ternary operator to check if the time should be rounded (for instance, 13:00:00 on the dot doesn't need to be rounded).

Round up/down to the nearest minute

var m = moment('2017-02-17 12:01:01');
var roundDown = m.startOf('minute');
console.log(roundDown.toString()); // outputs Tue Feb 17 2017 12:01:00 GMT+0000


var m = moment('2017-02-17 12:01:01');
var roundUp = m.second() || m.millisecond() ? m.add(1, 'minute').startOf('minute') : m.startOf('minute');
console.log(roundUp.toString());  // outputs Tue Feb 17 2017 12:02:00 GMT+0000

Round up/down to the nearest hour

var m = moment('2017-02-17 12:59:59');
var roundDown = m.startOf('hour');
console.log(roundDown.toString()); // outputs Tue Feb 17 2017 12:00:00 GMT+0000


var m = moment('2017-02-17 12:59:59');
var roundUp = m.minute() || m.second() || m.millisecond() ? m.add(1, 'hour').startOf('hour') : m.startOf('hour');
console.log(roundUp.toString());  // outputs Tue Feb 17 2017 13:00:00 GMT+0000

Just another possibility:

const now = moment();
// -> Wed Sep 30 2015 11:57:20 GMT+0200 (CEST)
now.add(1, 'm').startOf('minute');
// -> Wed Sep 30 2015 11:58:00 GMT+0200 (CEST)

Rounding Down

Easy. As stated by many others, just use Moment.startOf:

var roundDown = moment('2015-02-17 12:59:59').startOf('hour');
roundDown.format('HH:mm:SS'); // 12:00:00

Importantly, this also works as expected:

var roundDown = moment('2015-02-17 12:00:00').startOf('hour');
roundDown.format('HH:mm:SS'); // 12:00:00

Rounding Up

Slightly trickier, if we want to round up with a proper ceiling function: for example, when rounding up by hour, we want 12:00:00 to round up to 12:00:00.

This does not work

var roundUp = moment('2015-02-17 12:00:00').add(1, 'hour').startOf('hour');
roundUp.format('HH:mm:SS'); // ERROR: 13:00:00

Solution

function roundUp(momentObj, roundBy){
return momentObj.add(1, roundBy).startOf(roundBy);
}




var caseA = moment('2015-02-17 12:00:00');
roundUp(caseA, 'minute').format('HH:mm:SS'); // 12:00:00


var caseB = moment('2015-02-17 12:00:00.001');
roundUp(caseB, 'minute').format('HH:mm:SS'); // 12:01:00


var caseC = moment('2015-02-17 12:00:59');
roundUp(caseC, 'minute').format('HH:mm:SS'); // 12:01:00

Rounding to the nearest hour can be achieved by adding half an hour and then run .startOf('hour'). This is the same for any time measurement.

var now = moment();
// -> Wed Sep 30 2015 11:01:00
now.add(30, 'minutes').startOf('hour'); // -> Wed Sep 30 2015 11:31:00
// -> Wed Sep 30 2015 11:00:00


var now = moment();
// -> Wed Sep 30 2015 11:31:00
now.add(30, 'minutes').startOf('hour'); // -> Wed Sep 30 2015 12:01:00
// -> Wed Sep 30 2015 12:00:00

A more precise answer:

t.add(30, 'seconds').startOf('minute')

Case1: Rounding down if seconds < 30

t = moment(); //12:00:05
t.add(30, 'seconds').startOf('minute') //12:00:00

Case2: Rounding up if seconds >= 30

t = moment(); //12:00:33
t.add(30, 'seconds').startOf('minute') //12:01:00

This solution worked for me;

function round_up_to_nearest_hour(date = new Date()) {
return moment(date).add(59, 'minutes').startOf('hour').toDate();
}

I was searching for this same question and found a better solution: Use the third parameter in diff() function:

moment("2019-05-02 17:10:20").diff("2019-05-02 17:09:30","minutes",true)

By setting third parameter to true, you get the raw value as response that you can round by yourself using Math.round()

See JSFiddle: https://jsfiddle.net/2wqs4o0v/3/

The simplest solution so far:

function floor(time, floorBy = 'minute') {
return time.startOf(floorBy);
}


function ceil(time, ceilBy = 'minute') {
return time.subtract(1, 'millisecond').add(1, ceilBy).startOf(ceilBy);
}


// The solution is above. The code below is an optional test:


console.log(
floor(moment('2019-01-01 12:00:00.000')).format('H:mm:ss.SSS') === '12:00:00.000',
ceil(moment('2019-01-01 12:00:00.000')).format('H:mm:ss.SSS') === '12:00:00.000',
floor(moment('2019-01-01 12:00:00.001')).format('H:mm:ss.SSS') === '12:00:00.000',
ceil(moment('2019-01-01 12:00:00.001')).format('H:mm:ss.SSS') === '12:01:00.000',
floor(moment('2019-01-01 12:15:16.876'), 'hour'  ).format('H:mm:ss.SSS') === '12:00:00.000',
ceil(moment('2019-01-01 12:15:16.876'), 'hour'  ).format('H:mm:ss.SSS') === '13:00:00.000',
floor(moment('2019-01-01 12:59:59.999'), 'second').format('H:mm:ss.SSS') === '12:59:59.000',
ceil(moment('2019-01-01 12:59:59.999'), 'second').format('H:mm:ss.SSS') === '13:00:00.000',
floor(moment('2019-01-01 12:00:00.025'), 'ms'    ).format('H:mm:ss.SSS') === '12:00:00.025',
ceil(moment('2019-01-01 12:00:00.025'), 'ms'    ).format('H:mm:ss.SSS') === '12:00:00.025'
);

<script src="//cdn.jsdelivr.net/npm/moment@2.24.0/min/moment.min.js"></script>

a better (and simple) approach will be -

moment('2021-07-22 14:56:58')
.startOf('hour')
.add(1, 'hour')
// optional: .format('MMMM D, YYYY (h:mm A)')
//output: July 22, 2021 (3:00 PM)

Round up to the next hour

a simple approach will be -

moment('2021-07-22 14:56:58')
.startOf('hour')
.add(1, 'hour')
// optional: .format('MMMM D, YYYY (h:mm A)')
//output: July 22, 2021 (3:00 PM)