#19. Kevin on 30 December 2008

@ Brett Zamir: Thanks Brett. I've added the functions. I do have the idea they could be standardized & improved a bit though, but I'll leave that up to the 'future us' :) Let those guys handle it.

Seriously though: I think the class_exists example I've made should return true, but it doesn't. That's a good one to start with.

#18. Brett Zamir on 23 December 2008

Added one last condition which will find if there is a static members on the class to which an object belongs, as well as some example tests for it as well:

myClass2.prototype.instanceMethod = function () {}
myClass2.prototype.mine = 'my member';
var_dump(property_exists(new myClass2, 'mine')); //true
var_dump(property_exists(new myClass2, 'xpto'));   //true, as of PHP 5.3.0
var_dump(property_exists(new myClass2, 'bar'));    //false
var_dump(property_exists(new myClass2, 'staticProp'));   //true, as of PHP 5.3.0
var_dump(property_exists(new myClass2, 'staticMethod'));    //false
var_dump(property_exists(new myClass2, 'instanceMethod'));    //false
var myclass2 = new myClass2();
myclass2.staticMethod(); // doesn't exist

function property_exists (cls, prop) {
    cls = (typeof cls === 'string') ? window[cls] : cls;
    if (typeof cls === 'function' && cls.toSource && cls.toSource().match(new RegExp('this\\.'+prop+'\\s'))) { // Hackish and non-standard but can probably detect if setting the property (we don't want to test by instantiating as that may have side-effects)
        return true;
    }
    return (cls[prop] !== undefined && typeof cls[prop] !== 'function') || (cls.prototype !== undefined && cls.prototype[prop] !== undefined && typeof cls.prototype[prop] !== 'function') || cls.constructor && cls.constructor[prop] !== undefined && typeof cls.constructor[prop] !== 'function';
}

#17. Brett Zamir on 23 December 2008

And here's one for property_exists(), based on PHP doc examples:

var myClass = {
    mine : {},
    xpto : {},
    test : function () {
        var_dump(property_exists('myClass', 'xpto')); // true
    }
}
var_dump(property_exists('myClass', 'mine'));   //true
var_dump(property_exists('myClass', 'xpto'));   //true
var_dump(property_exists('myClass', 'bar'));    //false
var_dump(property_exists('myClass', 'test'));   // false (PHP considers methods as distinct from properties)
myClass.test(); // true
 
 
function myClass2 () {
    this.xpto = 'something';
}
myClass2.staticProp = 'staticValue';
myClass2.staticMethod = function () {
        var_dump(property_exists('myClass2', 'xpto')); // true
}
myClass2.prototype.instanceMethod = function () {}
myClass2.prototype.mine = 'my member';
 
var_dump(property_exists('myClass2', 'mine'));   //true
var_dump(property_exists(new myClass2, 'mine')); //true
var_dump(property_exists('myClass2', 'xpto'));   //true, as of PHP 5.3.0
var_dump(property_exists('myClass2', 'bar'));    //false
var_dump(property_exists('myClass2', 'staticProp'));   //true, as of PHP 5.3.0
var_dump(property_exists('myClass2', 'staticMethod'));    //false
var_dump(property_exists('myClass2', 'instanceMethod'));    //false
myClass2.staticMethod(); // true
 
 
function property_exists (cls, prop) {
    cls = (typeof cls === 'string') ? window[cls] : cls;
    if (typeof cls === 'function' && cls.toSource && cls.toSource().match(new RegExp('this\\.'+prop+'\\s'))) { // Hackish and non-standard but can probably detect if setting the property (we don't want to test by instantiating as that may have side-effects)
        return true;
    }
    return (cls[prop] !== undefined && typeof cls[prop] !== 'function') || (cls.prototype !== undefined && cls.prototype[prop] !== undefined && typeof cls.prototype[prop] !== 'function');
}

#16. Brett Zamir on 23 December 2008

Here's a slightly hackish and partially non-standard way to get class_exists(). Of course, any function can be instantiated in JavaScript, but I've attempted to do a hopefully more sophisticated checking to see whether it was designed as one.

function A (z) {this.z=z}
alert(class_exists('A')); // true (constructor sets 'this')
var a = new A('str');
alert(class_exists('a')); // false (objects not classes)
 
function B () {}
B.c = function () {}; // Add a static method, making it a class
alert(class_exists('B')); // true
 
function C () {}
C.prototype.z = function () {};
alert(class_exists('C')); // true
 
function D (b) {}
alert(class_exists('D')); // false (seems like a regular function)
 
var e = {
    E : function (z) {this.z=z;}
}
alert(class_exists('e.E')); // false (the 'this' refers to containing object, not to an instance property)
 
 
function class_exists (cls) {
    cls = window[cls]; // Note: will prevent inner classes
    if (typeof cls !== 'function') {return false;}
    for (var i in cls.prototype) {
        return true;
    }
    for (var i in cls) { // If static members exist, then consider a "class"
        if (i !== 'prototype') {
            return true;
        }
    }
    if (cls.toSource && cls.toSource().match(/this\./)) { // Hackish and non-standard but can probably detect if setting a property (we don't want to test by instantiating as that may have side-effects)
        return true;
    }
    return false;
}

#15. Brett Zamir on 23 December 2008

Fixing an error and adding more examples:

function Directory () {}
Directory.test = function () {}
Directory.prototype.read = function () {}
$directory = new Directory('.');
alert(true === method_exists($directory,'read')); // true
alert(true === method_exists($directory,'write')); // false
alert(true === method_exists('Directory','test')); // true
alert(true === method_exists('Directory','read')); // false
alert(true === method_exists($directory,'test')); // false
 
function method_exists (obj, method) {
    if (typeof obj === 'string') {
        return window[obj] && typeof window[obj][method] === 'function'
    }
    return typeof obj[method] === 'function';
}

#14. Brett Zamir on 20 December 2008

Sorry, neglected to see a string was allowable to test for a static method:

function Directory () {}
Directory.test = function () {}
Directory.prototype.read = function () {}
$directory = new Directory('.');
alert(true === method_exists($directory,'read')); // true
alert(true === method_exists($directory,'write')); // false
alert(true === method_exists('Directory','test')); // true

function method_exists (obj, method) {
    if (typeof obj === 'string') {
        return typeof window[obj][method] === 'function'
    }
    return typeof obj[method] === 'function';
}

#13. Brett Zamir on 20 December 2008

Here's another one more related to the function here...

Sample based on PHP manual...

function Directory () {}
Directory.prototype.read = function () {}
$directory = new Directory('.');
alert(true === method_exists($directory,'read')); // true
alert(true === method_exists($directory,'write')); // false

function method_exists (obj, method) {
    return typeof obj[method] === 'function';
}

#12. Kevin on 17 December 2008

@ Brett Zamir: get_defined_functions... I must say, sometimes I'm really surprised what you guys come up with :) But it works! I have even hacked a testcase around it. Thanks again.

#11. Brett Zamir on 17 December 2008

Here's one more...

function get_defined_functions() {
    var arr = [];
    for (var i in window) {
        try {
            if (typeof window[i] === 'function') {
                arr.push(window[i].name);
            }
        }
        catch (e) {
        }
    }
    return arr;
}
alert(get_defined_functions());

#10. Kevin on 15 January 2008

@ Andrea Giammarchi: Wow you did some impressive work that I was unaware of. Cool :) I will look into the define function later today and add it here, thanks a lot for that.

About the PHP vs JS stuff.. I'm not trying to port or emulate the entire language or control structures of PHP. Indeed I don't see the need because (and this is quite a statement), Javascript seems to have more elegant features in that category anyway.

However in my eyes, PHP does provide a large set of standard functions that make developing very easy, and some of them don't have good standard Javascript implementations, though they often would be great to have client-side.
... [more]
So in this project by also providing the functions separately, I hope to keep people from inventing the wheel and give them a head start.

Thanks for your comment Andrea, well appreciated. And respect for your Overbyte editor & JHP environment. The idea is very interesting, and I can see it's all coded with very high skill.

#9. Andrea Giammarchi on 14 January 2008

If you are interested in some similar stuff, looks for JHP setting in overbyte editor.

Finally, You could use my define function too, that accept only scalar values as PHP and is compatible with IE, FireFox, Safari and Opera (Opera devs will fix soon their const keyword ... I guess ...)

http://webreflection.blogspot.com/2007/10/cow-javascript-define-php-like-function.html
... [more]
However, nice stuff .. not so useful in my mind because of different languages nature (I would like to have JS behaviours in PHP, for example :D) but good luck for the project

#8. Legaev Andrey on 08 January 2008

@ Kevin: I'm sorry. Not necessary to enlist my email. I did not think about spammers :)

#7. Kevin on 07 January 2008

@ Legaev Andrey: Hi, I've updated the function and changed your name. I wasn't sure you really want me to enlist your email address?

#6. Legaev Andrey (aka Andrey) on 07 January 2008

Sorry for my short previous comment and my bad English. Below full version.

If we pass function_name as String then all ok. But if we pass the link to function (link to Object-function) then
this function returns false. In my opinion in this case this function should return true when first
parameter is instance of Function.
... [more]
function function_exists_new( function_name ) {
if (typeof function_name == \'string\')
return (typeof window[function_name] == \'function\');
else
return (function_name instanceof Function);
}

P.S. Please, change my name to Legaev Andrey <legaev_andrey@mail.ru>. Thanks.

#5. Kevin on 06 January 2008

@ Cord: Thanks for noticing. Fixed!

#4. Cord on 06 January 2008

>>function is_array() {
should be
>>function is_array(a) {

#3. Kevin on 04 January 2008

@ Steve Clay & Andrey: Thanks You guys I've updated the function. I left the old code in the comments for future reference.

#2. Andrey on 04 January 2008

>return (typeof window[function_name] == 'function');

Object-function may be defined as not a member of Window object.

#1. Steve Clay on 04 January 2008

return (typeof window[function_name] == 'function');