Funciones integradas en JavaScript

Este artículo explica las funciones predefinidas en JavaScript.

YouTube Video

Funciones integradas en JavaScript

JavaScript ofrece una variedad de funciones predefinidas, que son herramientas poderosas para crear programas de manera eficiente. Aquí, explicaremos en detalle las funciones predefinidas típicas en JavaScript. Al aprender los roles, usos y precauciones de cada función, podrás utilizar JavaScript de manera más efectiva.

¿Qué son las funciones integradas?

Las funciones predefinidas son funciones que se proporcionan como estándar en JavaScript. Estas funciones están diseñadas para ejecutar tareas específicas de manera concisa. Los programadores no tienen que implementarlas por su cuenta, lo que mejora la legibilidad y el mantenimiento del código.

Funciones integradas representativas

parseInt()

1// Convert string to integer
2console.log(parseInt("42"));      // Output: 42
3console.log(parseInt("42px"));    // Output: 42
4console.log(parseInt("0xF", 16)); // Output: 15
5console.log(parseInt("0xF"));     // Output: 15
6console.log(parseInt("px42"));    // Output: NaN

• parseInt() es una función que analiza una cadena y la convierte en un número entero. Si el comienzo de la cadena contiene un número, esa parte se devuelve como un número entero. También se puede especificar una base (radix) opcional.

• Si el comienzo de la cadena no contiene un número, devuelve NaN (Not-a-Number o no es un número). Además, si no se especifica una base, se usará la base decimal por defecto, pero si la cadena comienza con "0x", se interpretará como hexadecimal.

parseFloat()

1// Convert string to float
2console.log(parseFloat("3.14"));      // Output: 3.14
3console.log(parseFloat("3.14abc"));   // Output: 3.14
4console.log(parseFloat("42"));        // Output: 42

• parseFloat() analiza una cadena y la convierte en un número de punto flotante. Se usa al trabajar con números que incluyen un punto decimal.

• Al igual que parseInt(), si el comienzo de la cadena no es un número, devuelve NaN. Se caracteriza por analizar correctamente no solo la parte entera, sino también la parte decimal.

isNaN()

1console.log(isNaN(NaN));         // Output: true
2console.log(isNaN(42));          // Output: false
3console.log(isNaN("hello"));     // Output: true

• isNaN() determina si un valor dado es NaN. NaN (Not-a-Number o no es un número) representa un valor no válido como número.

• isNaN() también es válido para tipos de datos distintos a números, y por ejemplo, devuelve true si una cadena no se puede convertir en un número.

Number()

1console.log(Number("42"));        // Output: 42
2console.log(Number("3.14"));      // Output: 3.14
3console.log(Number("0xff"));      // Output: 255
4console.log(Number("abc"));       // Output: NaN

• Number() es una función que convierte cadenas u otros tipos de datos en un número. Devuelve NaN si se proporciona una cadena no numérica.

• A diferencia de parseInt() o parseFloat(), Number() considera que la conversión es inválida y devuelve NaN si la cadena contiene caracteres no numéricos.

String()

1console.log(String(42));           // Output: "42"
2console.log(String(3.14));         // Output: "3.14"
3console.log(String(true));         // Output: "true"
4console.log(String(null));         // Output: "null"
5console.log(String(undefined));    // Output: "undefined"

• String() es una función que convierte números y otros tipos de datos en cadenas de texto. String(42) devuelve la cadena de texto "42".
• Si el valor a convertir es null o undefined, devuelve las cadenas de texto "null" o "undefined", respectivamente.
• Es útil para manejar varios tipos de datos, como números, booleanos u objetos, convirtiéndolos en cadenas de texto.

Array

1const arr = Array(3);
2console.log(arr); // Output: [ <3 empty items> ]
3
4const arr2 = Array(1, 2, 3);
5console.log(arr2); // Output: [1, 2, 3]

• Array es un constructor utilizado para crear nuevos arreglos.
• Si hay un argumento, se interpreta como la longitud del arreglo y se crea un arreglo vacío.
• Si hay múltiples argumentos, se crea un arreglo con esos valores como sus elementos.

Array.isArray()

1console.log(Array.isArray([1, 2, 3])); // Output: true
2console.log(Array.isArray("not an array")); // Output: false

• Array.isArray() es un método que determina si el argumento es un arreglo.
• Devuelve true si el argumento es un arreglo, y false en caso contrario.

isFinite()

1console.log(isFinite(42));         // Output: true
2console.log(isFinite(Infinity));   // Output: false
3console.log(isFinite(NaN));        // Output: false

• isFinite() determina si un valor dado es finito. Devuelve true para números finitos y false en caso contrario (como para infinito o NaN).

• En JavaScript, Infinity y -Infinity representan infinito y son del tipo número, pero isFinite() considera el infinito como un valor no válido.

eval()

1let expression = "2 + 2";
2console.log(eval(expression));    // Output: 4
3
4console.log(eval("var x = 10; x * 2"));  // Output: 20

• eval() es una función que evalúa y ejecuta código JavaScript proporcionado como una cadena. Puedes ejecutar código JavaScript de forma dinámica.

• eval() es muy poderosa, pero representa un riesgo de seguridad, por lo que debe evitarse en el desarrollo real. Ejecutar código proporcionado externamente con eval() puede causar comportamientos inesperados y vulnerabilidades de seguridad.

encodeURI() / decodeURI()

1let url = "https://example.com/?name=John Doe&age=25";
2let encodedUrl = encodeURI(url);
3console.log(encodedUrl);
4// Output: https://example.com/?name=John%20Doe&age=25
5
6let decodedUrl = decodeURI(encodedUrl);
7console.log(decodedUrl);
8// Output: https://example.com/?name=John Doe&age=25

• encodeURI() es una función utilizada para codificar (convertir) caracteres que no pueden ser utilizados en una URL. Por otro lado, decodeURI() decodifica una URL codificada a su forma original.

• La codificación es particularmente importante al tratar con caracteres especiales. Por ejemplo, caracteres como espacios o & deben ser codificados para incluirse correctamente en una URL, por lo que deben procesarse adecuadamente utilizando encodeURI().

setTimeout() / setInterval()

 1// Execute a function after 2 seconds
 2setTimeout(() => {
 3    console.log("This runs after 2 seconds");
 4}, 2000);
 5
 6// Execute a function every 1 second
 7let intervalId = setInterval(() => {
 8    console.log("This runs every 1 second");
 9}, 1000);
10
11// Stop the interval after 5 seconds
12setTimeout(() => {
13    clearInterval(intervalId);
14}, 5000);

• setTimeout() es una función temporizadora utilizada para ejecutar una función una vez después de un tiempo especificado. setInterval() ejecuta una función repetidamente en intervalos especificados.

• setTimeout() y setInterval() se ejecutan de manera asincrónica, llamando a la función después del tiempo especificado. También es posible cancelar ejecuciones utilizando clearTimeout() o clearInterval().

Resumen

Utilizar las funciones integradas de JavaScript te permite escribir programas más simples y eficientes. Las funciones introducidas aquí son básicas y útiles en varias situaciones. Asegúrate de escribir código real y confirmar su comportamiento para profundizar tu comprensión.

Aprende procesamientos más complejos y el uso avanzado de funciones para mejorar aún más tus habilidades en 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