Sobrecarga de Funções em TypeScript

Às vezes, encontramos funções que retornam valores cujo tipo depende dos parâmetros passados. Para isso, no TypeScript, usa-se sobrecarga de funções. Ela permite especificar diferentes variantes de assinaturas para a função.

Vamos ver um exemplo. Suponha que temos uma função que divide os caracteres de uma string em um array de letras:

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

Suponha também que temos uma função que divide os dígitos de um número em um array de números:

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

Vamos combinar ambas as funções em uma. A nova função, dependendo do tipo do parâmetro, deve retornar ou um array de números ou um array de strings.

Vamos usar a sobrecarga para declarar diferentes assinaturas para nossa função:

function splitVal(val: number): number[];
function splitVal(val: string): string[] {
	// implementação de ambas as assinaturas
}

Agora, vamos escrever a implementação da função. Em seu código, devemos usar uma condição para determinar qual das assinaturas da função foi acionada e, dependendo disso, executar o código correspondente com o resultado do tipo correto:

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);
	}
}

Diferente de outras linguagens, no TypeScript a sobrecarga cria uma única função. Não é possível criar várias funções com o mesmo nome, mas com assinaturas diferentes.

Escreva uma função que irá retornar ou alterar o texto de um elemento DOM. Ela deve funcionar da seguinte maneira:

text('#elem', 'texto'); // define o texto
text('#elem');          // retorna o texto atual