Funciones integradas en TypeScript

Este artículo explica funciones integradas en TypeScript.

YouTube Video

Funciones integradas en TypeScript

Las funciones integradas en TypeScript son funciones convenientes que permiten realizar operaciones cotidianas de manera concisa. Estas son funciones estándar de JavaScript con seguridad de tipos añadida, lo que las hace particularmente útiles al programar en TypeScript. Aquí explicaremos en detalle algunas funciones integradas importantes, su uso y especificación de tipos.

¿Qué son las funciones integradas?

Las funciones integradas de TypeScript se basan en funciones estándar de JavaScript. Aplicar el sistema de tipos de TypeScript mejora la verificación de tipos y el autocompletado. Las funciones principales incluyen las siguientes:.

• parseInt()
• parseFloat()
• isNaN()
• isFinite()
• Number()
• String()
• Array()
• Array.isArray()
• eval()
• encodeURI()
• decodeURI()
• setTimeout()
• setInterval()

Estas funciones son ampliamente utilizadas en proyectos de TypeScript para conversión y evaluación de datos de manera concisa.

parseInt()

parseInt() es una función utilizada para convertir una cadena en un número entero. Puedes especificar la base (como binario, decimal) como segundo argumento. En TypeScript, puedes especificar el tipo de la siguiente manera:.

 1function stringToInt(value: string, radix: number = 10): number {
 2    const result: number = parseInt(value, radix);
 3    if (isNaN(result)) {
 4        throw new Error('Invalid number format');
 5    }
 6    return result;
 7}
 8
 9console.log(stringToInt("42")); // 42
10console.log(stringToInt("101010", 2)); // 42 (converted from binary)

• Especifica que la entrada es una cadena con value: string
• El valor de retorno se especifica explícitamente como del tipo number.

parseFloat()

parseFloat() es una función utilizada para convertir una cadena en un número de punto flotante.

 1function stringToFloat(value: string): number {
 2    const result: number = parseFloat(value);
 3    if (isNaN(result)) {
 4        throw new Error('Invalid number format');
 5    }
 6    return result;
 7}
 8
 9console.log(stringToFloat("3.14")); // 3.14
10console.log(stringToFloat("2.71828")); // 2.71828

• parseFloat() puede analizar correctamente números que incluyan puntos decimales.
• Al especificar el tipo, puedes recibir una advertencia durante la verificación de tipos si la entrada no es un número.

isNaN()

isNaN() es una función que determina si el valor dado es NaN (No es un Número). Un ejemplo de uso en TypeScript es el siguiente:.

1function checkNaN(value: unknown): boolean {
2    return isNaN(Number(value));
3}
4
5console.log(checkNaN("hello")); // true
6console.log(checkNaN(123)); // false

• El tipo unknown es un tipo genérico que puede aceptar cualquier tipo.
• Convierte a un número usando la función Number() y verifica si el resultado es NaN.

isFinite()

isFinite() determina si un valor es finito.

1function isValueFinite(value: unknown): boolean {
2    return isFinite(Number(value));
3}
4
5console.log(isValueFinite("100")); // true
6console.log(isValueFinite(Infinity)); // false

• Esta función también utiliza Number() para convertir el valor a un número antes de determinar.

Number()

La función Number() convierte cadenas o valores booleanos en números.

1function convertToNumber(value: string | boolean): number {
2    return Number(value);
3}
4
5console.log(convertToNumber("42")); // 42
6console.log(convertToNumber(true)); // 1

• En este ejemplo, se utiliza un tipo de unión string | boolean para especificar que el argumento es una cadena o un valor booleano.

String()

La función String() convierte números o valores booleanos en cadenas.

1function convertToString(value: number | boolean): string {
2    return String(value);
3}
4
5console.log(convertToString(123)); // "123"
6console.log(convertToString(false)); // "false"

• En este ejemplo, se crea una función que acepta una unión del tipo number | boolean y convierte el resultado en una cadena.

Array()

La función Array() se usa para crear un nuevo arreglo. Además, proporciona muchos métodos útiles para crear subarreglos a partir de arreglos existentes o extraer elementos específicos.

 1function createArray(): Array<number> {
 2    return Array(1, 2, 3, 4, 5); // 新しい配列を作成
 3}
 4
 5function getSubArray(array: Array<number>): Array<number> {
 6    return array.slice(1, 4); // サブ配列を作成
 7}
 8
 9const numbers = createArray();
10console.log(numbers); // [1, 2, 3, 4, 5]
11
12const subArray = getSubArray(numbers);
13console.log(subArray); // [2, 3, 4]

• Este ejemplo demuestra cómo crear un nuevo arreglo usando la función Array() y crear un subarreglo usando el método slice().

Array.isArray()

Array.isArray() determina si el valor dado es un array.

1function checkArray(value: unknown): boolean {
2    return Array.isArray(value);
3}
4
5console.log(checkArray([1, 2, 3])); // true
6console.log(checkArray("Not an array")); // false

• Usando el tipo unknown, aceptamos cualquier tipo mientras verificamos si es un array.

eval()

La función eval() evalúa una cadena como una expresión y devuelve el resultado. Sin embargo, no se recomienda su uso debido a riesgos de seguridad y rendimiento.

1function evaluateExpression(expression: string): any {
2    return eval(expression);
3}
4
5console.log(evaluateExpression("2 + 3")); // 5
6console.log(evaluateExpression("'Hello ' + 'World!'")); // "Hello World!"

• En este ejemplo, una expresión proporcionada como una cadena es evaluada usando eval, y se muestra el resultado.

encodeURI()

La función encodeURI() codifica toda la URL y escapa ciertos caracteres.

1const uri = "https://example.com/page?name=John Doe&age=30";
2const encodedURI = encodeURI(uri);
3
4console.log(encodedURI); // "https://example.com/page?name=John%20Doe&age=30"

• Este ejemplo convierte los espacios en %20 para generar una URL segura.

decodeURI()

La función decodeURI() decodifica una URL codificada de vuelta a su formato original.

1const encodedURI = "https://example.com/page?name=John%20Doe&age=30";
2const decodedURI = decodeURI(encodedURI);
3
4console.log(decodedURI); // "https://example.com/page?name=John Doe&age=30"

• Este ejemplo decodifica una cadena de URL codificada de vuelta a la URL original.

setTimeout()

La función setTimeout() ejecuta una función especificada después del tiempo de retraso dado (en milisegundos).

1setTimeout(() => {
2    console.log("Executed after 2 seconds");
3}, 2000);

• Este ejemplo muestra un mensaje después de 2 segundos.

setInterval()

La función setInterval() ejecuta repetidamente una función especificada en el intervalo especificado (en milisegundos).

1let count = 0;
2const intervalId = setInterval(() => {
3    count++;
4    console.log(`Interval executed ${count} time(s)`);
5    if (count === 3) {
6        clearInterval(intervalId); // Stops the interval after 3 executions
7    }
8}, 1000);

• Este ejemplo muestra un mensaje a intervalos de un segundo y se detiene después de ser ejecutado tres veces.

Conclusión

Las funciones integradas de TypeScript permiten una codificación más segura y eficiente al agregar tipos de seguridad a las funciones estándar de JavaScript. Estas funciones simplifican las tareas de programación diaria y mejoran la legibilidad y el mantenimiento del código. Cada función se utiliza correctamente según su propósito, y especificar tipos permite detectar errores de antemano, desempeñando un papel importante en la mejora de la fiabilidad del proceso de desarrollo.

Al usar TypeScript, el desarrollo puede beneficiarse de la tipificación estática mientras aprovecha la flexibilidad de JavaScript.

Puedes seguir el artículo anterior utilizando Visual Studio Code en nuestro canal de YouTube. Por favor, también revisa nuestro canal de YouTube.

YouTube Video