EcoConception Logicielle

The Closure Compiler compiles JavaScript into compact, high-performance code. The compiler removes dead code and rewrites and minimizes what's left so that it downloads and runs quickly. It also checks syntax, variable references, and types, and warns about common JavaScript pitfalls. These checks and optimizations help you write apps that are less buggy and easier to maintain.

A performance playground for JavaScript developers. Easily create and share test cases and run cross-browser benchmarks to find out which code snippet is most efficient.

This article will discuss a simple optimization to save you a few characters and a little performance when evaluating equality. In JavaScript, there are two types of equality: structural equality (==) where the content of two references are the same, and physical equality (===) where two object point to the same reference or are structurally equal and have the same object type. For the most part I use physical equality when comparing values, to ensure any variable is exactly what it is expected to be. For example, consider this function:

I went to the Bayjax Meetup held by Yahoo! yesterday. The theme of the speakers was how to improve the performance of your JavaScript. There were lots of good presentations that will hopefully be online soon. The presentation that was most useful for me was by Nicholas Zakas, from his book High Performance JavaScript. His talk inspired todays article, explaining how the timer works for timeouts in JavaScript.

First of all, it is important to understand that in a browser there is one thread managing both JavaScript execution and UI updates (the UI thread). This means that while JavaScript is executing the UI cannot update and vice-versa. If the UI thread is processing something, all new JavaScript and UI tasks are added to a queue, and executed in order.

I recently solved a recursive problem in JavaScript, using a static function instead of adding the function to the prototype of the object I was working on. The pair programmer asked me why I choose to do it that way. After a few minutes discussion, I settled on two reason why I intuitively felt static functions are faster, especially for recursion: less scope lookups and better Just-In-Time compilation (JIT) optimizations. This article describes my hypothesis that static functions are faster and the results which clearly show using this in recursion does not meaningfully affect performance in modern browsers.

Insertion sort is a simple, quadratic (O(n2)) sorting algorithm that iterates forward through the array, sorting the current index value in-place by inserting it into the correct position among the values at smaller indices, which were sorted in previous passes. In practice it out performs the other quadratic sorting algorithms, such as bubble sort and selection sort.

Note: This post was inspired by work done by Nicholas Zakas. It turns out he has already written a blog article solving this problem and has a more elegant solution at Timed Array Processing in JavaScript.

Since JavaScript is executed by the same thread that handles updating the UI, developers can easily lock up the UI and make it unresponsive to end-users.

Slow operations, such as bubble sorting a million value array, or adding hundreds of table rows to the DOM, will cause the JavaScript engine to lock the UI thread, making the page unusable to the end-user. To work around this, if you have large, slow operations, you can split the execution into chunks, so that the UI thread can respond to the end-user between chunks, and thereby improving the responsiveness of your site. Todays article will show you one way to chunk slow iterative operations.

It has been a while since we looked at the performance of various iteration techniques in JavaScript. Since most developers use a JavaScript framework nowadays, you may not even be aware of the trade-offs being made each time you call $.each or your library’s equivalent iteration function. This article describes the four most common iteration techniques and how well they perform on several browsers, and compares it to the native browser Array.prototype.forEach.

Selection sort is a simple, quadratic (O(n2)) in-place comparison sort algorithm that divides the array into two lists: an already sorted part and a to-sort part. The algorithm moves for through the array and inserts the next value in-place by searching the unsorted part of the array for the next value. In practice, the selection sort is useful when memory is limited.

Continuing our sorting algorithm discussion, today’s article will cover a technique known as Shell Sort.

Shell sort is a quadratic (O(n2)) in-place comparison sort algorithm developed by Donald Shell in 1959 that is basically Insertion Sort with a gap between comparing indexes. The assumption is that comparing farther apart elements can move some out-of-place elements into position faster.