Question

What’s the proper way to create an object (with its “namespaces” and such)?

1

//Company object
var Microsoft = {};

//Create an employee
Microsoft.employee = function(name) {
   this.name = name;
}

or

2

//Company object
Apple = {

   employee: function(name) {
      this.name = name;
   }

}

OR another way? Shoot.

Read something about prototypes and such. What’s the proper way to do it; benefits and downsides?

Answer 1

First off, you forgot the var for Apple. But otherwise these are basically the same thing.

Secondly, in my examples I’m not going to use the attribute name since, when dealing with functions, the name is an empty string by default. At least in Node.js and Chrome. So I’ll use empName instead.

In the Microsoft example you are making an empty object and then adding an attribute to it after the fact.

In the Apple example you are making an object with the attribute right away.

It’s really just what makes the most sense to you, and which you prefer. Since they are, more or less, equivalent.

Now, this has nothing to do with prototypes. Here’s an example of what you did:

var Apple = { 
    employee: function(empName) {
        this.empName = empName;
    }
};

Apple.employee('Hank');
Apple.empName; // 'Hank'

And here’s how you would do this with an instance (using the new operator, and the prototype)

var Apple = function() {}; // base 'parent'

Apple.prototype.employee = function(empName) {
    this.empName = empName
};

var a = new Apple();
a.employee('Hank');
a.empName; // 'Hank'
Apple.empName; // undefined

So prototype is used to add attributes to new instances of an object (using ‘object’ loosely). Note that to access employee in Apple, on this second example, you would have to do something like

Apple.prototype.employee('Hank'); // doesn't really do much
Apple.empName; // undefined

// but you can call the employee prototype with a bound variable
// you'd do this if you don't want to make an instance of Apple
// but still want to use one of it's prototypes
var obj = {};
Apple.prototype.employee.call(obj, 'Hank');
obj.empName; // 'Hank'

// a practical use of accessing a prototype method is
// when wanting to convert a function's arguments
// to an array. function arguments are like an array,
// but until turned into one they are not completely the same
var func = function() {
    var args = Array.prototype.slice.call(arguments);
    var sum = 0;
    for(var i = 0, l = args.length; i < l; i++) {
        sum += args[i];
    }
    return sum;
};

func(1); // 1
func(1, 2, 3, 4, 5); // 15

Hope that helps.

EDIT: Also, don’t prototype objects (e.g. {} or Object). It’s not safe to do this. Since, essentially, every variable in JavaScript is an object, then any prototypes you add to them will be available on all variables. So if you did Object.prototype.xyz = 12 then had var obj = { a: 1, b: 2, c: 3} and then tried for(var key in obj) { console.log(key); } you would result in the following logs: a, b, c and xyz … which you wouldn’t want.