CSC/ECE 517 Fall 2014/ch1b 30 cs

Prototype-based Programming

Most people are familiar with class-based languages, in which to create an object, one defines a class containing functions and variables, and then objects are instantiated from the class. Prototype-based programming is an alternative approach to creating objects, where instead of a class, they get their properties from other objects<ref name="moz" />.

As an example, consider creating an object in a class-based approach. We would define a Class that contains the variable var1 and function func1(). Then within the class we would define a constructor, which will create Object which can access func1() and may have a value assigned to var1. Our object is limited to these two properties which we defined in Class, so if we wanted to have Object.var2 as well, we would need to define a new subclass and create objects from the subclass. On the other hand, in a prototype-based approach we would just create an object from another prototype object containing var1 and func1(). But in this case, if we want to have Object.var2 or Object.func2(), we can simply declare them after object creation because we are not bound by a class definition.

Benefits and Drawbacks

Classes and prototypes are commonly seen as not strictly better than the other, but rather just appropriate for different situations<ref name="shah" /><ref name="se1" />. Prototypes offer more flexibility in object creation and modification, without needing separate classes for each variation. Thus, creating clones or descendants of objects can be accomplished with less code. However, your code might not be as structured without centralized classes, and you may be giving up benefits of static typing.

Examples of class-based languages are Java and C++. The most popular prototype-based language is JavaScript, but some other examples are Io<ref name="io" />, REBOL<ref name="rebol" /> and Self<ref name="self" />.

Prototypes in JavaScript

Although JavaScript is a prototype-based language, its syntax can give the appearance of being class-based, e.g.

function Student(Name, Id) {
    this.id = Id;
    this.name = name;
    this.addToCourse = function(course) {
        console.log("Added " + this.name + " to " + course + "!");
    };
}

var james = new Student("James Jones", 200031416);

However, this does not create an object of a Student class<ref name="pivotal" />. Also note that there is nothing special about the Student function that makes it a "constructor". Instead, we use the new keyword before the function call to signify that a new object is being created. The james.constructor property of our new object is set to the Student function, and then the function runs while treating this as the new object.

Perhaps more true to a prototype-based style would be to start with our first object:

var james = {
    id: 200031416,
    name: "James Jones",
    addToCourse : function(course) {
       console.log("Added " + this.name + " to " + course + "!");
    }
};

We can then create a copy of this object:

var susan = Object.create(james);
susan.name = "Susan Smith";

susan.addToCourse("CSC 505");              // Added Susan Smith to CSC505!
james.addToCourse("CSC 517");              // Added James Jones to CSC517!

And freely change it without affecting the original:

susan.semesterCreditLimit = 13;
console.log(susan.semesterCreditLimit);    // 13
console.log(james.semesterCreditLimit);    // undefined

susan.addToCourse = "This was supposed to be a function";
console.log(susan.addToCourse);            // This was supposed to be a function

Prototypes in Ruby

Although Ruby is a class-based language, its dynamic nature allows some similarity between prototype-based languages<ref name="rubyproto" />. We can take advantage of singleton classes<ref name="singleton" /> to recreate our previous JavaScript program:

class Student
  attr_accessor :name, :id
  
  def initialize(name, id)
    @name = name
    @id = id
  end
  
  def add_to_course(course)
    puts "Added " + name + " to " + course + "!"
  end
end

james = Student.new "James Jones", 200031416

susan = james.clone

class << susan 
  attr_accessor :semester_credit_limit, :add_to_course
end

susan.semester_credit_limit = 13
james.semester_credit_limit = 13              # NoMethodError
susan.add_to_course = "This was supposed to be a function"
puts susan.semester_credit_limit              # 13
puts susan.add_to_course                      # This was supposed to be a function

References

<references> <ref name="moz">Mozilla Developer Network, "Details of the Object Model"</ref> <ref name="shah">Aadit Shah, "Why Prototypal Inheritance Matters"</ref> <ref name="se1">Programmers Stack Exchange, "What are the advantages of prototype-based OOP over class-based OOP?"</ref> <ref name="io">Io</ref> <ref name="rebol">REBOL - Objects</ref> <ref name="self">Self</ref> <ref name="pivotal">Pivotal Labs, "JavaScript constructors, prototypes, and the `new` keyword"</ref> <ref name="rubyproto">Avdi Grimm, "An Adventure in Prototypes"</ref> <ref name="singleton">Peter Jones, "Understanding Ruby Singleton Classes"</ref> </references>