CODEWITHSUNDEEP
javascriptprototypeperformance
Prasad Jadhav
Prasad Jadhav

Reputation: 5208

Does JavaScript Object initialization time depends on number of Variables and function?

Ques 1: Does it take significantly more time to initialize a JavaScript Object if it has a large number of variables and functions?

Ques 2: Does a large JavaScript(.js) file size is a performance issue?

For Instance: I am creating a JavaScript Object using Prototype, my sample code is below:

function SimpleObject(){
     // no variables and functions attached to it
}
function RootObject(){
   var one = "one";
   var two = "two";
   .
   .
   var one_thousand = "One Thousand";
}
function Child_1_Object(){
    // n number of variables
}
.
.
function Child_1000_Object(){
    // n number of variables
}

RootObject.prototype.get_Child_1_Object = function(){
   return new Child_1_Object();
}
.
.
RootObject.prototype.get_Child_1000_Object = function(){
   return new Child_1000_Object();
}

All the above code is in one .js file which has 10k lines of code(10KLOC).
My question is when I will create an object of RootObject will it take significantly more time comparing to creation of a SimpleObject?

Upvotes: 0

Views: 919

Answers (3)

RobH
RobH

Reputation: 3612

Question one:

Making an object more complicated, with members, functions etc. will increase the amount of time needed to instantiate it. I wrote a simple jsPerf test here to prove the point: http://jsperf.com/simple-vs-complex-object

One thing to note though, you're still creating hundreds of thousands of objects a second - it's hardly slow, even for very complex objects.

Question two:

Large files are problematic only because of their size in terms of a client having to download them. Minifying your code will help with this. e.g. http://javascript-minifier.com/

Upvotes: 2

Mike Thomsen
Mike Thomsen

Reputation: 37506

  1. No. Most of the amount of time required to instantiate a new object will be determined by what is done in the constructor.
  2. The main issue with having a lot of JavaScript (10k is not even remotely a large JavaScript file) is still a matter of what is it really doing? Sure some JavaScript VMs may run into issues with performance if you have 10mb of JavaScript, but I've never seen even Internet Explorer 7 choke on something like ExtJS 3.4 which has about 2.5mb of uncompressed JavaScript.

Now, download speed may be an issue, but parsing JavaScript is not. All of that is written in C or C++ and runs very quickly. When you are just declaring object types in JavaScript, much of that is just code parsing and assigning the prototype as a known type within the JavaScript VM. It doesn't have to actually execute the constructor at that point so the code you have above will run quickly until, perhaps, you start initializing objects.

Another thing about parsing JavaScript is that parsing is only one of the steps that other languages take. Java, C#, C, C++, etc. also have at least a stage of converting the parse tree into some form of object code. Java and C# stop there because their runtime has to do additional JIT compilation and optimization on the fly; C/C++ and some others have to do linking and optimization before generating usable machine code. Not that "parsing is easy" by any means on a programming language, but it is not the most performance-intensive part.

Upvotes: 1

Dziad Borowy
Dziad Borowy

Reputation: 12579

  1. Definitely. In fast, modern browsers these are miliseconds (or less), but every variable must be initialised, so 10k is always worse than 1.

  2. It is, as it needs to be downloaded by the browser (so the bigger - the slower) and than parsed by the js engine (again - the bigger - the slower)

It's simple math, although - like I said before - it you're just initialising variables - the delays are negligible, so you don't have to worry about that.

Upvotes: 1

Related Questions