Generic functions with arrays in Typescript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a generic function in TypeScript?

A generic function is a function that can work with any data type, allowing you to write flexible and reusable code by using type variables.

beginner

How do you declare a generic function that accepts an array of any type and returns the first element?

You declare it using a type parameter like <T> and use it for the array and return type: <br>

function firstElement<T>(arr: T[]): T | undefined {<br>  return arr[0];<br>}

intermediate

Why use generic functions with arrays instead of using 'any' type?

Generics keep type safety by preserving the type information, so you get better error checking and autocompletion, unlike 'any' which disables type checks.

beginner

What does this function do?<br>

function reverseArray<T>(arr: T[]): T[] {<br>  return arr.slice().reverse();<br>}

It takes an array of any type T, creates a copy of it, reverses the order of elements, and returns the reversed array without changing the original.

beginner

How can you call a generic function with an array of numbers to get the first element?

You can call it like this:<br><pre>const nums = [10, 20, 30];<br>const first = firstElement<number>(nums);<br>console.log(first); // Output: 10</pre>

What does the <T> mean in a TypeScript function declaration?

A It specifies the function is asynchronous.

B It is a syntax error.

C It means the function returns a string.

D It declares a generic type parameter.

The declares a generic type parameter that can be used inside the function for flexible typing.

What is the return type of this function?<br>

function getLast<T>(arr: T[]): T | undefined {<br>  return arr[arr.length - 1];<br>}

A T or undefined

B T[]

C void

D T

The function returns the last element of the array or undefined if the array is empty.

Why is it better to use generics instead of 'any' for array functions?

A Generics remove all type checks.

B Generics make the code slower.

C Generics keep type safety and help catch errors.

D Generics only work with numbers.

Generics preserve type information, so TypeScript can check types and prevent mistakes.

Which of these is a correct way to define a generic function that returns the length of an array?

A function length(arr: any): number { return arr.length; }

B function length<T>(arr: T[]): number { return arr.length; }

C function length(arr: T): number { return arr.length; }

D function length<T>(arr: T): T { return arr.length; }

Option B correctly uses a generic type parameter T for an array and returns a number.

What will this code output?<br>

function identity<T>(arr: T[]): T[] { return arr; }<br>console.log(identity(['a', 'b', 'c']));

A ['a', 'b', 'c']

B undefined

C Error

D ['c', 'b', 'a']

The function returns the same array it receives, so the output is ['a', 'b', 'c'].

Explain how to write a generic function in TypeScript that takes an array and returns its first element.

Think about how to keep the function flexible for any array type.

Describe the benefits of using generic functions with arrays instead of using the 'any' type.

Consider what happens when you lose type information.