#6. Brett Zamir on 26 January 2009

As far as the callbacks-as-strings, on second thought, just using window[funcName]() (or building a function with an inner function if hard-wiring arguments is needed) avoids the eval()ish nature of setTimeout-with-1st-arg-as-string. But it was a fun thought... :)

#5. Kevin on 25 January 2009

@ Brett Zamir: You convinced me! Interesting idea about the callbacks as well!

#4. Brett Zamir on 23 January 2009

Ok, as far as "not-null", that should be changed to "changed" (to be more clear). That is just providing some way to ensure that an undefined variable will return false (since "changed" will not equal 'undefined'). We need to do some test for whether it is defined, since it will otherwise throw an error. This is safe since the value will be reset back to its original value (in this case to undefined).

As far as the NaN issue in the function... NaN is actually is considered to be typeof number, but that was redundant, and I shouldn't have handled it as a constant anyways because I've since discovered NaN, Infinity, and undefined are all variables in JavaScript--you can change them!

The only way that adding the 'changed' keyword to the "variable" could result in the same value as the original temporary variable is if the original was a constant. For example, (non-constant) objects or arrays will have their toString() methods called, but they will get an additional string "changed" appended, so they can never match (and thus the variable will get set back to its original value).

As far as failing, I don't see any reason which could cause it to fail--do you? (if it crashed at that point, the changed variable would be meaningless anyways).

As far as a parallel process, even if the person is using a setTimeout "thread", my understanding is that the function must fully complete before yielding since JavaScript doesn't have true threads. So the variable should always get set back, as far as I can tell.

(Off the subject, but speaking of setTimeout, I just realized we could allow passing of PHP-style callbacks-as-strings into JavaScript functions by calling setTimeout with a 0 ms timeout (optionally building arguments to pass in as necessary).)

var a = function(b){alert('aaa');}
runCallback('a')
function runCallback (cb) {
    var a = setTimeout(cb+"()",0) 
}

function defined (constant) {
    var tmp = window[constant];
    window[constant] = window[constant] ? 'changed'+window[constant].toString() : 'changed';
    var returnval = window[constant] === tmp;
    if (!returnval) { // Reset
        window[constant] = tmp;
    }
    return returnval;
}

#3. Kevin on 30 December 2008

@ Brett Zamir: If I'm not mistaken you are reassigning the variable a value to make sure it really is a constant.

If it's not set, you set it to not-null? That part I don't get.
Then, if it's a number AND it's not a number (?!) and the types of the original & newly set var do not match you reset it to it's original value. But if they do match you leave the 'changed' keyword there? I don't understand that.

... [more] One concern that comes to surface is that you are changing a user variable (if they accidentally specify a variable instead of a const).

If the function fails or there is a parallel process, a the changed value will be returned.

Could you explain a bit more about this approach? I'm just not getting it I guess.

#2. Brett Zamir on 21 December 2008

Whoops... forgot to reassign the variable I temporarily changed:

function defined (constant) {
    var returnval;
    var tmp = window[constant];    
    window[constant] = window[constant] ? 'changed'+window[constant].toString() : 'not-null';
    if (typeof window[constant] === 'number' && isNaN(window[constant])) { // NaN
        returnval = typeof tmp === typeof window[constant];
        if (!returnval) {
            window[constant] = tmp;
        }
        return returnval;
    }
    returnval = window[constant] === tmp;
    if (!returnval) {
        window[constant] = tmp;
    }
    return returnval;
}

#1. Brett Zamir on 21 December 2008

Here's an implementation which works with the 'const' keyword. Tested with NaN, booleans, numbers, strings, arrays, objects, regular expression literals.

const a = 5;
var b = 5;
alert(defined('a')); // true 
alert(defined('b'));  // false
 
function defined (constant) {
    var tmp = window[constant];    
    window[constant] = window[constant] ? 'changed'+window[constant].toString() : 'not-null';
    if (typeof window[constant] === 'number' && isNaN(window[constant])) { // NaN
        return typeof tmp === typeof window[constant];
    }
    return window[constant] === tmp;
}