Question

My problem is with objInfo(). How can I return an object via a passed-in variable? I’m trying to namespace my code and use private/public vars.

Bonus Q: How would you otherwise improve the code?

// Namespace all my code
var bab = new function() {

    // Declare cat object
    function cat()
    {
      this.eyes = 2;
      this.legs = 4;
      this.diet = 'carnivore';

      return true;
    }

    // Declare lion object
    function lion()
    {
      this.mane = true;
      this.origin = 'Africa';
      this.diet = 'people'; // has priority over cat's diet

      return true;
    }

    // Make lion a subclass of cat
    lion.prototype = new cat();

    // Create an instance of class lion
    var simba = new lion();

    // Share diet publicly
    this.objInfo = function(name) {
        return name; // simba works, name doesn't
    };

};

alert(bab.objInfo('simba').diet);

Note: Source is sampled from various places

Answer 1

Other than namespacing, it’s not clear to me what you’re trying to do, but I’ve included a code review of sorts under the divider below. More high-level comments first.

There are a couple of issues here. First off, you almost never want to write new function() { }. It’s a very advanced technique that’s easy to get wrong (and very easy for anyone doing maintenance on the code to misunderstand). There’s an example of another, less-confusing way to get the same effect (plus some other benefits) below.

Here’s an example of a namespaced module providing two “classes”, Cat and Lion (I’ve made them initially-capped because that’s the usual convention: initial caps on constructor functions and initial lower case on non-constructor functions, just to make it easy to read code):

var Animals = (function() {
    var publics = {};

    // A Cat
    publics.Cat = Cat;
    function Cat() {
        this.eyes = 2;
        this.legs = 4;
        this.diet = 'carnivore';
    }

    // A Lion
    publics.Lion = Lion;
    function Lion() {
        this.mane = true;
        this.origin = 'Africa';
        this.diet = 'people'; // has priority over cat's diet
    }
    Lion.prototype = new Cat();

    // Return our public symbols
    return publics;
})();

// Usage
var l = new Animals.Lion();
alert(l.eyes); // alerts "2" (inherited from Cat)
alert(l.diet); // alerts "people" (overridden by Lion)

(You can, of course, call publics anything else you want — pubs, p, whatever. It’s the equivalent of this in the outermost layer of your new function() { } function, but less confusing.)

But just replacing the prototype on Lion is a bit simplistic. When you start getting into subclassing, there are several other things you want to look at doing. Here’s a blog post that details a fairly complete means of building classes, including subclassing, calling superclass functions, etc.

In terms of looking something up by string, you can do that with brackets notation on any object:

var obj = {};
obj.foo = 42;
alert(obj["foo"]); // alerts "42" by retrieving the property "foo" from `obj`
var x = "f" + "o" + "o";
alert(obj[x]);     // alerts "42" by retrieving the property "foo" from `obj`

Code review follows.

---

Here’s a code review:

// Namespace all my code
// [TJC] Use the (function() { ... })(); mechanism described above rather than
// `new function() { ... }`, which is fairly confusing to the reader and troublesome
// to use inside inner functions (see below)
var bab = new function() {

    // Declare cat object
    // [TJC] Convention is to use initial caps for constructor functions,
    // e.g. "Cat" not "cat"
    function cat()
    {
      this.eyes = 2;
      this.legs = 4;
      this.diet = 'carnivore';

      // [TJC] Don't return anything out of constructor functions
      return true;
    }

    // Declare lion object
    // [TJC] "Lion" rather than "lion" would be more conventional
    function lion()
    {
      this.mane = true;
      this.origin = 'Africa';
      this.diet = 'people'; // has priority over cat's diet

      // [TJC] Don't return anything out of constructor functions
      return true;
    }

    // Make lion a subclass of cat
    // [TJC] There are several other things you want to consider in
    // addition to replacing the prototype
    lion.prototype = new cat();

    // Create an instance of class lion
    // [TJC] From your usage below, it looks like you
    // want to be able to look up "simba" using a string
    // later. So use the below rather than this commented-out
    // line:
    //var simba = new lion();
    var instances = {};           // [TJC]
    instances.simba = new lion(); // [TJC]

    // Share diet publicly
    // [TJC] You don't need a function for this at all, just
    // expose "instances" directly. But if you want it:
    this.objInfo = function(name) {
            // [TJC] To look up something by name using a string,
            // use brackets:
        //return name; // simba works, name doesn't
            return instances[name]; // [TJC]
    };

};

alert(bab.objInfo('simba').diet);