Funções Integradas no JavaScript

Este artigo explica as funções integradas no JavaScript.

YouTube Video

Funções Integradas no JavaScript

O JavaScript oferece uma variedade de funções integradas, que são ferramentas poderosas para criar programas de forma eficiente. Aqui, explicaremos em detalhes as funções integradas típicas do JavaScript.

O que São Funções Integradas?

Funções Integradas são funções fornecidas como padrão no JavaScript. Essas funções são projetadas para executar tarefas específicas de forma concisa. Os programadores não precisam implementá-las de forma independente, o que melhora a legibilidade e a manutenção do código.

Funções 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() é uma função que analisa uma string e a converte em um número inteiro. Se o início da string contiver um número, essa parte será retornada como um número inteiro. Uma base (radix) opcional também pode ser especificada.

• Se o início da string não contiver um número, ela retornará NaN (Not-a-Number). Além disso, se uma base não for especificada, ela é assumida como decimal, mas se a string começar com "0x", ela é interpretada 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() analisa uma string e a converte em um número de ponto flutuante. Ela é usada ao lidar com números que incluem um ponto decimal.

• Assim como parseInt(), se o início da string não for um número, retorna NaN. É caracterizada por analisar corretamente não apenas a parte inteira, mas também a parte decimal.

isNaN()

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

• isNaN() determina se um valor fornecido é NaN. NaN (Not-a-Number) representa um valor inválido como número.

• isNaN() também é válido para tipos de dados além de números e, por exemplo, retorna true se uma string não puder ser convertida em um 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
5
6console.log(parseFloat("3.14abc"));  // Output: 3.14
7console.log(Number("3.14abc"));      // Output: NaN

• Number() é uma função que converte strings ou outros tipos de dados em um número. Ele retorna NaN se uma string não numérica for fornecida.

• Ao contrário de parseInt() ou parseFloat(), Number() considera isso uma conversão inválida e retorna NaN se a string contiver caracteres não 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() é uma função que converte números e outros tipos de dados em strings. String(42) retorna a string "42".
• Se o valor a ser convertido for null ou undefined, ele retorna respectivamente as strings "null" ou "undefined".
• É útil para manipular vários tipos de dados, como números, booleanos ou objetos, convertendo-os em strings.

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 é um construtor usado para criar novos arrays.
• Se houver um argumento, ele será tratado como o comprimento do array e um array vazio será criado.
• Se houver vários argumentos, um array com esses valores como seus elementos será criado.

Array.isArray()

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

• Array.isArray() é um método que verifica se o argumento é um array.
• Ele retorna true se o argumento for um array e false caso contrário.

isFinite()

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

• isFinite() determina se um valor fornecido é finito. Retorna true para números finitos e false caso contrário (como para infinito ou NaN).

• Em JavaScript, Infinity e -Infinity representam infinito e são do tipo número, mas isFinite() considera infinito como um valor inválido.

eval()

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

• eval() é uma função que avalia e executa código JavaScript fornecido como uma string. Você pode executar código JavaScript dinamicamente.

• eval() é muito poderoso, mas representa um risco de segurança, por isso deve ser evitado no desenvolvimento real. Executar código fornecido externamente com eval() pode levar a comportamentos indesejados e vulnerabilidades de segurança.

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() é uma função usada para codificar (converter) caracteres que não podem ser usados em uma URL. Por outro lado, decodeURI() decodifica uma URL codificada para sua forma original.

• A codificação é particularmente importante ao lidar com caracteres especiais. Por exemplo, caracteres como espaços ou & precisam ser codificados para serem incluídos corretamente em uma URL, então devem ser processados adequadamente usando 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() é uma função de temporizador usada para executar uma função uma vez após um tempo especificado. setInterval() executa repetidamente uma função em intervalos especificados.

• setTimeout() e setInterval() são executados de forma assíncrona, chamando a função após o tempo especificado. Também é possível cancelar execuções usando clearTimeout() ou clearInterval().

Resumo

Utilizar as funções internas do JavaScript permite escrever programas mais simples e eficientes. As funções introduzidas aqui são básicas e úteis em várias situações.

Você pode acompanhar o artigo acima usando o Visual Studio Code em nosso canal do YouTube. Por favor, confira também o canal do YouTube.

YouTube Video