Free Online Courses for Software Developers - MrBool
× Please, log in to give us a feedback. Click here to login
×

You must be logged to download. Click here to login

×

MrBool is totally free and you can help us to help the Developers Community around the world

Yes, I'd like to help the MrBool and the Developers Community before download

No, I'd like to download without make the donation

×

MrBool is totally free and you can help us to help the Developers Community around the world

Yes, I'd like to help the MrBool and the Developers Community before download

No, I'd like to download without make the donation

JavaScript Inheritance with Prototypes

This article introduces you to the JavaScript prototype inheritance. Here we would be covering all the main topics with relevant and simple examples about it.


This article introduces you to the JavaScript prototype inheritance. Here I would be covering the following topics with relevant and simple examples
  • Introduction to prototype inheritance
  • Features
  • Advantages of Prototypal inheritance
  • JavaScript Object
  • Attributes of object data properties
    • Configurable Attribute
    • Writable Attribute
    • Enumerable Attribute
  • JavaScript Prototype
  • Prototype properties
    • Object.prototype.constructor
    • Object.prototype.__proto__
    • Object.prototype.__noSuchMethod__
  • Prototype Methods
    • Object.prototype.__defineGetter__()
    • Object.prototype.watch()
    • Object.prototype.hasOwnProperty()
    • Object.prototype.isPrototypeOf()
    • object.prototype.toString()
    • Object.prototype.toLocaleString()
    • Object.prototype.valueOf()
  • Prototype Inheritance
  • Delegation or differential inheritance
  • Cloning or Concatenative inheritance
  • Difference between Delegation and Concatenative inheritance
  • Conclusion

Introduction

In this article we are going to discuss prototype inheritance using JavaScript object oriented code. JavaScript is an object oriented programming language. It is commonly used to create interactive effects within web browser. JavaScript is an OOP scripting language and its code runs on a browser only.

JavaScript language has

  • types and operators,
  • standard built in objects, and
  • methods.

JavaScript syntax is taken from C and Java language. JavaScript language does not have classes; instead of classes it is accomplished by object prototype.

Inheritance is the process of creating a new class using an existing class. Most of the programming language contains classes and objects. One class inherits from other class. In JavaScript language inheritance is prototype based. Because of prototype inheritance JavaScript does not have classes; instead of classes one object inherits from another object.

Features

  • Prototype inheritance provides various functions for developing JavaScript applications.
  • Using this, DOM can easily be manipulated.
  • Prototype provides its own object inheritance system to provide a hierarchy of Ajax helper objects.
  • It requires only objects and extending objects for the operation.

Advantages of Prototypal inheritance in JavaScript

  • Prototype inheritance can be modified. This can be either mutable or immutable.
  • In this prototype, objects can inherit from multiple prototypes.
  • This is very useful for an application where there is a creation of an object.
  • This provides an easy way of inheritance and also there is a performance boost as well.
  • Debugging and testing can be easily done.

JavaScript Object

For understanding the prototype in JavaScript, first you need to understand the objects in JavaScript. An object is a primitive data type that is stored as a series of name-value pairs. Each item in the list is called a property. JavaScript uses objects rather than classes.

Attributes of object data properties

Object property has not only the name or value pair, but also the attributes as defined below:

  • Configurable Attribute: Property can either be deleted or edited.
  • Writable Attribute: This attribute specifies you can replace the property.
  • Enumerable Attribute: It specifies that whether the property can be returned in for loop or in loop.

To create the object in JavaScript, you can use the syntax

  var object=Object.create{};
   

This is an empty object that is of no use, so you need to add some properties. Property has name and value. Property can be enumerable, configurable and writable.

Example

Look at the following example how to add the property to an object.

Listing 1: object.html

<!DOCTYPE html>
<html>
<body>
  <p>Creating a JavaScriptObject.</p>
   <p id="demo"></p>
    <script>
var person = {
    firstName : "Mahantesh",
    lastName  : "Nagthan",
    age       : 24,
    };
document.getElementById("demo").innerHTML =
person.firstName  + person.lastName + " is " + person.age + " years old.";
     </script>
</body>
</html> 

Details of the code

  • The above code describes how to add the properties to an object.
  • document.getElementById ("demo").innerHTML”, this line of code is used to access an HTML element from the JavaScript.
  • id”, attribute is used to identify the HTML element.

Output

  • Save the file as object.html in your system.
  • Open the file in the browser, you will an output as below:

Figure 1: ObjectExample

JavaScript Prototype

A prototype is an object from which other objects inherit properties. It is a property of functions and of objects that are created by constructor functions. Prototype internally links objects.

All JavaScript objects inherit the properties and methods of their object.Prototype, although they may be overridden except object with a null value. The prototype of a function is an object. It is mainly used when a function is used as a constructor.

Example

Let’s create one simple example which displays how to create a prototype.

Listing 2: prototype.html

  <!DOCTYPE html>
  <html>
  <head>
  <title>Prototype Example</title>
  </head>
     <body>
        <script>
              var myObject = function(name){
                  this.name = name;
                  return this;
              };
              document.write(typeof myObject.prototype); 
              myObject.prototype.getName = function(){
                  return this.name;
              };
       </script>
    </body>
  </html>
  

Details of the code

  • In the above example we have created a function, by calling myObject().
  • Function returns the window object; this is because it is defined in the global scope .this. Hence this returns the global scope object.

Output

  • Save the file as prototype.html in your system.
  • Open the file in the browser, you will an output as below:

Figure 2: PrototypeExample

Prototype properties

JavaScript prototype has following properties.

  1. Object.prototype.constructor
  2. Object.prototype.__proto__
  3. Object.prototype.__noSuchMethod__
  1. Object.prototype.constructor:This property specifies the function which made the object prototype or this specifies the function that creates an object’s prototype. All objects inherit a constructor property from their prototype.

    Syntax

      Object.prototype.constructor ==obj ();
      

    Example:

    Following example displays the constructor property of the object.

    Listing 3: constuctor.html

      <!DOCTYPE html>
      <html>
      <head>
      <title>Prototype Example</title>
      </head>
          <body>
                <script language="javascript" type="text/javascript">
      function bike(name) {
          this.name = name;
          this.run = function() {
              document.write( this.name + " is the best bike!" )
               }
         }
               bike1 = new bike("yamaha")
               bike1.run()
                   </script>
            </body>
      </html>
      

    Details of the code

    • In the example, the function “bike ()” is an object constructor, and its properties and methods are declared inside it by prefixing them with the keyword “this.”
    • Object defined using an object constructor is then instantiated using the new keyword.

    Output

    • Save the file as constuctor.html in your system.
    • Open the file in the browser, you will an output as below:

    Figure 3: ConstructorExample

  2. Object.prototype.__proto__: This property specifies the object which was used as prototype when the object was represented. The _proto_ property always begins and ends with underscore.

    Syntax

    Object.prototype.__proto__===function.prototype
    

    Example

    Let’s see the following example to display Object.prototype._proto_ property of prototype.

    Listing 4: proto.html

    <!DOCTYPE html>
    <html>
    <head>
    <title>Prototype Example</title>
    </head>
    <body>
    <script>
                function Rectangle() {
                           }
                           var rec = new Rectangle();
                           if (console && console.log) {
                                       document.write(rec.__proto__ === Rectangle.prototype);
                                       document.write("<br>");
                                       rec.__proto__ = Object.prototype;
                                       document.write(rec.__proto__ === Rectangle.prototype);
                }
          </script>
      </body>
    </html>
                                                          
    

    Details of the code

    • The above example demonstrates how to set the prototype for an object using _proto_ property.
    • var rec = new Rectangle();” this line of code demonstrate the object or function inherits all the methods and properties of the prototype along with the function Rectangle().
    • rec.__proto__ === Rectangle.prototype” this line refers to the prototype property of the class used to create the object.
    • document.write(rec.__proto__ === Rectangle.prototype);” this code is used to display the output.

    Output

    • Save the file as proto.html in your system.
    • Open the file in the browser, you will an output as below:

    Figure 4: ProtoExample

  3. Object.prototype.__noSuchMethod__: This property allows a function to be defined that will be executed an undefined object member as a method.

    Syntax

    Obj.prototype_noSuchMethod_= fun();
    

    • fun”, is a function that takes the form it has parameters like “id” and “args”.
    • id”, contains the name of the non-existence method that was called
    • args”, is an array of the arguments passed to the method.

    Example

    Let’s create an example which displays the Object.prototype.__noSuchMethod__ property.

    Listing 5: noSuchMethod.html

    <!DOCTYPE html>
    <html>
    <head>
    <title>Prototype Example</title>
    </head>
     <body>
        <script>
                var obj = {
                  __noSuchMethod__: function(id, args)
                  {
                    document.write(id, '(' + args.join(', ') + ')');
                    document.write("<br>");
                   }
                };
                obj.abc(a,b,c);
                oob.xyz(x,y,z);
        </script>
    </body>
    </html>
    

    Details of the code

    Above code defines the variable “obj” with a “_noSuchMethod_” method defined.

    Output

    • Save the file as noSuchMethodExample.html in your system.
    • Open the file in the browser, you will an output as below:

    Figure 5: noSuchMethodExample

Prototype Methods

JavaScript prototype has following methods.

  1. Object.prototype.__defineGetter__()
  2. Object.prototype.__defineSetter__()
  3. Object.prototype.watch()
  4. Object.prototype.hasOwnProperty ()
  5. Object.prototype.isPrototypeOf()
  6. Object.prototype.toString ()
  7. Object.prototype.toLocaleString()
  8. Object.prototype.valueOf()

Now let’s study each of these in detail:

  1. Object.prototype.__defineGetter__(): This method connects a function with property that, when retrieve, executes that function and returns its value.

    Syntax

      Obj._defineGetter_(Prop, func)
      

    • Parameter “Prop” contains the name of the property that bind with the given property.
    • Parameter “func” contains the function of the given property.

    Example

    Following example shows the working of Object.prototype.__defineGetter__() method.

    Listing 6: prototype_defineGetter.html

      <!DOCTYPE html>
      <html>
      <head>
      <title>Prototype Example</title>
      </head>
      <body>
            <script>
                       var myObject = {};
                       myObject.__defineGetter__('number', function() {
                       return Math.floor(Math.random()*10); })
                      document.write(myObject.number);    
             </script>
      </body>
      </html>
      

    Details of the code

    • In the above example, we have seen how Object.prototype.__defineGetter__() method works.
    • “myObject.__defineGetter__ ('number', function () {“this code define the getter function body.
    • “Return Math.floor (Math.random ()*10);})” this code used to return a random number between 1 to 10.

    Output

    • Save the file as prototype_defineGetter.html in your system.
    • Open the file in the browser, you will an output as below:

    Figure 6: prototype_defineGetterExample

  2. Object.prototype.__defineSetter__(): JavaScript setter is a function that gets invoked when an objects property is accessed. This method binds an object’s property to a function to be called when the object sets the property.

    Syntax

    Obj._defineSetter_(Prop, func)
    

    • Parameter “Prop” contains the name of the property that binds with the given property.
    • A function(func) to be called when there is an attempt to set the specified property.

    Let’s see the following example of Object.prototype.__defineSetter__() method.

    Listing 7: prototype_defineSetter.html

    <!DOCTYPE html>
    <html>
    <head>
    <title>Prototype Example</title>
    </head>
    <body>
    <script>
                    var myObject = {};
                    myObject.__defineSetter__('value', function(val) { this.Value = val; });
                    myObject.value = 777;
                    document.write(myObject.Value);
    </script>
    </body>
    </html>
    

    Details of code

    • var myObject = {};” this code creates an empty object for the prototype.
    • myObject.__defineSetter__('value', function(val) { this.Value = val; }); this code shows the function accepts a parameter whose value is assigned.

    Output

    • Save the file as prototype_defineSetter.html in your system.
    • Open the file in the browser, you will an output as below:

    Figure 7: prototype_defineSetterExample

  3. Object.prototype.watch(): This method is used to add a watch point to a property of the object.

    Syntax

    Obj.watch(prop, handler)
    

    • Parameter “Prop” contains the name of the property that binds with the given property.
    • handler” parameter is a function to call when the specified property value changes.

    Example

    Let’s see the following example of Object.prototype.watch() method.

    Listing 8: objetc_prototypeWatchExample.html

    <!DOCTYPE html>
    <html>
    <head>
    <title>Prototype Example</title>
    </head>
    <body>
      <script>
                var obj = { p: 1 };
     
                obj.watch('p', function (id, oldval, newval) {
                  document.write('obj.' + id + ' changed from ' + objldval + ' to ' + newval);
                  return newval;
                });
                obj.p = 2;
                obj.p = 3;
        </script>
      </body>
    </html>
    

    Details of code

    • obj.watch('p', function (id, oldval, newval) { Using this code you can call the watch() method and assign a function that is to be called when certain property changes.
    • document.write('obj.' + id + ' changed from ' + objldval + ' to ' + newval); prints the output of the object with the new value

    Output

    • Save the file as objetc_prototypeWatchExample.html in your system.
    • Open the file in the browser, you will an output as below:

    Figure 8: objetc_prototypeWatchExample
  4. Object.prototype.hasOwnProperty(): This method checks whether an object has a property with the given name. This method returns true if specified property belongs to specified object, not inherited from its prototype object chain.

    Syntax

    Object.prototype.hasOwnProperty(prop)
    

    Name of the property is shown by using parameter “prop”.

    Example

    Let’s create simple example of Object.prototype.hasOwnProperty () method.

    Listing 9: hasownproperty.html

    <!DOCTYPE html>
    <html>
    <head>
    <title>Prototype Example</title>
       </head>
        <body>
            <script>
                           Object.prototype.each = function(m) {
                             for(var prop in this) {
                               if (Object.prototype.hasOwnProperty(prop)) continue
                               var value = this[prop]
                               m.call(value, prop, value)
                             }
                           }
                           var obj = { Name : ': XYZ', Age  : ': 25'}
                           obj.each(function(prop, val) {
                           document.write("<br>");
                             document.write(prop, val)
                           })
        </script>
    </body>
         </html>
    

    Details of the code

    • “Object.prototype.each = function(m) {“ this code defines the function of the object.
    • “if (Object.prototype.hasOwnProperty(prop)) continue” code demonstrate the hasOwnProperty() method returns a true value if the object has the specified property.
    • “var value = this[prop]” this indicates the property name is assigned to variable.
    • “m.call(value, prop, value)” displays the value proposition of the object.

    Output

    • Save the file as hasownproperty.html in your system.
    • Open the file in the browser, you will an output as below:

    Figure 9: hasownpropertyExample

  5. Object.prototype.isPrototypeOf(): This method returns true if object is the prototype of another object or else it returns false.

    Syntax

    Prototype.isPrototypeOf (obj)
    

    Obj is the object whose prototype chain is to be checked.

    Example

    Let’s see the following example of prototype_isPrototypeOf () method.

    Listing 10: prototype_isPrototypeOf ().html

    <!DOCTYPE html>
    <html>
     <head>
      <title>Prototype Example</title>
       </head>
        <body>
                <script>
     
                            function Rectangle() {
                               }
                              var rec = new Rectangle();
                            document.write(Rectangle.prototype.isPrototypeOf(rec));
                </script>
        </body>
     </html>
    

    Details of code

    • “function Rectangle() {“ this is a function name.
    • “var rec = new Rectangle();” this line of code demonstrate the object or function inherits all the methods and properties of the prototype along with the function Rectangle().
    • “document.write(Rectangle.prototype.isPrototypeOf(rec));” this code returns the true result if the object has prototype in its prototype chain.

    Output

    • Save the file as prototype_isPrototypeOf().html in your system.
    • Open the file in the browser, you will an output as below:

    Figure 10: prototype_isPrototypeOfExample

  6. Object.prototype.toString(): This method returns a string representation of this object. Every object has a toString() method that is automatically called when the object is to be represented as text value.

    Syntax

    obj.toString()
    

    toString() method converts an object to a string whenever the object is used in a string context.

    Example

    Let’s create an example of Object.prototype.toString() method.

    Listing 11: object_toString().html

    <!DOCTYPE html>
    <html>
     <head>
      <title>Prototype Example</title>
       </head>
        <body>
          <script>
                      function Obj()
                        {
                        }
                         Obj.prototype.toString = function()
                        {
                          return "[object Obj]";
                      }
     
                      var o = new Obj();
          document.write(o);
          </script>
      </body>
    </html>
    

    Details of the code

    • “function obj() {“ this is a function name.
    • “Obj.prototype.toString = function()” this code returns a string representation.
    • “return "[object Obj]"; returns the hash code value returning zero when the object is null.
    • “var o = new Obj();” constructs the new object.

    Output

    • Save the file as object_toString().html in your system.
    • Open the file in the browser, you will an output as below:

    Figure 11: object_toStringExample

  7. Object.prototype.toLocaleString(): This method returns the calling of toString(). This method is provided to give all objects a generic toLocaleString interface. This method returns an object, localized string representation.

    Syntax

    Obj.toLocaleString();
    

    Method returns a string representation of the object, localized as appropriate for the current locale.

    Example

    Let’s see the following example of Object.prototype.toLacaleString() method.

    Listing 12: Object_prototypetoLocaleString.html

     <!DOCTYPE html>
    <html>
    <head>
    <title>Prototype Example</title>
      </head>
                <body>
                            <script>
     
                                       var number = 1234567;
                                       var options1 = { style: "percent" };
                                       var options2 = { style: "currency", currency: "INR" };
                                       document.write(number.toLocaleString("en-US"));
                                       document.write("<br>");
                                       document.write(number.toLocaleString("ar-SA", options1));
                            </script>
                </body>
    </html>
    

    Details of code

    • var options2 = { style: "currency", currency: "INR" }; using this we can assign the value to the object
    • document.write(number.toLocaleString("en-US")); used to print the value of the string locale in US format.
    • document.write(number.toLocaleString("ar-SA", options1)); this used to print the value of the locale string in the SA(South Africa) format.

    Output

    • Save the file as object_toLocaleString.html in your system.
    • Open the file in the browser, you will an output as below:

    Figure 12: Object_prototypetoLocaleStringExample

  8. Object.prototype.valueOf(): This method specifies the primitive value of the given object or in other words valueOf() method returns the objects this value.

    Syntax

    obj.valueOf();
    

    This returns the primitive value of the object if there is only one value.

    Example

    Let’s see the following example which display the obj.ValueOf() method.

    Listing 13: Object_prototypeValueOf.html

    <!DOCTYPE html>
    <html>
    <head>
    <title>Prototype Example</title>
    </head>
    <body>
      <script>
                            var obj = 1234;
                            var s = obj.valueOf();
                            if (obj === s)
                            document.write("same");
                            else
                       document.write("different");
      </script>
    </body>
    </html>
    

    Detail of code

    • We can assign value for the using var obj= 1234;
    • var s = obj.valueOf(); This returns the primitive value a string.

    Output

    • Save the file as object_valueOfExample.html in your system.
    • Open the file in the browser, you will an output as below:

    Figure 13: Object_valueOfExample

Prototype Inheritance

This is a very simple concept. Most of the programming languages contain classes and objects. One class inherits the property of another class. But in JavaScript language it contains objects instead of classes as like other programming language where one object inherits the property of another object. We have already discussed about how to create an object.

In simple terms inheritance means one object gaining the properties of another object. Consider an object A inherits the properties of an object B. This means that object A is of type object B and B is said to be prototype of A.

Let’s consider we have an object “objA” and a “ObjB” that inherits “objC”.

  Var objA = {firstName: ‘Mahantesh’, lastName: ‘Nagthan’}
  Var ObjB = { firstName: ‘Ganesh’}
  objB._proto_=  objA
  

In the above code we use object objA and objB this means that one object inherits the property of other object. From the above code we say objA is prototype of objB and objB inherits the properties of objA.

From the above code, we know that in JavaScript language instead of classes it uses objects for inheritance. JavaScript language uses prototype inheritance. This prototype works as follows:

  • It uses objects instead of classes as like other programming languages and object has number of properties which includes attributes.
  • An object contains prototype parent property called _proto_. In JavaScript language an object inherits all the properties of its parent.
  • Using constructor we can create an object and each constructor has an associated prototype object.
  • You can also set its parent to the prototype object which is associated with its constructor when an object is created.

Listing 14: prototypeInheritance.html

  <!DOCTYPE html>
  <html>
  <head>
  <title>Prototype Example</title>
  </head>
              <body>
                 <script>
                                 var xyz = {
                                   kind: 'xyz'
                                 }
   
                                 var person = {
                                     kind: 'person'
                                   }
                                   var abc = {};
   
                                    abc.__proto__ = xyz
   
                                  document.write (abc.kind);
   
                                   document.write ("<br>");
   
                                     abc.__proto__ = person
   
                                 document.write (abc.kind);
                     </script>
   
              </body>
  </html>
  

Details of the code

  • In the example above, object abc inherits from the another object xyz. This means that in JavaScript abc._proto_=xyz..
    var xyz = { kind: 'xyz'}
    This code is used to create an object xyz.
  • var person = { kind: 'person'}
    Above code is used to create another object person.
  • “var abc = {};” this line of code is used to called an object abc.
  • “abc.__proto__ = xyz” this assign an object xyz as the prototype of abc.
  • “abc.__proto__ = person” assign an object person as the prototype of abc.
  • “document.write (abc.kind);” this show object abc is linked to person and prints the output. The examples using the _proto_ are only runs in chrome and Firefox because it does not support in IE.

Output

  • Save the file as prototypeInheritance.html in your system.
  • Open the file in the browser, you will an output as below:

Figure 14: prototypeInheritanceExample

As we know _proto_ is not supported in IE (Internet Explorer) and it’s not the way of assigning the prototype to object. The Object.create is a simplest way to create an object.

Example

Let’s look at the following example how to create an example

Listing 15: object_create.html

<!DOCTYPE html>
<html>
<head>
<title>Prototype Example</title>
</head>
<body>
            <script>
                        var person = {
                          kind: 'person'
                        }
                        var xyz = Object.create(person);               
                        document.write (xyz.kind);
    </script>
 </body>
</html>

Details of the code

var person = {
kind: 'person'
           }

The code is used to create an object person.

var xyz = Object.create(person); creates a new object for the prototype person.

Output

Save the file as object_create.html in your system.

Open the file in the browser, you will an output as below:

Figure 15: object_createExample

The Object.create function can also be used to clone an existing object as follows.

         var person = {
                          kind: function(){
                                    return this;
                            }
                        };
                        var xyz = Object.create(person);               

Details of the code

  • The xyz inherits the properties of kind function from person.
  • In the code, person is an object literal. Object literal is the way of creating clone of object.prototype and extending with the new properties.

There are two methods of prototypal inheritance in JavaScript language as defined below:

  1. Delegation or Differential inheritance
  2. Cloning or Concatenative inheritance

Delegation or differential inheritance

Delegation prototype provide base for another object. When an object inherits through this method the new object is a reference to the prototype. Before accessing the property of new object it checks the object’s own property. If the property of the object does not find it, it checks for the prototype and is continued until it gets back to Object.prototype.

Example

function get(object, property) {
               if (!Object.hasOwnProperty.call(object, property)) {
                    var prototype = Object.getPrototypeOf(object);
                                if (prototype) return get(prototype, property);
               }
               else return object[property];
      }

Details of code

  1. Above code demonstrates how property access is delegated to the prototype of an object.
  2. function get(object, property) - this defines the property of an object.
  3. if (!Object.hasOwnProperty.call(object, property)) - this line describes whether the object has specified property; if it is true then it returns the boolean value for the object.
  4. var prototype = Object.getPrototypeOf(object); this returns the prototype that is the value of the internal prototype and property of the object.
  5. if (prototype) return get(prototype, property); this returns false if the object does not have the specified property.

Cloning or Concatenative inheritance

In cloning method, properties of one object are copied to another object without continued reference between the two objects. This stores the default state for objects. When we want to modify the original object then it is propagated to its copies to achieve true prototypal inheritance.

Let’s look at the following code which provides a simple method for cloning object.

          Object.prototype.clone = function(){                       
                          var p = Object.create(this);                       
                          return p;
           };

Detail of code

  • Object.prototype.clone = function() - this code sends an object to a function and clones the object with the function.
  • var p = Object.create(this); this is used to create a new object with this as its prototype.

Difference between Delegation and Concatenative inheritance

Delegation

Concatenative

In delegation prototype inheritance, one object is base for another object.

In concatenative inheritance, properties of one object is copied to another object

In delegation, the new object get reference to the prototype

In concatenative, properties of one object are copied to another without continuing reference between two objects.

As it traverses up the prototype chain the property access is slower than the concatenative.

Because of inherited properties are copied from one object to another the property access is faster compared to delegation.

Conclusion

Prototype inheritance is very simple to understand. The source code of each of the examples is attached with this article. You can execute and play around to understand this prototype inheritance better.



I''m a full stack developer with around 10+ yrs of experience. I enjoy writing technical articles on upcoming technical trends.

What did you think of this post?
Services
[Close]
To have full access to this post (or download the associated files) you must have MrBool Credits.

  See the prices for this post in Mr.Bool Credits System below:

Individually – in this case the price for this post is US$ 0,00 (Buy it now)
in this case you will buy only this video by paying the full price with no discount.

Package of 10 credits - in this case the price for this post is US$ 0,00
This subscription is ideal if you want to download few videos. In this plan you will receive a discount of 50% in each video. Subscribe for this package!

Package of 50 credits – in this case the price for this post is US$ 0,00
This subscription is ideal if you want to download several videos. In this plan you will receive a discount of 83% in each video. Subscribe for this package!


> More info about MrBool Credits
[Close]
You must be logged to download.

Click here to login