TypeScript Hello World of Generics

In this article, we will learn about Hello World of Generics in Typescript. Generics allows a user to write the code and make reusable components which further ensures the scalability and flexibility of the program or the code for a long time. “Hello World” of generics is the identity function that will return whatever is passed in. We define a generic identity function identity<T>(arg: T) that takes an argument of any type T and returns it as is. We call the identity function with different types of arguments and assign the results to variables of corresponding types.

Syntax

function functionName<T>(paramName: T): T {
    // Function implementation here
    return paramName;
}

Where,

• functionName: This is the name you choose for your generic function.
• <T>: This is the generic type parameter declaration, enclosed in angle brackets (<>). T is a placeholder for the specific type that will be determined when the function is called.
• paramName: This is the name of the function parameter. You can name it anything you like; it represents the argument that will be passed to the function.
• T: This indicates the type of the parameter and return value. In this example, it's used for both the parameter and return value, but they could be different types depending on your function's logic.

Parameter

• T: This represents the generic type parameter. It can be any valid type identifier, like T, U, A, or any meaningful name you choose.

Return Type

It returns the type of argument to the identity function. The function needs to accept any and all types for the type of arg, while implementing any as type.

When you call the generic function, TypeScript infers or you explicitly specify the actual type for T, and the function operates with that type. The benefit of generics is that it allows you to write reusable functions that work with different data types while maintaining type safety.

Example 1: In this example: We define a generic identity function identity<T>(arg: T) that takes an argument of any type T and returns it as is. We call the identity function with different types of arguments and assign the results to variables of corresponding types.

// Define a generic identity function
function identity<T>(arg: T): T {
    return arg;
}

// Call the identity function
// with different types
let str: string = identity("Hello, World!");
let num: number = identity(42);
let arr: number[] = identity([1, 2, 3]);
let obj: { name: string } = 
    identity({ name: "Alice" });

console.log(str); // Outputs: Hello, World!
console.log(num); // Outputs: 42
console.log(arr); // Outputs: [1, 2, 3]
console.log(obj); // Outputs: { name: 'Alice' }

Output:

"Hello, World!" 
42 
[1, 2, 3] 
{ "name": "Alice" } 

Example 2: In this example, we define the generic identity function identity<T>(arg: T) as before. We call the identity function with different types of arguments and assign the results to variables of corresponding types.

// Define a generic identity function
function identity<T>(arg: T): T {
    return arg;
}

// Call the identity function
// with different types
let result1: string = 
    identity("Hello, Generics!");
let result2: number = identity(42);
let result3: boolean[] = 
    identity([true, false, true]);

console.log(result1); // Outputs: Hello, Generics!
console.log(result2); // Outputs: 42
console.log(result3); // Outputs: [true, false, true]

Output

Hello, Generics!
42
[true, false, true]

Reference: https://www.typescriptlang.org/docs/handbook/2/generics.html#hello-world-of-generics