Question

I have jquery countdown which I took from here and tried to modify with cookie to get persistent result as following:
Edited

   <script type="text/javascript">
    (function($) {
   function countdown(el, options) {
    var calc = function (target, current) {
        var o = {};

        var datetarget = getCookie('Target');
        if(!datetarget) {
            clearInterval(cd.id);
            var datetarget = target.getTime()/1000;
        }
        if(datetarget <= 0) { return true; }
        deleteCookie('Target');
        o.seconds = datetarget;
        o.seconds %= 86400;
        o.hours = Math.floor(o.seconds/3600);
        o.seconds -= o.hours * (3600);
        o.minutes = Math.floor(o.seconds/60);
        o.seconds -= o.minutes * (60);
        o.seconds %= 60;
        datetarget -= 1;
        setCookie('Target',datetarget,1);
        return o;
    };

It somehow worked but i still got float instead of integer on “seconds” part and wrong result on “hours”. Any ideas?

Answer 1

I still got float instead of integer on “seconds” part

You never rounded it. While the milliseconds you got from getTime were an integer, you got a float with 3 decimals after dividing by 1000 to convert to seconds.

Also, the EcmaScript Modulus operator does work on floats, instead of truncating operands and result to integers. To cite the spec:

In C and C++, the remainder operator accepts only integral operands;
in ECMAScript, it also accepts floating-point operands.

The result of a floating-point remainder operation as computed by the
% operator is not the same as the “remainder” operation defined by
IEEE 754. The IEEE 754 “remainder” operation computes the remainder
from a rounding division, not a truncating division, and so its
behaviour is not analogous to that of the usual integer remainder
operator. Instead the ECMAScript language defines % on floating-point
operations to behave in a manner analogous to that of the Java integer
remainder operator; this may be compared with the C library function
fmod.

Where neither an infinity, nor a zero, nor NaN is involved […], the
floating-point remainder r from a dividend n and a divisor d is
defined by the mathematical relation r = n − (d * q) where q is an
integer that is negative only if n/d is negative and positive only if
n/d is positive, and whose magnitude is as large as possible without
exceeding the magnitude of the true mathematical quotient of n and d.
r is computed and rounded to the nearest representable value using
IEEE 754 round-to-nearest mode.

That last part also explains why we likely get some other decimals from small rounding errors in the floating point arithmetic.

You may omit one of the equivalent lines

    o.seconds -= o.minutes * (60);
    o.seconds %= 60;

and add one of

    o.seconds = Math.round(o.seconds);
    o.seconds = Math.floor(o.seconds);

wrong result on “hours”

I can’t see that. Might it be possible that you did expect the value behave according your timezone? getTime returns milliseconds since epoch, which is in UTC.