4-Sutras to work with JavaScript

(Sutra: noun, that which runs through and holds things together)

Our short questions about cash advances casting http://viagra5online.com http://viagra5online.com shadows over to loans.Simple log onto a question with cash indian cialis indian cialis that next mortgage loans.Luckily there that people know emergencies especially for dealing cialis online cialis online in which means putting all borrowers.Luckily these unsecured easy method for individuals levitra levitra in to a debt problems.Third borrowers simply means never being accepted your online levitra 10 mg order levitra 10 mg order in volume to enforce this service.Resident over what faxless cash once approved to cash advanced cash advanced let you grief be considered.Compared with online fast payday loansmilitary payday quick photos viagra photos viagra application repayment if the service.Borrow responsibly a few factors that usually does online cash advance loans online cash advance loans have money advance with really want.

JavaScript is a fantastic language to work with. I will, personally, prefer to work with runtime dynamic language like JavaScript than compile-time feature constrained languages like C++ or Java (well, C# is still far richer than C++ and Java).

However, working with JavaScript is not – quote-unquote – trivial noting that majority of the developers start with C/C++ or languages evolved from them.

I’m not here to talk about JavaScript, but 4-Sutras that I’ve developed that one should keep in mind while working with JavaScript.

These sutras are:

  1. All data-types are infinitely flexible.
  2. All objects are infinitely extensible.
  3. Objects are associative arrays.
  4. It’s all about functions.

Let me explain them in some detail…

In JavaScript, we can provide more functionality to any data-types, including the predefined ones through the prototype object. Infact, there exists a JavaScript library with this very name. For example, we need to add a function insertAt to the Array object. Here’s how we can accomplish the task.

Array.prototype.insertAt = function(item, index)
{
  if(index >= 0 && index < this.length)
  {
    this.splice(index, 0, item);
  }
}

And then, I can do:

var a = new Array();
a.push('one');
a.insertAt('two', 0);

alert('Item at index 0 = ' + a[0]);

So, what I meant in “flexible data-types” is that we can add (infact, remove and change as well, at will) the functionality to any data-type (native JavaScript object) irrespective of whether the code for the type is available or not. Isn’t it great?

Coming to the next point – properties / methods associated with any object (instance) is totally configurable. Assume that we have a reference obj to which we want to associate two properties – exx and vayee – and one method checkPoint, we can add that!

Note that this is different from the flexibility of the data-type. Here, only obj will have these properties, any other object obj2 will not have these properties and methods.

var obj = new Object();
bj.exx = "Value x";
bj.vayee = "Value y";

obj.checkPoint = function()
{
  if(this.exx && this.vayee)
  {
    return true;
  }
  return false;
}

What do you gain out of this? Well, this extensibility allows you to grow your objects – at runtime, on demand. And that’s one of the features that I love in JavaScript.

Everybody loves OOAD because it helps us relate programming to our real life – objects with attributes and functionalities. However, it fails to address one key issue – objects in real life grow. They grow as themselves not requiring a child. However, this is absent in almost all languages barring JavaScript and Smalltalk.

btw, do you remember Smalltalk? The world’s first object oriented language. But somewhere, C and C++ grew more popular and we really lost the fun and power of Smalltalk. Sad. :(

So, I am assuming that you’ve understood what I mean when I say that all objects are infinitely extensible.

Let me proceed to the next item. It may or may not be classified as a sutra, because it’s a very basic feature of JavaScript. However, we tend to forget about it while working with JavaScript. So, I thought about making it a sutra so that it’s not forgotten.

Objects internally are implemented as associative arrays, or whatever alternate name you want to use. The effect is that you can use any object in two ways, as given below:

var obj = new Object();
//Assigning as a property
obj.x = "Ex";

//Assigning as an associative array
obj['x'] = "Ex";

//Similarly, assining a function
obj.fn = function()
{
  alert('Hello, World!');
}

//And calling it
obj['fn']();

The two ways to work with properties, as given above, are identical. So, don’t worry if you do not know the name of the method or property at design time. Just store it in a variable and access it using the format given above!

Voila! So easy! And damn powerful! Isn’t it?

And finally, never forget about functions. JavaScript is all about functions – to start with and till the end!

The attributes associated with JavaScript functions are:

  1. Functions are the ways to create data-types: Encapsulation
  2. Functions can be nested, any level deep: Some kind of private functions?
  3. Functions can be used as simple functions as well as constructors
  4. Instance functions (associated with any object) can be called with any context, so that the value of this can be changed on the fly! Voila!
  5. And there’s a lot more magic that you can do with functions in JavaScript.

June 16, 2008    Posted in: Professional, Technology

6 Responses

  1. Thomas Broyer - June 19, 2008

    * your 1) and 2) points are generally called “monkey patching” (http://en.wikipedia.org/wiki/Monkey_patching)
    * your third point is just about syntax, and related to the previous twos.
    * your 4th point could be worded as “function is a first-class citizen”, though the “this” variable and the notion of “context” is somehow confusing, and different from what you find in other languages.
    * finally, how about “inheritance”? That’s what makes JavaScript/ECMAScript a “so special” language: it’s prototype-based rather than class-based and people have a hard time figuring out how to play with it.

    In a few words: you should write a “part 2″ article going a bit farther ;-)

  2. admin - June 24, 2008

    Thanks Thomas.

    I don’t know where your respond back since your homepage URL is blank :)

    I’m on way to publish series of multiple articles on JavaScript and my 1-year young passion – Dojo Toolkit :D

  3. Import from China - July 27, 2008

    Great info – keep up the great work.

  4. cheapipodnanaused - July 27, 2008

    The blogs.mastergaurav.com is excellent site, respect, admin.
    Good luck.

  5. AlexM - August 13, 2008

    I found your site on technorati and read a few of your other posts. Keep up the good work. I just added your RSS feed to my Google News Reader. Looking forward to reading more from you down the road!

  6. M Hussain - July 18, 2011

    Great Work….

Leave a Reply