Milisaniyeleri okunabilir biçime nasıl dönüştürebilirim?

Rasgele bir milisaniyeyi Gün, Saat, Dakika Saniye'ye dönüştürmem gerekiyor.

Örneğin: 10 Gün, 5 saat, 13 dakika, 1 saniye.

Pekala, kimse adım atmadığına göre, bunu yapmak için kolay kodu yazacağım:

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

Sadece günler durup aylarca sormadığına sevindim. :)

Yukarıda, /tamsayı bölümünün kesilmesini temsil ettiğinin varsayıldığına dikkat edin . Bu kodu /kayan nokta bölmesini temsil eden bir dilde kullanırsanız , bölümün sonuçlarını gerektiği gibi manuel olarak kesmeniz gerekecektir.

A, milisaniye miktarı olsun. O zaman sizde:

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

ve benzeri ( %modül operatörüdür).

Bu yardımcı olur umarım.

Aşağıdaki her iki çözüm de javascript kullanıyor (çözümün dilden bağımsız olduğu hakkında hiçbir fikrim yoktu!). Süreler yakalanacaksa her iki çözümün de uzatılması gerekecektir > 1 month.

1.Çözüm: Date nesnesini kullanın

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

verir:

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

Kitaplıklar faydalıdır, ancak tekerleği yeniden icat etmek varken neden bir kitaplık kullanmalısınız? :)

2.Çözüm: Kendi ayrıştırıcınızı yazın

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

İhtiyaç duyduğunuz alanlarla birlikte bir "süre" nesnesi oluşturur. Bir zaman damgasını biçimlendirmek daha sonra basitleşir ...

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

verir:

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

Apache Commons Lang , formatDurationWords gibi çok yararlı yöntemlere sahip olan bir DurationFormatUtils'e sahiptir .

Kullandığınız dilin datetime işlevlerini kullanmalısınız, ancak sadece eğlenmek için kod burada:

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;

Bu yazdığım bir yöntem. Bir alır integer milliseconds valueve bir döndürür 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;

}

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

Dilinizin / seçim çerçevenizin sağladığı tarih / saat işlevlerini / kitaplıklarını kullanmanızı öneririm. Ayrıca, genellikle tarih / zaman damgalarını geçirmek ve insan tarafından okunabilir bir dize formatı çıkarmak için kolay yollar sağladıkları için dize biçimlendirme işlevlerine de göz atın.

Seçimleriniz basit:

1. Dönüştürmeyi yapmak için kodu yazın (yani, günleri elde etmek için milliSecondsPerDay'e bölün ve saatleri elde etmek için miliSecondsPerHour'a bölmek için modülü kullanın ve miliSecondsPerMinute'a bölmek ve saniyeler için 1000'e bölmek için modülü kullanın. MilliSecondsPerMinute = 60000, miliSecondsPerHour milliSecondsPerMinute, milliSecondsPerDay = 24 * milliSecondsPerHour.
2. Bir tür çalışma rutini kullanın. UNIX ve Windows, bir Ticks veya saniye türü değerinden elde edebileceğiniz yapılara sahiptir.

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

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

Bu şunu yazdırmalıdır: 0,0: 1: 9

Neden böyle bir şey yapmıyorsun:

var ms = 86400;

var saniye = ms / 1000; //86.4

var dakika = saniye / 60; //1.4400000000000002

var saat = dakika / 60; //0.024000000000000004

var gün = saat / 24; //0.0010000000000000002

Ve kayan nokta hassasiyetiyle uğraşmak, örn. Sayı (minutes.toFixed (5)) //1.44

Java'da

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

Şöyle bir şey verir:

12h 1 min, 34 sec

Sorunuza ilk cevabı yorumlayamıyorum ama küçük bir hata var. Kayan noktalı sayıları tam sayıya dönüştürmek için parseInt veya Math.floor kullanmalısınız, 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);

Şahsen, projelerimde CoffeeScript kullanıyorum ve kodum şöyle görünüyor:

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 

Bu bir çözümdür. Daha sonra ":" ile bölebilir ve dizinin değerlerini alabilirsiniz

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

İşte TimeUnit kullanan çözümüm.

GÜNCELLEME: Bunun harika bir şekilde yazıldığını belirtmeliyim, ancak Java neredeyse aynı.

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"

Bunu yapmanın esnek bir yolu:
(Geçerli tarih için yapılmamış, ancak süreler için yeterince iyi)

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

Not: Zaman aralıklarını kontrol etmek istiyorsanız, timeSteps'ı da parametre olarak ayarlayabilirsiniz .

nasıl kullanılır (bir testi kopyalayın):

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

Http://www.ocpsoft.org/prettytime/ kitaplığını kullanmanızı öneririm ..

İnsan tarafından okunabilir biçimde zaman aralığı elde etmek çok basittir.

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

"şu andan itibaren" gibi yazdırılacak

diğer örnek

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

then string ago = "1 saat önce"

İşte JAVA'da daha kesin bir yöntem, bu basit mantığı uyguladım, umarım bu size yardımcı olur:

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