Basic JavaScript Interview Questions
Tags: webdev, programming, beginners, javascript
Published: 2021-01-24 01:55:34

**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/**


To get a job as a JavaScript developer, front end or otherwise, we need to nail the coding interview.

In this article, we’ll look at some basic questions and the answers to them.

* * *

### What’s the Difference Between undefined and null?

They both indicate a non-existent value, but we have to set `null` explicitly.

On the other hand, `undefined` is the value for undeclared variables, array positions that have been set with a value, and declared variables that haven’t been set with a value.

Also, `null` has the type object and `undefined` has type undefined. They’re both falsy and they are both primitive types.

The following will get us `undefined`:

```
let x;
let y = undefined;
```

Also, array positions that haven’t been assigned a value will also be `undefined`:

```
let arr = [];
arr[1];
```

`arr[1]` is `undefined` above.

Holes in arrays are also `undefined`:

```
let arr = [,1];
arr[0]
```

They both convert to `false` when cast to a boolean as follows:

```
Boolean(undefined);
Boolean(null);
!!undefined;
!!null;
```

`null` equals `undefined` when compared with the `==` operator, because they’re falsy. They aren’t equal when we compare them with the `===` operator since they’re of different types.

* * *

### What Does the && Operator Do?

The `&&` operator is the _AND_ operator and it finds the first falsy expression and returns it. If there are no falsy expressions then it returns the last expression.

For example, if we have:

```
let foo = null && undefined && 'foo';
```

The `foo` is `null` since `null` and `undefined` are falsy.

If we have:

```
let foo = true && 'foo';
```

Then we have `'foo'` assigned to `foo`. It does short-circuit evaluation to prevent unnecessary checks.

It’s also a handy shortcut for:

```
if (condition){
  doSomething();
}
```

Because the code above is the same as:

```
condition && doSomething();
```

Because, if `condition` is falsy then `doSomething();` won’t run because of short-circuiting.

* * *

### What Does the || Operator Do?

The `||` operator is the _OR_ operator. It finds the first truthy expression and returns it.

It also uses short-circuiting to avoid unnecessary checks. Therefore, it’s handy for setting a default value of a variable in case the ones before the default choice are falsy.

For example, if we have:

```
let foo = null || undefined || 'foo';
```

Then we have `'foo'` as the value of `foo`.

* * *

### What Does the + Operator Do?

The `+` operator has three meanings.

#### 1. Unary +

If it’s put before an expression, it’ll try to convert it to a number. Putting an operator before an expression makes it a unary operator.

For example, if we want to get the UNIX timestamp for the current date-time, we can write:

```
+new Date();
```

`+new Date(2020,1,1);` will return`1580544000000`.

It’s a fast way to convert a string to a number also. For instance:

```
+'1'
```

This returns `1`.

Therefore, the unary `+` operator tries to convert an expression after it. We can convert an expression to a number by wrapping it around parentheses as follows:

```
+(1 + '1');
```

Then we get `11` since `1 + ‘1’` returns `'11'`.

If the expression can’t be converted to a number, it’ll return `NaN`.

#### 2. Addition operator

If the `+` operator is between two numbers, it’ll add the two numbers.

For example, if we have:

```
1 + 2;
```

Then we get 3.

If we have:

```
let a = 1, b = 2;
a + b;
```

We also get 3.

#### 3. Concatenation operator

If one or more operands in the expression aren’t numbers, it’ll try to convert it in different ways.

For example, if we have:

```
1 + '1'
```

Or:

```
'1' + 1
```

Then we get `'11'`.

Of course, if we have two strings as operands then the `+` operator will be used for string concatenation:

```
'foo' + 'bar';
```

That’ll return `“foobar”`.

* * *

### What’s the Difference Between `==` and `===`?

The difference between `==` and `===` is that `==` only checks the content for equality and `===` checks both the content and the data type for equality.

For example:

```
2 == '2'
```

This will return `true` since they both have `2` as their content. This is because `==` does type coercion.

The full list of rules for type coercion for the `==` operator is:

1.  If `x` and `y` have the same value, compare with the `===` operator.
2.  If `x` is `null` and `y` is `undefined`, return `true`.
3.  If `x` is `undefined` and `y` is `null`, return `true`.
4.  If `x` has the `number` type and `y` is a string, return `x == +y`.
5.  If `x` has the `string` type and `y` is a `number`, return `+x == y`.
6.  If `y` has the `boolean` type, return `+x == y`.
7.  If `y` is a `boolean`, return `x == +y`.
8.  If `x` is a `string`, `symbol`, or `number` and `y` is an `object` then:

*   Return `x == y.valueOf()` if `y` is a `String` instance.
*   Return `x == y.valueOf()` if `y` is a `Number` instance.
*   Return `x == y[Symbol.toPrimitive]()` if `y` is any other kind of object or value.

* * *

### Conclusion

These are the most basic questions. To nail a JavaScript interview, these are the questions to start studying for.