Moment: निकटतम 15 मिनट के अंतराल पर गोलाई।

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

मैंने इसे अपने उपयोग के लिए बनाया है और मुझे लगा कि यह दूसरों की मदद कर सकता है। ध्यान रखें कि यह निकटतम NEXT 15 मिनट तक चक्कर लगाता है।

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

संपादित करें: इस के पक्ष में this.incrementHours() हटा दिया। जोड़ें ('घंटे', 1);

क्या आप कृपया इन कार्यों को पल में जोड़ सकते हैं .. निकटतम, अगले और पिछले समय अंतराल में चक्कर लगाने में सक्षम होना वास्तव में अच्छा होगा ... इसके लिए लाखों Google परिणाम हैं और सैकड़ों स्टैक ओवरफ्लो अपवोट हैं ..

अब जब मैं इसे फिर से देखता हूं तो मुझे नहीं पता कि कैसे वेतन वृद्धि घंटे काम कर रहे थे।
मैंने अपनी पोस्ट को सही कोड के साथ इस मुद्दे पर संपादित किया है। आनंद लेना!

सोम, मार्च १०, २०१४ अपराह्न २:२९ अपराह्न, ब्लेक नीमीज़्स्की पर
सूचनाएं@github.comलिखा :

इंक्रीमेंट आवर्स के लिए आपका क्या कार्य था? मैं अनुमान लगा रहा हूँ कि दिन भी किया था
बहुत।

इस ईमेल का सीधे उत्तर दें या इसे Gi tHub पर देखेंhttps://github.com/moment/moment/issues/959#issuecomment -37223821
.

उस विधि के लिए धन्यवाद @zbarnett । ठीक वही जो मुझे अपने प्रोजेक्ट के लिए चाहिए था

वैसे हम startOf इंटरफ़ेस का उपयोग इस तरह कर सकते हैं startOf(15, 'm') । यह सभी इकाइयों के लिए काम कर सकता है। जनसंपर्क की प्रतीक्षा में :)

यहाँ एक बहुत ही सरल सूत्र है (कॉफ़ीस्क्रिप्ट सिंटैक्स में, क्योंकि यही वह संदर्भ है जहाँ मैं इस मुद्दे पर भागा था):

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

मैं अभी अन्य चीजों में काफी व्यस्त हूं, लेकिन अगर कोई इस कोड को लेना चाहता है और इसे सीधे पीआर में डालना चाहता है, तो बेझिझक।

#1595 . के पक्ष में समापन

जटिल, सरल गणित की आवश्यकता नहीं है:

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)

निकटतम 15 मिनट की तिमाही में आउटपुट।

मुझे काम करने के लिए @janwerkhoven का समाधान नहीं मिला, इसलिए यह मेरा है:

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

@ ग्राउंड5हार्क

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

कोड पेन पर परीक्षण किया गया

महत्वपूर्ण बिट कर रहा है .clone() । इसके बिना आप मूल moment() का संपादन कर रहे होंगे जो कि Moment.js का उपयोग करते समय एक सामान्य नुकसान है।

यह कोशिश करो दोस्तों

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

पार्टी के लिए देर हो चुकी है, मुझे पता है, लेकिन ...

@janwerkhoven का nearestMinutes फ़ंक्शन सही नहीं है; इसका मतलब है कि यह मिनट के आधार पर ऊपर या नीचे होगा, इसलिए निकटतम 15 तक हम 12:34 -> 12:30 और 12:39 -> 12:45 अपेक्षा करेंगे

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

@Silviusconcept का समाधान minutesRounded साथ इस पर काबू पाता है

@kevlarr
Math.round(39/15) रिटर्न 3 नहीं 2।
Math.round(39/15) * 15 45 नहीं 30 देता है।

हाहा मुझे दिन के अंत में बहुत सारे सूत्र पढ़ने के लिए मिलता है जब मैं सोया नहीं था .. मैं Math.floor कर रहा था

मुझे _zbarnett समाधान_ पसंद है! प्रयोग करने में आसान
समारोह के लिए थोड़ा अद्यतन _ this.milliseconds(0); _

var newdate=turno.date.clone().roundNext15Min().add(प्रत्याशा, 'मिनट');

मोमेंट.fn.राउंडनेक्स्ट१५मिन = फंक्शन () {
वर अंतराल = Math.floor (यह। मिनट () / 15);
अगर (यह। मिनट ()% 15! = 0)
अंतराल++;
अगर (अंतराल == 4) {
this.add ('घंटे', 1);
अंतराल = 0;
}
यह। मिनट (अंतराल * 15);
यह। सेकंड (0);
_ यह। मिलीसेकंड (0); _
इसे वापस करो;
}

उत्तर का मेरा संस्करण

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

ऐसे करें इस्तेमाल:

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

ये फ़ंक्शन मूल वस्तु को बदल देंगे, जरूरत पड़ने पर clone() उपयोग करें

एक और समाधान होगा:
let next15Minutes = moment().add(15, 'minutes'); next15Minutes.minutes(Math.floor(next15Minutes.minutes() / 15) * 15); next15Minutes.format('HH:mm');