Retorno de funciones en TypeScript

En programación, una función puede devolver un valor después de ejecutar su bloque de código. Este valor se llama “retorno” de la función.

En TypeScript, se puede especificar el tipo de retorno de una función para asegurarse de que la función devuelve el tipo de dato esperado. Esto ayuda a prevenir errores y mejora la legibilidad del código.

La sintaxis básica para definir una función con un tipo de retorno en TypeScript es la siguiente:

function nombreFuncion(parametros): tipoDeRetorno {
    // cuerpo de la función
    return valor;
}

Por ejemplo, una función que suma dos números y devuelve el resultado como un número (number):

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

En este caso, number es el tipo de retorno de la función sumar.

Tipos de retorno primitivos

TypeScript permite especificar tipos de retorno primitivos (como number, string, boolean, etc).

Aquí hay algunos ejemplos:

function obtenerNombre(): string {
    return "Juan";
}

function esMayorDeEdad(edad: number): boolean {
    return edad >= 18;
}

Tipos de retorno complejos

Además de los tipos primitivos, las funciones en TypeScript también pueden devolver tipos complejos (como objetos, arrays, o tuplas).

Objetos

function crearPersona(nombre: string, edad: number): { nombre: string; edad: number } {
    return { nombre, edad };
}

const persona = crearPersona("Ana", 25);
console.log(persona); // { nombre: 'Ana', edad: 25 }

Arrays

function obtenerNumeros(): number[] {
    return [1, 2, 3, 4, 5];
}

const numeros = obtenerNumeros();
console.log(numeros); // [1, 2, 3, 4, 5]

Tipos Personalizados

TypeScript también permite devolver tipos personalizados, como los creados mediante type o interface.

type Persona = {
    nombre: string;
    edad: number;
};

function crearPersona(nombre: string, edad: number): Persona {
    return { nombre, edad };
}

const persona = crearPersona("Carlos", 30);
console.log(persona); // { nombre: 'Carlos', edad: 30 }

Funciones que no retornan valores

En TypeScript, si una función no devuelve ningún valor, se utiliza el tipo void como tipo de retorno. Esto es útil para funciones que solo realizan acciones y no necesitan devolver un valor.

function saludar(nombre: string): void {
    console.log(`Hola, ${nombre}`);
}

saludar("María"); // Hola, María

Retornos opcionales

A veces, una función puede devolver un valor opcionalmente. Es decir, puede devolver un valor o undefined. En estos casos, se puede usar una unión de tipos (type union).

function encontrarElemento(arr: number[], valor: number): number | undefined {
    return arr.find((el) => el === valor);
}

const resultado = encontrarElemento([1, 2, 3], 2);
console.log(resultado); // 2

const resultadoInexistente = encontrarElemento([1, 2, 3], 4);
console.log(resultadoInexistente); // undefined