IS JAVASCRIPT OBJECT-ORIENTED? Contains objects Data Methods Doesn’t have classes Does have constructors Does have prototype functions Doesn’t provide information hiding??? No private members “per se” Can closures be used???

DOUGLAS CROCKFORD’S METHOD // Person class – example of access to private data members via functions function Person(firstName, lastName) { // Define a `getName()` function for combining the private name variables. this.getName = function() { return firstName + " " + lastName; }; // Define a `setLastName()` function to update the private last name variable. this.setLastName = function(newLastName) { lastName = newLastName; return this; }; } // Sets age for object, but publicly Person.prototype.setAge = function(age) { this.age = age; }; // Getter for the public `age` property Person.prototype.getAge = function() { return this.age; };

DOWNFALL OF CROCKFORD’S METHOD All instances of the Person pseudo-class have unique private member accessor methods. var a = new Person("John", "Resig"), b = new Person("Douglas", "Crockford"); alert(a.getName == b.getName); // false alert(a.getAge == b.getAge); // true Prototype functions don’t have direct access to the private members. Person.prototype.getFirstName = function() { return this.getName().replace(/.*? /g, ""); }; No direct access to the private members. If first name has a space in it, this will not work correctly.

PRIVILEGED PROTOTYPE FUNCTIONS Prototype functions are good — no unnecessary duplication Prototype functions have access to any variables in their ancestral function scopes Let’s use a closure to solve our dilemma

PRIVILEGED PROTOTYPE FUNCTIONS (function(key) { // Define Person in global scope Person = function(firstName, lastName) { // Store private members in one object. var privateVars = { firstName : firstName, lastName : lastName }; // Define a getter function that will only return private members // for privileged functions. this._ = function(aKey) { return aKey === key && privateVars; }; /* PROTOTYPE FUNCTIONS DEFINED ON NEXT SLIDE */ })({});

PRIVILEGED PROTOTYPE FUNCTIONS (function(key) { /*...CODE IN CLOSURE FROM PREVIOUS SLIDE... */ // Define a getter for the full name. Person.prototype.getName = function() { var _ = this._(key); return _.firstName + " " + _.lastName; }; // Define a setter for the last name. Person.prototype.setLastName = function(newLastName) { this._(key).lastName = newLastName; return this; }; // Define a getter for the first name. Person.prototype.getFirstName = function() { return this._(key).firstName; }; })({});

PROS & CONS Pros Create prototype functions that now have access to private variables. Eliminate duplication of getters and setters for each instance. Using a closure to prevent access from outside code. Cons A function call to access private members. Still have one function that is being duplicated for each instance. Overwriting the `_` (underscore) function will render the object useless. If the closure code is changed, the private members can become public.

FINAL NOTES The pros outweigh the cons. The `_` (underscore) function is really lightweight. Developers rarely overwrite an object’s `_` (underscore) property. Being able to change the code will always be a con of client-side JS code. Currently in use jPaq Color object implementation of a JS Hashtable classHashtable JavaScript is not necessarily object-oriented, but due to its unique capabilities, it doesn’t need to be.