Breaking News: Grepper is joining You.com. Read the official announcement!

typescript generic method & Utility Type

Sore Sardine answered on November 21, 2022 Popularity 4/10 Helpfulness 2/10

answer typescript generic method & Utility Type

related Typescript method generic type

typescript generic method & Utility Type

Comment

### Generic

# Get all datas

const getAllDatas = <T>(datas: T[]): T[] => {
    return datas.map((data) => data);
}


# Get all datas by Key

const getAllDataByKey = <T, K extends keyof T>(datas: T[], key: K): T[K][] => {
    return datas.map((data) => data[key])
}

##### -----------------------

### Utility Type

# Partial Utility Type :: Update property 

const updateProperty = <T>(assign: T, propsToUpdate: Partial<T>): T => {
    return {...assign, ...propsToUpdate}
};


# Required : Utility Type : Must have all property for : such as send data to Sever

const requiredAllProperties = <T>(assign: Required<T>): T => {
    return assign;
} 

console.log("$$$$$ Main ::: Line : 37 ::: " ,  requiredAllProperties(assign));

# Record : Utility Type :  Compound all Type property

type Students = "Sara" | "Kelly" | "Boie" | "Girl";
type LetterGrades = "A" | "B" | "C" | "D" | "U";

const finalGrades: Record<Students, LetterGrades> = {
    Kelly: "U",
    Sara: "A",
    Boie: "B",
    Girl: "C"
}

type Grades = {
    assign1: number,
    assign2: number
}

const gradeDatas: Record<Students, Grades> = {
    Boie: { assign1: 85, assign2: 83 },
    Kelly: { assign1: 72, assign2: 50 },
    Girl: { assign1: 82, assign2: 23 },
    Sara: { assign1: 73, assign2: 98 }
}


# Pick  : Utility Type :::: Pick only declared 

type AssignResult = Pick<Assignment, "studentId" | "grade">;

const score: AssignResult = {
    studentId: "K 123",
    grade: 82
};



# Omit : Utility Type ::::: Omit only declared 


type AssignPreview = Omit<Assignment, "grade" | "verified" >;

const preview: AssignPreview = {
    studentId: "K 123",
    title: "Final Project"
}



# Exclude : Utility Type :::: Not include declared property

type AdjustedGrade = Exclude<LetterGrades, "U">
const adjustedGrade: AdjustedGrade = "A";



# Extract : Utility Type :::: Include declared property

type HighGrades = Extract<LetterGrades, "A" | "B">
const highGrades: HighGrades = "A";

# Nonnullable : Utility Type ::::: Get only have value : Not null, undefined

type AllPossibleGrades = "Superman" | "Spider man" | "" | null | undefined;

type HasValue = NonNullable<AllPossibleGrades>;


# ReturnType : Utility Type :::::   

const createNewAssign = (title: string, points: number) => {
    return {title, points}
}

type NewAssign = ReturnType<typeof createNewAssign>

const  tsAssign: NewAssign = createNewAssign("UtilitY Type", 99999);
console.log("$$$$$ Main ::: Line : 117 ::: " ,  tsAssign);

# //  Parameters =>  type AssignParams = [title: string, points: number]

type AssignParams = Parameters<typeof createNewAssign>

const assignArgs: AssignParams = ["Generics", 100];
console.log("$$$$$ Main ::: Line : 124 ::: AssignArgs: " ,  assignArgs);


const tsAssign2: NewAssign = createNewAssign(...assignArgs)
console.log("$$$$$ Main ::: Line : 126 ::: tsAssign2: " ,  tsAssign2);


# Awaited  // help us with the ReturnType of a Promised

type User = {
    id: number,
    name: string,
    username: string,
    email: string
}

const fetchedUsers = async (): Promise<User[]> => {
    const data = await fetch('https://jsonplaceholder.typicode.com/users').then((res) => {
        return res.json();
    }).catch((err) => {
        if (err instanceof Error) console.log("$$$$$ Main ::: Line : 144 ::: " ,  err.message);
        
    })
    return data;
}

type FetchUsersReturnType = Awaited<ReturnType<typeof fetchedUsers>>

fetchedUsers().then((users) => console.log("$$$$$ Main ::: Line : 152 ::: " ,  users));

Popularity 4/10 Helpfulness 2/10 Language typescript

Source: Grepper

Tags: generic-method typescript utility

Link to this answer
Share Copy Link

Contributed on Jan 02 2023

Sore Sardine

0 Answers Avg Quality 2/10

Closely Related Answers

Typescript method generic type

Comment

function identity<Type>(arg: Type): Type {
  return arg;
}
 
let myIdentity: <Input>(arg: Input) => Input = identity;

Popularity 10/10 Helpfulness 2/10 Language typescript

Source: www.typescriptlang.org

Tags: typescript t

Link to this answer
Share Copy Link

Contributed on Nov 21 2022

Pleasant Pigeon

0 Answers Avg Quality 2/10

typescript generic method & Utility Type

Contents

More Related Answers

typescript generic method & Utility Type

Closely Related Answers

Typescript method generic type

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.