JavaScript Best Practices — Unexpected Values and More
Tags: webdev, programming, javascript, codequality
Published: 2021-01-26 21:43:17

**Check out my books on Amazon at https://www.amazon.com/John-Au-Yeung/e/B08FT5NT62**

**Subscribe to my email list now at http://jauyeung.net/subscribe/**

Like any other programming language, JavaScript has its own list of best practices to make programs easier to read and maintain. There are lots of tricky parts to JavaScript, and there are many things to avoid. We can follow some best practices to make our JavaScript code easy to read.

In this article, we look at the best way to compare objects and function parameters, adding a default value to switch statements and function parameters and avoiding the use of the `eval` function.

### Use === For Comparing Objects

In JavaScript, there are 2 operators for equality comparison. One is the `==` operator and the other is the `===` operator. `==` compares the operands by converting them to the same type automatically.

`===` compares by both comparing the content and the type of both operands.

We want to use `===` because it compares both the type and the content so that we won’t get any mismatch in the type.

For example, if we use the `==` operator, we can the following expressions evaluated to `true` :

```
0 == "";  
0 == null;  
0 == undefined;  
null == undefined;  
1 == "1";
```

In the first 4 lines, everything is falsy so they’re all converted to `false` before comparing for equality with the `==` operator.

In the last line, `'1'` is converted to `1` before comparison so that we get the value `true` returned.

To avoid these confusing results, we can use the `===` operator, which compares both the type and the content of the values. With `===`, everything above will be evaluated to `false` .

If we want to compare things with the same content and different types with the `===` operator, we can convert them to the same type first.

For example, if we want compare `1` and `'1'` , we can write:

```
+1 === +'1'
```

Then they’ll both be converted to `1` and the expression will evaluate to `true`.

This way, we don’t get anything with unexpected types being compared.

### Default Parameters

JavaScript functions can take in any number of parameters even though they have their own signatures. This means that we can pass in fewer parameters than we expect.

With ES6, we get the default parameter value feature. This lets us set the default value for function parameters.

For example, we can write:

```
const add = (a, b = 0) => a + b;
```

Then we don’t have to pass in the second argument for the function to return a numerical value. If we write:

```
console.log(add(1));
```

We get 1 since the value of `b` will be set 0 if nothing is passed, so we get 1 + 0 which is 1.

![](https://cdn-images-1.medium.com/max/800/0*7Tsd0E9oF3liGe26)Photo by [Kristina Paparo](https://unsplash.com/@krispaparo?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)

### Add Default Value for Switch Statements

We should always add a `default` block to `switch` statements, since we might have unexpected values being passed into the `switch` statement.

For example, we should write:

```
const getDayName = (dayOfWeek) => {  
  let day;  
  switch (dayOfWeek) {  
    case 0:  
      day = "Sunday";  
      break;  
    case 1:  
      day = "Monday";  
      break;  
    case 2:  
      day = "Tuesday";  
      break;  
    case 3:  
      day = "Wednesday";  
      break;  
    case 4:  
      day = "Thursday";  
      break;  
    case 5:  
      day = "Friday";  
      break;  
    case 6:  
      day = "Saturday";  
      break;  
    default:  
      day = "Unknown";  
  }  
  return day;  
}
```

To get the day of the week, because we can pass in anything to the `getDayName` function. For example, we can write:

```
console.log(getDayName(0));  
console.log(getDayName(1));  
console.log(getDayName(1000));
```

If we pass in 1000, we need to handle that, so we need a default value.

### Don’t Use Eval

The `eval` function accepts a string that contains JavaScript code, which will be run by this function.

We shouldn’t use it because it lets code from unknown sources run, which is a big security risk.

Also, it’s also slower than normal code since it’s interpreted on the fly. This is because the code can’t be optimized by JavaScript engines.

Modern interpreters convert code to machine code, which can’t be done with code passed into `eval` . This means that the interpreter has to do variable lookups on the fly to set things to the right variables.

Any operations that are done to variables will force the browser to re-evaluate the code again if it’s running code passed into the `eval` function.

### Conclusion

When we compare objects for equality, we should use the `===` operator since it compares both the content and the type of the object. Also, we should put default values for parameters in case they aren’t passed into the function when it’s called. Also, we should add a `default` block to `switch` statements to deal with unexpected values. Finally, don’t use the `eval` function because it’s a big security that allows people to inject malicious code to our programs and it’s slow to run code with `eval` .