DEV Community

Cover image for Mastering Optimization: Writing the Most Performant JavaScript Code
Shubham Thakur
Shubham Thakur

Posted on

Mastering Optimization: Writing the Most Performant JavaScript Code

Optimization is at the heart of creating a smooth, efficient, and enjoyable user experience. When it comes to JavaScript, a language known for its dynamism and versatility, writing optimal code becomes an interesting task. This article will explore how to write performant JavaScript code, including some common pitfalls to avoid and practices to adopt. We'll illustrate this through several code examples, comparing suboptimal solutions with their more optimized counterparts.

1. Minimizing Global Variables

One of the fundamental principles of writing optimal JavaScript code is limiting the scope of variables. Global variables, while convenient, can quickly clutter the global namespace, potentially leading to naming conflicts and memory leaks. Moreover, they can make your code harder to understand and maintain.

Suboptimal Code:

var globalVar = "I am global!";

function showGlobalVar() {
  console.log(globalVar);
}

showGlobalVar();  // Outputs: "I am global!"
Enter fullscreen mode Exit fullscreen mode

Optimized Code:

function showLocalVar() {
  var localVar = "I am local!";
  console.log(localVar);
}

showLocalVar();  // Outputs: "I am local!"
Enter fullscreen mode Exit fullscreen mode

By using local variables, we can keep our code cleaner, avoid potential conflicts, and conserve memory resources.

2. Using const and let over var

Before ES6, JavaScript only had var for declaring variables. However, var has some quirks that can lead to bugs in your code. In particular, it's function-scoped, not block-scoped, which can lead to unexpected behavior.

Suboptimal Code:

var x = 10;
if (true) {
    var x = 20;  // Same variable!
    console.log(x);  // 20
}
console.log(x);  // 20 - Oops, not what we expected!
Enter fullscreen mode Exit fullscreen mode

Optimized Code:

let x = 10;
if (true) {
    let x = 20;  // A different variable
    console.log(x);  // 20
}
console.log(x);  // 10 - That's more like it!
Enter fullscreen mode Exit fullscreen mode

By using let and const for block-scoping, we ensure our variables only exist where they're supposed to, preventing bugs and making our code easier to read and understand.

3. Opting for Strict Equality Checking

In JavaScript, it's generally more efficient to use strict equality (===) over loose equality (==). Loose equality can lead to potentially misleading results due to type coercion. Additionally, strict equality checks tend to run faster because they don't require type conversion.

Suboptimal Code:

var x = '5';
if (x == 5) {  // This will execute
    console.log('Loose equality');
}
Enter fullscreen mode Exit fullscreen mode

Optimized Code:

var x = '5';
if (x === 5) {  // This won't execute
    console.log('Strict equality');
}
Enter fullscreen mode Exit fullscreen mode

By using strict equality, we prevent unnecessary type conversions, making our comparisons faster and less prone to bugs.

4. Choosing the Right Data Structure

JavaScript provides various data structures, each with their advantages and disadvantages. Knowing when to use which is crucial for writing performant code. Let's compare the array and set data structures for an existence check operation.

Suboptimal Code:

let arr = [1, 2, 3, 4, 5];
if (arr.includes(4)) {  // O(n) time complexity
    console.log

('Number exists in array');
}
Enter fullscreen mode Exit fullscreen mode

Optimized Code:

let mySet = new Set([1, 2, 3, 4, 5]);
if (mySet.has(4)) {  // O(1) time complexity
    console.log('Number exists in set');
}
Enter fullscreen mode Exit fullscreen mode

In this example, the Set is more efficient for checking existence as it has O(1) time complexity for the .has() method, compared to an array's .includes() which has O(n) time complexity. Of course, this doesn't mean you should always use a set instead of an array, but it's important to choose the right tool for the right task.

5. Avoiding Unnecessary Loops

Loops can be costly, especially if you're iterating over large data sets. Let's compare a scenario where we can replace a loop with an inbuilt JavaScript method.

Suboptimal Code:

let arr = [1, 2, 3, 4, 5];
let sum = 0;
for (let i = 0; i < arr.length; i++) {
    sum += arr[i];
}
console.log(sum);  // Outputs: 15
Enter fullscreen mode Exit fullscreen mode

Optimized Code:

let arr = [1, 2, 3, 4, 5];
let sum = arr.reduce((a, b) => a + b, 0);
console.log(sum);  // Outputs: 15
Enter fullscreen mode Exit fullscreen mode

In this example, the reduce method makes our code more readable and concise. However, it's worth noting that while this approach makes your code cleaner, the performance is virtually identical. Sometimes, optimization is more about writing cleaner, more maintainable code than getting every last drop of performance.

In conclusion, writing optimized JavaScript is a blend of understanding the language's nuances, using modern features wisely, and choosing the right constructs and data structures. Performance is crucial, but it's just as important to write clean, maintainable, and understandable code. Happy coding Guys, Thanks for reading this !

Top comments (5)

Collapse
 
krofdrakula profile image
Klemen Slavič

As Jon mentioned, if you're talking about performance, only point 4 applies, but it doesn't do much to illustrate what other options are available apart from the one example. Point 5 is also misleading, as both things do the exact same thing, and without benchmarking the claim is insubstantial.

Collapse
 
shubhamt619 profile image
Shubham Thakur

Thanks for the insight @krofdrakula

Collapse
 
shubhamt619 profile image
Shubham Thakur

Thanks @krofdrakula , I will improve the quality of my writing and content.

Collapse
 
jonrandy profile image
Jon Randy 🎖️

Most of these points/suggestions have little or nothing to do with performance

Collapse
 
shubhamt619 profile image
Shubham Thakur

Thanks @jon, I will work on the quality of my content.