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. Ao aprender os papéis, usos e cuidados de cada função, você poderá utilizar o JavaScript de forma mais eficaz.

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

• 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. Certifique-se de escrever código real e confirmar seu comportamento para aprofundar sua compreensão.

Aprenda processamentos mais complexos e o uso avançado de funções para melhorar ainda mais suas habilidades em JavaScript.

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