JIYIK CN >

TypeScript is a strongly typed language and it is always encouraged to define the types correctly for all variables used in TypeScript. These types can help in development later, especially during debugging.

In addition to variables, functions can also have a return type. Usually, when the type is not defined, the compiler automatically infers the type based on the type of the variable returned.

However, this is inconvenient and may result in less strict types like anyor even as return type, so it is better to return the type to a TypeScript function.undefined

returnUsing types for statements in TypeScript functions

If no type is mentioned, the TypeScript compiler automatically infers the return type. It is a good idea to add types to your functions to ensure that the correct types are passed through your application code.

Here's how to add types to a TypeScript function.

function addTwoNumbers( a : number, b : number) : number {
    return a + b;
}

console.log(addTwoNumbers(5,6));

Output:

11

So numberthe type has been added addTwoNumbersto the end of , so it indicates that addTwoNumbersthe return type of the function is numberof type . TypeScript supports unions and complex types as return types of functions.

The following example shows an example of type union as the return type of a function.

function conditionalAdd(a : number, b : number ) : number | string {
    if ( a + b > 20){
        return "more than 20!";
    } else {
        return a + b;
    }
}

console.log(conditionalAdd(3,21));

Output:

"more than 20!"

You can even use an interface as the return type of a function. Suppose you have a function that returns all configuration information.

It can be achieved as follows.

interface Config {
    logLevel : string,
    cache : boolean,
    dbUrl : string,
    password : string,
    production : boolean,
    version : number
}


function getConfig() : Config {
    return {
        logLevel : "debug",
        cache : true,
        dbUrl : "localhost:5432",
        password : "postgres",
        production : false,
        version : 2
    }
}

The benefit of using this approach is that you can return objects directly without declaring variables and get suggestions during development.

ReturnTypeGet the return type of a function in TypeScript using type

ReturnTypeTypes is useful to understand the type of a function which may or may not be written by a user as it may be in a third-party library. The following code snippet shows ReturnTypehow types can detect the return type.

function findStudentWithRoll(roll : number){
    const students : Student[] = [
        {
            name : 'Tintin',
            roll : 1,
            passed : true
        },
        {
            name : 'Haddock',
            roll : 2,
            passed : false
        },
        {
            name : 'Calculus',
            roll : 3,
            passed : true
        },
    ];
    return students.find( student => student.roll === roll) || null;
}


const studentRoll_1 : ReturnType<typeof findStudentWithRoll> = findStudentWithRoll(1);
if ( studentRoll_1 !== null){
    console.log(studentRoll_1);
}

Output:

 {
  "name": "Tintin",
  "roll": 1,
  "passed": true
}

Hence, ReturnType<typeof findStudentWithRoll>it is convenient to return <int> Student | nullfor further use in writing application logic.