typescript

What typescript is not ...

typescript does ->

static checking ( in other programming languages their IDE throws error right when you're writing it but in JS you only know there's an error when you actually execute the program & typescript just does that)

premitive types

number , string,boolean

type inference

typescript automatically detects the type of input given to a variable so most of the time we don't need to specify that explicitly.

(inference) means typescript automatically detecting the type of the input. and it's only should be let done in case of variables not functions.

let numberOne = 3345;
let numberTwo: number = 41; // it's just too redundant

//Now this is where you should use explicit typecasting 
let hero: string;
function getHero(){
return "Thor";
}
hero = getHero();


//not only we are accepting only number type we are also just returning number type
function addTwo(num: number):number{
    return num + 2;
}
//if not returning anything then mention void as the return type
function logError(errMsg: string): void {
    console.log(errMsg);
}
//never return type for error handling
function logError(errMsg: string): never {
    console.log(errMsg);
}

there is a type "never" similar to "void" but instead of returning "nothing" it "never" returns anything.(good for error handling)

type alias

you can create alias for new types (can create new types)

type User = {
    name : string,
    isPaid : boolean,
}
function createUser(paramUser:User): User{
    return {name:'',isPaid:true}
}

readonly

type User = {
    readonly _id: string, 
    name: string,
    isPaid: boolean,
    creditCardDetails?: number
}

here "readonly" is a keyword and keeps the "_id" from getting altered.
"creditCardDetails?:" is another keyword that makes the particular parameter optional.
we can mix&match multiple user-defined types and make new types

type houseGuest = {
  name: string,
  isPaid: boolean,
  creditCardDetails?: number,
}

type owner = {
  name: string,
  gotPaid: boolean,
}

type student = houseGuest & owner & {
  rollNo?: number,
}

const myStudent: student ={
  name: "Atharv",
  isPaid: false,
  gotPaid: true,
  rollNo : 123,
}

arrays

const superHeros: string[] = []; // first way of defining the type
const superVillans: Array<string> = []; // second way of defining the type

// defining type as array of number arrays 
const MLModel: number[][] = [
    [244,444,222],
    ...
];

arrays needs to have types like this above.

Union

a cover for multiple types

let score: number | string;
score = 33;
score = "44";
// it's all okay...
type User = {
    name: string,
    id: number,
}
type Admin = {
    username: string,
    id: number
}

let myUser: User | Admin = {username:"Atharv",name:"Rajesh",id:111};
console.log(myUser);
// myUser can have either the properties of User or Admin or both of them but no less or no more

tuples

we can add more strictness to arrays so that we know how many elements are gonna be there and which data type

type rgb = [number,number,number];
const myrgb: rgb = [12,34,22];
//only 3 elements with only number type

const myArr: [string,number,boolean];
myArr = ['23',23,true];
//now the myArr can only hold 3 items and it'll only accept these 3 types in the same order

DISADVANTAGE even if we cannot directly add new values to already fixed typed tuple we can push,pop,unshift ... to the tuple and it'll mess things up.

Enums

enums are (in my view) objects with a little more flexibility.

enum Color {
  Red,
  Green = 10,
  Blue,
}

let chosenColor: Color;
chosenColor = Color.Red;
console.log(chosenColor); // Output: 0
chosenColor = Color.Green;
console.log(chosenColor); // Output: 10
chosenColor = Color.Blue;
console.log(chosenColor); // Output: 11

to not complicate the converted JS file with IFFY by enums we declare enums with const // const enums {...}

interface

it's kind of a class that gives a blueprint to define objects and it's methods
if we declare and define multiple interfaces with same name then it's all get merged
we can extend from other interfaces too.

interface User {
  readonly dbId: number,
  name: string,
  userId: number,
  googelId?: string,
  getLogIn(num:number): number,
}

interface Admin extends User {
  adminKey: number,
}