Moment: Rundung auf das nächste 15-Minuten-Intervall.

moment.fn.roundMinutes = function () { return ~(this.minutes() / 15) * 15; }

Ich habe dies für meinen eigenen Gebrauch erstellt und dachte, es könnte anderen helfen. Denken Sie daran, dass es auf die nächsten NÄCHSTEN 15 Minuten rundet.

moment.fn.roundNext15Min = function () {
var intervals = Math.floor(this.minutes() / 15);
if(this.minutes() % 15 != 0)
    intervals++;
    if(intervals == 4) {
        this.add('hours', 1);
        intervals = 0;
    }
    this.minutes(intervals * 15);
    this.seconds(0);
    return this;
}

BEARBEITEN: this.incrementHours () zugunsten von this.add ('hours', 1) entfernt;

Können Sie bitte diese Funktionen zu Moment hinzufügen.

Jetzt, wo ich es mir noch einmal ansehe, habe ich keine Ahnung, wie InkrementHours funktioniert hat.
Ich habe meinen Beitrag zum Problem mit dem korrigierten Code bearbeitet. Genießen!

Am Mo, 10.03.2014 um 14:29 Uhr, Blake Niemyjski
[email protected] schrieb :

Was war Ihre Funktion für inkrementStunden? Ich vermute, das hat auch Tage gemacht
auch.

Antworten Sie direkt auf diese E-Mail oder zeigen Sie sie auf Gi tHub anhttps://github.com/moment/moment/issues/959#issuecomment -37223821
.

danke für diese Methode @zbarnett . Genau das was ich für mein Projekt gebraucht habe

Nun, wir können die startOf-Schnittstelle wie folgt verwenden startOf(15, 'm') . Es kann für alle Einheiten funktionieren. Warte auf PRs :)

Hier ist eine ziemlich einfache Formel (in Coffeescript-Syntax, da dies der Kontext ist, in dem ich auf dieses Problem gestoßen bin):

round_interval = 15
remainder = time.minute() % round_interval
time.subtract('minutes', remainder).add('minutes', if remainder > round_interval / 2 then round_interval else 0)

Ich bin gerade mit anderen Dingen beschäftigt, aber wenn jemand diesen Code nehmen und direkt in eine PR einfügen möchte, fühlen Sie sich frei.

Schluss zu Gunsten von #1595

Keine Notwendigkeit, zu komplizieren, einfache Mathematik:

const rounded = Math.round(moment().minute() / 15) * 15;
const roundedDown = Math.floor(moment().minute() / 15) * 15;
const roundedUp = Math.ceil(moment().minute() / 15) * 15;

moment().minute(roundedUp).second(0)

Ausgabe zum nächsten 15-Minuten-Viertel.

Ich konnte die Lösung von @janwerkhoven nicht zum

function round15(minute) {
  let intervals = [15, 30, 45, 59, 0];
  let closest;
  let min = 90;

  for (let i = 0; i < intervals.length; i++) {
    let iv = intervals[i];
    let maybeMin = Math.abs(minute - iv);

    if (maybeMin < min) {
      min = maybeMin;
      closest = iv;
    }
  }

  if (closest === 59) {
    closest = 0;
  }

  return closest;
}

let myMoment = moment();
myMoment.minutes(round15(myMoment.minutes()));

@ground5hark

function nearestMinutes(interval, someMoment){
  const roundedMinutes = Math.round(someMoment.clone().minute() / interval) * interval;
  return someMoment.clone().minute(roundedMinutes).second(0);
}

function nearestPastMinutes(interval, someMoment){
  const roundedMinutes = Math.floor(someMoment.minute() / interval) * interval;
  return someMoment.clone().minute(roundedMinutes).second(0);
}

function nearestFutureMinutes(interval, someMoment){
  const roundedMinutes = Math.ceil(someMoment.minute() / interval) * interval;
  return someMoment.clone().minute(roundedMinutes).second(0);
}

const now = moment();
const nearest5min = nearestMinutes(5, now);
const nearest15min = nearestMinutes(15, now);
const nearest30min = nearestMinutes(30, now);
const nearestFuture5min = nearestFutureMinutes(5, now);
const nearestPast5min = nearestPastMinutes(5, now);

Getestet auf Code-Stift

Das Entscheidende ist, .clone() tun. Ohne sie würden Sie das ursprüngliche moment() bearbeiten, was bei der Verwendung von Moment.js eine häufige Falle ist.

Versuchen Sie das, Jungs

time = moment("01:46", "HH:mm");
round_interval = 30;//15;
intervals = Math.floor(time.minutes() / round_interval);
minutesToRound = time.minutes() % round_interval;
minutesRounded = minutesToRound>round_interval/2 ? round_interval: 0;
minutes = intervals * round_interval + minutesRounded;
time.minutes(minutes);

alert(time.format("HH:mm"))

Zu spät zur Party, ich weiß, aber...

Die Funktion nearestMinutes @janwerkhoven ist nicht richtig; das bedeutet, dass es je nach Minute auf- oder abrunden wird, sodass wir beim Runden auf die nächsten 15 12:34 -> 12:30 und 12:39 -> 12:45 erwarten würden

const roundedMinutes = Math.round(someMoment.clone().minute() / interval) * interval;

// 12:34 is fine...
// => Math.round(34 / 15) * 15
// => 2 * 15
30

// ... but 12:39 is not - it should be 45
// => Math.round(39 / 15) * 15
// => 2 * 15
30

Die Lösung von @Silviusconcept überwindet dies mit minutesRounded

@kevlarr
Math.round(39/15) gibt 3 und nicht 2 zurück.
Math.round(39/15) * 15 gibt 45 statt 30 zurück.

Haha, das bekomme ich, wenn ich am Ende des Tages zu viele Threads lese, wenn ich nicht geschlafen habe. Ich habe Math.floor

Ich mag _zbarnett-Lösung_ ! Einfach zu verwenden
Kleines Update der Funktion _ this.milliseconds(0); _

var newdate=turno.date.clone().roundNext15Min().add(Vorausschau, 'Minuten');

moment.fn.roundNext15Min = Funktion () {
var-Intervalle = Math.floor(this.minutes() / 15);
if(diese.minutes() % 15 != 0)
Intervalle++;
if(Intervalle == 4) {
this.add('Stunden', 1);
Intervalle = 0;
}
this.minutes(Intervalle * 15);
this.seconds(0);
_ this.Millisekunden(0); _
gib dies zurück;
}

Meine Version einer Antwort

const startOf = (m, n, unit) => {
  const units = [
    'year',
    'month',
    'hour',
    'minute',
    'second',
    'millisecond',
  ];
  const pos = units.indexOf(unit);
  if (pos === -1) {
    throw new Error('Unsupported unit');
  }
  for (let i = pos + 1; i < units.length; i++) {
    m.set(units[i], 0);
  }
  m.set(unit, Math.floor(m.get(unit) / n) * n);

  return m;
};

const endOf = (m, n, unit) => {
  const units = [
    'year',
    'month',
    'hour',
    'minute',
    'second',
    'millisecond',
  ];
  const pos = units.indexOf(unit);
  if (pos === -1) {
    throw new Error('Unsupported unit');
  }
  for (let i = pos + 1; i < units.length; i++) {
    m.set(units[i], units[i] === 'millisecond' ? 999 : 59);
  }
  m.set(unit, Math.floor(m.get(unit) / n) * n + n - 1);

  return m;
};

Verwenden Sie wie folgt:

startOf(moment(), 15, 'minute');
endOf(moment(), 15, 'minute')
// with moment-timezone
startOf(moment().tz("Europe/London"), 15, 'minute');

Diese Funktionen ändern das ursprüngliche Objekt, verwenden Sie clone() Bedarf

eine andere lösung wäre:
let next15Minutes = moment().add(15, 'minutes'); next15Minutes.minutes(Math.floor(next15Minutes.minutes() / 15) * 15); next15Minutes.format('HH:mm');