
Hello folks!

I've decided to write a series of posts sharing some javascript concepts that I believe JS developers should be concerned about. The idea is not to extend too much, so I'll try to add some resources at the end of the post if you want to dive into it.

Hope it helps someone, so let's start!

In this post, we're going to talk about **Typing**.

Javascript is a _"weakly typed"_ or even _"untyped"_ language, this means that we don't need to care about specifying types for our variables, functions, etc. Javascript will infer it for us based on the data.

But what if we want to check types before running some logic? We have some options to do it, so let's see them.

## Equality operators (== vs ===)

When we want to compare the equality in our logic, we can use double equals(`==`) or triple equals(`===`).

The simple difference between these operators is that the triple `===` compares **type** and **value**, and the double `==` will perform a _type coercion_, meaning that it will try to convert the values to a common type before comparing it.

E.g.

|             |         |
| ----------- | ------- |
| `1 == "1"`  | `true`  |
| `1 === "1"` | `false` |

### Falsy values

Something we need to be concerned about is that when javascript performs the type coercion for us, some values are considered `false` when it is used in a Boolean context.

E.g.

|               |         |
| ------------- | ------- |
| `0 == false`  | `true`  |
| `0 === false` | `false` |

This is useful because we can't do something like `if (!value)`, but we need to be concerned about what we are doing.

These are the falsy values:

- `false`
- `0`
- `''`
- `null`
- `undefined`
- `NaN`

## Type checking

Now we have talked a little about how typing works, coercion, etc. Let's how we can check these types.
The most common approach is to use `typeof`. This will give us the type of the variable we pass to id.

E.g.

```js
const myNumber = 1;
typeof myNumber; // "number"

const myString = "string";
typeof myString; // "string"

const myArray = [1, 2];
typeof myArray; // "object"
```

### Arrays

You may have noticed that `typeof myArray` gave us an output of `object`. WTF?

As you can see, in Javascript, arrays are objects, so whenever we call `typeof` for it, we'll get `object` as type.

So, when we need to check if a given object is an Array, we have a few options:

- use the Array API.
  E.g.
  ```js
  Array.isArray([]); // true
  ```
- use `instanceof`.
  E.g.
  ```js
  [] instanceof Array; // true
  ```
- use `Object.prototype.toString.call()`.
  E.g.
  ```js
  Object.prototype.toString.call([]); // "[object Array]"
  ```

### null, undefined

Other types we should be aware of are `null` and `undefined`. Although they both are falsy, they are not equal, as the name itself says, `null` is a variable with `null` value, `undefined` is a variable which **value** was not defined.

## Further reading

1. [MDN Falsy](https://developer.mozilla.org/en-US/docs/Glossary/Falsy)
2. [MDN Equality Operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Equality)
3. [MDN Strict Equality Operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)
4. [MDN typeof](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof)
5. [MDN instanceof](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof)
6. [Book Eloquent Javascript](https://eloquentjavascript.net/)


Javascript Series - Typing


Sometimes, for some reason, we are connected through multiple VPNs that may have different DNS servers to provide domains for all internal VPN stuff, the issue is that `/etc/resolv.conf` accepts only a single server.

The quick solution would be map every resource we need to `/etc/hosts`

E.g.

```plaintext
resource-one.example.com 1.2.3.4
resource-two.example.com 5.6.7.8
```

This works well but is very annoying, because everytime we have a new resource or an IP address changes, we need to update this file.

## The solution

To solve it we can use the `dnsmasq`, it provides us a DNS server and the best is that it comes with NetworkManager in the latest Ubuntu versions!

### Setting NetworkManager to use dnsmasq

Open `/etc/NetworkManager/NetworkManager.conf` and check `dns` property:

```plaintext
[main]
...
dns=dnsmasq
...
```

### Setting /etc/resolv.conf

Now we need to set up the `/etc/resolv.conf` to use `dnsmasq` as a DNS server and protect it from being overwritten by VPN clients.

```bash
$ sudo echo "nameserver 127.0.1.1" > /etc/resolv.conf # set dnsmasq as DNS server
$ sudo chattr +i /etc/resolv.conf # set immutable state to prevent changes to the file
```

**Note:** Unfortunately Cisco AnyConnect just doesn't work if we prevent it from editing that file).

### Setting dnsmasq to use the servers based on domain

Now you add a new file or edit the existing one in `/etc/NetworkManager/dnsmasq.d` with the DNS servers based on domain.

#### Example

- General domains:

```plaintext
server=1.1.1.1
server=1.0.0.1
```

- VPN 1:

```plaintext
server=/vpn.example1.com/1.1.1.1
server=/example1.com/10.10.1.1
```

- VPN 2:

```plaintext
server=/connect.example2.com/1.1.1.1
server=/example2.com/192.100.0.3
```

**Note:** Notice that "hardcoded" VPN domains to 1.1.1.1 (Cloudflare). This is done to be able to connect to the VPN once its address is part of the domains we've set up to internal VPN servers.

So the final config file for it will be:

```plaintext
server=1.1.1.1
server=1.0.0.1
server=/vpn.example1.com/1.1.1.1
server=/example1.com/10.10.1.1
server=/connect.example2.com/1.1.1.1
server=/example2.com/192.100.0.3
```

Now you can connect in both VPN at the same time with no issues!


@renantatsuo

Javascript Series - Typing

Setting up multiple DNS servers on Ubuntu