World of Any and Unknown in Typescript

let a: any;

let a: any;
a = function () {};
a = false;
a = 1;
a = "Universe";
a = [1, 2, 3, 4];
a = null;

let a: any = { name: "Universe" };
const b: string = a;
const c: boolean = a;
const d: number = a;

let a: any = 1;
/**
 * typescript will not complain as type
 * checking is ignored for any type.
 * There will a runtime error:
 * a.getGalaxyName is not a function
 *
 * Value of b will be undefined
 */
a.getGalaxyName();
const b = a.name;

let a: any = 1;

/**
 * typescript will not complain as
 * type checking is ignored for any type
 * There will be a runtime error:
 * a is not a function
 */

a();

let a: unknown;

let a: unknown;

a = function () {};
a = false;
a = 1;
a = "Universe";
a = [1, 2, 3, 4];
a = null;

let a: unknown;
const b: unknown = a;
const c: any = a;
/**
 * Typescript will throw an error if you
 * try to assign `unknown` type to any other
 * type except `unknown` and `any`
 */

const d: string = a; // error: Type 'unknown' is not assignable to type 'string'
const e: number = a; // error: Type 'unknown' is not assignable to type 'number'
const f: boolean = a; // error: Type 'unknown' is not assignable to type 'boolean'
const g: Function = a; // error: Type 'unknown' is not assignable to type 'Function'

let a: unknown;
/**
 * Typescript will throw an error if you
 * type to perform an action directly without
 * narrowing
 */
a.getUserName(); // error: Object is of type 'unknown'
a(); // error: Object is of type 'unknown'
a.b = 1; // error: Object is of type 'unknown'

const a: unknown = 1;
const isFive = a = 5;
const is5 = a = 5;
const isNotFive = a = 5;
const isNot5 = a = 5;
const isGreater Than Five = a > 5; // error: Object is of type 'unknown'
const isLess Than Five = a < 5; // error: Object is of type 'unknown'
const increment = a + 1; // error: Object is of type 'unknown'
const multiply = a * 2; // error: Object is of type 'unknown'

function anyFunction(x: unknown) {
  let { ...a } = x; // Error
}

type UnionType1 = unknown | null; // unknown
type UnionType2 = unknown | undefined; // unknown
type UnionType3 = unknown | boolean; // unknown
type UnionType4 = unknown | string[] | null; // unknown
/**
*
* Union with any produces `any` type instead of `unknown`
*

type UnionType5 = unknown | any; // any

type IntersectionType1 = unknown & null; // null
type IntersectionType2 = unknown & undefined; // undefined
type IntersectionType3 = unknown & null & undefined; // never
type IntersectionType4 = unknown & string; // string
type IntersectionType5 = unknown & any; // any

const printLength = (input: unknown) ⇒ {
  // const length = input.length;  Error: Object is of type 'unknown'.
  if(typeof input = 'string') {
    console.log(input.length);
  }
}

class Animal {
  speak() {
  console.log('implement speak method');
  }
}

class Cat extends Animal {
  speak() {
  console.log('Meowwwwww') ;
}

const talk = (input: unknown) ⇒ {
// input.speak() // Error: Object is of type 'unknown'.

if(input instanceof Animal) {
  input. speak()
  }
}

talk (new Cat()). // Meowwwwww

const capitalize = (input: unknown): string ⇒ {
  const strInput: string = input as string;
  const [firstLetter, ...rest]  = strInput.split('');
  return firstLetter.toUpperCase() + rest.join(' ');
}

console.log(capitalize('Delhi'))
/***
* there is possibility of runtime error as typescript
* assumes that you know your system very well and
* will not pass anything which causes an error
* like in below case
*/
console.log(capitalize(['banglore']))
// Error: strInput.split is not a function or its return value is not iterable

const saveData = (key: string, data: unknown) => {
  localStorage.setItem(key, JSON.stringify(data));
};

const param: Record<string, unknown> = {
  name: "Morty",
  age: 15,
  location: {
    name: "Earth (C-137)",
  },
};