generic ts and utility types

ts-adv.ts

// // // 1. Simple Types (premetive) string boolean number null undifiend symbol

// // // const title: string = "pouriya";
// // // const isActive: boolean = true;
// // // const Age: number = 5;
// // // const NullValue: null = null;
// // // const UndeifiendValue: undefined = undefined;

// // // // type zadegi !!!!!! magr dar yek halat

// // // //  expilict typing
// // // const name2: string = "pouriya"; // ts => type prediction implicit typing

// // // ************Jaee Be Man Type Bede Ke Prediction Man Drost Tashkhis Nemidahd !!!******************
// // // const onSubmit = (data: number) => {
// // //   console.log(data);
// // // };

// // // Special Types

// // // any ts:(man natoonestm tashkhis bedm ke type to chie )
// // // any => ts (disable)
// // // any => ts (disable) => type check nmikone
// // // let x: any = "ali";
// // // x = 5;
// // // console.log(x);

// // // unkonwn
// // // let x: unknown = "ali";
// // // x = 5;
// // // console.log(x);

// // // never

// // // let x2: never;
// // // console.log(x2); // exception throw mikonad !!!!

// // // any vs unkonwn vs never

// // // any => disable sho
// // // unkonwn va never type ++

// // // non premetive

// // // array object function class [Object]

// // // const names: string[] = ["ali", "mohammad"];
// // // const names2: number[] = [1, 2, 3, 4];
// // // const names23: boolean[] = [true, false];

// // // const person: {
// // //   name: string;
// // //   age: number;
// // // } = {
// // //   name: "ali",
// // //   age: 10
// // // };

// // // function Sum2(a: number, b: number): number {
// // //   return a + b;
// // // }
// // // const x = (a: number, b: number): number => a + b;
// // // console.log(Sum2(5, 6));

// // // function onLogin(): void {
// // //   console.log("login ...");
// // // }
// // // const x = (a: number, b: number): void => {
// // //   console.log("login ...");
// // // };

// // // const names: readonly string[] = ["ali", "mohammad"];
// // // Object.freeze(names);
// // // names.push("ali2");

// // // function add(a: number, b: number, ...rest: number[]) {
// // //   return a + b + rest.reduce((p, c) => p + c, 0);
// // // }

// // // const useState = (
// // //   intialState: string
// // // ): [string, (newState: string) => void] => {
// // //   let state: string = intialState;

// // //   function setState(newState: string): void {
// // //     state = newState;
// // //     // rerender fiber ++
// // //   }

// // //   return [state, setState]; // tuple
// // // };

// // // const [state,setState] = useState();

// // // union types

// // // const person: {
// // //   name: string;
// // //   age: number | string | null | undefined;
// // // } = {
// // //   name: "ali",
// // //   age: "twenty"
// // // };
// // // let name222: string | number = 10;
// // // name222 = "ali";
// // // const x: (string | number)[] = ["a", "b", 5];

// // // const props: {
// // //   name?: string;
// // //   age?: number;
// // // } = {};

// // export type Tree = {
// //   node: string;
// //   age: number;
// // };

// // export interface Person2 {
// //   name2: string;
// //   age2: number;
// // }

// // export interface Person extends Person2 {
// //   name: string;
// //   age: number;
// // }

// // type PropsType = {
// //   name?: string;
// //   age?: number;
// // } & Tree;

// // // const props: Person = {};

// // // const x: Person = {
// // //   name: "ali",
// // //   age: 20
// // // };

// // // const person = {
// // //   name: "pouriya",
// // //   age: 2,
// // //   country: 3
// // // };

// // // step besazim

// // // export enum Directive {
// // //   North = "North",
// // //   South = "South",
// // //   East = "East",
// // //   West = "West"
// // // }

// // // console.log(Directive.East);

// // // export enum RegisterFlow {
// // //   Challange,
// // //   Verify
// // // }

// // // export const Authentication = () => {
// // //   const [step, setstep] = usestate<RegisterFlow>(RegisterFlow.Challange);

// // //   setstep( RegisterFlow.Verify)
// // //   setstep( RegisterFlow.Challange)
// // //   return (() => {
// // //     switch (step) {
// // //       case RegisterFlow.Challange:
// // //         return <>Challange</>

// // //         case RegisterFlow.Verify:
// // //             return <>Verify</>
// // //       default:
// // //         break;
// // //     }
// // //   })();
// // // };

// // const name222: any = "aa";

// // jalase 2

// // factory
// class Car {
//   constructor() {}

//   static New(name: string) {
//     return new Car();
//   }

//   static New2() {
//     // 2 ta noon bekhr
//     return new Car();
//   }
// }

// // jalse 2

// // as

// let name2: unknown = 5;
// let name3: string = "";
// name3 = name2 as string;
// console.log(typeof name3);

// // class (access modifierha)

// interface Shape {
//   GetShape: () => number;
//   _shape: number;
// }

// class Car {
//   private readonly _type: string;
//   private readonly _color: string;
//   private readonly _name: string;
//   private readonly _year: number;
//   private constructor(type: string, color: string, name: string, year: number) {
//     this._type = type;
//     this._color = color;
//     this._name = name;
//     this._year = year;
//   }

//   public static New() {
//     return new Car("perayd", "red", "perayd", 1402);
//   }
// }

// const newCar = Car.New();

// // mashgh shab
// //abstract
// // protected private public internal
// // static
// // implement inhritance az yek abstract class dgr ham motale
// // abstract clss che frqi ba interface va class
// // 4 osol OOP inhritance abstraction polymorficm Encapsulation

// // Generic - polymorficm oop

// interface ApiResult<T> {
//   status: string;
//   statusCode: string;
//   data: T;
//   message: string;
// }

// export const fetchData = (): Promise<ApiResult<string[]>> => {
//   return fetch("felanja")
//     .then((res) => res.json())
//     .then((res) => res);
// };

// function useState<T>(intialState: T): [T, (newState: T) => void] {
//   let state = intialState;
//   function setState(newState: T) {
//     state = newState;
//   }
//   return [state, setState];
// }

// export const Button = () => {
//   const [state, setState] = useState<boolean>(false);
//   function handleClick() {
//     setState(true);
//   }

//   function handleBlur() {
//     setState(true);
//   }
// };

// // utility type ts

// interface Point {
//   name: string;
//   age: number;
// }

// const Score: Partial<Point> = {};

// interface Point2 {
//   name?: string;
//   age?: number;
// }

// const Score2: Required<Point> = {
//   age: 1,
//   name: ""
// };

// const keyValue = new Map();
// keyValue.set("token", "eyadlkkaspjkpdasjpsadj");

// const KeyValue2: Record<string, number[]> = {
//   token: [5],
//   token2: [10555]
// };

// KeyValue2["token"];

// interface Point22 {
//   name: string;
//   age: number;
//   nationailty: string;
//   country: string;
// }

// const nationailty: Omit<Point22, "name" | "age"> = {
//   country: "iran",
//   nationailty: "irani"
// };

// const nationailty2: Pick<Point22, "nationailty" | "country"> = {
//   country: "iran",
//   nationailty: "irani"
// };

// const nationailty23: Readonly<Point22> = {
//   country: "iran",
//   nationailty: "irani",
//   age: 20
// };

// nationailty23.age = 5;

// // Partial

// // Required

// interface Person {
//   name?: string;
//   age?: number;
// }

// type Partial2<T> = {
//   [P in keyof T]?: T[P]; // type mapping
// };

// type Required2<T> = {
//   [P in keyof T]-?: T[P]; // type mapping
// };

// const x: Required2<Person> = {};

// type LocalStorage = {
//   [p in string]: string;
// };

// import React from "react";

// declare module react {
//   interface useState<T> {
//     state: T;
//     setState: React.Dispatch<SetState<T>>;
//   }
// }