সি # মধ্যে আপেক্ষিক সময় গণনা

একটি নির্দিষ্ট তারিখের সময় মান দেওয়া হয়েছে, আমি কিভাবে আপেক্ষিক সময় প্রদর্শন করব, যেমন:

  • 2 ঘন্টা আগে
  • 3 দিন আগে
  • এক মাস আগে
0
যোগ সম্পাদিত
মতামত: 13
যদি আপনি এখন থেকে ভবিষ্যত থেকে একটি আপেক্ষিক সময় গণনা করতে চান?
যোগ লেখক Jhonny D. Cano -Leftware-, উৎস
এখানে .net প্যাকেজ রয়েছে যা github.com/NickStrupat/TimeAgo যা জিজ্ঞাসা করা হচ্ছে তা অনেক বেশি।
যোগ লেখক Rossco, উৎস
moment.js একটি খুব সুন্দর তারিখ পার্সিং লাইব্রেরী .. আপনি আপনার প্রয়োজনের উপর নির্ভর করে (সার্ভার সাইড বা ক্লায়েন্ট সাইড) ব্যবহার করে বিবেচনা করতে পারেন। শুধু fyi কারণ কেউ এখানে উল্লেখ নেই
যোগ লেখক code ninja, উৎস

32 উত্তর

public static string RelativeDate(DateTime theDate)
{
    Dictionary thresholds = new Dictionary();
    int minute = 60;
    int hour = 60 * minute;
    int day = 24 * hour;
    thresholds.Add(60, "{0} seconds ago");
    thresholds.Add(minute * 2, "a minute ago");
    thresholds.Add(45 * minute, "{0} minutes ago");
    thresholds.Add(120 * minute, "an hour ago");
    thresholds.Add(day, "{0} hours ago");
    thresholds.Add(day * 2, "yesterday");
    thresholds.Add(day * 30, "{0} days ago");
    thresholds.Add(day * 365, "{0} months ago");
    thresholds.Add(long.MaxValue, "{0} years ago");
    long since = (DateTime.Now.Ticks - theDate.Ticks) / 10000000;
    foreach (long threshold in thresholds.Keys) 
    {
        if (since < threshold) 
        {
            TimeSpan t = new TimeSpan((DateTime.Now.Ticks - theDate.Ticks));
            return string.Format(thresholds[threshold], (t.Days > 365 ? t.Days / 365 : (t.Days > 0 ? t.Days : (t.Hours > 0 ? t.Hours : (t.Minutes > 0 ? t.Minutes : (t.Seconds > 0 ? t.Seconds : 0))))).ToString());
        }
    }
    return "";
}

I prefer this version for its conciseness, and ability to add in new tick points. This could be encapsulated with a Latest() extension to Timespan instead of that long 1 liner, but for the sake of brevity in posting, this will do. This fixes the an hour ago, 1 hours ago, by providing an hour until 2 hours have elapsed

0
যোগ
আমি এই ফাংশন ব্যবহার করে সব ধরনের সমস্যা পাচ্ছি, উদাহরণস্বরূপ যদি আপনি 'তারিখটি ডেট টাইম। এখন। অ্যাডমিন্টস (-40);' আমি '40 ঘন্টা আগে পেয়েছি ', কিন্তু মাইকেল এর refactorm_code প্রতিক্রিয়া সঙ্গে, এটি '40 মিনিট আগে সঠিক ফিরে'?
যোগ লেখক GONeale, উৎস
@ কোডমুনকিকিং দ্বারা উল্লিখিত সমস্যাটি ঠিক করতে, আপনি একটি সাধারণ অভিধান এর পরিবর্তে সাজানো হয়েছে ব্যবহার করতে পারেন: ব্যবহার একই, কিন্তু এটি নিশ্চিত করে যেগুলি সাজানো হয়। কিন্তু তারপরও, অ্যালগরিদমের ত্রুটি আছে, কারণ রিলেটিভেটড (তারিখ টাইম.Now.AddMonths (-3)। অ্যাডডেস (-3)) ফেরত "95 মাস আগে" , নির্বিশেষে আপনি যে অভিধানটি ব্যবহার করছেন সেটি ভুল (যা "3 মাস আগে" বা "4 মাস আগে" আপনি কোনটি থ্রেশহোল্ড ব্যবহার করছেন তার উপর নির্ভর করে) - এমনকি যদি -3-এর আগের বছরে একটি তারিখ তৈরি না করেও ( আমি ডিসেম্বর মাসে এই পরীক্ষা আছে, তাই এই ক্ষ
যোগ লেখক Matt, উৎস
ওপরে টি.ডয়েস ভুলে গেছেন 30? টি। দিন / 30:
যোগ লেখক Lars Holm Jensen, উৎস
হুম, যখন এই কোডটি কাজ করতে পারে এটি ভুল এবং অবৈধ বলে অনুমান করা যায় যে অভিধানের কীগুলির একটি নির্দিষ্ট ক্রমে থাকবে। অভিধানটি ব্যবহার করে Object.GetHashCode() যা একটি দীর্ঘ কিন্তু একটি int ফিরে না !. যদি আপনি এটি সাজানোর চান তবে আপনাকে একটি সাজানো তালিকা <�দীর্ঘ, স্ট্রিং> ব্যবহার করতে হবে যদি / এ যদি /.../ অন্য কোন থ্রেডের মূল্যায়নের মূল্যায়ন করা হয় তবে কি ভুল আছে? আপনি তুলনা একই সংখ্যা পেতে। দীর্ঘ জন্য হ্যাশ FYI। MXValue int.MinValue হিসাবে একই হতে সক্রিয়!
যোগ লেখক CodeMonkeyKing, উৎস
আমি মনে করি আপনি একটি শূন্য অনুপস্থিত আছেন, চেষ্টা করুন: দীর্ঘ সময় = (DateTime.Now টিক্স - theDate.Ticks) / 10000000;
যোগ লেখক robnardo, উৎস

এখানে আমি এটা কিভাবে

var ts = new TimeSpan(DateTime.UtcNow.Ticks - dt.Ticks);
double delta = Math.Abs(ts.TotalSeconds);

if (delta < 60)
{
  return ts.Seconds == 1 ? "one second ago" : ts.Seconds + " seconds ago";
}
if (delta < 120)
{
  return "a minute ago";
}
if (delta < 2700) // 45 * 60
{
  return ts.Minutes + " minutes ago";
}
if (delta < 5400) // 90 * 60
{
  return "an hour ago";
}
if (delta < 86400) // 24 * 60 * 60
{
  return ts.Hours + " hours ago";
}
if (delta < 172800) // 48 * 60 * 60
{
  return "yesterday";
}
if (delta < 2592000) // 30 * 24 * 60 * 60
{
  return ts.Days + " days ago";
}
if (delta < 31104000) // 12 * 30 * 24 * 60 * 60
{
  int months = Convert.ToInt32(Math.Floor((double)ts.Days / 30));
  return months <= 1 ? "one month ago" : months + " months ago";
}
int years = Convert.ToInt32(Math.Floor((double)ts.Days / 365));
return years <= 1 ? "one year ago" : years + " years ago";

পরামর্শ? মন্তব্য? এই অ্যালগরিদম উন্নত করার উপায়?

0
যোগ
তবে বর্তমানে কেবলমাত্র "সময় আগে" বিন্যাসটি 2 দিন পর্যন্ত দেখানো হবে। 2 দিনের বেশি সময় এবং আপনি প্রমিত তারিখ সময় বিন্যাস করা। আমি কি সঠিক ?
যোগ লেখক Hugo Hilário, উৎস
যেহেতু সবগুলি যদি..এটি কেবল টাইমস্ল্যাব হয়, তবে আপনি আরও ভাল পঠনযোগ্যতা জন্য একটি enum তৈরি করতে পারেন। enum TimeSlabs {সেকেন্ড = 60, মিনিট = 60 * 60, ঘন্টা = 60 * 60 * 24, দিন = 60 * 60 * 24 * 365,}
যোগ লেখক Antony Thomas, উৎস
আমি মনে করি এই "গতকাল" এর একটি অদ্ভুত সংজ্ঞা, আমি যদি এখন (রবিবার সন্ধ্যায়) শুক্রবার সন্ধ্যায় "গতকাল" হিসাবে একটি উত্তর দেখতে।
যোগ লেখক Paŭlo Ebermann, উৎস
"<48 * 60 * 60 সেকেন্ড" "কাল" এর পরিবর্তে একটি অপ্রচলিত সংজ্ঞা। যদি বুধবার সকাল 9 টা হয়, তাহলে আপনি কি সোমবার সকাল 9 টায় "কাল" হিসাবে ভাববেন? আমি গতকালের জন্য একটি অ্যালগরিদম চিন্তা করেছি অথবা "n দিন আগে" মধ্যরাতের আগে / পরে বিবেচনা করা উচিত।
যোগ লেখক Joe, উৎস
আমি শুধু var delta = ts.Duration() বরাদ্দ করতে চাই তাই আপনি TimeSpan বস্তুর পরম মান পেতে পারেন, এবং তারপর আপনি এর মতো জিনিস করতে পারেন (যদি ডেল্টা <�টাইমসান.ফ্রোম মিনিট (1)) বা যদি (ডেলটা <�টাইমসেন। ফ্রমডাই (1)) । এখনও পাঠযোগ্য, এবং রহস্যময় সংখ্যা বা ধ্রুবক জন্য কোন প্রয়োজন।
যোগ লেখক Rufus L, উৎস
কম্পাইলারগুলি সাধারণত ধ্রুবক এক্সপ্রেশন গণনা করা ভাল, যেমন 24 * 60 * 60, তাই আপনি এটি 86400 হতে আপনার হিসাব করার পরিবর্তে সরাসরি ব্যবহার করতে পারেন এবং মন্তব্যগুলিতে আসল অভিব্যক্তি লিখতে পারেন
যোগ লেখক zvolkov, উৎস
@ বিজ্লিম আমি মনে করি আমি একটি প্রকল্প যা আমি কাজ ছিল জন্য করেনি। এখানে আমার প্রেরণা অন্যদের সতর্ক ছিল যে এই কোড নমুনা থেকে সপ্তাহ বাদ দেওয়া হয়। কিভাবে এটা করতে হবে, এটা আমার কাছে বেশ সোজা এগিয়ে ছিল।
যোগ লেখক jray, উৎস
লক্ষ করা যায় যে এই ফাংশন সপ্তাহ বাদ দেয়
যোগ লেখক jray, উৎস
আমি মনে করি অ্যালগরিদম উন্নত করার ভালো উপায় সঠিকতা বাড়ানোর জন্য "2 মাস ২1 দিন আগে", "1 ঘন্টা 40 মিনিট আগে" 2 টি ইউনিট প্রদর্শন করছে।
যোগ লেখক Evgeny Levin, উৎস
@ জেফি, আপনি লিপ বছর এবং সম্পর্কিত চেকগুলির জন্য হিসাব মিস করেছেন
যোগ লেখক Saboor Awan, উৎস
45 মিনিট "একটি ঘন্টা আগে" হিসাবে প্রদর্শিত হচ্ছে ?! এটি একটি বাগ নয়? যদি না হয় তবে কেন সেকেন্ড এবং মিনিটের জন্য একই কাজ করবেন না?
যোগ লেখক Eldritch Conundrum, উৎস

@jeff

IMHO আপনার একটু লম্বা মনে হয় তবে এটি "গতকাল" এবং "বছর" এর সমর্থন সহ সামান্য আরও শক্তিশালী বলে মনে হচ্ছে। কিন্তু আমার অভিজ্ঞতা যখন এই ব্যবহার করা হয় তখন ব্যক্তিরা প্রথম 30 দিনের মধ্যে বিষয়বস্তু দেখতে সম্ভবত। এটা কেবল সেই সত্যিকারের হার্ডকোর লোক যারা এর পরে আসে। তাই আমি সাধারণত এই ছোট এবং সহজ রাখতে নির্বাচন কেন।

এই পদ্ধতিটি আমি বর্তমানে আমার ওয়েবসাইটে এক ব্যবহার করছি। এটি শুধুমাত্র একটি আপেক্ষিক দিন, ঘন্টা, সময় প্রদান করে। এবং তারপর ব্যবহারকারী "আউট" উপর চপেটায়েত আছে আউটপুট।

public static string ToLongString(this TimeSpan time)
{
    string output = String.Empty;

    if (time.Days > 0)
        output += time.Days + " days ";

    if ((time.Days == 0 || time.Days == 1) && time.Hours > 0)
        output += time.Hours + " hr ";

    if (time.Days == 0 && time.Minutes > 0)
        output += time.Minutes + " min ";

    if (output.Length == 0)
        output += time.Seconds + " sec";

    return output.Trim();
}
0
যোগ

জেফ, আপনার কোড সুন্দর কিন্তু ধ্রুবকগুলির সাথে পরিষ্কার হতে পারে (কোড সম্পূর্ণ প্রস্তাবিত হিসাবে)

const int SECOND = 1;
const int MINUTE = 60 * SECOND;
const int HOUR = 60 * MINUTE;
const int DAY = 24 * HOUR;
const int MONTH = 30 * DAY;

var ts = new TimeSpan(DateTime.UtcNow.Ticks - yourDate.Ticks);
double delta = Math.Abs(ts.TotalSeconds);

if (delta < 1 * MINUTE)
  return ts.Seconds == 1 ? "one second ago" : ts.Seconds + " seconds ago";

if (delta < 2 * MINUTE)
  return "a minute ago";

if (delta < 45 * MINUTE)
  return ts.Minutes + " minutes ago";

if (delta < 90 * MINUTE)
  return "an hour ago";

if (delta < 24 * HOUR)
  return ts.Hours + " hours ago";

if (delta < 48 * HOUR)
  return "yesterday";

if (delta < 30 * DAY)
  return ts.Days + " days ago";

if (delta < 12 * MONTH)
{
  int months = Convert.ToInt32(Math.Floor((double)ts.Days / 30));
  return months <= 1 ? "one month ago" : months + " months ago";
}
else
{
  int years = Convert.ToInt32(Math.Floor((double)ts.Days / 365));
  return years <= 1 ? "one year ago" : years + " years ago";
}
0
যোগ
@ এটমোঃ না এটা সম্ভব নয়
যোগ লেখক André Pena, উৎস
আমি সত্যিই মোট ব্যবহারকারী, TotalDays, TotalHours ব্যবহার করি না কেন বুঝতে পারছি না ... এটা এই অনেকটা ছোট করবে ...
যোগ লেখক lord.fist, উৎস
একটি কাস্টম ফর্ম্যাট স্ট্রিং সঙ্গে এটি প্রয়োগ করা যেতে পারে কিভাবে কেউ নির্দেশিকা আছে, যাতে `string.format (mydate," dd / MM / yyyy (YTT) ") ==" 26/04/2011 (আজ) "?
যোগ লেখক Neil Barnwell, উৎস
আমি একটি আবেগ সঙ্গে যেমন ধ্রুবক ঘৃণা কেউ কি এই চেহারা ভুল? <�কোড> থ্রেড। স্লিপ (1 * মিনিট) ? কারণ এটি 1000 এর একটি ফ্যাক্টর দ্বারা ভুল।
যোগ লেখক Roman Starkov, উৎস
আরেকটি বাগ: কারণ ডেলটা সম্পূর্ণ, "না" এর পথ কখনও পৌঁছে যায় না। এতে পরিবর্তন করুন: ডেলটা = টি।
যোগ লেখক StefanG, উৎস
আমি মনে করি যদি ধ্রুবকগুলিকে তাদের মধ্যে থাকা মানটি সঠিকভাবে বর্ণনা করা হয় তবে এটি বুঝতে সহজ হবে। তাই সেকেন্ডসপিরেমিন্ট = 60; মিনিটসপেরহর = 60; সেকেন্ডপিয়ারহর = মিনিটসফায়ারহুর * সেকেন্ডপিয়ারহাউর; ইত্যাদি। শুধু MINUTE = 60 এ কল করলে পাঠককে মূল্য কি নির্ধারণ করতে দেয় না।
যোগ লেখক slolife, উৎস
গতকালের "গ্লাইবার" এ সমস্যাটি ঘটেছে, এটি আজকের 7 টা আজকের দিনে যা দেখছি তা থেকে তাৎপর্যপূর্ণ নয়, যেটি দুই দিন আগে 10 টায় ঘটেছে, "কাল" উত্পন্ন হবে, যা সঠিক নয়।
যোগ লেখক Ayyash, উৎস
কিছু ভাষাতে আপনি সুইচ() - বিবৃতি, যেমন>,> => <= ইত্যাদি জন্য কোনও ধরনের অপারেটর তুলনা করতে পারেন ... এটি C# এ একরকম সম্ভব নয়?
যোগ লেখক Atmocreations, উৎস
কেন var ts = DateTime.UtcNow - আপনার তারিখ; , এটা কি সহজ? Math.Abs ​​ এর পক্ষে যুক্তি কী?
যোগ লেখক Jeppe Stig Nielsen, উৎস
যদি না (ডেলটা <= 90 * MINUTE) না হয়? একরকম আমি একটি "1 ঘন্টা আগে" পেয়েছিলাম।
যোগ লেখক Roberto, উৎস
কেন কেউ (জো ছাড়া) ভুল 'কাল' বা 'দিন আগে' মান সম্পর্কে যত্ন ??? গতকাল একটি ঘন্টা গণনা করা হয় না, কিন্তু দিন গণনার একটি দিন। তাই হ্যাঁ, এটি একটি ভুল কোড কমপক্ষে দুটি ঘন ঘন ক্ষেত্রে।
যোগ লেখক CtrlX, উৎস
const int SECOND = 1; তাই অদ্ভুত একটি দ্বিতীয় এক সেকেন্ড হয়।
যোগ লেখক seriousdev, উৎস
এই ধরনের কোড স্থানীয়করণ করা প্রায় অসম্ভব। যদি আপনার এপ্লিকেশন শুধুমাত্র ইংরেজিতে থাকা দরকার, তাহলে জরিমানা কিন্তু যদি আপনি অন্যান্য ভাষায় লাফালাফি করেন, তাহলে আপনি এই মত যুক্তি করার জন্য নিজেকে ঘৃণা করবেন। শুধু তাই বলে তুমি জানো ...
যোগ লেখক Nik Reiman, উৎস
@romkyns থ্রেড। স্লিপ (1 * MINUTE) আছে আমাকে ভুল দেখায়, এবং এর কারণ হল MINUTE এর কোনও ইউনিট নির্দিষ্ট নেই এখন, MINUTE_IN_SECONDS , স্পট এবং সহজেই ফিক্স করা সহজ হবে: থ্রেড। স্লিপ (1 * MINUTE_IN_SECONDS * 1000) বা থ্রেড। স্লিপ (1 * MINUTE_IN_SECONDS * SECOND_IN_MILLISECONDS) </ কোড>। (অক্ষর পেতে, কিন্তু গোপন বাগগুলির চেয়ে ভাল।)
যোগ লেখক jpmc26, উৎস
যখন আমি সমস্ত মূলধন দেখতে পাচ্ছি আমি C / C ++ এর জন্য উন্নত কোডিং শৈলীতে ফিরে তাকাই। মাইক্রোসফটের সুপারিশ হল পাਸਕকে জারি করা এই প্রশ্নের উত্তর পরীক্ষা করুন -
যোগ লেখক CodeMonkeyKing, উৎস
@ একক যদি আপনি এইটি একটি IValueConverter এ রাখেন, এটি আপনার জন্য স্বয়ংক্রিয়ভাবে CultureInfo পরিচালনা করবে (আপনি প্রথমে সংস্কৃতি সেট করেছেন অভিমানী)
যোগ লেখক Lance McCarthy, উৎস
আপনি DateTime টাইপ উপর সংজ্ঞায়িত সংকলন ব্যবহার করে সমাধান অপটিমাইজ করতে পারেন, আপনি তাদের ম্যানুয়ালি সংজ্ঞায়িত না আছে
যোগ লেখক SOAL ABDELDJALLIL, উৎস

আমি ভাবলাম আমি ক্লাস এবং পলিমরফিজম ব্যবহার করে এই একটি শট দিতে চাই। আমি একটি পূর্ববর্তী পুনরাবৃত্তির ছিল যা সাব-ক্লাসিং ব্যবহার করে যা শেষ পর্যন্ত অনেক বেশি ওভারহেড ছিল। আমি আরো বেশি নমনীয় প্রতিনিধি / পাবলিক প্রোপার্টি অবজেক্ট মডেল চালু করেছি যা উল্লেখযোগ্যভাবে ভাল। আমার কোড খুব সামান্য আরো সঠিক, আমি "মাস আগে" উৎপাদনের একটি ভাল উপায় নিয়ে আসতে পারে আশা করি যে খুব বেশী প্রকৌশলী বলে মনে হচ্ছে না।

আমি মনে করি আমি এখনও জেফ এর সাথে থাকবো যদি-তারপর ক্যাসকেড কারণ এটি কম কোড এবং এটি সহজ (এটি নিশ্চিতভাবে এটি নিশ্চিত হিসাবে এটি প্রত্যাশিত হিসাবে কাজ করতে হবে)।

নীচের কোডটি মুদ্রণ রিলাইটটাইম.গেট রিলেটিভ টাইমমেসেজ (সময়সীমা আগে) আপেক্ষিক বার বার (যেমন, "গতকাল") ফেরত দেয়।

public class RelativeTimeRange : IComparable
{
    public TimeSpan UpperBound { get; set; }

    public delegate string RelativeTimeTextDelegate(TimeSpan timeDelta);

    public RelativeTimeTextDelegate MessageCreator { get; set; }

    public int CompareTo(object obj)
    {
        if (!(obj is RelativeTimeRange))
        {
            return 1;
        }
        // note that this sorts in reverse order to the way you'd expect, 
        // this saves having to reverse a list later
        return (obj as RelativeTimeRange).UpperBound.CompareTo(UpperBound);
    }
}

public class PrintRelativeTime
{
    private static List timeRanges;

    static PrintRelativeTime()
    {
        timeRanges = new List{
            new RelativeTimeRange
            {
                UpperBound = TimeSpan.FromSeconds(1),
                MessageCreator = (delta) => 
                { return "one second ago"; }
            }, 
            new RelativeTimeRange
            {
                UpperBound = TimeSpan.FromSeconds(60),
                MessageCreator = (delta) => 
                { return delta.Seconds + " seconds ago"; }

            }, 
            new RelativeTimeRange
            {
                UpperBound = TimeSpan.FromMinutes(2),
                MessageCreator = (delta) => 
                { return "one minute ago"; }
            }, 
            new RelativeTimeRange
            {
                UpperBound = TimeSpan.FromMinutes(60),
                MessageCreator = (delta) => 
                { return delta.Minutes + " minutes ago"; }
            }, 
            new RelativeTimeRange
            {
                UpperBound = TimeSpan.FromHours(2),
                MessageCreator = (delta) => 
                { return "one hour ago"; }
            }, 
            new RelativeTimeRange
            {
                UpperBound = TimeSpan.FromHours(24),
                MessageCreator = (delta) => 
                { return delta.Hours + " hours ago"; }
            }, 
            new RelativeTimeRange
            {
                UpperBound = TimeSpan.FromDays(2),
                MessageCreator = (delta) => 
                { return "yesterday"; }
            }, 
            new RelativeTimeRange
            {
                UpperBound = DateTime.Now.Subtract(DateTime.Now.AddMonths(-1)),
                MessageCreator = (delta) => 
                { return delta.Days + " days ago"; }
            }, 
            new RelativeTimeRange
            {
                UpperBound = DateTime.Now.Subtract(DateTime.Now.AddMonths(-2)),
                MessageCreator = (delta) => 
                { return "one month ago"; }
            }, 
            new RelativeTimeRange
            {
                UpperBound = DateTime.Now.Subtract(DateTime.Now.AddYears(-1)),
                MessageCreator = (delta) => 
                { return (int)Math.Floor(delta.TotalDays / 30) + " months ago"; }
            }, 
            new RelativeTimeRange
            {
                UpperBound = DateTime.Now.Subtract(DateTime.Now.AddYears(-2)),
                MessageCreator = (delta) => 
                { return "one year ago"; }
            }, 
            new RelativeTimeRange
            {
                UpperBound = TimeSpan.MaxValue,
                MessageCreator = (delta) => 
                { return (int)Math.Floor(delta.TotalDays / 365.24D) + " years ago"; }
            }
        };

        timeRanges.Sort();
    }

    public static string GetRelativeTimeMessage(TimeSpan ago)
    {
        RelativeTimeRange postRelativeDateRange = timeRanges[0];

        foreach (var timeRange in timeRanges)
        {
            if (ago.CompareTo(timeRange.UpperBound) <= 0)
            {
                postRelativeDateRange = timeRange;
            }
        }

        return postRelativeDateRange.MessageCreator(ago);
    }
}
0
যোগ

আমি খুব ক্লায়েন্ট দিকে এই কম্পিউটিং সুপারিশ করবে। সার্ভারের জন্য কম কাজ

নিম্নলিখিত আমি ব্যবহার করে যে সংস্করণ (Zach Leatherman থেকে)

/*
 * Javascript Humane Dates
 * Copyright (c) 2008 Dean Landolt (deanlandolt.com)
 * Re-write by Zach Leatherman (zachleat.com)
 * 
 * Adopted from the John Resig's pretty.js
 * at http://ejohn.org/blog/javascript-pretty-date
 * and henrah's proposed modification 
 * at http://ejohn.org/blog/javascript-pretty-date/#comment-297458
 * 
 * Licensed under the MIT license.
 */

function humane_date(date_str){
        var time_formats = [
                [60, 'just now'],
                [90, '1 minute'], // 60*1.5
                [3600, 'minutes', 60], // 60*60, 60
                [5400, '1 hour'], // 60*60*1.5
                [86400, 'hours', 3600], // 60*60*24, 60*60
                [129600, '1 day'], // 60*60*24*1.5
                [604800, 'days', 86400], // 60*60*24*7, 60*60*24
                [907200, '1 week'], // 60*60*24*7*1.5
                [2628000, 'weeks', 604800], // 60*60*24*(365/12), 60*60*24*7
                [3942000, '1 month'], // 60*60*24*(365/12)*1.5
                [31536000, 'months', 2628000], // 60*60*24*365, 60*60*24*(365/12)
                [47304000, '1 year'], // 60*60*24*365*1.5
                [3153600000, 'years', 31536000], // 60*60*24*365*100, 60*60*24*365
                [4730400000, '1 century'] // 60*60*24*365*100*1.5
        ];

        var time = ('' + date_str).replace(/-/g,"/").replace(/[TZ]/g," "),
                dt = new Date,
                seconds = ((dt - new Date(time) + (dt.getTimezoneOffset() * 60000)) / 1000),
                token = ' ago',
                i = 0,
                format;

        if (seconds < 0) {
                seconds = Math.abs(seconds);
                token = '';
        }

        while (format = time_formats[i++]) {
                if (seconds < format[0]) {
                        if (format.length == 2) {
                                return format[1] + (i > 1 ? token : ''); // Conditional so we don't return Just Now Ago
                        } else {
                                return Math.round(seconds / format[2]) + ' ' + format[1] + (i > 1 ? token : '');
                        }
                }
        }

        // overflow for centuries
        if(seconds > 4730400000)
                return Math.round(seconds / 4730400000) + ' centuries' + token;

        return date_str;
};

if(typeof jQuery != 'undefined') {
        jQuery.fn.humane_dates = function(){
                return this.each(function(){
                        var date = humane_date(this.title);
                        if(date && jQuery(this).text() != date) // don't modify the dom if we don't have to
                                jQuery(this).text(date);
                });
        };
}
0
যোগ
প্রশ্ন হল C# tagged কেন জাভাস্ক্রিপ্ট কোড ?
যোগ লেখক Kiquenet, উৎস

পিএইচপি ইন, আমি এই ভাবে এটি করতে:

<?php
function timesince($original) {
    // array of time period chunks
    $chunks = array(
        array(60 * 60 * 24 * 365 , 'year'),
        array(60 * 60 * 24 * 30 , 'month'),
        array(60 * 60 * 24 * 7, 'week'),
        array(60 * 60 * 24 , 'day'),
        array(60 * 60 , 'hour'),
        array(60 , 'minute'),
    );

    $today = time(); /* Current unix time  */
    $since = $today - $original;

    if($since > 604800) {
    $print = date("M jS", $original);

    if($since > 31536000) {
        $print .= ", " . date("Y", $original);
    }

    return $print;
}

// $j saves performing the count function each time around the loop
for ($i = 0, $j = count($chunks); $i < $j; $i++) {

    $seconds = $chunks[$i][0];
    $name = $chunks[$i][1];

    // finding the biggest chunk (if the chunk fits, break)
    if (($count = floor($since / $seconds)) != 0) {
        break;
    }
}

$print = ($count == 1) ? '1 '.$name : "$count {$name}s";

return $print . " ago";

} ?>
0
যোগ
প্রশ্ন হল C# ট্যাগ । কেন এটি পিএইচপি কোড ? IMHO, শুধুমাত্র C# কোড এ প্রয়োগ করে
যোগ লেখক Kiquenet, উৎস

@Jeff

var ts = নতুন   টাইমস্প্যান (তারিখ টাইম। ইউটিসিএনএইচ টিক্স -   dt.Ticks);?

বিয়োগান্তরিত এ একটি বিয়োগ করা সময়সীমা </কোড> যাই হোক না কেন।

তাই আপনি শুধু করতে পারেন

(DateTime.UtcNow - dt).TotalSeconds

আমি দৃঢ়তার সাথে দেখেছি যে বিরাট সংখ্যায় গুণিত হ'ল এবং তারপর মন্তব্যগুলি বহুগুনের সাথে যোগ করে দেখেছি। এটা কি কিছু বিপথগামী অপ্টিমাইজেশান ছিল?

0
যোগ

এই, আমি বিল গেটস ব্লগের এক থেকে পেয়েছিলাম। আমার ব্রাউজারের ইতিহাসে এটি খুঁজে বের করতে হবে এবং আমি আপনাকে লিঙ্কটি দেব।

জাভাস্ক্রিপ্ট কোড একই জিনিস (অনুরোধ হিসাবে) করতে:

function posted(t) {
    var now = new Date();
    var diff = parseInt((now.getTime() - Date.parse(t)) / 1000);
    if (diff < 60) { return 'less than a minute ago'; }
    else if (diff < 120) { return 'about a minute ago'; }
    else if (diff < (2700)) { return (parseInt(diff / 60)).toString() + ' minutes ago'; }
    else if (diff < (5400)) { return 'about an hour ago'; }
    else if (diff < (86400)) { return 'about ' + (parseInt(diff / 3600)).toString() + ' hours ago'; }
    else if (diff < (172800)) { return '1 day ago'; } 
    else {return (parseInt(diff / 86400)).toString() + ' days ago'; }
}

মূলত, আপনি সেকেন্ডের শর্তে কাজ করেন ...

0
যোগ

আপনি সময়সীমা এক্সটেনশন ব্যবহার করতে পারেন যা থেকে নিম্নের মত দেখায়:

public static string TimeAgo(this DateTime dateTime)
{
    string result = string.Empty;
    var timeSpan = DateTime.Now.Subtract(dateTime);

    if (timeSpan <= TimeSpan.FromSeconds(60))
    {
        result = string.Format("{0} seconds ago", timeSpan.Seconds);
    }
    else if (timeSpan <= TimeSpan.FromMinutes(60))
    {
        result = timeSpan.Minutes > 1 ? 
            String.Format("about {0} minutes ago", timeSpan.Minutes) :
            "about a minute ago";
    }
    else if (timeSpan <= TimeSpan.FromHours(24))
    {
        result = timeSpan.Hours > 1 ? 
            String.Format("about {0} hours ago", timeSpan.Hours) : 
            "about an hour ago";
    }
    else if (timeSpan <= TimeSpan.FromDays(30))
    {
        result = timeSpan.Days > 1 ? 
            String.Format("about {0} days ago", timeSpan.Days) : 
            "yesterday";
    }
    else if (timeSpan <= TimeSpan.FromDays(365))
    {
        result = timeSpan.Days > 30 ? 
            String.Format("about {0} months ago", timeSpan.Days / 30) : 
            "about a month ago";
    }
    else
    {
        result = timeSpan.Days > 365 ? 
            String.Format("about {0} years ago", timeSpan.Days / 365) : 
            "about a year ago";
    }

    return result;
}

অথবা Timeago থেকে রেজার এক্সটেনশন সহ jQuery প্লাগইন ব্যবহার করুন।

0
যোগ

আমি এই জন্য কিছু সহজ এক্সটেনশন পদ্ধতি প্রদান এবং কোড আরো পাঠযোগ্য করতে হবে। প্রথমত, Int32 এর জন্য এক্সটেনশন পদ্ধতিগুলির কয়েকটি।

public static class TimeSpanExtensions {

    public static TimeSpan Days(this int value) {

        return new TimeSpan(value, 0, 0, 0);
    }

    public static TimeSpan Hours(this int value) {

        return new TimeSpan(0, value, 0, 0);
    }

    public static TimeSpan Minutes(this int value) {

        return new TimeSpan(0, 0, value, 0);
    }

    public static TimeSpan Seconds(this int value) {

        return new TimeSpan(0, 0, 0, value);
    }

    public static TimeSpan Milliseconds(this int value) {

        return new TimeSpan(0, 0, 0, 0, value);
    }

    public static DateTime Ago(this TimeSpan value) {

        return DateTime.Now - value;
    }
}

তারপর, তারিখের সময় এর জন্য একটি।

public static class DateTimeExtensions {

    public static DateTime Ago(this DateTime dateTime, TimeSpan delta) {

        return dateTime - delta;
    }
}

এখন, আপনি নীচের মত কিছু করতে পারেন:

var date = DateTime.Now;
date.Ago(2.Days()); // 2 days ago
date.Ago(7.Hours()); // 7 hours ago
date.Ago(567.Milliseconds()); // 567 milliseconds ago
0
যোগ

এখানে পিএইচপি জন্য জেফস স্ক্রিপ্ট থেকে একটি পুনর্লিখন:

define("SECOND", 1);
define("MINUTE", 60 * SECOND);
define("HOUR", 60 * MINUTE);
define("DAY", 24 * HOUR);
define("MONTH", 30 * DAY);
function relativeTime($time)
{   
    $delta = time() - $time;

    if ($delta < 1 * MINUTE)
    {
        return $delta == 1 ? "one second ago" : $delta . " seconds ago";
    }
    if ($delta < 2 * MINUTE)
    {
      return "a minute ago";
    }
    if ($delta < 45 * MINUTE)
    {
        return floor($delta / MINUTE) . " minutes ago";
    }
    if ($delta < 90 * MINUTE)
    {
      return "an hour ago";
    }
    if ($delta < 24 * HOUR)
    {
      return floor($delta / HOUR) . " hours ago";
    }
    if ($delta < 48 * HOUR)
    {
      return "yesterday";
    }
    if ($delta < 30 * DAY)
    {
        return floor($delta / DAY) . " days ago";
    }
    if ($delta < 12 * MONTH)
    {
      $months = floor($delta / DAY / 30);
      return $months <= 1 ? "one month ago" : $months . " months ago";
    }
    else
    {
        $years = floor($delta / DAY / 365);
        return $years <= 1 ? "one year ago" : $years . " years ago";
    }
}    
0
যোগ
প্রশ্ন হল C# tagged কেন পিএইচপি কোড ?
যোগ লেখক Kiquenet, উৎস

using Fluent DateTime https://github.com/FluentDateTime

var dateTime1 = 2.Hours().Ago();
var dateTime2 = 3.Days().Ago();
var dateTime3 = 1.Months().Ago();
var dateTime4 = 5.Hours().FromNow();
var dateTime5 = 2.Weeks().FromNow();
var dateTime6 = 40.Seconds().FromNow();
0
যোগ

এখানে অ্যালগরিদম স্ট্যাকওভারফ্লো ব্যবহার করে কিন্তু একটি বাগ ফিক্স (কোন "এক ঘন্টা আগে") সঙ্গে perlish pseudocode আরো সংক্ষেপে পুনরায় লিখেছেন ফাংশনটি (ইতিবাচক) সংখ্যা সেকেন্ড আগে নেয় এবং "3 ঘন্টা আগে" বা "গতকাল" এর মতো একটি মানুষের বন্ধুত্বপূর্ণ স্ট্রিংটি ফেরত দেয়।

agoify($delta)
  local($y, $mo, $d, $h, $m, $s);
  $s = floor($delta);
  if($s<=1)            return "a second ago";
  if($s<60)            return "$s seconds ago";
  $m = floor($s/60);
  if($m==1)            return "a minute ago";
  if($m<45)            return "$m minutes ago";
  $h = floor($m/60);
  if($h==1)            return "an hour ago";
  if($h<24)            return "$h hours ago";
  $d = floor($h/24);
  if($d<2)             return "yesterday";
  if($d<30)            return "$d days ago";
  $mo = floor($d/30);
  if($mo<=1)           return "a month ago";
  $y = floor($mo/12);
  if($y<1)             return "$mo months ago";
  if($y==1)            return "a year ago";
  return "$y years ago";
0
যোগ
using System;
using System.Collections.Generic;
using System.Linq;

public static class RelativeDateHelper
{
    private static Dictionary> sm_Dict = null;

    private static Dictionary> DictionarySetup()
    {
        var dict = new Dictionary>();
        dict.Add(0.75, (mins) => "less than a minute");
        dict.Add(1.5, (mins) => "about a minute");
        dict.Add(45, (mins) => string.Format("{0} minutes", Math.Round(mins)));
        dict.Add(90, (mins) => "about an hour");
        dict.Add(1440, (mins) => string.Format("about {0} hours", Math.Round(Math.Abs(mins / 60)))); // 60 * 24
        dict.Add(2880, (mins) => "a day"); // 60 * 48
        dict.Add(43200, (mins) => string.Format("{0} days", Math.Floor(Math.Abs(mins / 1440)))); // 60 * 24 * 30
        dict.Add(86400, (mins) => "about a month"); // 60 * 24 * 60
        dict.Add(525600, (mins) => string.Format("{0} months", Math.Floor(Math.Abs(mins / 43200)))); // 60 * 24 * 365 
        dict.Add(1051200, (mins) => "about a year"); // 60 * 24 * 365 * 2
        dict.Add(double.MaxValue, (mins) => string.Format("{0} years", Math.Floor(Math.Abs(mins / 525600))));

        return dict;
    }

    public static string ToRelativeDate(this DateTime input)
    {
        TimeSpan oSpan = DateTime.Now.Subtract(input);
        double TotalMinutes = oSpan.TotalMinutes;
        string Suffix = " ago";

        if (TotalMinutes < 0.0)
        {
            TotalMinutes = Math.Abs(TotalMinutes);
            Suffix = " from now";
        }

        if (null == sm_Dict)
            sm_Dict = DictionarySetup();

        return sm_Dict.First(n => TotalMinutes < n.Key).Value.Invoke(TotalMinutes) + Suffix;
    }
}

এই প্রশ্নের অন্য একটি উত্তর কিন্তু একটি এক্সটেনশন হিসাবে একই একটি স্ট্যাটিক অভিধান সঙ্গে পদ্ধতি।

0
যোগ
অভিধানটি আপনাকে এখানে কেন কিনেছে?
যোগ লেখক StriplingWarrior, উৎস
আমি দেখি. আমি শুধু চিন্তা করছিলাম, যেহেতু অভিধান এর ডকুমেন্টেশনটি বলে যে "যে আইটেমগুলি ফেরত দেওয়া হয় সেটি অনির্ধারিত," ( msdn.microsoft.com/en-us/library/xfhwa508.aspx ) সম্ভবত আপনি যখন যত্ন নেন না তখন এটি ব্যবহার করার জন্য সেরা ডেটা কাঠামো নয় প্রায় সময় হিসাবে যতটা জিনিষ থাকার থাকার সময় হিসাবে দেখা।
যোগ লেখক StriplingWarrior, উৎস
StriplingWarrior: একটি সুইচ বিবৃতি বা যদি / অন্য বিবৃতির একটি স্ট্যাকের তুলনায় পড়া এবং সংশোধন সহজ। অভিধানটি স্ট্যাটিক মানে হল যে এটি এবং Func <,> বস্তুগুলি আমরা ToRelativeDate ব্যবহার করতে চাইলে প্রত্যেক বার তৈরি করতে হবে না; এটা শুধুমাত্র একবার তৈরি, আমি আমার উত্তর জুড়ে এক তুলনায় তুলনায়।
যোগ লেখক Chris Charabaruk, উৎস
StriplingWarrior: আমি বিশ্বাস করি যে LINQ এই কোডে ব্যবহার করে যখন অভিধান s এর সাথে ব্যবহার করা হয় আপনি যদি এখনও এটির সাথে অস্বস্তিকর হন, তবে আপনি সাজানো অংকিতকরণ </ কোড> , কিন্তু আমার নিজের অভিজ্ঞতা দেখায় যে অপ্রয়োজনীয় হতে হবে।
যোগ লেখক Chris Charabaruk, উৎস
public string getRelativeDateTime(DateTime date)
{
    TimeSpan ts = DateTime.Now - date;
    if (ts.TotalMinutes < 1)//seconds ago
        return "just now";
    if (ts.TotalHours < 1)//min ago
        return (int)ts.TotalMinutes == 1 ? "1 Minute ago" : (int)ts.TotalMinutes + " Minutes ago";
    if (ts.TotalDays < 1)//hours ago
        return (int)ts.TotalHours == 1 ? "1 Hour ago" : (int)ts.TotalHours + " Hours ago";
    if (ts.TotalDays < 7)//days ago
        return (int)ts.TotalDays == 1 ? "1 Day ago" : (int)ts.TotalDays + " Days ago";
    if (ts.TotalDays < 30.4368)//weeks ago
        return (int)(ts.TotalDays / 7) == 1 ? "1 Week ago" : (int)(ts.TotalDays / 7) + " Weeks ago";
    if (ts.TotalDays < 365.242)//months ago
        return (int)(ts.TotalDays / 30.4368) == 1 ? "1 Month ago" : (int)(ts.TotalDays / 30.4368) + " Months ago";
    //years ago
    return (int)(ts.TotalDays / 365.242) == 1 ? "1 Year ago" : (int)(ts.TotalDays / 365.242) + " Years ago";
}

একটি মাস এবং বছরের জন্য দিন রূপান্তর মান Google থেকে নেওয়া হয়েছে

0
যোগ

দলটি দেরী কয়েক বছর, কিন্তু আমি অতীতের এবং ভবিষ্যতের উভয় তারিখের জন্য এটি করতে একটি প্রয়োজন ছিল, তাই আমি জেফ 'গুলি এবং ভিনসেন্ট এর এই মধ্যে। এটি একটি ternarytastic চরমপন্থা! :)

public static class DateTimeHelper
    {
        private const int SECOND = 1;
        private const int MINUTE = 60 * SECOND;
        private const int HOUR = 60 * MINUTE;
        private const int DAY = 24 * HOUR;
        private const int MONTH = 30 * DAY;

        /// 
/// Returns a friendly version of the provided DateTime, relative to now. E.g.: "2 days ago", or "in 6 months". ///
 
        /// 
The DateTime to compare to Now
        /// A friendly string
        public static string GetFriendlyRelativeTime(DateTime dateTime)
        {
            if (DateTime.UtcNow.Ticks == dateTime.Ticks)
            {
                return "Right now!";
            }

            bool isFuture = (DateTime.UtcNow.Ticks < dateTime.Ticks);
            var ts = DateTime.UtcNow.Ticks < dateTime.Ticks ? new TimeSpan(dateTime.Ticks - DateTime.UtcNow.Ticks) : new TimeSpan(DateTime.UtcNow.Ticks - dateTime.Ticks);

            double delta = ts.TotalSeconds;

            if (delta < 1 * MINUTE)
            {
                return isFuture ? "in " + (ts.Seconds == 1 ? "one second" : ts.Seconds + " seconds") : ts.Seconds == 1 ? "one second ago" : ts.Seconds + " seconds ago";
            }
            if (delta < 2 * MINUTE)
            {
                return isFuture ? "in a minute" : "a minute ago";
            }
            if (delta < 45 * MINUTE)
            {
                return isFuture ? "in " + ts.Minutes + " minutes" : ts.Minutes + " minutes ago";
            }
            if (delta < 90 * MINUTE)
            {
                return isFuture ? "in an hour" : "an hour ago";
            }
            if (delta < 24 * HOUR)
            {
                return isFuture ? "in " + ts.Hours + " hours" : ts.Hours + " hours ago";
            }
            if (delta < 48 * HOUR)
            {
                return isFuture ? "tomorrow" : "yesterday";
            }
            if (delta < 30 * DAY)
            {
                return isFuture ? "in " + ts.Days + " days" : ts.Days + " days ago";
            }
            if (delta < 12 * MONTH)
            {
                int months = Convert.ToInt32(Math.Floor((double)ts.Days / 30));
                return isFuture ? "in " + (months <= 1 ? "one month" : months + " months") : months <= 1 ? "one month ago" : months + " months ago";
            }
            else
            {
                int years = Convert.ToInt32(Math.Floor((double)ts.Days / 365));
                return isFuture ? "in " + (years <= 1 ? "one year" : years + " years") : years <= 1 ? "one year ago" : years + " years ago";
            }
        }
    }
0
যোগ

আমি মনে করি এই পোস্টটি থেকে ইতিমধ্যেই কয়েকটি উত্তর রয়েছে, কিন্তু এটি এমন একটি ব্যবহার করতে পারে যা প্লাগইন এবং সহজেই প্রোগ্রামারদের জন্য সহজেই পড়ার মত ব্যবহার করা যায়। আপনার নির্দিষ্ট তারিখ পাঠান, এবং স্ট্রিং ফর্ম তার মান পেতে:

public string RelativeDateTimeCount(DateTime inputDateTime)
{
    string outputDateTime = string.Empty;
    TimeSpan ts = DateTime.Now - inputDateTime;

    if (ts.Days > 7)
    { outputDateTime = inputDateTime.ToString("MMMM d, yyyy"); }

    else if (ts.Days > 0)
    {
        outputDateTime = ts.Days == 1 ? ("about 1 Day ago") : ("about " + ts.Days.ToString() + " Days ago");
    }
    else if (ts.Hours > 0)
    {
        outputDateTime = ts.Hours == 1 ? ("an hour ago") : (ts.Hours.ToString() + " hours ago");
    }
    else if (ts.Minutes > 0)
    {
        outputDateTime = ts.Minutes == 1 ? ("1 minute ago") : (ts.Minutes.ToString() + " minutes ago");
    }
    else outputDateTime = "few seconds ago";

    return outputDateTime;
}
0
যোগ

আমার পথ অনেক সহজ। আপনি চাইলে রিটার্ন স্ট্রিংগুলির সাথে তুলনা করতে পারেন

    public static string TimeLeft(DateTime utcDate)
    {
        TimeSpan timeLeft = DateTime.UtcNow - utcDate;
        string timeLeftString = "";
        if (timeLeft.Days > 0)
        {
            timeLeftString += timeLeft.Days == 1 ? timeLeft.Days + " day" : timeLeft.Days + " days";
        }
        else if (timeLeft.Hours > 0)
        {
            timeLeftString += timeLeft.Hours == 1 ? timeLeft.Hours + " hour" : timeLeft.Hours + " hours";
        }
        else
        {
            timeLeftString += timeLeft.Minutes == 1 ? timeLeft.Minutes+" minute" : timeLeft.Minutes + " minutes";
        }
        return timeLeftString;
    }
0
যোগ

নিশ্চিতভাবেই '1 ঘন্টা আগে' সমস্যা থেকে মুক্তি পেতে একটি সহজ ফিক্সটি উইন্ডোটি বাড়ানো হবে যা 'এক ঘন্টা আগে' জন্য বৈধ। পরিবর্তন

if (delta < 5400) // 90 * 60
{
    return "an hour ago";
}

মধ্যে

if (delta < 7200) // 120 * 60
{
    return "an hour ago";
}

এর মানে হল যে 110 মিনিট আগে যে কিছু ঘটেছিল তা 'এক ঘণ্টা আগে' হিসাবে পড়বে- এটা নিখুঁত নাও হতে পারে, তবে আমি বলব এটা '1 ঘন্টা আগে' বর্তমান পরিস্থিতির চেয়ে ভালো।

0
যোগ

বিশ্বের দেওয়া এবং তার স্বামী কোড নমুনার পোস্টিং বলে মনে হয়, এই উত্তর কয়েকটি উপর ভিত্তি করে, আমি কিছু সময় আগে লিখেছেন কি।

এই কোডটি স্থানীয়করণযোগ্য হওয়ার জন্য একটি নির্দিষ্ট প্রয়োজন ছিল। তাই আমি দুটি ক্লাস আছে? ব্যাকরণ , যা স্থানীয়করণযোগ্য শর্তাবলী এবং FuzzyDateExtensions নির্দিষ্ট করে, যা এক্সটেনশন পদ্ধতিগুলির একটি গুচ্ছ রাখে। আমি ভবিষ্যতের তারিখগুলি মোকাবেলা করতে হবে না, তাই এই কোড দিয়ে তাদের পরিচালনা করার জন্য কোন প্রচেষ্টা করা হয় না।

আমি উত্সের XMLdoc কিছু বাকি করেছি, কিন্তু সংক্ষিপ্ততা এর অনুরোধে অধিকাংশ (যেখানে তারা স্পষ্ট হবে) মুছে ফেলা আমি এখানে প্রত্যেক শ্রেণীর সদস্যকেও অন্তর্ভুক্ত করি নি:

public class Grammar
{
    /// 
Gets or sets the term for "just now".
 
    public string JustNow { get; set; }
    /// 
Gets or sets the term for "X minutes ago".
 
    /// 
    ///     This is a  pattern, where {0}
    ///     is the number of minutes.
    /// 
    public string MinutesAgo { get; set; }
    public string OneHourAgo { get; set; }
    public string HoursAgo { get; set; }
    public string Yesterday { get; set; }
    public string DaysAgo { get; set; }
    public string LastMonth { get; set; }
    public string MonthsAgo { get; set; }
    public string LastYear { get; set; }
    public string YearsAgo { get; set; }
    /// 
Gets or sets the term for "ages ago".
 
    public string AgesAgo { get; set; }

    /// 
/// Gets or sets the threshold beyond which the fuzzy date should be /// considered "ages ago". ///
 
    public TimeSpan AgesAgoThreshold { get; set; }

    /// 
/// Initialises a new instance with the /// specified properties. ///
 
    private void Initialise(string justNow, string minutesAgo,
        string oneHourAgo, string hoursAgo, string yesterday, string daysAgo,
        string lastMonth, string monthsAgo, string lastYear, string yearsAgo,
        string agesAgo, TimeSpan agesAgoThreshold)
    { ... }
}

FuzzyDateString শ্রেণীতে রয়েছে:

public static class FuzzyDateExtensions
{
    public static string ToFuzzyDateString(this TimeSpan timespan)
    {
        return timespan.ToFuzzyDateString(new Grammar());
    }

    public static string ToFuzzyDateString(this TimeSpan timespan,
        Grammar grammar)
    {
        return GetFuzzyDateString(timespan, grammar);
    }

    public static string ToFuzzyDateString(this DateTime datetime)
    {
        return (DateTime.Now - datetime).ToFuzzyDateString();
    }

    public static string ToFuzzyDateString(this DateTime datetime,
       Grammar grammar)
    {
        return (DateTime.Now - datetime).ToFuzzyDateString(grammar);
    }


    private static string GetFuzzyDateString(TimeSpan timespan,
       Grammar grammar)
    {
        timespan = timespan.Duration();

        if (timespan >= grammar.AgesAgoThreshold)
        {
            return grammar.AgesAgo;
        }

        if (timespan < new TimeSpan(0, 2, 0))    // 2 minutes
        {
            return grammar.JustNow;
        }

        if (timespan < new TimeSpan(1, 0, 0))    // 1 hour
        {
            return String.Format(grammar.MinutesAgo, timespan.Minutes);
        }

        if (timespan < new TimeSpan(1, 55, 0))    // 1 hour 55 minutes
        {
            return grammar.OneHourAgo;
        }

        if (timespan < new TimeSpan(12, 0, 0)    // 12 hours
            && (DateTime.Now - timespan).IsToday())
        {
            return String.Format(grammar.HoursAgo, timespan.RoundedHours());
        }

        if ((DateTime.Now.AddDays(1) - timespan).IsToday())
        {
            return grammar.Yesterday;
        }

        if (timespan < new TimeSpan(32, 0, 0, 0)    // 32 days
            && (DateTime.Now - timespan).IsThisMonth())
        {
            return String.Format(grammar.DaysAgo, timespan.RoundedDays());
        }

        if ((DateTime.Now.AddMonths(1) - timespan).IsThisMonth())
        {
            return grammar.LastMonth;
        }

        if (timespan < new TimeSpan(365, 0, 0, 0, 0)    // 365 days
            && (DateTime.Now - timespan).IsThisYear())
        {
            return String.Format(grammar.MonthsAgo, timespan.RoundedMonths());
        }

        if ((DateTime.Now - timespan).AddYears(1).IsThisYear())
        {
            return grammar.LastYear;
        }

        return String.Format(grammar.YearsAgo, timespan.RoundedYears());
    }
}

"আজ" এর অর্থ কেবল "এই ক্যালেন্ডার দিবস" অর্জনের জন্য আমি কী কী কী অর্জন করতে চেয়েছিলাম, সেটিও ছিল, তাই IsToday , IsThisMonth , < কোড> ইশাইয়ার </কোড> পদ্ধতি এই মত চেহারা:

public static bool IsToday(this DateTime date)
{
    return date.DayOfYear == DateTime.Now.DayOfYear && date.IsThisYear();
}

এবং বৃত্তাকার পদ্ধতিগুলি এইরকম (আমি গোলমালগুলি অন্তর্ভুক্ত করেছি, যেটা একটু ভিন্ন):

public static int RoundedDays(this TimeSpan timespan)
{
    return (timespan.Hours > 12) ? timespan.Days + 1 : timespan.Days;
}

public static int RoundedMonths(this TimeSpan timespan)
{
    DateTime then = DateTime.Now - timespan;

    // Number of partial months elapsed since 1 Jan, AD 1 (DateTime.MinValue)
    int nowMonthYears = DateTime.Now.Year * 12 + DateTime.Now.Month;
    int thenMonthYears = then.Year * 12 + then.Month;                    

    return nowMonthYears - thenMonthYears;
}

আমি মানুষ এই দরকারী এবং / অথবা আকর্ষণীয় এটি আশা করি: o)

0
যোগ

ক্লায়েন্ট-সাইড gwt ব্যবহারের জন্য জাভা:

import java.util.Date;

public class RelativeDateFormat {

 private static final long ONE_MINUTE = 60000L;
 private static final long ONE_HOUR = 3600000L;
 private static final long ONE_DAY = 86400000L;
 private static final long ONE_WEEK = 604800000L;

 public static String format(Date date) {

  long delta = new Date().getTime() - date.getTime();
  if (delta < 1L * ONE_MINUTE) {
   return toSeconds(delta) == 1 ? "one second ago" : toSeconds(delta)
     + " seconds ago";
  }
  if (delta < 2L * ONE_MINUTE) {
   return "one minute ago";
  }
  if (delta < 45L * ONE_MINUTE) {
   return toMinutes(delta) + " minutes ago";
  }
  if (delta < 90L * ONE_MINUTE) {
   return "one hour ago";
  }
  if (delta < 24L * ONE_HOUR) {
   return toHours(delta) + " hours ago";
  }
  if (delta < 48L * ONE_HOUR) {
   return "yesterday";
  }
  if (delta < 30L * ONE_DAY) {
   return toDays(delta) + " days ago";
  }
  if (delta < 12L * 4L * ONE_WEEK) {
   long months = toMonths(delta);
   return months <= 1 ? "one month ago" : months + " months ago";
  } else {
   long years = toYears(delta);
   return years <= 1 ? "one year ago" : years + " years ago";
  }
 }

 private static long toSeconds(long date) {
  return date / 1000L;
 }

 private static long toMinutes(long date) {
  return toSeconds(date) / 60L;
 }

 private static long toHours(long date) {
  return toMinutes(date) / 60L;
 }

 private static long toDays(long date) {
  return toHours(date) / 24L;
 }

 private static long toMonths(long date) {
  return toDays(date) / 30L;
 }

 private static long toYears(long date) {
  return toMonths(date) / 365L;
 }

}
0
যোগ
প্রশ্ন হল C# ট্যাগ । কেন এটি জাভা কোড ? IMHO, শুধুমাত্র C# কোড এ প্রয়োগ করে
যোগ লেখক Kiquenet, উৎস

Nuget উপর Humanizer নামে একটি প্যাকেজ আছে এবং এটি আসলে সত্যিই ভাল কাজ করে

DateTime.UtcNow.AddHours(-30).Humanize() => "yesterday"
DateTime.UtcNow.AddHours(-2).Humanize() => "2 hours ago"

DateTime.UtcNow.AddHours(30).Humanize() => "tomorrow"
DateTime.UtcNow.AddHours(2).Humanize() => "2 hours from now"

TimeSpan.FromMilliseconds(1299630020).Humanize() => "2 weeks"
TimeSpan.FromMilliseconds(1299630020).Humanize(3) => "2 weeks, 1 day, 1 hour"

Scott Hanselman has a writeup on it on his blog

0
যোগ
তাই দরকারী! এই উত্তর এই তালিকায় অনেক বেশি হবে। যদি আমার 100 টি ভোট থাকে, আমি এটি এটিকে দিতে চাই। দৃশ্যত (JS- জমি থেকে আসছে), এই প্যাকেজ জন্য অনুসন্ধান করা সহজ ছিল না।
যোগ লেখক kumar_harsh, উৎস
বন্ধুত্বপূর্ণ নোট: উপর 4.5 বা উপরে সম্পূর্ণ Humanizer ইনস্টল করা হয় না ... শুধুমাত্র Humanizer ইনস্টল। এটির অংশ। অন্য সংস্করণ এই সংস্করণে সমর্থিত নয় কারণ
যোগ লেখক Ahmad, উৎস

যখন আপনি দর্শকের সময় অঞ্চলটি জানেন, তখন দিনের স্কেলতে ক্যালেন্ডার দিনগুলি ব্যবহার করা পরিষ্কার হতে পারে। আমি .NET লাইব্রেরি সাথে পরিচিত না তাই আমি জানি না কিভাবে আপনি সি যে #, দুর্ভাগ্যবশত।

গ্রাহক সাইটগুলিতে, আপনি এক মিনিটের মধ্যে হাত-জাদুকরও হতে পারে। "এক মিনিট আগেও কম" বা "শুধু এখন" যথেষ্ট ভাল হতে পারে।

0
যোগ

jquery.timeago প্লাগইন

Jeff, because Stack Overflow uses jQuery extensively, I recommend the jquery.timeago প্লাগইন .

উপকারিতা:

  • "1 মিনিট আগে" টাইমস্ট্যাম্পগুলি এড়িয়ে যান, যদিও 10 মিনিট আগে পাতা খোলা ছিল; timeago স্বয়ংক্রিয়ভাবে রিফ্রেশ করে।
  • আপনি আপনার ওয়েব অ্যাপ্লিকেশনে পৃষ্ঠা এবং / অথবা টুকরা ক্যাশে পূর্ণ সুবিধা নিতে পারেন, কারণ টাইমস্ট্যাম্পগুলি সার্ভারে গণনা করা হয় না।
  • আপনি শীতল বাচ্চাদের মত মাইক্রোফরম্যাট ব্যবহার করতে পারেন।

শুধু DOM প্রস্তুত আপনার টাইমস্ট্যাম্প এটি সংযুক্ত করুন:

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

এটি সব সময় abbr উপাদানগুলি টাইমসাগোর একটি ক্লাস সহ এবং একটি ISO 8601 শিরোনামে টাইমস্ট্যাম্প:

July 17, 2008

এই মত কিছু মধ্যে:

4 months ago

যা উত্পাদন: 4 মাস আগে। সময় পাস হিসাবে, টাইমস্ট্যাম্পগুলি স্বয়ংক্রিয়ভাবে আপডেট হবে।

অস্বীকৃতি: আমি এই প্লাগইনটি লিখেছিলাম, তাই আমি পক্ষপাতিত্ব করছি।

0
যোগ
@ রোব ফনসেকা-এনসোর - এখন এটা আমাকে কান্নাকাটি করছে। সঠিক তথ্য প্রদর্শন করার জন্য প্রতি মিনিটে এক আপডেট কিভাবে হয়, যেকোনো উপায়ে পাঠ্যকে দ্বিতীয়বার একবার ব্লিঙ্কিং সম্পর্কিত করতে হয়?
যোগ লেখক Daniel Earwicker, উৎস
একটি মহান প্লাগইন - মজা করার জন্য আমি "স্বয়ংক্রিয়ভাবে মোডের মত কার্যকরীতা" দ্বারা এটি স্লিমড করে "এবং এটি পুনর্বিবেচনাকারী কোডের উত্তর </ a> - jsfiddle.net/drzaus/eMUzF
যোগ লেখক drzaus, উৎস
রায়ান, আমি তাই কিছু সময় সময়সীমার ব্যবহার সুপারিশ। জেফের প্রতিক্রিয়া আমাকে কাঁদতে বলল, আমি আপনাকে বসতে বলছি: stackoverflow.uservoice.com/pages/1722-general/suggestions/…
যোগ লেখক Rob Fonseca-Ensor, উৎস
@ রায়ান ম্যাকগ্রিরি: সম্ভবত এটি জিজ্ঞাসা করার জন্য ভুল জায়গা কিন্তু টাইমআগোর ব্যবহার সম্পর্কে আমার একটি প্রশ্ন আছে। আমি যুক্তরাজ্যে আছি (জিএমটি যা ডিএসটি অন্তর্ভুক্ত করে) এবং আমার ডাটাবেসে সংরক্ষিত তারিখগুলি UTC। যদি আমি উবুন্টুতে ইউটিসি হিসাবে আমার ডিবিতে একটি তারিখ সন্নিবেশ করান, তবে অবশ্যই 1 ঘন্টা সময় হবে। তাই টাইমআগোর পরিবর্তে "প্রায় 1 মিনিট আগে" এটি "প্রায় 1 ঘন্টা আগে" বলে। টাইমআগে প্লাগইন কি ডিএসটি পার্থক্য নিয়ে কাজ করে?
যোগ লেখক TheCarver, উৎস
প্রশ্ন সম্পর্কে সি #, আমি দেখতে কিভাবে ব্যর্থ একটি jQuery প্লাগইন প্রাসঙ্গিক।
যোগ লেখক BartoszKP, উৎস
এবং যদি ব্যবহারকারীর জাভাস্ক্রিপ্ট নিষ্ক্রিয় করা হয়? jQuery (এবং সাধারণভাবে জাভা স্ক্রিপ্ট) কেবল ক্লায়েন্ট-সাইডের অভিজ্ঞতা উন্নত করতে ব্যবহার করা উচিত, তবে আপনার অ্যাপ্লিকেশন বৈশিষ্ট্যগুলি ক্লায়েন্ট প্রযুক্তির উপর নির্ভর করা উচিত নয়। আপনি জাভাস্ক্রিপ্ট ব্যবহার না করে এটি সম্পন্ন করতে পারেন।
যোগ লেখক Seb, উৎস
অটো অক্ষম অক্ষম একটি বিকল্প যে কঠিন হবে না, এটা হবে? যদি এটি ইতিমধ্যেই বিদ্যমান না হয়, তবে ... শুধুমাত্র pageload একবার টাইমস্ট্যাম্প আপডেট করুন এবং এটির সাথে সম্পন্ন করুন।
যোগ লেখক Dean Harding, উৎস
এই সমর্থন করে C# datetime.utcNow ?? এটা ভালো হত
যোগ লেখক blackholeearth0_gmail, উৎস
@PaparazzoKid হ্যাঁ, আপনার টাইমস্ট্যাম্প একটি সঠিক ISO8601 টাইমস্ট্যাম্প হয় যতক্ষণ সময়সীমার সময় অঞ্চলগুলি ঠিক সময় অঞ্চল পরিচালনা করে। কিন্তু তুমি ঠিক আছো এই প্রশ্ন জিজ্ঞাসা করা এই ভুল জায়গা। পরিবর্তে এখানে যান: github.com/rmm5t/jquery-timeago/issues
যোগ লেখক Ryan McGeary, উৎস
উদাহরণস্বরূপ, যদি আপনি জাভাস্ক্রিপ্ট নিষ্ক্রিয় আছে, তারপর আপনি মূলত abbr ট্যাগ মধ্যে স্থাপন স্ট্রিং প্রদর্শিত হয়। সাধারণত, এটি আপনি চান কোনও ফরম্যাটে একটি তারিখ বা সময়। Timeago চিত্তাকর্ষক degrades এটা অনেক সহজ না।
যোগ লেখক Ryan McGeary, উৎস
হেহ, ধন্যবাদ রোব ঠিক আছে. এটি কেবলমাত্র লক্ষণীয়, বিশেষত যখন পরিবর্তনের সময় কেবলমাত্র একটি সংখ্যা পরিবর্তন হয়, যদিও SO পৃষ্ঠাগুলিতে অনেক সময়সীমা থাকে আমি মনে করতাম তিনি পৃষ্ঠা ক্যাশিং এর উপকারিতা কমপক্ষে প্রশংসা করতেন, এমনকি যদি তিনি স্বয়ংক্রিয় আপডেটগুলি এড়াতে চান তবে আমি নিশ্চিত যে জেফ প্লাগইনটি উন্নত করতে প্রতিক্রিয়া প্রদান করতে পারে। আমি arstechnica.com এটি ব্যবহার করে সান্ত্বনা জানাই।
যোগ লেখক Ryan McGeary, উৎস

এখানে একটি বাস্তবায়ন আমি DateTime বর্গ একটি এক্সটেনশন পদ্ধতি হিসাবে যোগ করা যা ভবিষ্যত এবং অতীতের উভয় এবং হ্যান্ডলগুলি একটি এক্সটেনশন বিকল্প প্রদান করে যা আপনাকে বিস্তারিত বিবরণ ("3 ঘন্টা আগে" বনাম "3 ঘন্টা, 23 মিনিট, 1২ সেকেন্ড আগে "):

using System.Text;

/// 
/// Compares a supplied date to the current date and generates a friendly English /// comparison ("5 days ago", "5 days from now") ///
 
/// 
The date to convert
/// 
When off, calculate timespan down to the second.
/// When on, approximate to the largest round unit of time.
/// 
public static string ToRelativeDateString(this DateTime value, bool approximate)
{
    StringBuilder sb = new StringBuilder();

    string suffix = (value > DateTime.Now) ? " from now" : " ago";

    TimeSpan timeSpan = new TimeSpan(Math.Abs(DateTime.Now.Subtract(value).Ticks));

    if (timeSpan.Days > 0)
    {
        sb.AppendFormat("{0} {1}", timeSpan.Days,
          (timeSpan.Days > 1) ? "days" : "day");
        if (approximate) return sb.ToString() + suffix;
    }
    if (timeSpan.Hours > 0)
    {
        sb.AppendFormat("{0}{1} {2}", (sb.Length > 0) ? ", " : string.Empty,
          timeSpan.Hours, (timeSpan.Hours > 1) ? "hours" : "hour");
        if (approximate) return sb.ToString() + suffix;
    }
    if (timeSpan.Minutes > 0)
    {
        sb.AppendFormat("{0}{1} {2}", (sb.Length > 0) ? ", " : string.Empty, 
          timeSpan.Minutes, (timeSpan.Minutes > 1) ? "minutes" : "minute");
        if (approximate) return sb.ToString() + suffix;
    }
    if (timeSpan.Seconds > 0)
    {
        sb.AppendFormat("{0}{1} {2}", (sb.Length > 0) ? ", " : string.Empty, 
          timeSpan.Seconds, (timeSpan.Seconds > 1) ? "seconds" : "second");
        if (approximate) return sb.ToString() + suffix;
    }
    if (sb.Length == 0) return "right now";

    sb.Append(suffix);
    return sb.ToString();
}
0
যোগ

আইফোন obj- সি সংস্করণ

+ (NSString *)timeAgoString:(NSDate *)date {
int delta = -(int)[date timeIntervalSinceNow];

if (delta < 60)
{
    return delta == 1 ? @"one second ago" : [NSString stringWithFormat:@"%i seconds ago", delta];
}
if (delta < 120)
{
    return @"a minute ago";
}
if (delta < 2700)
{
    return [NSString stringWithFormat:@"%i minutes ago", delta/60];
}
if (delta < 5400)
{
    return @"an hour ago";
}
if (delta < 24 * 3600)
{
    return [NSString stringWithFormat:@"%i hours ago", delta/3600];
}
if (delta < 48 * 3600)
{
    return @"yesterday";
}
if (delta < 30 * 24 * 3600)
{
    return [NSString stringWithFormat:@"%i days ago", delta/(24*3600)];
}
if (delta < 12 * 30 * 24 * 3600)
{
    int months = delta/(30*24*3600);
    return months <= 1 ? @"one month ago" : [NSString stringWithFormat:@"%i months ago", months];
}
else
{
    int years = delta/(12*30*24*3600);
    return years <= 1 ? @"one year ago" : [NSString stringWithFormat:@"%i years ago", years];
}

}

0
যোগ
var ts = new TimeSpan(DateTime.Now.Ticks - dt.Ticks);
0
যোগ

আপনি এটি চেষ্টা করতে পারেন। আমি মনে করি এটি সঠিকভাবে কাজ করবে।

long delta = new Date().getTime() - date.getTime();
const int SECOND = 1;
const int MINUTE = 60 * SECOND;
const int HOUR = 60 * MINUTE;
const int DAY = 24 * HOUR;
const int MONTH = 30 * DAY;

if (delta < 0L)
{
  return "not yet";
}
if (delta < 1L * MINUTE)
{
  return ts.Seconds == 1 ? "one second ago" : ts.Seconds + " seconds ago";
}
if (delta < 2L * MINUTE)
{
  return "a minute ago";
}
if (delta < 45L * MINUTE)
{
  return ts.Minutes + " minutes ago";
}
if (delta < 90L * MINUTE)
{
  return "an hour ago";
}
if (delta < 24L * HOUR)
{
  return ts.Hours + " hours ago";
}
if (delta < 48L * HOUR)
{
  return "yesterday";
}
if (delta < 30L * DAY)
{
  return ts.Days + " days ago";
}
if (delta < 12L * MONTH)
{
  int months = Convert.ToInt32(Math.Floor((double)ts.Days / 30));
  return months <= 1 ? "one month ago" : months + " months ago";
}
else
{
  int years = Convert.ToInt32(Math.Floor((double)ts.Days / 365));
  return years <= 1 ? "one year ago" : years + " years ago";
}
0
যোগ
/** 
 * {@code date1} has to be earlier than {@code date2}.
 */
public static String relativize(Date date1, Date date2) {
    assert date2.getTime() >= date1.getTime();

    long duration = date2.getTime() - date1.getTime();
    long converted;

    if ((converted = TimeUnit.MILLISECONDS.toDays(duration)) > 0) {
        return String.format("%d %s ago", converted, converted == 1 ? "day" : "days");
    } else if ((converted = TimeUnit.MILLISECONDS.toHours(duration)) > 0) {
        return String.format("%d %s ago", converted, converted == 1 ? "hour" : "hours");
    } else if ((converted = TimeUnit.MILLISECONDS.toMinutes(duration)) > 0) {
        return String.format("%d %s ago", converted, converted == 1 ? "minute" : "minutes");
    } else if ((converted = TimeUnit.MILLISECONDS.toSeconds(duration)) > 0) {
        return String.format("%d %s ago", converted, converted == 1 ? "second" : "seconds");
    } else {
        return "just now";
    }
}
0
যোগ

যদি আপনি "2 দিন, 4 ঘন্টা এবং 1২ মিনিট আগে" একটি আউটপুট চান, তাহলে আপনাকে বারবার সময় প্রয়োজন:

TimeSpan timeDiff = DateTime.Now-CreatedDate;

তারপর আপনি আপনার পছন্দ মান অ্যাক্সেস করতে পারেন:

timeDiff.Days
timeDiff.Hours

প্রভৃতি

0
যোগ

এটি আমার ফাংশন, একটি কবজ ভালো কাজ করে :)

public static string RelativeDate(DateTime theDate)
        {
            var span = DateTime.Now - theDate;
            if (span.Days > 365)
            {
                var years = (span.Days / 365);
                if (span.Days % 365 != 0)
                    years += 1;
                return $"about {years} {(years == 1 ? "year" : "years")} ago";
            }
            if (span.Days > 30)
            {
                var months = (span.Days / 30);
                if (span.Days % 31 != 0)
                    months += 1;
                return $"about {months} {(months == 1 ? "month" : "months")} ago";
            }
            if (span.Days > 0)
                return $"about {span.Days} {(span.Days == 1 ? "day" : "days")} ago";
            if (span.Hours > 0)
                return $"about {span.Hours} {(span.Hours == 1 ? "hour" : "hours")} ago";
            if (span.Minutes > 0)
                return $"about {span.Minutes} {(span.Minutes == 1 ? "minute" : "minutes")} ago";
            if (span.Seconds > 5)
                return $"about {span.Seconds} seconds ago";

            return span.Seconds <= 5 ? "about 5 seconds ago" : string.Empty;
        }
0
যোগ
সুখী কোডিং: ডি
যোগ লেখক VnDevil, উৎস
একটি যাদুমন্ত্র মত কাজ করে :)
যোগ লেখক densityx, উৎস