× 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 Object Theory

In this article, you will be trained with reference to OOP (Object-Oriented Programming) and how it relates to JavaScript.

As a developer, you almost certainly have some knowledge operational with substance, and you may even be recognizable with concepts such as legacy. However, if not you're previously a knowledgeable JavaScript programmer, you almost certainly aren't memorable with the way JavaScript substance and functions really work. This acquaintance is essential in order to comprehend how the Microsoft AJAX Library works, and this episode will educate you the essential practicalities. More purposely, you will learn:

  1. What encapsulation, inheritance, and polymorphism indicate?
  2. How JavaScript functions work?
  3. How to use unidentified functions and closures?
  4. How to read a class diagram, and apply it using JavaScript code?
  5. How to work with JavaScript prototypes?
  6. How the implementation background and scope affect the output of JavaScript functions?
  7. How to execute legacy using closures and prototypes?

Mainly developers are recognizable with the basic OOP principles since this information is significant when just beginning for the .NET development. Correspondingly, to expand client-side code using the Microsoft AJAX Library, you need to be recognizable with JavaScript's OOP kind. Although not chiefly hard, sympathetic these kind can be a bit demanding at first, because JavaScript's OOP model is dissimilar than so as to of code base such since Java, C++.

JavaScript is an object-based speech. Just as in C#, you can produce substance, describe their methods, go by them as parameters, and so on. You could see this plainly when working by means of the DOM, anywhere you manipulated the HTML manuscript throughout the methods and properties of the implicit document object. However, JavaScript isn't usually measured a fully object-oriented language because it lacks sustain for some character that you ‘defined in "real" OOP languages, or simply equipment them in a different way. Your most significant goal for this chapter is to appreciate how to work with JavaScript substance. As an ASP.NET developer, we suppose that you previously know how OOP works with .NET languages, even though superior information isn't essential.

To make sure we start off from the similar square, in the subsequent pair of pages we'll review the necessary OOP concepts as they apply in C# and other languages—objects, lessons, encapsulation, inheritance, and polymorphism. Then we'll carry on by "porting" this information into the JavaScript realm. Objects in JavaScript, immediately as a lot of other indoctrination languages, can be compared to substance in genuine life. The notion of substance in JavaScript can be unspoken with real life, touchable objects.

In JavaScript, a thing is a separate body, with properties and type. Appraise it by means of a chalice, for instance. A chalice is a thing, with possessions. A chalice has a colour, a design, heaviness, a fabric it is made of, etc. The similar way, JavaScript objects can have properties, which describe their description.

Objects and properties

A JavaScript entity has properties connected by way of it. Possessions of an entity know how to be explained as a changeable so as to be emotionally involved to the object. Object properties are fundamentally the similar as usual JavaScript variables, excluding for the accessory to substance. The properties of an object describe the description of the object. You admission the properties of an object by means of an easy dot-memo:


Like all JavaScript variables, both the object name (which could be a normal variable) and possessions name is crate susceptible. You can identify a possessions by transmission it a significance. For instance, let's generate a thing named myfavouriteBike and furnish it possessions named make, model, and year as follows:

  var myfavouriteBike = new Object ();
  myfavouriteBike.make = "Tvs";
  myfavouriteBike.model = "Apache RTR 180";
  myfavouriteBike.year = 1990;

Properties of JavaScript objects can also be accessed or set by means of a category memo. Objects are from time to time called associative arrays, since each belonging is connected with a string charge that can be second-hand to access it. So, for instance, you could admittance the properties of the myfavouriteBike object as follows:

  myfavouriteBike["make"] = "Tvs";
  myfavouriteBike["model"] = "Apache RTR 180";
  myfavouriteBike["year"] = 1990;

An object possessions name can be any legitimate JavaScript string, or no matter which that can be rehabilitated to a string, counting the unfilled string. However, any belongings name that is not a valid JavaScript identifier (for instance, a property name that has a liberty or a hyphen, or that starts with a number) can only be accessed by means of the square bracket notation. This information is also very helpful when possessions names are to be animatedly resolute (when the property name is not resolute awaiting runtime). Examples are as follows:

  var myObj = new Object(),
      str = "myString",
      rand = Math.random(),
      obj = new Object();
  myObj.type              = "Dot syntax";
  myObj[str]              = "thread assessment";
  myObj[rand]            = "haphazard figure";
  myObj[obj]              = "thing";
  myObj[""]               = "Smooth an unfilled thread";


You be able to also right of entry properties by a string worth that is stored in a changeable:

  var propertyName = "make";
  myfavouriteBike[propertyName] = "Tvs";
  propertyName = "model";
  myfavouriteBike[propertyName] = "Apache RTR 180";

You be able to utilize the bracket notation with for...in two iterate in excess of all the enumerable properties of an object. To exemplify how this mechanism, the subsequent purpose displays the properties of the thing at what time you bypass the object and the object's name as influence to the purpose:

  function showProps(obj, objName) {
    var result = "";
    for (var i in obj) {
      if (obj.hasOwnProperty(i)) {
          result += objName + "." + i + " = " + obj[i] + "\n";
    return result;

So, the purpose call showProps(myfavouriteBike, "myfavouriteBike") would homecoming the subsequent:

  myfavouriteBike.make = Tvs
  myfavouriteBike.model = Apache RTR 180
  myfavouriteBike.year = 1990

Objects and Classes

What does "object-oriented programming" denote nevertheless? Basically, as the name suggests, OOP puts objects at the middle of the programming model. The object is most likely the most significant impression in the world of OOP—a self-sufficient individual that has state and performance, just like a real-world object. Each object is an occurrence of a class (also called type), which defines the performance that is shared by all its objects. We often use objects and classes in our programs to symbolize real-world objects, and types (lessons) of substance. For instance, we are able to have lessons like Car, Customer, manuscript, or individual, and substance such as myCar, johnsCar, or davesCar. The concept is sensitive: the class represents the blueprint, or model, and objects are meticulous instances of that model. For example, all substance of type Car will have the same performance—for example, the aptitude to change gear. Nevertheless, each personality Car object may be in a dissimilar gear at any exacting time—each object has its exacting state. In indoctrination, an object's state is described by its fields and properties, and its performance is distinct by its methods and events. You've previously worked with substance in the preceding chapter. First, you've worked with the built-in essay object. This is a default DOM object that represents the present sheet, and it allows you to change the condition of the piece of paper. However, you also erudite how to make your own objects, when you shaped the xmlHttp object. In that crate, xmlHttp is a thing of the XMLHttpRequest group. You could produce more XMLHttpRequest objects and all of them would have the same abilities (behaviour), Such as the ability to contact distant servers as you educated earlier, but each would have a diverse state. For example, every one of them may be contacting a dissimilar server.


Encapsulation is a impression that allows the use of an object with no having to know its inner functioning in detail. The communication with an object is done only via its public interface, which contains community members and methods. We be capable of speak that encapsulation allows an object to be treated as a "black box", unravelling the functioning from its boundary. Think of the objects you've worked with so distant: article, a DOM object, and xmlHttp, an XMLHttpRequest object. You positively don't know how these substances do their labour internally! All you have to be acquainted with is the kind you can use. The "features you can use" of a class form the community border of a class, which is the sum of all its civic members. The public members are those members that are noticeable and can be used by exterior lessons. For example, the innerHTML possessions of a DOM object (such as the default document object), or the open () and send () methods of XMLHttpRequest, are all public, since you were intelligent to use them. Each class can also enclose secret members, which are meant for interior procedure only and aren't perceptible from external.


Inheritance allows creating classes that are particular versions of a breathing class. For example suppose that you have the Car class, which exposes a default interface for substance such as myCar, johnsCar, or davesCar. Now, suppose that you desire to bring in in your scheme the notion of a supercar, which would have comparable functionality to the car, but a number of additional kinds as well, such as the potential to fly! If you're an OOP programmer, the palpable move would be to create a new class named SuperCar, and use this class to create the essential objects such as mySuperCar, or davesSuperCar. In such scenarios, legacy allows you to create the SuperCar class based on the Car class, so you don't require coding all the familiar description once again. In its place, you can make SuperCar as a particular description of Car, within which case SuperCar inherits all the functionality of Car. You would only require coding the supplementary variety you want for your SuperCar, such as a means named Fly. In this condition, Car is the bottom class (also referred to as superclass), and SuperCar is the unoriginal class (also referred to as subclass).

Inheritance is immense since it encourages code use again. The possible unconstructive side effect is that inheritance, by its scenery, creates a consequence that is acknowledged as tense combination flanked by the base class and the unoriginal lessons. Stretched combination refers to the statement that any changes that are completed to a base class are mechanically propagated to all the unoriginal classes. For example, if you construct a presentation enhancement in the code of the unique Car class, that development will broadcast to SuperCar as well. While this typically can be second-hand to your benefit, if the inheritance pecking order isn't shrewdly intended such combination can inflict prospect boundaries on how you can get bigger or adapt your base lessons with no violation the functionality of the imitative lessons.


Polymorphism is a supplementary superior OOP characteristic that allows by means of objects of diverse lessons when you only know a universal base division from which they both accept. Polymorphism permits by a base class orientation to admission substance of that division, or objects of unoriginal lessons. Using polymorphism, you can include, for example, a process that receives as limit an object of type Car, and when calling that process you provide as stricture an object of type SuperCar. Because SuperCar is a particular account of Car, all the public functionality of Car would also be supported by SuperCar, although the SuperCar implementations might be different from those of Car. This kind of suppleness gives a great deal authority to a knowledgeable programmer who knows how to take benefit of it.

Object-Oriented JavaScript

Objects and classes are implemented in a different way in JavaScript than in languages such as C#, VB.NET, Java, or C++. Nevertheless, when it comes to by them, you'll sense on recognizable earth. You make objects by the new worker, and you call their methods or admission their fields with the grammar you previously be acquainted with from C#. Here is a small figure of examples of creating objects in JavaScript:

  // create a generic object
  var obj = new Object();
  // create a Date object
  var oToday = new Date();
  // make an Array object with 3 elements
  var oMyList = new Array(3);
  // create an empty String object
  var oMyString = new String();

Object formation is, though, the only important resemblance flanked by JavaScript substance and those of "typical" OOP languages. The imminent JavaScript 2.0 will decrease the differences by introducing the idea of lessons, confidential members, and so on, but waiting after that we have to study how to live with no them. Objects in JavaScript have the subsequent particularities. In the subsequent pages we'll talk about every of them in feature:

  1. JavaScript cipher is not compiled, but parsed. This allows for suppleness at what time it comes to creating or changing objects. As you'll see, it's probable to put in new members or functions to an object or even some objects by changing their prototype, on the flutter.
  2. JavaScript doesn't hold up the concept of lessons as characteristic OOP languages do. In JavaScript, you produce functions that can act—in a lot of luggage—just like lessons. For example, you are able to call a reason supplying the required parameters, or you can make an occurrence of that purpose supplying those parameters. The previous container can be connected with a C# process call, and the presently can be connected with instantiating a division supplying principles to its constructor.
  3. JavaScript functions are unequalled objects. In English, this income that the function is regarded, and be capable of is manipulated, just as like other data types. For example, you can go by functions as parameters to other functions, or still homecoming functions. This idea may be hard to clutch since it's very dissimilar from the way C# developers usually believe of functions or method, but you'll observe that this type of suppleness is in fact cool.
  4. JavaScript supports closures.
  5. JavaScript supports prototypes.

Objects in JavaScript

In JavaScript, objects are data (variables), by means of properties and methods.

You make a JavaScript thread object at what time you announce a string changeable like this:

  var txt = new String ("Hello World");

Creating JavaScript Objects

Approximately "everything" in JavaScript can be objects, Strings, Dates, Arrays and Functions. You can as well generate your personal objects. This example creates an object called "person", and adds four properties to it:


  person=new Object();

Convenient are a lot of dissimilar habits to produce new JavaScript objects, and you will be able to also add fresh properties and methods to previously alive objects.

This instance uses the distance end to end possessions of the String thing to find the span of a string:

  var message="Hello World!";
  var x=message.length;

The worth of x, following implementation of the symbols on top of will be:


Accessing Object Methods

You be able to identify a process with the subsequent syntax:


This instance uses the toUpperCase() process of the String thing, to exchange a transcript to uppercase:

  var message="Hello world!";
  var x=message.toUpperCase();

The worth of x, following implementation of the symbols over will be:


JavaScript Functions

An easy piece of information that was tinted in the preceding episode, but that is frequently Overlooked, is input to sympathetic how objects in JavaScript employment: symbols that Doesn’t fit in to a meaning is executed when it's read by the JavaScript exponent, Even as a sign that belongs to a purpose is only executed at what time that purpose is called.

  // declaring new variables
  var date = new Date();
  var hour = date.getHours();
  // simple conditional content output
  if (hour >= 22 || hour <= 5)
  document.write("Goodnight, world!");


  document.write("Hello, world!");

This symbols resides in a folder named JavaScriptDom.js, which is mentioned on or after an HTML file (JavaScriptDom.html in the implement), but it might have been incorporated directly in a <script> tag of the HTML file. How it's stored is immaterial; what does Substance is that all that symbols is executed when it's read by the exponent. If it was incorporated in a purpose it would only perform if the purpose is called unambiguously, as is this instance:

  // describe purpose to exhibit salutation communication
  // "Hello, World" function
  function ShowHelloWorld()
  // declaring new variables
  var date = new Date();
  var hour = date.getHours();
  // simple conditional content output
  if (hour >= 22 || hour <= 5)
  document.write("Goodnight, world!");
  document.write("Hello, world!");

This symbols has the same production as the preceding description of the symbols, but it is only Because the ShowHelloWorld() purpose is called that will show "Goodnight, world!" or "Hello, world!" depending on the hour of the day. With no that purpose Call, the JavaScript exponent would take note of the survival of a purpose named ShowHelloWorld(), but would not implement it.


This episode walked you from through a lot of fields operational with OOP in JavaScript. It is positively not a simple mission, particularly if you haven't been uncovered to the unspoken concepts previous to. Where you don't sense certain sufficient, have a look at the supplementary property we've referenced.

Website: www.techalpine.com Have 16 years of experience as a technical architect and software consultant in enterprise application and product development. Have interest in new technology and innovation area along with technical...

What did you think of this post?
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
You must be logged to download.

Click here to login