Sobrecarga de funciones en TypeScript

A veces nos encontramos con funciones que retornan valores cuyo tipo depende de los parámetros pasados. Para esto en TypeScript se utiliza la sobrecarga de funciones. Esta permite especificar diferentes variantes de firmas de la función.

Veamos un ejemplo. Supongamos que tenemos una función que divide los caracteres de una cadena en un array de letras:

function splitStr(str: string): string[] {
	return str.split('');
}

Supongamos también que tenemos una función que divide los dígitos de un número en un array de números:

function splitNum(num: number): number[] {
	let str: string = String(num);
	let arr: string[] = str.split('');
	
	return arr.map(elem => +elem);
}

Combinemos ambas funciones en una. La nueva función dependiendo del tipo del parámetro debe retornar un array de números o un array de cadenas.

Utilicemos sobrecarga para declarar diferentes firmas para nuestra función:

function splitVal(val: number): number[];
function splitVal(val: string): string[] {
	// implementación de ambas firmas
}

Escribamos ahora la implementación de la función. En su código debemos determinar con una condición cuál de las firmas de la función se activó, y dependiendo de esto ejecutar el código necesario con el resultado del tipo requerido:

function splitVal(val: number): number[];
function splitVal(val: string): string[] {
	if (typeof val === 'string') {
		return val.split('');
	} else {
		let str: string = String(val);
		let arr: string[] = str.split('');
		
		return arr.map((elem: string): number => +elem);
	}
}

A diferencia de otros lenguajes, en TypeScript en la sobrecarga se crea una sola función. No se puede crear múltiples funciones con un mismo nombre, pero con diferentes firmas.

Escriba una función que retorne o modifique el texto de un elemento DOM. Debe funcionar de la siguiente manera:

text('#elem', 'texto'); // establecerá el texto
text('#elem');          // retornará el texto actual