Los parámetros en funciones de TypeScript ofrecen una flexibilidad extraordinaria que permite optimizar nuestro código y hacerlo más eficiente. Al dominar los diferentes tipos de parámetros, podemos crear métodos versátiles que se adapten a múltiples escenarios sin necesidad de duplicar código. Esta capacidad no solo mejora la legibilidad sino que también reduce significativamente el tiempo de desarrollo.
¿Cómo hacer que nuestras funciones sean más flexibles con parámetros especiales?
Cuando trabajamos con TypeScript, podemos hacer que nuestras funciones sean mucho más adaptables utilizando diferentes tipos de parámetros. Esto nos permite escribir menos código que realice más tareas, lo que resulta en aplicaciones más mantenibles y eficientes.
Los parámetros opcionales nos permiten definir argumentos que pueden o no ser proporcionados al llamar a una función. Para indicar que un parámetro es opcional, simplemente agregamos un signo de interrogación (?) después del nombre del parámetro.
"Buenos días, Amin!" (cuando sí proporcionamos el saludo)
La ventaja principal de los parámetros opcionales es que nos evitan tener que crear múltiples versiones de la misma función para manejar diferentes casos. Una sola función puede adaptarse a distintas situaciones dependiendo de los argumentos que reciba.
Parámetros múltiples: ¿Cómo manejar un número variable de argumentos?
Los parámetros múltiples (o rest parameters) nos permiten pasar un número indefinido de argumentos a una función. Se indican con tres puntos (...) antes del nombre del parámetro.
functionsumarTodos(...numeros:number[]):number{return numeros.reduce((acumulador, valor)=> acumulador + valor,0);}console.log(`El resultado de sumar todos es ${sumarTodos(1,2,3,4,5)}`);
Este código sumará todos los números proporcionados (1+2+3+4+5) y mostrará "El resultado de sumar todos es 15".
El método reduce utilizado en este ejemplo es una forma elegante de procesar todos los elementos de un array sin necesidad de utilizar un ciclo foreach. Este método va acumulando los valores a medida que recorre el array.
Los parámetros múltiples pueden resultar complicados al principio, pero con práctica se convierten en una herramienta muy poderosa para crear funciones flexibles que puedan manejar diferentes cantidades de datos.
Valores por defecto: ¿Cómo establecer valores predeterminados?
Los valores por defecto nos permiten asignar un valor predeterminado a un parámetro en caso de que no se proporcione ninguno al llamar a la función.
"Hasta luego, Amin" (sobrescribiendo el valor por defecto)
La diferencia clave entre los parámetros opcionales y los valores por defecto es que los primeros pueden no estar presentes, mientras que los segundos siempre tendrán un valor, ya sea el proporcionado o el predeterminado.
¿Por qué optimizar nuestras funciones con estos parámetros?
La implementación de estos tipos de parámetros en nuestras funciones nos permite:
Simplificar nuestro código: en lugar de escribir múltiples funciones para diferentes casos, podemos crear una sola función más versátil.
Optimizar el tiempo de desarrollo: menos código significa menos tiempo escribiendo y depurando.
Mejorar la legibilidad: un código más conciso es generalmente más fácil de entender y mantener.
Dominar estos conceptos en TypeScript nos ayuda a escribir código más elegante y eficiente, aprovechando al máximo las capacidades del lenguaje para crear aplicaciones robustas y mantenibles.
Los parámetros especiales en TypeScript son herramientas poderosas que todo desarrollador debería conocer y utilizar. ¿Has implementado alguno de estos tipos de parámetros en tus proyectos? ¿Cuál te ha resultado más útil? Comparte tu experiencia en los comentarios.
El titulo dice sobre carga de funciones y en ningún momento del video se toca este tema
📐 Sobrecarga de funciones en TypeScript
La sobrecarga de funciones nos permite declarar múltiples versiones de una misma función con diferentes firmas de entrada, pero una sola implementación.
🔹 Sintaxis:
Primero declaramos las firmas sobrecargadas.
Luego implementamos la función con lógica para cubrir todos los casos.
📌 Ejemplo clásico:
// Firmas de sobrecargafunctioncombinar(a: string,b: string): string;functioncombinar(a: number,b: number): number;// Implementación únicafunctioncombinar(a: string | number,b: string | number): string | number {if(typeof a ==="string"&&typeof b ==="string"){return a + b;// Concatenación}if(typeof a ==="number"&&typeof b ==="number"){return a + b;// Suma numérica}thrownewError("Tipos incompatibles");}console.log(combinar("Hola"," Mundo"));// "Hola Mundo"console.log(combinar(10,20));// 30```// Firmas de sobrecargafunctioncombinar(a: string,b: string): string;functioncombinar(a: number,b: number): number;// Implementación únicafunctioncombinar(a: string | number,b: string | number): string | number { if(typeof a ==="string"&&typeof b ==="string"){ return a + b;// Concatenación } if(typeof a ==="number"&&typeof b ==="number"){ return a + b;// Suma numérica } thrownewError("Tipos incompatibles");}console.log(combinar("Hola"," Mundo"));// "Hola Mundo"console.log(combinar(10,20));// 30⚠️ TypeScript**no permite múltiples implementaciones**, solo múltiples **firmas**.
Para la sobrecarga de funciones les dejo un ejemplo practico
type User={id: number; name: string };// Base de datos simuladaconstusers:User[]=[{id:1,name:"Osorio"},{id:2,name:"Daniela"}];// Firmas de sobrecargafunctionfindUser(query: number):User|undefined;functionfindUser(query: string):User|undefined;// ImplementaciónfunctionfindUser(query: number | string):User|undefined{if(typeof query ==="number"){return users.find(user=> user.id=== query);}else{return users.find(user=> user.name=== query);}}// Usoconsole.log(findUser(1));// { id: 1, name: "Osorio" }console.log(findUser("Daniela"));// { id: 2, name: "Daniela" }
Cual es la diferencia entre Funcion y Metodo?
A nivel práctico es lo mismo, pero técnicamente la diferencia es que un método pertenece a una clase, la función no.
Un tipo de dato primitivo es una categoría de datos básicos que no se pueden descomponer en otros tipos más simples. En programación, los tipos primitivos suelen incluir números (enteros y flotantes), cadenas de texto (strings), booleanos (true/false) y, a veces, caracteres. En TypeScript, estos tipos son fundamentales para la construcción de variables y funciones, permitiendo un manejo eficiente de los datos en las aplicaciones. Estos tipos son la base sobre la cual se construyen tipos más complejos, como objetos y arrays.
Mi aporte con un ejemplo de la función con parámetros múltiples, entendiendo que el array también puede ser de varios tipos:
const informacionPersona =(...elementos:(string | number | boolean)[]):void=>{ elementos.forEach((elemento)=>console.log(typeof elemento, elemento));}informacionPersona('Sofia',23,'Colombia',true);
El parámetro rest (...args) debe ir al final y solo puede haber uno:tsCopiarEditarfunction listarFrutas(principal: string, ...otras: string[]) {}
❌ Esto no está permitido:tsCopiarEditarfunction listarFrutas(...otras: string[], principal: string) {} // ❌ errorfunction listarFrutas(...a: string[], ...b: string[]) {} // ❌ error
TypeScript es hermoso cuando lo entiendes, ejemplo:
enumNumerosElegir{UNO=1,DOS=2,TRES=3,CUATRO=4,CINCO=5,}type Multiplicador={num1: number;num2:NumerosElegir;}functionsumarTodo(...nums:number[]):number {return nums.reduce((a, b)=> a + b,0);}functionMultiplicar(numero:Multiplicador):number {return numero.num1* numero.num2;}functiondecirNumero(resultado:number,fraseInicial: string ="El resultado es:", fraseFinal?: string):void{console.log(`${fraseInicial}${resultado}${fraseFinal ? fraseFinal :""}`);}const sumaTotal =sumarTodo(1,2,3,4,5,6,7,8,9,10,20)const multiTotal =Multiplicar({num1: sumaTotal,num2:NumerosElegir.CUATRO})const decirSuma =decirNumero(sumaTotal,"El resultado de la suma es:","y eso es todo");const decirMulti =decirNumero(multiTotal);
En TypeScript, la sobrecarga de funciones permite definir múltiples firmas para una función, pero solo una implementación real. Es útil para crear funciones que pueden recibir diferentes tipos o combinaciones de parámetros y devolver distintos resultados según el caso.
Ejemplo de sobrecarga de funciones en TypeScript
Explicación
// Firmas de la función
function saludar(nombre: string): string;
function saludar(nombres: string[]): string;
// Implementación de la función
function saludar(param: string | string[]): string {
if (typeof param === "string") {
return `¡Hola, ${param}!`;
} else {
return `¡Hola a todos: ${param.join(", ")}!`;
}
}
// Uso de la función
console.log(saludar("Juan")); // ¡Hola, Juan!
console.log(saludar(["Ana", "Luis"])); // ¡Hola a todos: Ana, Luis!
Es importante recordar que la implementación real de la función debe coincidir con las firmas declaradas, y que la lógica dentro de la función debe manejar correctamente los diferentes tipos de entrada.