Maximum JavaScript Performance
Tags: coding, javascript
Published: 2018-04-01 16:12:01

---
title: Maximum JavaScript Performance
published: true
description: How to write fast JavaScript
cover_image: https://thepracticaldev.s3.amazonaws.com/i/kyrcrvb58bdbv9gdjv5m.jpg
tags: coding, javascript
---

_[Cover image by Fachstelle für Öffentliche Bibliotheken NRW on Flickr.](https://www.flickr.com/photos/fst_oeb_nrw/)_

If you're a bit like me you probably think a lot about how to make your software even better. One big point of cause is, to increase the performance __TO THE MAX__. Today I'll tell you the well kept performance secrets senior JS devs hiding from you.

## 1. Global variables only

Shadowing clutters your metal model of the software and often you need access to stuff you didn't anticipate when starting your project. If you always reuse your global namespace, you can be safe not to clutter your memory.

```javascript
// instead of 
const a = "Hello";
const b = "World";

// write
a = "Hello";
b = "World";
```

## 2. Short variable names

Never go over board with the length of a variable, parsing time is a big problem in modern JavaScript, so only use more than one letter for a variable name when your global namespace is finally full.

```javascript
// instead of 
loginTimeout = 2300;

// write
a = 2300;
```

## 3. Don't use functions

Functions are the root of all evil! Not only do they add mental overhead to your code by cluttering it with indirections, they also slow it down. So when in doubt, always in-line your code.

```javascript
// instead of
const substract = (x, y) => x - y;
a = substract(2000, substract(500, 50));

// write
a = 2000 - (500 - 50);
```

## 4. `setTimeout` all the way

Often you need to get stuff done quickly and the synchronous way is just not what cuts it. The best thing to do is replacing all the loops with `setTimeout` calls, so the event-loop takes care of everything.

```javascript
// instead of
let x = 1; 
while (x < 1000) {
  console.log(x);
  x++;
}

// write
x = 1;
const fastLoop = () => {
  console.log(x);
  x++;
  if (x < 1000) setTimeout(fastLoop, 1);
}
fastLoop();
```

## 5. Object access through `with`

If you've written any amount of meaningful JavaScript code in your life, you probably ended up with huge objects that you need to dig deep into. Would't it be nice to get rid of all these dots operators that slow you down while you code? Well the `with` operator got you covered here. Less code to parse means faster code.

```javascript
// instead of 
console.log(u.profile.name);
console.log(u.profile.birthday);
console.log(u.profile.town);

// write
with(u.profile) {
  console.log(name);
  console.log(birthday);
  console.log(town);
}
```

## 7. Cached randomness

Get yourself to the next tabletop shop and buy a bag of dice. They will help you to get random values you can cache in constants for later use. Calculating random values is rather slow and should be done static.

```javascript
// instead of 
myRandomNumber = Math.random();

// write
r = 17;
```

## Conclusion

There are many easy ways to speed up your code that even starters can follow. It's already the _1st of April 2018_, so I don't understand why we should settle with slow software.





_April Fool's!_