Typescript - Data Types
Tags: typescript, javascript, webdev
Published: 2020-08-08 11:56:38

Types are the most basics of every programming language. So, let's start looking into Typescript's data types

## Booleans
Booleans are the most basic data type with just two values `true` or `false`. In typescript, we define typescript as
```js
let isAuthenticated: boolean = false; 
```
The extra part `: boolean` is a variable type.

## Numbers
To define a variable which has type number, we simply have to add `: number` before the assignment operator
```js
let num: number = 5;
```
If you change its value from `5` to `"5"`, Typescript will give an error `Type '"5"' is not assignable to type 'number'` because this variable can now only hold numbers.
It can also hold **Floating**, **binary** , **hexadecimal**, **octal** numbers. 

## Strings
By now, I am sure you know the basic syntax for Typescript variables. We can declare strings as
```js
let name: string = "Arsalan";
```
You can also use single quotes
```js
let name: string = 'Arsalan';
```

## Null and Undefined
In Typescript, we have other types known as **null** and **undefined** and we can declare them as
```js
let somethingNull: null = null;
let somethingUndefined: undefined = undefined;
```
These two variables will always be `null` and `undefined` and you can't change them. They are not extremely useful on their own but there are some cases where they come in handy. For example, if you are trying to fetch a value from somewhere and that value is either string or null, in that case, you can declare a variable that can be string or null.
```js
let fetchedValue: string | null;
```
If you try assigning `null` or `undefined` to a variable which must be of type `string`, you will see it works, e.g.
```js
let thisWorks: string = null;
```
That's because Typescript avoids `null` and `undefined` because these two types are subtypes of `string`, `number` etc.
To avoid this behavior, and show an error, you can add this one line to your `compilerOptions` in `tsconfig.json`
```js
"strictNullChecks": true
```

## Array
Let’s talk about some non-primitive types such as Arrays and Objects. For Arrays, we have to add square brackets after the type
For example, if we want to want to have an array of numbers
```js
let numArr: number[] = [1,2,3,4,5];
```
Similarly, for Strings
```js
let names: string[] = ["John", "Lisa", "Smith"];
```
There is also a second way to declare arrays, by using `Array<elementType>`
```js
let names: Array<String> = ["John", "Lisa", "Smith"];
```



## Tuple

Tuple is something you never heard of in javascript, In javascript, we don’t define the length of our arrays, because we can not, Tuple helps us to express the length of our arrays. Here's a simple example of Tuple
```js
let numbers: [number,number] = [1,2];
```
If you try to add any additional item to `names` array, you will get an array

```js
let numbers: [number,number] = [1,2,3];
// Error: Type '[number, number, number]' is not assignable to type '[number, number]'
```
but this will work still work
```js
let numbers: [number, number] = [1, 2];
numbers.push(2);
```
That's because type safety doesn't work with `.push()`.

You can also have an array of fixed length which can store different types. For example,
```js
let mixed: [number, string, number] = [1, "Two", 3]
```

## Objects
We have covered most of the things, let's talk about the most interesting type, Objects. Here's a simple object declared in Typescript.
```js
let obj: object = {
    val: 4,
    foo: "bar"
}
```
We will talk more about Objects in upcoming blogs when you learn some more Typescript.

## Enum
If you have worked with C# or Java, you are most likely familiar with `Enum`. They are a set of predefined constant values. A simple example of `Enum` is
```js
enum Days {
  Monday,
  Tuesday,
  Wednesday,
  Thursday,
  Friday,
  Saturday,
  Sunday,
}

let satur: Days = Days.Saturday;  // 5
```
Enums can also be accessed by their index.
```js
enum Days {
  Monday,
  Tuesday,
  Wednesday,
  Thursday,
  Friday,
  Saturday,
  Sunday,
}

let sat: string = Days[6]; // Sunday
```
By default, enum starts with an index 0 but we can modify their index. For example
```js
enum Days {
  Monday,
  Tuesday,
  Wednesday,
  Thursday,
  Friday,
  Saturday,
  Sunday = 10,
}

let sat: string = Days[10]; // Sunday
```
In the above example, `Sunday` has an index of `10`.

## Any
At this point, you learned all the primitive and non-primitive types that exist in Javascript. But, you might be wondering how can I have a variable which can accept any value? Is there any way to declare such a variable in Typescript? The good news is YES, there is a way to declare such a variable.
```js
let giveMeAnyValue: any = 1;
giveMeAnyValue = "Two";
giveMeAnyValue = [1,"Two"];
giveMeAnyValue = {
    one: 1,
    two: "Two"
}
```
The above code snippet will work fine because we specified its type as `any`, which means this variable can have any type.

This also works for Tuple
```js
let arrayOfUnknownTypes: [any, any, any] = [1,2,3];
arrayOfUnknownTypes = ["One", 2, "Three"]
```
If you are not sure about the type, you can use any.

## Never
One other type, we can use is `never` which means no value. 
```js
let dontGiveMeValue: never = 1;
```
The above example will give you an error `Type '1' is not assignable to type 'never'.`. That's because it will not accept any value at all.
This `never` is used as the return type for those functions which always throw an error or which goes into an infinite loop.
```js
function dontWork (): never {
    throw Error("You FAILED!")
}
```

This was all about Typescript Data Types. You can take advantage of these static types to avoid javascript coercions if you don't like them.