स्टैक एक्सचेंज साइटों के समान "4 मिनट पहले" जैसे xxx के बाद से समय कैसे प्रारूपित करें


210

सवाल यह है कि Dateस्टैक ओवरफ्लो पर प्रदर्शित होने वाले समय को देखने के तरीके के समान एक स्ट्रिंग के रूप में एक जावास्क्रिप्ट को कैसे प्रारूपित किया जाए।

जैसे

  • 1 मिनट पहले
  • 1 घंटे पहले
  • 1 दिन पहले
  • 1 महीने पहले
  • 1 साल पहले



इसके लिए उपयोगी Intl.RelativeTimeFormat.prototype.format():।
Константин Ван

जवाबों:


324

function timeSince(date) {

  var seconds = Math.floor((new Date() - date) / 1000);

  var interval = Math.floor(seconds / 31536000);

  if (interval > 1) {
    return interval + " years";
  }
  interval = Math.floor(seconds / 2592000);
  if (interval > 1) {
    return interval + " months";
  }
  interval = Math.floor(seconds / 86400);
  if (interval > 1) {
    return interval + " days";
  }
  interval = Math.floor(seconds / 3600);
  if (interval > 1) {
    return interval + " hours";
  }
  interval = Math.floor(seconds / 60);
  if (interval > 1) {
    return interval + " minutes";
  }
  return Math.floor(seconds) + " seconds";
}
var aDay = 24*60*60*1000;
console.log(timeSince(new Date(Date.now()-aDay)));
console.log(timeSince(new Date(Date.now()-aDay*2)));


3
@ चेलो - हाँ, बाहर निकलने का एक बिंदु यह गुण है जब यह रास्ते में नहीं मिलता है। जो लोग इसे इन दिनों बहुत गंभीरता से लेते हैं वे अधिकतम की उत्पत्ति को गलत समझ रहे हैं।
स्काई सैंडर्स

36
अच्छा कार्य, लेकिन कुछ टिप्पणी। यूनिक्स टाइमस्टैम्प के साथ काम करने के लिए पहली पंक्ति को: var सेकंड = Math.floor (((नई तारीख ()। GetTime) (/ 1000) - तारीख) बदल दिया। और>> 1 को intval> = 1 में बदलने की आवश्यकता है अन्यथा यह 75 मिनट (1 और 2 घंटे के बीच) जैसी चीजें दिखाएगा।
पानमैन

3
@PmanMan अगर आप सिर्फ> से> = बदलते हैं तो आप "1 मिनट" जैसे समय के साथ समाप्त हो जाएंगे। मैंने इस उत्तर का एक संशोधित संस्करण पोस्ट किया है जो सशर्त रूप से "s" जोड़ता है: stackoverflow.com/a/23259289/373655
लूट

कभी स्ट्रिंग संयोजन का उपयोग करें, लेकिन String.Format यदि आप एक समाधान है कि अंतरराष्ट्रीयकरण किया जा सकता है चाहता हूँ
आरडीएस

अगर मैं इसे दिव्यांग वर्ग में रखना चाहता हूं तो क्या होगा? मैं क्या कर सकता हूँ? क्षमा करें, मैं जावास्क्रिप्ट में समर्थक नहीं हूं। मैंने इस दस्तावेज़ की कोशिश की ।getElementsByTagName ('। नमूनाक्लास') [0] .innerHTML = timeSince (दिनांक); और यह डॉक्यूमेंट .getElementById ('idname') [0] .innerHTML = timeSince (दिनांक); लेकिन यह काम नहीं कर रहा है। कोई मदद? धन्यवाद।
x'tian

118

इस मामले में एक ओवरकिल हो सकता है, लेकिन अगर अवसर दिखाता है क्षण है। बस भयानक है!

Moment.js एक जावास्क्रिप्ट डेटाटाइम लाइब्रेरी है, इस तरह के परिदृश्य के लिए इसका उपयोग करने के लिए, आप यह करेंगे:

moment(yourdate).fromNow()

http://momentjs.com/docs/#/displaying/fromnow/

2018 परिशिष्ट : लक्सन एक नया आधुनिक पुस्तकालय है और देखने लायक हो सकता है!


नमस्कार, मैं आपके उत्तर का समय प्राप्त करने के लिए उपयोग कर रहा हूँ। यदि मुझे डेटेलिक वर्ष के पहले अक्षर y, महीना और m और दिन d के रूप में चाहिए तो मैं क्या कर सकता हूँ?
Nodirabegimxonoyim

57

मैंने जाँच नहीं की है (हालाँकि यह कठिन नहीं होगा), लेकिन मुझे लगता है कि स्टैक एक्सचेंज साइटें इन टाइम स्ट्रिंग्स को बनाने के लिए jquery.timeagoप्लगइन का उपयोग करती हैं


प्लगइन का उपयोग करना काफी आसान है, और यह स्वचालित रूप से साफ और अपडेट है।

यहाँ एक त्वरित नमूना है (प्लगइन के होम पेज से):

सबसे पहले, jQuery और प्लगइन लोड करें:

<script src="jquery.min.js" type="text/javascript"></script> <script src="jquery.timeago.js" type="text/javascript"></script>

अब, चलो इसे DOM टाइम के लिए अपने टाइमस्टैम्प पर संलग्न करें:

jQuery(document).ready(function() {
jQuery("abbr.timeago").timeago(); });

यह शीर्षक के abbrसाथ timeagoऔर आईएसओ 8601 टाइमस्टैम्प के एक वर्ग के साथ सभी तत्वों को बदल देगा : <abbr class="timeago" title="2008-07-17T09:24:17Z">July 17, 2008</abbr>कुछ इस तरह से: <abbr class="timeago" title="July 17, 2008">about a year ago</abbr>जो पैदावार: लगभग एक साल पहले। समय बीतने के साथ टाइमस्टैम्प अपने आप अपडेट हो जाएगा।


11
हर कोई JQuery का उपयोग नहीं करता है।

2
यह एक jQuery प्लगइन के रूप में है करने के लिए कोई मतलब नहीं है।
15

57

यह आपको पिछले और पिछले समय के प्रारूपों को दिखाएगा जैसे '2 दिन पहले' 'अब से 10 मिनट' और आप इसे किसी दिनांक ऑब्जेक्ट, संख्यात्मक टाइमस्टैम्प या डेट स्ट्रिंग के रूप में पास कर सकते हैं

function time_ago(time) {

  switch (typeof time) {
    case 'number':
      break;
    case 'string':
      time = +new Date(time);
      break;
    case 'object':
      if (time.constructor === Date) time = time.getTime();
      break;
    default:
      time = +new Date();
  }
  var time_formats = [
    [60, 'seconds', 1], // 60
    [120, '1 minute ago', '1 minute from now'], // 60*2
    [3600, 'minutes', 60], // 60*60, 60
    [7200, '1 hour ago', '1 hour from now'], // 60*60*2
    [86400, 'hours', 3600], // 60*60*24, 60*60
    [172800, 'Yesterday', 'Tomorrow'], // 60*60*24*2
    [604800, 'days', 86400], // 60*60*24*7, 60*60*24
    [1209600, 'Last week', 'Next week'], // 60*60*24*7*4*2
    [2419200, 'weeks', 604800], // 60*60*24*7*4, 60*60*24*7
    [4838400, 'Last month', 'Next month'], // 60*60*24*7*4*2
    [29030400, 'months', 2419200], // 60*60*24*7*4*12, 60*60*24*7*4
    [58060800, 'Last year', 'Next year'], // 60*60*24*7*4*12*2
    [2903040000, 'years', 29030400], // 60*60*24*7*4*12*100, 60*60*24*7*4*12
    [5806080000, 'Last century', 'Next century'], // 60*60*24*7*4*12*100*2
    [58060800000, 'centuries', 2903040000] // 60*60*24*7*4*12*100*20, 60*60*24*7*4*12*100
  ];
  var seconds = (+new Date() - time) / 1000,
    token = 'ago',
    list_choice = 1;

  if (seconds == 0) {
    return 'Just now'
  }
  if (seconds < 0) {
    seconds = Math.abs(seconds);
    token = 'from now';
    list_choice = 2;
  }
  var i = 0,
    format;
  while (format = time_formats[i++])
    if (seconds < format[0]) {
      if (typeof format[2] == 'string')
        return format[list_choice];
      else
        return Math.floor(seconds / format[2]) + ' ' + format[1] + ' ' + token;
    }
  return time;
}

var aDay = 24 * 60 * 60 * 1000;
console.log(time_ago(new Date(Date.now() - aDay)));
console.log(time_ago(new Date(Date.now() - aDay * 2)));


मिलीसेकंड के बजाय बड़ी समय अवधि के लिए शताब्दियों की वापसी के लिए अंतिम पंक्ति return time;को बदलें format = time_formats[time_formats.length - 1]; return Math.floor(seconds / format[2]) + ' ' + format[1] + ' ' + token;
एक्विला सैंड्स

बहुत अच्छा! हालाँकि मैंने आईओएस में देखा, जब एक फिल्टर के रूप में कोणीय के साथ उपयोग किया जाता है, तो ब्राउज़र यहां NaN देता है। यह इसे ठीक करता है: समय = + नई तिथि (time.replace (/ - / g, '/'));
टिआगो

महान, लेकिन उस समय में काम लूप बदसूरत और भ्रमित है। एक बेहतर लूप में बदलना बेहतर होगा
मार्टिन डॉसन 20

25

यहां स्काई सैंडर के समाधान पर एक मामूली संशोधन है जो तारीख को एक स्ट्रिंग के रूप में इनपुट करने की अनुमति देता है और "73 सेकंड" के बजाय "1 मिनट" जैसे स्पैन प्रदर्शित करने में सक्षम है।

var timeSince = function(date) {
  if (typeof date !== 'object') {
    date = new Date(date);
  }

  var seconds = Math.floor((new Date() - date) / 1000);
  var intervalType;

  var interval = Math.floor(seconds / 31536000);
  if (interval >= 1) {
    intervalType = 'year';
  } else {
    interval = Math.floor(seconds / 2592000);
    if (interval >= 1) {
      intervalType = 'month';
    } else {
      interval = Math.floor(seconds / 86400);
      if (interval >= 1) {
        intervalType = 'day';
      } else {
        interval = Math.floor(seconds / 3600);
        if (interval >= 1) {
          intervalType = "hour";
        } else {
          interval = Math.floor(seconds / 60);
          if (interval >= 1) {
            intervalType = "minute";
          } else {
            interval = seconds;
            intervalType = "second";
          }
        }
      }
    }
  }

  if (interval > 1 || interval === 0) {
    intervalType += 's';
  }

  return interval + ' ' + intervalType;
};
var aDay = 24 * 60 * 60 * 1000;
console.log(timeSince(new Date(Date.now() - aDay)));
console.log(timeSince(new Date(Date.now() - aDay * 2)));


2
यह सेकंड के लिए काम नहीं करता है क्योंकि अंतराल 0 से छोड़ा गया है interval = Math.floor(seconds / 60);। मैंने interval = seconds;फाइनल में जोड़ा elseऔर यह ठीक काम करता है।
हावर्ड

2
यदि अंतराल 0 है, तो आपको "एस" भी जोड़ना चाहिए।
जेडब्ल्यू।

यह कमाल का है। टीएस के लिए मुझे एक let seconds = Math.floor((+new Date() - date) / 1000);
गैर

आप interval === 0आखिरी में भी जांच क्यों करते हैं if?
Smartmouse

1
@smartmouse ताकि यह "0 सेकंड" के बजाय "0 सेकंड" कहेगा
लूट

14

आप humanized_time_span को देखना चाहते हैं: https://github.com/layam/js_humanized_span

यह रूपरेखा अज्ञेय और पूरी तरह से अनुकूलन है।

बस स्क्रिप्ट को डाउनलोड / शामिल करें और फिर आप यह कर सकते हैं:

humanized_time_span("2011-05-11 12:00:00")  
   => '3 hours ago'

humanized_time_span("2011-05-11 12:00:00", "2011-05-11 16:00:00)  
   => '4 hours ago'

या यहां तक ​​कि:

var custom_date_formats = {
  past: [
    { ceiling: 60, text: "less than a minute ago" },
    { ceiling: 86400, text: "$hours hours, $minutes minutes and $seconds seconds ago" },
    { ceiling: null, text: "$years years ago" }
  ],
  future: [
    { ceiling: 60, text: "in less than a minute" },
    { ceiling: 86400, text: "in $hours hours, $minutes minutes and $seconds seconds time" },
    { ceiling: null, text: "in $years years" }
  ]
}

humanized_time_span("2010/09/10 10:00:00", "2010/09/10 10:00:05", custom_date_formats) 
  => "less than a minute ago"

अधिक जानकारी के लिए डॉक्स पढ़ें।


4
बस इसका मतलब है कि यह jQuery पर निर्भर नहीं है या यहां तक ​​कि एक डोम होने पर।
विल टोमलिन्स

यह मुझे NaN years agoक्यों देता है ??

यह मुझे समझ में आ गया ... इसका उपयोग करने का आपका उदाहरण गलत है। आप वास्तव में "-" .. के बजाय स्लैश के साथ पहले नंबर का परिसीमन करते हैंhumanized_time_span("2011/05/11 12:00:00")

यह आपकी स्थानीय संस्कृति पर निर्भर हो सकता है और उपयोगकर्ताओं के बीच भिन्न हो सकता है :)
mikus

13

ऊपर दिए गए फ़ंक्शन को बदल दिया

function timeSince(date) {

    var seconds = Math.floor(((new Date().getTime()/1000) - date)),
    interval = Math.floor(seconds / 31536000);

    if (interval > 1) return interval + "y";

    interval = Math.floor(seconds / 2592000);
    if (interval > 1) return interval + "m";

    interval = Math.floor(seconds / 86400);
    if (interval >= 1) return interval + "d";

    interval = Math.floor(seconds / 3600);
    if (interval >= 1) return interval + "h";

    interval = Math.floor(seconds / 60);
    if (interval > 1) return interval + "m ";

    return Math.floor(seconds) + "s";
}

अन्यथा यह "75 मिनट" (1 से 2 घंटे के बीच) जैसी चीजें दिखाएगा। अब यह भी माना जाता है कि इनपुट तिथि एक यूनिक्स टाइमस्टैम्प है।


कृपया तारीख को 1000 से भाग दें।

मैंने इसका उपयोग किया जहां डेटा एक डेटाबेस से यूनिक्स टाइमस्टैम्प के साथ सेकंड में आया था। जब यह मिलीसेकंड में होता है, तो आपको 1000 से विभाजित करने की आवश्यकता होती है।
पानमैन

11

बहुत पठनीय और पार ब्राउज़र संगत कोड:

जैसा कि @Travis द्वारा दिया गया है

var DURATION_IN_SECONDS = {
  epochs: ['year', 'month', 'day', 'hour', 'minute'],
  year: 31536000,
  month: 2592000,
  day: 86400,
  hour: 3600,
  minute: 60
};

function getDuration(seconds) {
  var epoch, interval;

  for (var i = 0; i < DURATION_IN_SECONDS.epochs.length; i++) {
    epoch = DURATION_IN_SECONDS.epochs[i];
    interval = Math.floor(seconds / DURATION_IN_SECONDS[epoch]);
    if (interval >= 1) {
      return {
        interval: interval,
        epoch: epoch
      };
    }
  }

};

function timeSince(date) {
  var seconds = Math.floor((new Date() - new Date(date)) / 1000);
  var duration = getDuration(seconds);
  var suffix = (duration.interval > 1 || duration.interval === 0) ? 's' : '';
  return duration.interval + ' ' + duration.epoch + suffix;
};

alert(timeSince('2015-09-17T18:53:23'));


ध्यान दें कि यह कुछ गलत धारणाएं बनाता है, जैसे कि हर दिन 86,400 सेकंड (जब तक कि समय यूटीसी पर सेट नहीं होता है, यह हमेशा यूटीसी के लिए धन्यवाद नहीं होता है)
इटलीपेलएले

10

एक छोटा संस्करण जिसे लोकेली द्वारा उपयोग किया जाता है :

const intervals = [
  { label: 'year', seconds: 31536000 },
  { label: 'month', seconds: 2592000 },
  { label: 'day', seconds: 86400 },
  { label: 'hour', seconds: 3600 },
  { label: 'minute', seconds: 60 },
  { label: 'second', seconds: 0 }
];

function timeSince(date) {
  const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
  const interval = intervals.find(i => i.seconds < seconds);
  const count = Math.floor(seconds / interval.seconds);
  return `${count} ${interval.label}${count !== 1 ? 's' : ''} ago`;
}

2
सबसे कम अंतराल में शून्य सेकंड की अवधि होती है - इसके परिणामस्वरूप शून्य त्रुटि द्वारा विभाजन होता है।
apk

@apk सही है। <60 सेकंड यह प्रिंट करता हैInfinity seconds ago
leonheess

8

अब से, यूनिक्स टाइमस्टैम्प परम,

function timeSince(ts){
    now = new Date();
    ts = new Date(ts*1000);
    var delta = now.getTime() - ts.getTime();

    delta = delta/1000; //us to s

    var ps, pm, ph, pd, min, hou, sec, days;

    if(delta<=59){
        ps = (delta>1) ? "s": "";
        return delta+" second"+ps
    }

    if(delta>=60 && delta<=3599){
        min = Math.floor(delta/60);
        sec = delta-(min*60);
        pm = (min>1) ? "s": "";
        ps = (sec>1) ? "s": "";
        return min+" minute"+pm+" "+sec+" second"+ps;
    }

    if(delta>=3600 && delta<=86399){
        hou = Math.floor(delta/3600);
        min = Math.floor((delta-(hou*3600))/60);
        ph = (hou>1) ? "s": "";
        pm = (min>1) ? "s": "";
        return hou+" hour"+ph+" "+min+" minute"+pm;
    } 

    if(delta>=86400){
        days = Math.floor(delta/86400);
        hou =  Math.floor((delta-(days*86400))/60/60);
        pd = (days>1) ? "s": "";
        ph = (hou>1) ? "s": "";
        return days+" day"+pd+" "+hou+" hour"+ph;
    }

}

5

@ User1012181 द्वारा प्रदान किए गए कोड का एक ES6 संस्करण

// Epochs
const epochs = [
    ['year', 31536000],
    ['month', 2592000],
    ['day', 86400],
    ['hour', 3600],
    ['minute', 60],
    ['second', 1]
];


// Get duration
const getDuration = (timeAgoInSeconds) => {
    for (let [name, seconds] of epochs) {
        const interval = Math.floor(timeAgoInSeconds / seconds);

        if (interval >= 1) {
            return {
                interval: interval,
                epoch: name
            };
        }
    }
};


// Calculate
const timeAgo = (date) => {
    const timeAgoInSeconds = Math.floor((new Date() - new Date(date)) / 1000);
    const {interval, epoch} = getDuration(timeAgoInSeconds);
    const suffix = interval === 1 ? '' : 's';

    return `${interval} ${epoch}${suffix} ago`;
};

@ Ibe-vanmeenen सुझावों के साथ संपादित। (धन्यवाद !)


आपको एसवीएस में "दूसरा: 1" भी शामिल करना चाहिए, अन्यथा यह 1 मिनट से कम समय पहले टूट जाएगा :)। पिछले 3 संस्करण भी एक निरंतर नहीं हो सकता है?
इबे वेनमेन

1
इसके अलावा, ऐन्ड्रस एक एरे होना चाहिए, क्योंकि ऑब्जेक्ट्स प्रॉपर्टी ऑर्डर की गारंटी नहीं देते हैं। मैंने gist.github.com/IbeVanmeenen/4e3e58820c9168806e57530563612886 पर अपने परिवर्तन संग्रहीत कर लिए हैं । आप इस उत्तर को संपादित करने के लिए उन्हें कॉपी करने के लिए आपका स्वागत करते हैं :)
Ibe Vanmeenen

5

सरल और पठनीय संस्करण:

const NOW = new Date()
const times = [["second", 1], ["minute", 60], ["hour", 3600], ["day", 86400], ["week", 604800], ["month", 2592000], ["year", 31536000]]

function timeAgo(date) {
    var diff = Math.round((NOW - date) / 1000)
    for (var t = 0; t < times.length; t++) {
        if (diff < times[t][1]) {
            if (t == 0) {
                return "Just now"
            } else {
                diff = Math.round(diff / times[t - 1][1])
                return diff + " " + times[t - 1][0] + (diff == 1?" ago":"s ago")
            }
        }
    }
}

3

मैं js और अजगर के साथ एक लिखता हूं, दो परियोजनाओं में उपयोग किया जाता है, बहुत अच्छा और सरल: एक साधारण पुस्तकालय (कम तब 2kb) के साथ दिनांक प्रारूप*** time ago कथन के ।

सरल, छोटा, आसान उपयोग, और अच्छी तरह से परीक्षण किया गया।

  1. npm install timeago.js

  2. import timeago from 'timeago.js'; // or use script tag

  3. आपी का उपयोग करें format

नमूना:

var timeagoIns  = timeago();
timeagoIns .format('2016-06-12');

इसके अलावा, आप वास्तविक समय में प्रस्तुत कर सकते हैं।

var timeagoIns = timeago();
timeagoIns.render(document.querySelectorAll('time'));

4.0 के रूप में आप इसके बजाय एक विनाशकारी आयात का उपयोग कर सकते हैं:import { format, render, cancel, register } from 'timeago.js';
23

3

हालाँकि यह प्रश्न काफी पहले पूछा गया था, लेकिन इस उत्तर को आशा के साथ लिखने से किसी को मदद मिलेगी।

उस तिथि को पास करें जिससे आप गिनती शुरू करना चाहते हैं। का उपयोग करते हुए moment().fromNow()की momentjs : (अधिक जानकारी देखें यहाँ )

getRelativeTime(date) {
    const d = new Date(date * 1000);
    return moment(d).fromNow();
}

यदि आप तारीखों के लिए प्रदान की गई जानकारी को बदलना चाहते हैं, तो आप अपने कस्टम रिलेटिव टाइम को पल में लिखें।

उदाहरण के लिए, अपने स्वयं के मामले में मैं 'one month ago'इसके बजाय मुद्रित करना चाहता था 'a month ago'( क्षण द्वारा प्रदान की गई (डी) .fromNow () )। इस मामले में, आप नीचे दिए गए कुछ लिख सकते हैं।

moment.updateLocale('en', {
    relativeTime: {
        future: 'in %s',
        past: '%s ago',
        s: 'a few seconds',
        ss: '%d seconds',
        m: '1 m',
        mm: '%d minutes',
        h: '1 h',
        hh: '%d hours',
        d: '1 d',
        dd: '%d days',
        M: '1 month',
        MM: '%d months',
        y: '1 y',
        yy: '%d years'
    }
});

नोट : मैंने Agular 6 में प्रोजेक्ट के लिए अपना कोड लिखा है


3

इसे हल करने के लिए dayjs सापेक्ष समय प्लगइन का भी उपयोग कर सकते हैं ।

import * as dayjs from 'dayjs';
import * as relativeTime from 'dayjs/plugin/relativeTime';

dayjs.extend(relativeTime);
dayjs(dayjs('1990')).fromNow(); // x years ago

3

यह Date.now (), एकवचन इकाइयों और भविष्य की तारीखों सहित किसी भी मान्य टाइमस्टैम्प को ठीक से संभालना चाहिए। मैंने महीनों छोड़ दिए, लेकिन उन्हें जोड़ना आसान होना चाहिए। मैंने इसे यथासंभव पठनीय रखने की कोशिश की।

function getTimeInterval(date) {
  let seconds = Math.floor((Date.now() - date) / 1000);
  let unit = "second";
  let direction = "ago";
  if (seconds < 0) {
    seconds = -seconds;
    direction = "from now";
  }
  let value = seconds;
  if (seconds >= 31536000) {
    value = Math.floor(seconds / 31536000);
    unit = "year";
  } else if (seconds >= 86400) {
    value = Math.floor(seconds / 86400);
    unit = "day";
  } else if (seconds >= 3600) {
    value = Math.floor(seconds / 3600);
    unit = "hour";
  } else if (seconds >= 60) {
    value = Math.floor(seconds / 60);
    unit = "minute";
  }
  if (value != 1)
    unit = unit + "s";
  return value + " " + unit + " " + direction;
}

console.log(getTimeInterval(Date.now())); // 0 seconds ago
console.log(getTimeInterval(Date.now() + 1000)); // 1 second from now
console.log(getTimeInterval(Date.now() - 1000)); // 1 second ago
console.log(getTimeInterval(Date.now() + 60000)); // 1 minute from now
console.log(getTimeInterval(Date.now() - 120000)); // 2 minutes ago
console.log(getTimeInterval(Date.now() + 120000)); // 2 minutes from now
console.log(getTimeInterval(Date.now() + 3600000)); // 1 hour from now
console.log(getTimeInterval(Date.now() + 360000000000)); // 11 years from now
console.log(getTimeInterval(0)); // 49 years ago


2

मैंने स्काई सैंडर्स के संस्करण को संशोधित किया है। अगर ब्लॉक में Math.floor (...) संचालन का मूल्यांकन किया जाता है

       var timeSince = function(date) {
            var seconds = Math.floor((new Date() - date) / 1000);
            var months = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
            if (seconds < 5){
                return "just now";
            }else if (seconds < 60){
                return seconds + " seconds ago";
            }
            else if (seconds < 3600) {
                minutes = Math.floor(seconds/60)
                if(minutes > 1)
                    return minutes + " minutes ago";
                else
                    return "1 minute ago";
            }
            else if (seconds < 86400) {
                hours = Math.floor(seconds/3600)
                if(hours > 1)
                    return hours + " hours ago";
                else
                    return "1 hour ago";
            }
            //2 days and no more
            else if (seconds < 172800) {
                days = Math.floor(seconds/86400)
                if(days > 1)
                    return days + " days ago";
                else
                    return "1 day ago";
            }
            else{

                //return new Date(time).toLocaleDateString();
                return date.getDate().toString() + " " + months[date.getMonth()] + ", " + date.getFullYear();
            }
        }

पिछले कुछ और लिखने में कोई गलती है, अगर वहाँ return days + "1 day ago";होना चाहिएreturn "1 day ago";
मार्को Gurnari

2
function dateToHowManyAgo(stringDate){
    var currDate = new Date();
    var diffMs=currDate.getTime() - new Date(stringDate).getTime();
    var sec=diffMs/1000;
    if(sec<60)
        return parseInt(sec)+' second'+(parseInt(sec)>1?'s':'')+' ago';
    var min=sec/60;
    if(min<60)
        return parseInt(min)+' minute'+(parseInt(min)>1?'s':'')+' ago';
    var h=min/60;
    if(h<24)
        return parseInt(h)+' hour'+(parseInt(h)>1?'s':'')+' ago';
    var d=h/24;
    if(d<30)
        return parseInt(d)+' day'+(parseInt(d)>1?'s':'')+' ago';
    var m=d/30;
    if(m<12)
        return parseInt(m)+' month'+(parseInt(m)>1?'s':'')+' ago';
    var y=m/12;
    return parseInt(y)+' year'+(parseInt(y)>1?'s':'')+' ago';
}
console.log(dateToHowManyAgo('2019-11-07 19:17:06'));

1
function timeago(date) {
    var seconds = Math.floor((new Date() - date) / 1000);
    if(Math.round(seconds/(60*60*24*365.25)) >= 2) return Math.round(seconds/(60*60*24*365.25)) + " years ago";
    else if(Math.round(seconds/(60*60*24*365.25)) >= 1) return "1 year ago";
    else if(Math.round(seconds/(60*60*24*30.4)) >= 2) return Math.round(seconds/(60*60*24*30.4)) + " months ago";
    else if(Math.round(seconds/(60*60*24*30.4)) >= 1) return "1 month ago";
    else if(Math.round(seconds/(60*60*24*7)) >= 2) return Math.round(seconds/(60*60*24*7)) + " weeks ago";
    else if(Math.round(seconds/(60*60*24*7)) >= 1) return "1 week ago";
    else if(Math.round(seconds/(60*60*24)) >= 2) return Math.round(seconds/(60*60*24)) + " days ago";
    else if(Math.round(seconds/(60*60*24)) >= 1) return "1 day ago";
    else if(Math.round(seconds/(60*60)) >= 2) return Math.round(seconds/(60*60)) + " hours ago";
    else if(Math.round(seconds/(60*60)) >= 1) return "1 hour ago";
    else if(Math.round(seconds/60) >= 2) return Math.round(seconds/60) + " minutes ago";
    else if(Math.round(seconds/60) >= 1) return "1 minute ago";
    else if(seconds >= 2)return seconds + " seconds ago";
    else return seconds + "1 second ago";
}

1

मेरा समाधान ।।

(function(global){
            const SECOND   = 1;
            const MINUTE   = 60;
            const HOUR     = 3600;
            const DAY      = 86400;
            const MONTH    = 2629746;
            const YEAR     = 31556952;
            const DECADE   = 315569520;

            global.timeAgo = function(date){
                var now = new Date();
                var diff = Math.round(( now - date ) / 1000);

                var unit = '';
                var num = 0;
                var plural = false;

                switch(true){
                    case diff <= 0:
                        return 'just now';
                    break;

                    case diff < MINUTE:
                        num = Math.round(diff / SECOND);
                        unit = 'sec';
                        plural = num > 1;
                    break;

                    case diff < HOUR:
                        num = Math.round(diff / MINUTE);
                        unit = 'min';
                        plural = num > 1;
                    break;

                    case diff < DAY:
                        num = Math.round(diff / HOUR);
                        unit = 'hour';
                        plural = num > 1;
                    break;

                    case diff < MONTH:
                        num = Math.round(diff / DAY);
                        unit = 'day';
                        plural = num > 1;
                    break;

                    case diff < YEAR:
                        num = Math.round(diff / MONTH);
                        unit = 'month';
                        plural = num > 1;
                    break;

                    case diff < DECADE:
                        num = Math.round(diff / YEAR);
                        unit = 'year';
                        plural = num > 1;
                    break;

                    default:
                        num = Math.round(diff / YEAR);
                        unit = 'year';
                        plural = num > 1;
                }

                var str = '';
                if(num){
                    str += `${num} `;
                }

                str += `${unit}`;

                if(plural){
                    str += 's';
                }

                str += ' ago';

                return str;
            }
        })(window);

        console.log(timeAgo(new Date()));
        console.log(timeAgo(new Date('Jun 03 2018 15:12:19 GMT+0300 (FLE Daylight Time)')));
        console.log(timeAgo(new Date('Jun 03 2018 13:12:19 GMT+0300 (FLE Daylight Time)')));
        console.log(timeAgo(new Date('May 28 2018 13:12:19 GMT+0300 (FLE Daylight Time)')));
        console.log(timeAgo(new Date('May 28 2017 13:12:19 GMT+0300 (FLE Daylight Time)')));
        console.log(timeAgo(new Date('May 28 2000 13:12:19 GMT+0300 (FLE Daylight Time)')));
        console.log(timeAgo(new Date('Sep 10 1994 13:12:19 GMT+0300 (FLE Daylight Time)')));

1

अन्य जवाबों के आधार पर मेरा छुरा।

function timeSince(date) {
    let minute = 60;
    let hour   = minute * 60;
    let day    = hour   * 24;
    let month  = day    * 30;
    let year   = day    * 365;

    let suffix = ' ago';

    let elapsed = Math.floor((Date.now() - date) / 1000);

    if (elapsed < minute) {
        return 'just now';
    }

    // get an array in the form of [number, string]
    let a = elapsed < hour  && [Math.floor(elapsed / minute), 'minute'] ||
            elapsed < day   && [Math.floor(elapsed / hour), 'hour']     ||
            elapsed < month && [Math.floor(elapsed / day), 'day']       ||
            elapsed < year  && [Math.floor(elapsed / month), 'month']   ||
            [Math.floor(elapsed / year), 'year'];

    // pluralise and append suffix
    return a[0] + ' ' + a[1] + (a[0] === 1 ? '' : 's') + suffix;
}

0

मैं इसका उत्तर ढूंढ रहा था और इनमें से किसी एक समाधान को लागू कर दिया था, लेकिन एक सहकर्मी ने मुझे react-intlलाइब्रेरी की जांच करने के लिए याद दिलाया क्योंकि हम इसका इस्तेमाल कर रहे थे।

इसलिए समाधानों को जोड़ते हुए ... मामले में आप react-intlपुस्तकालय का उपयोग कर रहे हैं , उनके पास इसके लिए एक <FormattedRelative>घटक है।

https://github.com/yahoo/react-intl/wiki/Components#formattedrelative


0

यहाँ मैंने क्या किया (वस्तु अपने मूल्य के साथ समय की इकाई लौटाती है):

function timeSince(post_date, reference)
{
	var reference = reference ? new Date(reference) : new Date(),
		diff = reference - new Date(post_date + ' GMT-0000'),
		date = new Date(diff),
		object = { unit: null, value: null };
	
	if (diff < 86400000)
	{
		var secs  = date.getSeconds(),
			mins  = date.getMinutes(),
			hours = date.getHours(),
			array = [ ['second', secs], ['minute', mins], ['hour', hours] ];
	}
	else
	{
		var days   = date.getDate(),
			weeks  = Math.floor(days / 7),
			months = date.getMonth(),
			years  = date.getFullYear() - 1970,
			array  = [ ['day', days], ['week', weeks], ['month', months], ['year', years] ];
	}

	for (var i = 0; i < array.length; i++)
	{
		array[i][0] += array[i][1] != 1 ? 's' : '';

		object.unit  = array[i][1] >= 1 ? array[i][0] : object.unit;
		object.value = array[i][1] >= 1 ? array[i][1] : object.value;
	}

	return object;
}

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.