Funções incorporadas no TypeScript

Este artigo explica as funções incorporadas no TypeScript.

YouTube Video

Funções incorporadas no TypeScript

As funções incorporadas no TypeScript são funções convenientes fornecidas para realizar operações do dia a dia de forma concisa. Estas são funções padrão do JavaScript com segurança de tipo adicional, tornando-as particularmente úteis ao programar em TypeScript. Aqui, explicaremos em detalhe algumas funções incorporadas importantes, seu uso e especificação de tipos.

O que são funções incorporadas?

As funções incorporadas do TypeScript são baseadas em funções padrão do JavaScript. Aplicar o sistema de tipos do TypeScript melhora a verificação de tipos e o autocompletar. As principais funções incluem as seguintes:.

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

Estas funções são amplamente utilizadas em projetos TypeScript para conversão e avaliação de dados de forma concisa.

parseInt()

parseInt() é uma função usada para converter uma string em um número inteiro. Você pode especificar a base (como binária ou decimal) como o segundo argumento. No TypeScript, você pode especificar o tipo da seguinte forma:.

 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)

• Especifique que a entrada é uma string com value: string
• O valor de retorno é explicitamente especificado como do tipo number.

parseFloat()

parseFloat() é uma função usada para converter uma string em um número de ponto flutuante.

 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() pode interpretar corretamente números, incluindo pontos decimais.
• Ao especificar o tipo, você pode receber um aviso durante a verificação de tipos caso a entrada não seja um número.

isNaN()

isNaN() é uma função que determina se o valor fornecido é NaN (Not-a-Number). Um exemplo de uso no TypeScript é o seguinte:.

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

• O tipo unknown é um tipo genérico que pode aceitar qualquer tipo.
• Converta para um número usando a função Number() e verifique se o resultado é NaN.

isFinite()

isFinite() determina se um valor é finito.

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

• Esta função também utiliza Number() para converter o valor em um número antes de determinar.

Number()

A função Number() converte strings ou valores booleanos em números.

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

• Neste exemplo, um tipo de união string | boolean é usado para especificar que o argumento é uma string ou um booleano.

String()

A função String() converte números ou valores booleanos em strings.

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

• Neste exemplo, é criada uma função que aceita uma união do tipo number | boolean e converte o resultado em uma string.

Array()

A função Array() é usada para criar um novo array. Além disso, oferece muitos métodos úteis para criar subarrays de arrays existentes ou extrair 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 exemplo demonstra como criar um novo array usando a função Array() e criar um subarray usando o método slice().

Array.isArray()

Array.isArray() determina se o valor fornecido é um 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 o tipo unknown, aceitamos qualquer tipo enquanto verificamos se é um array.

eval()

A função eval() avalia uma string como uma expressão e retorna o resultado. No entanto, seu uso não é recomendado devido a riscos de segurança e desempenho.

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

• Neste exemplo, uma expressão fornecida como string é avaliada usando eval, e o resultado é exibido.

encodeURI()

A função encodeURI() codifica todo o URL e escapa determinados 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 exemplo codifica espaços em %20 para gerar um URL seguro.

decodeURI()

A função decodeURI() decodifica um URL codificado de volta ao seu 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 exemplo decodifica uma string de URL codificada de volta ao URL original.

setTimeout()

A função setTimeout() executa uma função especificada após o tempo de atraso fornecido (em milissegundos).

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

• Este exemplo exibe uma mensagem após 2 segundos.

setInterval()

A função setInterval() executa repetidamente uma função especificada no intervalo definido (em milissegundos).

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 exemplo exibe uma mensagem em intervalos de um segundo e para após ser executado três vezes.

Conclusão

As funções integradas do TypeScript permitem uma codificação mais segura e eficiente ao adicionar segurança de tipo às funções padrão do JavaScript. Essas funções simplificam as tarefas de programação do dia a dia e melhoram a legibilidade e a manutenção do código. Cada função é usada corretamente de acordo com sua finalidade e, ao especificar tipos, é possível detectar erros com antecedência, desempenhando um papel importante na melhoria da confiabilidade do processo de desenvolvimento.

Ao usar o TypeScript, o desenvolvimento pode aproveitar a tipagem estática enquanto mantém a flexibilidade do 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