So formatieren Sie die Zeit seit xxx, z. B. "vor 4 Minuten", ähnlich wie bei Stack Exchange-Sites

Antworten:

322

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

Sky Sanders
quelle
3
@hello - ja, Single Point of Exit hat seine Tugenden, wenn es nicht im Weg ist. diejenigen, die es heutzutage zu ernst nehmen, verstehen den Ursprung der Maxime falsch.
Sky Sanders
36
Gute Funktion, aber einige Bemerkungen. Die erste Zeile wurde geändert in: var Sekunden = Math.floor (((neues Datum (). GetTime () / 1000) - Datum)), um mit Unix-Zeitstempeln zu arbeiten. Und musste das intval> 1 in intval> = 1 ändern, sonst würde es Dinge wie 75 Minuten (zwischen 1 und 2 Stunden) anzeigen.
PanMan
3
@PanMan Wenn Sie nur> zu> = ändern, erhalten Sie Zeiten wie "1 Minuten". Ich habe eine modifizierte Version dieser Antwort gepostet, die bedingt das "s" hinzufügt: stackoverflow.com/a/23259289/373655
rob
Verwenden Sie niemals die Verkettung von Zeichenfolgen, sondern String.format, wenn Sie eine Lösung
suchen
Was ist, wenn ich es in die Div-Klasse einordnen möchte? Was kann ich tun? Entschuldigung, ich bin kein Profi in Javascript. Ich habe versucht, dieses document.getElementsByTagName ('. Sampleclass') [0] .innerHTML = timeSince (date); und dieses document.getElementById ('idname') [0] .innerHTML = timeSince (date); aber es funktioniert nicht. Irgendeine Hilfe? Danke dir.
X'tian
118

Könnte in diesem Fall ein Overkill sein, aber wenn sich die Gelegenheit zeigt, ist moment.js einfach fantastisch!

Moment.js ist eine Javascript-Datetime-Bibliothek. Um sie für ein solches Szenario zu verwenden, gehen Sie wie folgt vor:

moment(yourdate).fromNow()

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

Nachtrag 2018 : Luxon ist eine neue moderne Bibliothek und könnte einen Blick wert sein!

Fabiano Soriani
quelle
Hallo, ich verwende Ihre Antwort, um Zeitunterschiede zu ermitteln. Was kann ich tun, wenn ich nur Anfangsbuchstaben des Datumsjahres y, Monat und m und Tag als d benötige?
Nodirabegimxonoyim
57

Ich habe nicht überprüft (obwohl es nicht schwer wäre), aber ich denke, dass Stack Exchange-Sites das jquery.timeagoPlugin verwenden , um diese Zeitzeichenfolgen zu erstellen .


Das Plugin ist recht einfach zu verwenden, es ist sauber und wird automatisch aktualisiert.

Hier ist ein kurzes Beispiel (von der Homepage des Plugins):

Laden Sie zuerst jQuery und das Plugin:

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

Lassen Sie es uns jetzt an Ihre Zeitstempel in DOM anhängen:

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

Dadurch werden alle abbrElemente mit einer Klasse von timeagound einem ISO 8601-Zeitstempel im Titel: <abbr class="timeago" title="2008-07-17T09:24:17Z">July 17, 2008</abbr>in etwa Folgendes umgewandelt: <abbr class="timeago" title="July 17, 2008">about a year ago</abbr>was vor etwa einem Jahr ergibt. Mit der Zeit werden die Zeitstempel automatisch aktualisiert.

Maxim Zaslavsky
quelle
11
Nicht jeder verwendet JQuery.
2
Es macht keinen Sinn, dies als jquery-Plugin zu haben.
AlexG
57

Dies zeigt Ihnen vergangene und frühere Zeitformate wie 'vor 2 Tagen' 'in 10 Minuten' und Sie können entweder ein Datumsobjekt, einen numerischen Zeitstempel oder eine Datumszeichenfolge übergeben

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

Das Gehirn
quelle
Ersetzen Sie die letzte Zeile return time;durch format = time_formats[time_formats.length - 1]; return Math.floor(seconds / format[2]) + ' ' + format[1] + ' ' + token;, um Jahrhunderte für große Zeitspannen anstelle der Millisekunden zurückzugeben.
Aquila Sands
Sehr schön! Obwohl ich in iOS festgestellt habe, dass der Browser bei Verwendung mit Angular als Filter NaN zurückgibt. Dies behebt das Problem: time = + new Date (time.replace (/ - / g, '/'));
Tiago
Großartig, aber die Zuordnung in dieser while-Schleife ist hässlich und verwirrend. Ein Wechsel zu einer forEach-Schleife wäre besser
Martin Dawson
25

Hier ist eine geringfügige Änderung an der Sky Sander-Lösung, mit der das Datum als Zeichenfolge eingegeben werden kann und Bereiche wie "1 Minute" anstelle von "73 Sekunden" angezeigt werden können.

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

rauben
quelle
2
Dies funktioniert für Sekunden nicht, da das Intervall als 0 von belassen wird interval = Math.floor(seconds / 60);. Ich habe interval = seconds;in das Finale hinzugefügt elseund es funktioniert gut.
Howard10
2
Wenn das Intervall 0 ist, sollten Sie auch das "s" hinzufügen.
JW.
Das ist fantastisch. Für TS musste ich einen unären Operator hinzufügenlet seconds = Math.floor((+new Date() - date) / 1000);
Ben Racicot
Warum prüfst du auch interval === 0im letzten if?
Smartmouse
1
@smartmouse, so dass "0 Sekunden" anstelle von "0 Sekunden" angezeigt wird
rob
14

Vielleicht möchten Sie sich humanized_time_span ansehen: https://github.com/layam/js_humanized_time_span

Es ist rahmenunabhängig und vollständig anpassbar.

Laden Sie einfach das Skript herunter / fügen Sie es hinzu, und dann können Sie Folgendes tun:

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'

oder sogar das:

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"

Lesen Sie die Dokumente für weitere Informationen.

Will Tomlins
quelle
4
Bedeutet nur, dass es nicht auf jQuery oder ein DOM angewiesen ist.
Will Tomlins
Es gibt mir NaN years agowarum?
Verdammt, ich habe es verstanden ... Ihr Beispiel für seine Verwendung ist falsch. Sie begrenzen die ersten Zahlen tatsächlich mit einem Schrägstrich anstatt mit "-" .. wie humanized_time_span("2011/05/11 12:00:00")
es könnte von Ihrer lokalen Kultur abhängen und sich zwischen den Benutzern unterscheiden :)
mikus
13

Die obige Funktion wurde in geändert

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

Andernfalls würde es Dinge wie "75 Minuten" (zwischen 1 und 2 Stunden) anzeigen. Es wird jetzt auch davon ausgegangen, dass das Eingabedatum ein Unix-Zeitstempel ist.

PanMan
quelle
Teilen Sie das Datum bitte durch 1000.
Ich habe dies verwendet, wenn Daten aus einer Datenbank mit Unix-Zeitstempeln in Sekunden stammen. Wenn es in Millisekunden ist, müssen Sie durch 1000 teilen.
PanMan
11

Viel lesbarer und browserübergreifender Code:

Wie von @Travis angegeben

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

user1012181
quelle
Beachten Sie, dass dies einige falsche Annahmen macht, wie zum Beispiel, dass jeder Tag 86.400 Sekunden beträgt (es sei denn, die Zeitzone ist auf UTC eingestellt, dies ist dank UTC nicht immer der Fall)
ItalyPaleAle
10

Eine kürzere Version, wie sie von Lokely verwendet wird :

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`;
}
Sam
quelle
2
Das kürzeste Intervall hat eine Dauer von null Sekunden - dies führt zu einem Fehler durch Division durch Null.
Apk
@apk ist richtig. <60 Sekunden druckt esInfinity seconds ago
Leonheess
8

ab jetzt unix timestamp param,

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

}
pkarc
quelle
5

Eine ES6-Version des von @ user1012181 bereitgestellten Codes

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

Bearbeitet mit @ ibe-vanmeenen Vorschlägen. (Vielen Dank !)

Geoffroy Warin
quelle
Sie sollten auch "second: 1" in EPOCHS aufnehmen, da es sonst kaputt geht, wenn es weniger als 1 Minute her ist :). Die letzten 3 Vars könnten auch eine Konstante sein, nein?
Ibe Vanmeenen
1
Außerdem sollte EPOCHS ein Array sein, da Objekte keine Reihenfolge der Eigenschaften garantieren. Ich habe meine Änderungen in gist.github.com/IbeVanmeenen/4e3e58820c9168806e57530563612886 gespeichert . Sie können sie gerne kopieren, um diese Antwort zu bearbeiten :)
Ibe Vanmeenen
5

Einfache und lesbare Version:

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")
            }
        }
    }
}
jcrs
quelle
3

Ich schreibe eine mit js und python, die in zwei Projekten verwendet wird, sehr schön und einfach: eine einfache Bibliothek (weniger als 2 KB), mit der das Datum formatiert wird*** time ago Anweisung verwendet wird.

einfach, klein, leicht zu bedienen und gut getestet.

  1. npm install timeago.js

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

  3. benutze api format.

Stichprobe:

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

Sie können auch in Echtzeit rendern.

var timeagoIns = timeago();
timeagoIns.render(document.querySelectorAll('time'));
ein Werkzeug
quelle
Ab 4.0 können Sie stattdessen einen destrukturierten Import verwenden:import { format, render, cancel, register } from 'timeago.js';
cmfolio
3

Obwohl die Frage vor ziemlich langer Zeit gestellt wurde, wird es jemandem helfen, diese Antwort mit der Hoffnung zu schreiben.

Übergeben Sie das Datum, ab dem Sie mit dem Zählen beginnen möchten. Verwendung moment().fromNow()von momentjs : (Weitere Informationen finden Sie hier )

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

Wenn Sie die für Daten von Now bereitgestellten Informationen ändern möchten, schreiben Sie Ihre benutzerdefinierte relative Zeit für den Moment.

In meinem Fall wollte ich beispielsweise 'one month ago'anstelle von 'a month ago'( bereitgestellt durch moment (d) .fromNow () ) drucken . In diesem Fall können Sie etwas unten angegebenes schreiben.

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

HINWEIS : Ich habe meinen Code für das Projekt in Agular 6 geschrieben

Nodirabegimxonoyim
quelle
3

Kann auch das dayjs relativeTime- Plugin verwenden, um dies zu lösen.

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

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

Dies sollte alle gültigen Zeitstempel ordnungsgemäß behandeln, einschließlich Date.now (), einzelne Einheiten und zukünftige Daten. Ich habe Monate ausgelassen, aber diese sollten leicht hinzuzufügen sein. Ich habe versucht, sie so gut wie möglich lesbar zu halten.

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

Wille
quelle
2

Ich habe die Version von Sky Sanders geändert. Die Math.floor (...) -Operationen werden im if-Block ausgewertet

       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();
            }
        }
Moses Koledoye
quelle
Es gibt einen Tippfehler im letzten, wenn es return days + "1 day ago";sein solltereturn "1 day ago";
Marco 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'));
Boumeziane Marouane
quelle
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";
}
Uygar
quelle
1

Meine Lösung..

(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)')));
Nikksan
quelle
1

Mein Stich dazu basiert auf anderen Antworten.

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;
}
Maksim Ivanov
quelle
0

Ich suchte nach einer Antwort darauf und hätte fast eine dieser Lösungen implementiert, aber ein Kollege erinnerte mich daran, die react-intlBibliothek zu überprüfen, da wir sie bereits verwendeten.

Hinzufügen zu den Lösungen ... Wenn Sie die react-intlBibliothek verwenden, haben sie eine <FormattedRelative>Komponente dafür.

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

ewH
quelle
0

Folgendes habe ich getan (das Objekt gibt die Zeiteinheit zusammen mit ihrem Wert zurück):

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

Nateclonch
quelle