Guest, register

Faster JavaScript Loading Speed Tips, Code and Tools This JavaScript article tutorial provides many full-detailed solutions as well as JavaScript tools, online web-based applications for the web developers to optimize speed, loading time of JavaScript codes - one of the factors to gain better performance for our websites.

These solutions in this JavaScript article post are listed from basis, such as: load JavaScript files at the bottom of the HTML page, group JavaScript files together, compress JavaScript source codes, etc to many advance customized solutions, along with many web services, web tools, online website optimizers to make website optimizations better, more efficient.

Please go to the detailed-post page for full instructions and solutions, or read other related articles below:
- Speed Up JavaScript Performance with SharePoint Minifier
- 20+ Helpful Web Tools for Better Code Development
- Writing JavaScript Code Efficiently
- Organizing your JavaScript code Better

Free iPage Web Hosting for First Year NOW

If you're still looking for a reliable web host provider with affordable rates, why you don't take a little of time to try iPage, only with $1.89/month, included $500+ Free Extra Credits for the payment of 24 months ($45)?

Over 1,000,000+ existisng customers can not be wrong, definitely you're not, too! More important, when you register the web hosting at iPage through our link, we're going to be happy for resending a full refund to you. That's awesome! You should try iPage web hosting for FREE now! And contact us for anything you need to know about iPage.
Try iPage for FREE First Year NOW

Here are some tips on high perfomance Javascript I have picked up. Most
of it comes from the books High Performance Javascript
by Nicholas C. Zakas and High Performance Web Sites
by Steve Souders.


Load files at the end of the HTML page

Load the Javascript files right before the body, this will allow the
page to render without having to wait for all the Javascript files.

Group files together

With normal loading, the files are loaded sequentially. Each file will
be loaded and parsed before the next file starts to load. Merge them
together into one large file. While you are at it, you should also
minimize it. Tools to help you with this are:

Load files asynchronously

If normal loading with grouped files is not good enough, it is also
possible to load the files asynchronously. This will also allow you to
load files on demand. Tools for this are:

Variable Access

Literal values and local variables can be accessed very quickly. Array
access and member access take longer. If the prototype chain or scope
needs to be traversed, it will take longer the further up the chain
the access is. Global variables are always the slowest to access because
they are always last in the scope chain.

You can improve the performance of JavaScript code by storing frequently
used, object members, array items, and out-of-scope variables, in local


All DOM manipulation is slow.

  • Minimize DOM access
  • Use local variables to store DOM references you'll access repeatedly.
  • HTML collections represent the live, underlying document, so:
    • Cache the collection length into a variable and use it when iterating
    • Make a copy of the collection into an array for heavy work on collections

Reflow and rendering

The browser contains two trees, the DOM tree and a render tree.
Whenever the DOM layout or geometry is changed the view will have to be
re-rendered. This is known as reflow.

Reflow happens when:

  • Visible DOM elements are added or removed
  • Elements change position
  • Elements change size (margin, padding, border thickness, width, height, etc.)
  • Content is changed, (text changes or an image is replaced with one of a different size)
  • The page renders initially
  • The browser window is resized

Combine multiple DOM and style changes into a batch and apply them once.
This can be done with documentFragments or by cloning the node.

// Create a document fragment
var fragment = document.createDocumentFragment(); 

// Do something with framgment 

// Append the fragments children to the DOM

// Clone Node
var old = document.getElementById('mylist');
var clone = old.cloneNode(true); 

// Do something with clone 

// Replace node with clone
old.parentNode.replaceChild(clone, old); 

Algorithms and Flow

Use algortithms with better complexity performance for large collections.

  • for-in loops are slower than for, while and do-while loops. Avoid
    for-in unless you need to iterate over a number of unknown object
  • Lookup-tables are faster than multiple conditionals.
  • Recursion can be re-written with iteration if you get stackoverflow

Strings and Regexes

Strings concatenation is quite fast in most browsers. In IE, you may
need to use Array.join.

Regular expression can be improved by:

  • Focus on failing faster.
  • Start regexes with simple, required tokens.
  • Make quantified patterns and their following pattern mutually exclusive /"[^"]*"/.
  • Use noncapturing groups. (?:) instead of ().
  • Capture text to reduce postprocessing.
  • Expose required tokens /^(ab|cd)/ instead of /(^ab|^cd)
  • Resue regexes by assigning them to variables.
  • Split complex regexes into simpler pieces.


The total amount of time that a single JavaScript operation should take
is 100. If it takes longer it needs to be split up, this can be done
using timers.

Two determining factors for whether a loop can be done asynchronously
using timers:

  • Does the processing have to be done synchronously?
  • Does the data have to be processed sequentially?

// Function for processing an array in parallel

function processArray(items, process, callback) {
  var minTimeToStart = 25;

  var copyOfItems = items.concat();
  setTimeout(function() {

    if (copyOfItems.length > 0)

      setTimeout(arguments.callee, minTimeToStart);

  }, minTimeToStart);

// Function for processing multiple tasks in parallel
function processTasks(tasks, args, callback) {

  var minTimeToStart = 25;
  var copyOfTasks = steps.concat();

  setTimeout(function() {
    var task = copyOfTasks.shift();

    task.apply(null, args || []);
    if (copyOfTasks.length > 0)

      setTimeout(arguments.callee, minTimeToStart);

  }, minTimeToStart);

You should limit the number of high-frequency repeating timers in your
web application. It is better to create a single repeating timer that
performs multiple operations with each execution.

It is not recommended to have minTimeToStart less than 25
milliseconds, because there is a risk that the timers will fill up the

// Timed version of process array, where each version is able to
// process items from the array for up to 50 milliseconds.
function timedProcessArray(items, process, callback) {

  var minTimeToStart = 25;
  var copyOfItems = items.concat();

  setTimeout(function() {
    // (+) converts the Date object into a numeric representation
    var start = +new Date();

    do {
    } while (copyOfItems.length > 0 && (+new Date() - start < 50));

    if (copyOfItems.length > 0)
      setTimeout(arguments.callee, minTimeToStart);

  }, minTimeToStart);

Newer browsers support web workers. Web workers does not run in the
UI-thread and does not affect responsiveness at all. Their environment
is limited to allow this to work. It is limited to:

  • A navigator object, which contains only four properties: appName,
    appVersion, user Agent, and platform.
  • A location object (same as on window, except all properties are read-only)
  • A self object that points to the global worker object
  • An importScripts() method that is used to load external JavaScript for
    use in the worker
  • All ECMAScript objects, such as Object, Array, Date, etc.
  • The XMLHttpRequest constructor
  • The setTimeout() and setInterval() methods
  • A close() method that stops the worker immediately

It is not possible to create a WebWorker from code. It needs to be
started with its own javascript file. You can however communicate with
it through events.

// Application code
var worker = new Worker("code.js");

worker.onmessage = function(event) {


// Worker code (code.js)
//inside code.js
importScripts("file1.js", "file2.js"); // importing some files 

self.onmessage = function(event) {
  self.postMessage("Hello, " + + "!");


Any code that takes longer than 100 milliseconds to run should be
refactored to use webworkers to decrease the load on the UI-thread.
Save up to 630$ when buy new iPhone 15
Free Airdrops to Claim, Share Up to $150,000 per Project
Open tool hub for free to use by any one for every one with hundreds of tools,,,
Talk to ChatGPT by your mother language
Generate creative images automatically with AI
Render creative video automatically with AI

JavaScript by day

Google Safe Browsing McAfee SiteAdvisor Norton SafeWeb Dr.Web