मिलीसेकंड को मानव पठनीय रूप में कैसे परिवर्तित करें?

Question

मुझे मिलीसेकंड की एक मनमानी राशि को दिनों, घंटों, मिनटों में बदलने की आवश्यकता है।

उदाहरण के लिए: 10 दिन, 5 घंटे, 13 मिनट, 1 सेकंड।

Comments

"मैं जिस भाषा का उपयोग कर रहा हूं उसमें यह अंतर्निहित नहीं है, अन्यथा मैं इसका उपयोग करता।" मुझे यह समझना मुश्किल है। क्या भाषा? क्या ओएस?

— एस.लूट।

ActionScript, किसी भी ओएस, यह दुखी दिनांक / समय समर्थन हासिल है

— FlySwat

मैं किसी भी भाषा के बारे में नहीं जानता, जो उसके लिए पूछ रही है, और न ही मुझे ऐसा कोई कारण दिखाई देता है। कुछ बहुत ही सरल विभाजन / मापांक गणित का जवाब ठीक मिलता है।

— किप

सभी वर्षों में समान दिन नहीं होते हैं, इसलिए आपको यह बताना होगा कि यह किस अवधि का था। या हो सकता है, आप बस इसे 'मानक' वर्षों (365.something) में चाहते हैं?

— मिलान बाबूसकोव

@ किप: मिल गया - सवाल को गलत बताया - मिलीसेकंड में ओएस टाइमस्टैम्प के बारे में सोच रहा था। डेल्टा समय या अंतराल नहीं। प्रश्न संपादित करने के लिए

— अस्थायी

Answer 1

खैर, जब से किसी और ने कदम नहीं उठाया है, मैं ऐसा करने के लिए आसान कोड लिखूंगा:

x = ms / 1000
seconds = x % 60
x /= 60
minutes = x % 60
x /= 60
hours = x % 24
x /= 24
days = x

मुझे खुशी है कि आपने कई दिनों तक रोका और महीनों तक नहीं पूछा। :)

ध्यान दें कि ऊपर में, यह माना जाता है कि /पूर्णांक विभाजन को दर्शाता है। यदि आप इस कोड का उपयोग उस भाषा में /करते हैं जहां फ्लोटिंग पॉइंट डिवीजन का प्रतिनिधित्व करता है, तो आपको आवश्यकतानुसार विभाजन के परिणामों को मैन्युअल रूप से कम करना होगा।

Comments

बस एक फ्लैश फंक्शन में इसका इस्तेमाल किया। धन्यवाद! (सादगी के लिए उत्कीर्ण)

— मकरम सालेह

यह सही ढंग से काम नहीं करता है। विभाजक का उपयोग करते समय parseInt का उपयोग करना चाहिए अन्यथा आपको लंबे फ्लोट मान दिखाई देंगे। अधिक व्यापक समाधान के लिए मेरा जवाब नीचे देखें।

— राजीव

@GGG Hewgill मुझे खुशी है कि आप दिन पर रुक गए और महीनों तक नहीं पूछा। :) हाहा :)

— मोशफिकुर

Answer 2

A को मिलीसेकंड की मात्रा होने दें। फिर आपके पास है:

seconds=(A/1000)%60
minutes=(A/(1000*60))%60
hours=(A/(1000*60*60))%24

और इतने पर ( %मापांक ऑपरेटर है)।

उम्मीद है की यह मदद करेगा।

Comments

@sabbibJAVA 24 में काम करना चाहिए था। आप किस भाषा में हैं? यदि /फ़्लोटिंग पॉइंट डिवीज़न होता है, तो आपको मान को छोटा करना होगा। यह अन्य उत्तरों में माना जाता है जो /पूर्णांक विभाजन कर रहा है।

— ब्रायन जे

Answer 3

नीचे दिए गए दोनों समाधान जावास्क्रिप्ट का उपयोग करते हैं (मुझे नहीं पता था कि समाधान भाषा अज्ञेय था!)। यदि ड्यूरेशन कैप्चर कर रहा है, तो दोनों समाधानों को विस्तारित करना होगा > 1 month।

समाधान 1: दिनांक ऑब्जेक्ट का उपयोग करें

var date = new Date(536643021);
var str = '';
str += date.getUTCDate()-1 + " days, ";
str += date.getUTCHours() + " hours, ";
str += date.getUTCMinutes() + " minutes, ";
str += date.getUTCSeconds() + " seconds, ";
str += date.getUTCMilliseconds() + " millis";
console.log(str);

देता है:

"6 days, 5 hours, 4 minutes, 3 seconds, 21 millis"

पुस्तकालय सहायक होते हैं, लेकिन जब आप पहिए का फिर से आविष्कार कर सकते हैं तो पुस्तकालय का उपयोग क्यों करें! :)

समाधान 2: अपना स्वयं का पार्सर लिखें

var getDuration = function(millis){
    var dur = {};
    var units = [
        {label:"millis",    mod:1000},
        {label:"seconds",   mod:60},
        {label:"minutes",   mod:60},
        {label:"hours",     mod:24},
        {label:"days",      mod:31}
    ];
    // calculate the individual unit values...
    units.forEach(function(u){
        millis = (millis - (dur[u.label] = (millis % u.mod))) / u.mod;
    });
    // convert object to a string representation...
    var nonZero = function(u){ return dur[u.label]; };
    dur.toString = function(){
        return units
            .reverse()
            .filter(nonZero)
            .map(function(u){
                return dur[u.label] + " " + (dur[u.label]==1?u.label.slice(0,-1):u.label);
            })
            .join(', ');
    };
    return dur;
};

एक "अवधि" ऑब्जेक्ट बनाता है, जो भी फ़ील्ड की आवश्यकता होती है। टाइमस्टैम्प को स्वरूपित करना तब सरल हो जाता है ...

console.log(getDuration(536643021).toString());

देता है:

"6 days, 5 hours, 4 minutes, 3 seconds, 21 millis"

Comments

एकवचन और बहुवचन प्राप्त करने के लिए उस पंक्ति को बदलें return dur[u.label] + " " + (dur[u.label]==1?u.label.slice(0,-1):u.label);

— फिलिप

@PhillipKamikaze धन्यवाद फिलिप! मैंने आपके सुझाव को शामिल किया है।

— निक ग्रीली

आप शायद शून्य मान वाले सेगमेंट नहीं दिखाना चाहते हैं, इसलिए निम्न फ़िल्टर जोड़ा जा सकता है ... var nonZero = function(u){ return !u.startsWith("0"); }; // convert object to a string representation... dur.toString = function(){ return units.reverse().map(function(u){ return dur[u.label] + " " + (dur[u.label]==1?u.label.slice(0,-1):u.label); }).filter(nonZero).join(', '); };

— रुस्लान उलानोव

धन्यवाद @RuslanUlanov! मैंने इसे उदाहरण में जोड़ दिया है (यदि संख्या "सत्य" है तो जांचने के लिए थोड़े संशोधन के साथ)।

— निक ग्रीली

Answer 4

अपाचे कॉमन्स लैंग में एक DurationFormatUtils है, जिसमें बहुत ही उपयोगी विधियाँ हैं जैसे कि प्रारूपड्रेनस्क्रिप्ट ।

Comments

धन्यवाद! इसे प्यार करो जब यह एक पुस्तकालय में होता है जो मेरे पास पहले से ही है ...

— लैंडन कुहन

Answer 5

आपको जिस भी भाषा का उपयोग कर रहे हैं, उसके डेटाटाइम कार्य का उपयोग करना चाहिए, लेकिन, यहां केवल मनोरंजन के लिए कोड है:

int milliseconds = someNumber;

int seconds = milliseconds / 1000;

int minutes = seconds / 60;

seconds %= 60;

int hours = minutes / 60;

minutes %= 60;

int days = hours / 24;

hours %= 24;

Answer 6

यह एक विधि है जो मैंने लिखी है। यह एक लेता है integer milliseconds valueऔर एक रिटर्न देता है human-readable String:

public String convertMS(int ms) {
    int seconds = (int) ((ms / 1000) % 60);
    int minutes = (int) (((ms / 1000) / 60) % 60);
    int hours = (int) ((((ms / 1000) / 60) / 60) % 24);

    String sec, min, hrs;
    if(seconds<10)  sec="0"+seconds;
    else            sec= ""+seconds;
    if(minutes<10)  min="0"+minutes;
    else            min= ""+minutes;
    if(hours<10)    hrs="0"+hours;
    else            hrs= ""+hours;

    if(hours == 0)  return min+":"+sec;
    else    return hrs+":"+min+":"+sec;

}

Answer 7

function convertTime(time) {        
    var millis= time % 1000;
    time = parseInt(time/1000);
    var seconds = time % 60;
    time = parseInt(time/60);
    var minutes = time % 60;
    time = parseInt(time/60);
    var hours = time % 24;
    var out = "";
    if(hours && hours > 0) out += hours + " " + ((hours == 1)?"hr":"hrs") + " ";
    if(minutes && minutes > 0) out += minutes + " " + ((minutes == 1)?"min":"mins") + " ";
    if(seconds && seconds > 0) out += seconds + " " + ((seconds == 1)?"sec":"secs") + " ";
    if(millis&& millis> 0) out += millis+ " " + ((millis== 1)?"msec":"msecs") + " ";
    return out.trim();
}

Answer 8

मैं सुझाव दूंगा कि जो भी दिनांक / समय फ़ंक्शन / लाइब्रेरी आपकी भाषा / पसंद की रूपरेखा प्रदान करती है, उसका उपयोग करें। स्ट्रिंग प्रारूपण कार्यों को भी देखें क्योंकि वे अक्सर तारीख / टाइमस्टैम्प को पारित करने के लिए आसान तरीके प्रदान करते हैं और मानव पठनीय स्ट्रिंग प्रारूप का उत्पादन करते हैं।

Answer 9

आपकी पसंद सरल है:

1. रूपांतरण करने के लिए कोड लिखें (यानी, दिनों को प्राप्त करने के लिए milliSecondsPerDay से विभाजित करें और घंटों का उपयोग करने के लिए milliSecondsPerHour से विभाजित करने के लिए मापांक का उपयोग करें और मापांक का उपयोग करने के लिए मिलीसेकंड के माध्यम से विभाजित करें और सेकंड के लिए 1000 से विभाजित करें। milliSecondsPerMinute = 60000,000 =) milliSecondsPerMinute, milliSecondsPerDay = 24 * milliSecondsPerHour।
2. किसी तरह की ऑपरेटिंग दिनचर्या का उपयोग करें। UNIX और Windows दोनों में संरचनाएं हैं जो आप एक टिक्स या सेकंड प्रकार के मूल्य से प्राप्त कर सकते हैं।

Answer 10

Long serverUptimeSeconds = 
    (System.currentTimeMillis() - SINCE_TIME_IN_MILLISECONDS) / 1000;


String serverUptimeText = 
String.format("%d days %d hours %d minutes %d seconds",
serverUptimeSeconds / 86400,
( serverUptimeSeconds % 86400) / 3600 ,
((serverUptimeSeconds % 86400) % 3600 ) / 60,
((serverUptimeSeconds % 86400) % 3600 ) % 60
);

Answer 11

Long expireTime = 69l;
Long tempParam = 0l;

Long seconds = math.mod(expireTime, 60);
tempParam = expireTime - seconds;
expireTime = tempParam/60;
Long minutes = math.mod(expireTime, 60);
tempParam = expireTime - minutes;
expireTime = expireTime/60;
Long hours = math.mod(expireTime, 24);
tempParam = expireTime - hours;
expireTime = expireTime/24;
Long days = math.mod(expireTime, 30);

system.debug(days + '.' + hours + ':' + minutes + ':' + seconds);

यह प्रिंट होना चाहिए: 0.0: 1: 9

Answer 12

ऐसा कुछ क्यों नहीं करते:

var ms = 86400;

var सेकंड = ms / 1000; //86.4

var मिनट = सेकंड / 60; //1.4400000000000002

var घंटे = मिनट / 60; //0.024000000000000004

var दिन = घंटे / 24; //0.0010000000000000002

और फ्लोट प्रिसिजन जैसे कि नंबर (मिनट्स .toFixed (5)) //1.44 से निपटना

Answer 13

जावा में

public static String formatMs(long millis) {
    long hours = TimeUnit.MILLISECONDS.toHours(millis);
    long mins = TimeUnit.MILLISECONDS.toMinutes(millis);
    long secs = TimeUnit.MILLISECONDS.toSeconds(millis);
    return String.format("%dh %d min, %d sec",
            hours,
            mins - TimeUnit.HOURS.toMinutes(hours),
            secs - TimeUnit.MINUTES.toSeconds(mins)
    );
}

कुछ इस तरह देता है:

12h 1 min, 34 sec

Answer 14

मैं पहले आपके प्रश्न का उत्तर नहीं दे पा रहा हूं, लेकिन एक छोटी सी गलती है। फ्लोटिंग पॉइंट नंबरों को पूर्णांक में बदलने के लिए आपको parseInt या Math.floor का उपयोग करना चाहिए, i

var days, hours, minutes, seconds, x;
x = ms / 1000;
seconds = Math.floor(x % 60);
x /= 60;
minutes = Math.floor(x % 60);
x /= 60;
hours = Math.floor(x % 24);
x /= 24;
days = Math.floor(x);

व्यक्तिगत रूप से, मैं अपनी परियोजनाओं में कॉफीस्क्रिप्ट का उपयोग करता हूं और मेरा कोड ऐसा दिखता है:

getFormattedTime : (ms)->
        x = ms / 1000
        seconds = Math.floor x % 60
        x /= 60
        minutes = Math.floor x % 60
        x /= 60
        hours = Math.floor x % 24
        x /= 24
        days = Math.floor x
        formattedTime = "#{seconds}s"
        if minutes then formattedTime = "#{minutes}m " + formattedTime
        if hours then formattedTime = "#{hours}h " + formattedTime
        formattedTime 

Answer 15

यह एक उपाय है। बाद में आप ":" से विभाजित कर सकते हैं और सरणी के मान ले सकते हैं

/**
 * Converts milliseconds to human readeable language separated by ":"
 * Example: 190980000 --> 2:05:3 --> 2days 5hours 3min
 */
function dhm(t){
    var cd = 24 * 60 * 60 * 1000,
        ch = 60 * 60 * 1000,
        d = Math.floor(t / cd),
        h = '0' + Math.floor( (t - d * cd) / ch),
        m = '0' + Math.round( (t - d * cd - h * ch) / 60000);
    return [d, h.substr(-2), m.substr(-2)].join(':');
}

var delay = 190980000;                   
var fullTime = dhm(delay);
console.log(fullTime);

Answer 16

यहाँ TimeUnit का उपयोग कर मेरा समाधान है।

अद्यतन: मुझे यह इंगित करना चाहिए कि यह ग्रूवी में लिखा गया है, लेकिन जावा लगभग समान है।

def remainingStr = ""

/* Days */
int days = MILLISECONDS.toDays(remainingTime) as int
remainingStr += (days == 1) ? '1 Day : ' : "${days} Days : "
remainingTime -= DAYS.toMillis(days)

/* Hours */
int hours = MILLISECONDS.toHours(remainingTime) as int
remainingStr += (hours == 1) ? '1 Hour : ' : "${hours} Hours : "
remainingTime -= HOURS.toMillis(hours)

/* Minutes */
int minutes = MILLISECONDS.toMinutes(remainingTime) as int
remainingStr += (minutes == 1) ? '1 Minute : ' : "${minutes} Minutes : "
remainingTime -= MINUTES.toMillis(minutes)

/* Seconds */
int seconds = MILLISECONDS.toSeconds(remainingTime) as int
remainingStr += (seconds == 1) ? '1 Second' : "${seconds} Seconds"

Answer 17

इसे करने का एक लचीला तरीका:
(वर्तमान तिथि के लिए नहीं लेकिन अवधि के लिए पर्याप्त अच्छा है)

/**
convert duration to a ms/sec/min/hour/day/week array
@param {int}        msTime              : time in milliseconds 
@param {bool}       fillEmpty(optional) : fill array values even when they are 0.
@param {string[]}   suffixes(optional)  : add suffixes to returned values.
                                        values are filled with missings '0'
@return {int[]/string[]} : time values from higher to lower(ms) range.
*/
var msToTimeList=function(msTime,fillEmpty,suffixes){
    suffixes=(suffixes instanceof Array)?suffixes:[];   //suffixes is optional
    var timeSteps=[1000,60,60,24,7];    // time ranges : ms/sec/min/hour/day/week
    timeSteps.push(1000000);    //add very big time at the end to stop cutting
    var result=[];
    for(var i=0;(msTime>0||i<1||fillEmpty)&&i<timeSteps.length;i++){
        var timerange = msTime%timeSteps[i];
        if(typeof(suffixes[i])=="string"){
            timerange+=suffixes[i]; // add suffix (converting )
            // and fill zeros :
            while(  i<timeSteps.length-1 &&
                    timerange.length<((timeSteps[i]-1)+suffixes[i]).length  )
                timerange="0"+timerange;
        }
        result.unshift(timerange);  // stack time range from higher to lower
        msTime = Math.floor(msTime/timeSteps[i]);
    }
    return result;
};

नायब: आप टाइमस्टेप्स भी सेट कर सकते हैं यदि आप समय सीमाओं को नियंत्रित करना चाहते हैं, तो आप को पैरामीटर के रूप में हैं।

कैसे उपयोग करें (एक परीक्षण की प्रतिलिपि बनाएँ):

var elsapsed = Math.floor(Math.random()*3000000000);

console.log(    "elsapsed (labels) = "+
        msToTimeList(elsapsed,false,["ms","sec","min","h","days","weeks"]).join("/")    );

console.log(    "half hour : "+msToTimeList(elsapsed,true)[3]<30?"first":"second"   );

console.log(    "elsapsed (classic) = "+
        msToTimeList(elsapsed,false,["","","","","",""]).join(" : ")    );

Answer 18

मैं http://www.ocpsoft.org/prettytime/ का उपयोग करने का सुझाव देता हूं लाइब्रेरी ।

मानव पठनीय रूप में समय अंतराल प्राप्त करना बहुत सरल है

PrettyTime p = new PrettyTime(); System.out.println(p.format(new Date()));

यह "अभी से क्षण" की तरह छपेगा

अन्य उदाहरण

PrettyTime p = new PrettyTime()); Date d = new Date(System.currentTimeMillis()); d.setHours(d.getHours() - 1); String ago = p.format(d);

फिर स्ट्रिंग पहले = "1 घंटा पहले"

Answer 19

यहाँ जावा में अधिक सटीक विधि है, मैंने इस सरल तर्क को लागू किया है, आशा है कि यह आपकी मदद करेगा:

    public String getDuration(String _currentTimemilliSecond)
    {
        long _currentTimeMiles = 1;         
        int x = 0;
        int seconds = 0;
        int minutes = 0;
        int hours = 0;
        int days = 0;
        int month = 0;
        int year = 0;

        try 
        {
            _currentTimeMiles = Long.parseLong(_currentTimemilliSecond);
            /**  x in seconds **/   
            x = (int) (_currentTimeMiles / 1000) ; 
            seconds = x ;

            if(seconds >59)
            {
                minutes = seconds/60 ;

                if(minutes > 59)
                {
                    hours = minutes/60;

                    if(hours > 23)
                    {
                        days = hours/24 ;

                        if(days > 30)
                        {
                            month = days/30;

                            if(month > 11)
                            {
                                year = month/12;

                                Log.d("Year", year);
                                Log.d("Month", month%12);
                                Log.d("Days", days % 30);
                                Log.d("hours ", hours % 24);
                                Log.d("Minutes ", minutes % 60);
                                Log.d("Seconds  ", seconds % 60);   

                                return "Year "+year + " Month "+month%12 +" Days " +days%30 +" hours "+hours%24 +" Minutes "+minutes %60+" Seconds "+seconds%60;
                            }
                            else
                            {
                                Log.d("Month", month);
                                Log.d("Days", days % 30);
                                Log.d("hours ", hours % 24);
                                Log.d("Minutes ", minutes % 60);
                                Log.d("Seconds  ", seconds % 60);   

                                return "Month "+month +" Days " +days%30 +" hours "+hours%24 +" Minutes "+minutes %60+" Seconds "+seconds%60;
                            }

                        }
                        else
                        {
                            Log.d("Days", days );
                            Log.d("hours ", hours % 24);
                            Log.d("Minutes ", minutes % 60);
                            Log.d("Seconds  ", seconds % 60);   

                            return "Days " +days +" hours "+hours%24 +" Minutes "+minutes %60+" Seconds "+seconds%60;
                        }

                    }
                    else
                    {
                        Log.d("hours ", hours);
                        Log.d("Minutes ", minutes % 60);
                        Log.d("Seconds  ", seconds % 60);

                        return "hours "+hours+" Minutes "+minutes %60+" Seconds "+seconds%60;
                    }
                }
                else
                {
                    Log.d("Minutes ", minutes);
                    Log.d("Seconds  ", seconds % 60);

                    return "Minutes "+minutes +" Seconds "+seconds%60;
                }
            }
            else
            {
                Log.d("Seconds ", x);
                return " Seconds "+seconds;
            }
        }
        catch (Exception e) 
        {
            Log.e(getClass().getName().toString(), e.toString());
        }
        return "";
    }

    private Class Log
    {
        public static void d(String tag , int value)
        {
            System.out.println("##### [ Debug ]  ## "+tag +" :: "+value);
        }
    }