Tipos de Dados no TypeScript

Este artigo explica os tipos de dados no TypeScript.

YouTube Video

Tipos de Dados no TypeScript

O TypeScript oferece uma variedade de tipos de dados. Isso permite que você defina tipos estritos para variáveis, argumentos de funções e valores de retorno. Abaixo estão os principais tipos de dados e seu uso.

Tipos Primitivos

Tipo number

1let age: number = 25;
2console.log(age);          // Outputs: 25
3console.log(typeof age);    // Outputs: number

• number é um tipo usado para lidar com valores numéricos, incluindo inteiros e números de ponto flutuante (decimais). Manipular valores que excedem certos limites resulta em Infinity ou NaN (Not-a-Number).

1// Decimal calculations
2console.log(0.1 + 0.2 === 0.3); // false
3console.log(0.1 + 0.2); // 0.30000000000000004
4
5// Calculations with large numbers
6console.log(9007199254740991 + 1); // correct value
7console.log(9007199254740991 + 2); // incorrect value

• No TypeScript, os números são representados como números de ponto flutuante. Isso pode resultar em pequenas imprecisões nos resultados dos cálculos.

• Quando cálculos precisos são necessários, como em valores financeiros, é necessário evitar erros de arredondamento como este. Por exemplo, você pode usar BigInt ou toFixed(), ou ajustar as casas decimais usando bibliotecas como decimal.js.

Tipo string

O tipo string lida com dados textuais.

1let greeting: string = "Hello, TypeScript!";
2console.log(greeting);     // Outputs: Hello, TypeScript!
3console.log(typeof greeting);  // Outputs: string

boolean (Tipo Lógico)

O tipo boolean possui dois valores: true ou false.

1let isOpen: boolean = true;
2console.log(isOpen);       // Outputs: true
3console.log(typeof isOpen);    // Outputs: boolean

null e undefined

null representa um 'valor inexistente', e undefined representa um 'valor indefinido'.

1let emptyValue: null = null;
2let notDefined: undefined = undefined;
3
4console.log(emptyValue);       // Outputs: null
5console.log(typeof emptyValue);    // Outputs: object (JavaScript specification)
6
7console.log(notDefined);       // Outputs: undefined
8console.log(typeof notDefined);    // Outputs: undefined

Array

No TypeScript, você pode especificar o tipo dos elementos de um array. number[] é um array de números, e string[] é um array de strings.

1let numbers: number[] = [1, 2, 3, 4];
2console.log(numbers);        // Outputs: [1, 2, 3, 4]
3console.log(typeof numbers); // Outputs: object
4
5let words: string[] = ["TypeScript", "JavaScript"];
6console.log(words);          // Outputs: ["TypeScript", "JavaScript"]
7console.log(typeof words);   // Outputs: object

Tupla

Uma tupla é um array com elementos de tipos diferentes.

1let person: [string, number] = ["Alice", 30];
2console.log(person);         // Outputs: ["Alice", 30]
3console.log(typeof person);  // Outputs: object

Enumeração

enum define um conjunto de constantes nomeadas.

1enum Color {
2    Red,
3    Green,
4    Blue
5}
6
7let favoriteColor: Color = Color.Green;
8console.log(favoriteColor);  // Outputs: 1 (Defaults start from 0)
9console.log(typeof favoriteColor); // Outputs: number

any

O tipo any pode armazenar qualquer tipo de valor e é usado quando você deseja desativar a verificação de tipo.

1let anything: any = "Hello";
2console.log(anything);       // Outputs: Hello
3console.log(typeof anything);    // Outputs: string
4
5anything = 42;
6console.log(anything);       // Outputs: 42
7console.log(typeof anything);    // Outputs: number

Tipo de União

Usando tipos de união, você pode definir variáveis que podem conter um dentre vários tipos.

1let identifier: number | string = "ID_12345";
2console.log(identifier);     // Outputs: ID_12345
3console.log(typeof identifier);  // Outputs: string
4
5identifier = 12345;
6console.log(identifier);     // Outputs: 12345
7console.log(typeof identifier);  // Outputs: number

Resumo

• number, string, boolean: Tipos primitivos.
• null, undefined: Valores especiais.
• Array: Um array com anotações de tipo.
• Tuple: Um array com elementos de diferentes tipos.
• enum: Um tipo enumerado.
• any: Qualquer tipo.
• Union: Uma variável que pode assumir um de vários tipos.

Ao utilizar esses tipos de dados, o TypeScript melhora a segurança de tipos, tornando mais fácil prevenir erros durante o desenvolvimento.

Objetos Wrapper

Wrapper Objects no TypeScript são objetos criados automaticamente para tratar tipos de dados primitivos como objetos. Os tipos primitivos permitem operações leves e rápidas, enquanto os tipos de objeto possuem métodos e propriedades, permitindo operações mais ricas.

No JavaScript (e TypeScript), existem objetos wrapper correspondentes a tipos primitivos como string, number e boolean. Eles são criados usando funções construtoras chamadas String, Number e Boolean, respectivamente.

Abaixo estão exemplos de objetos wrapper.

Objeto String

O objeto String fornece propriedades e métodos para strings.

1let strPrimitive: string = "Hello, World!";
2let strObject: String = new String("Hello, World!");
3
4console.log(strPrimitive);         // Outputs: Hello, World!
5console.log(typeof strPrimitive);  // Outputs: string
6
7console.log(strObject);            // Outputs: [String: 'Hello, World!']
8console.log(typeof strObject);     // Outputs: object

Recursos:

• Ao contrário do string primitivo, um objeto String é tratado como object pelo typeof.
• Objetos wrapper são úteis ao manipular strings ou chamar métodos nelas.

Objeto Number

O objeto Number fornece propriedades e métodos para números.

1let numPrimitive: number = 42;
2let numObject: Number = new Number(42);
3
4console.log(numPrimitive);         // Outputs: 42
5console.log(typeof numPrimitive);  // Outputs: number
6
7console.log(numObject);            // Outputs: [Number: 42]
8console.log(typeof numObject);     // Outputs: object

Recursos:

• O objeto Number, como um wrapper para números, inclui métodos para operações numéricas (por exemplo, toFixed).

Objeto Boolean

O objeto Boolean fornece propriedades e métodos para valores booleanos.

1let boolPrimitive: boolean = true;
2let boolObject: Boolean = new Boolean(true);
3
4console.log(boolPrimitive);        // Outputs: true
5console.log(typeof boolPrimitive); // Outputs: boolean
6
7console.log(boolObject);           // Outputs: [Boolean: true]
8console.log(typeof boolObject);    // Outputs: object

Recursos:

• O objeto Boolean é um wrapper para o tipo primitivo boolean e é tratado como object.

Diferenças entre Objetos Wrapper e Tipos Primitivos

Como os objetos wrapper são tratados como objetos, há uma leve redução de desempenho, mas mais operações funcionais são possíveis devido às propriedades e métodos adicionados. Além disso, existem diferenças na comparação usando == e ===.

1let numPrimitive: number = 123;
2let numObject: Number = new Number(123);
3
4console.log('==  : ', numPrimitive == numObject);  // Outputs: true (Value comparison)
5console.log('=== : ', numPrimitive === numObject); // Outputs: false (Due to differing types)

Recursos:

• == compara valores, enquanto === compara estritamente, incluindo os tipos. === retorna false ao comparar objetos wrapper com tipos primitivos.

Conversão de Tipos

No TypeScript, é importante gerenciar adequadamente as conversões de tipos implícitas e explícitas.

Conversão Implícita de Tipos

• No TypeScript, as conversões implícitas de tipos devem ser evitadas sempre que possível para garantir a segurança dos tipos.

1const result: string = 5 + "5"; // "55" (the number is converted to a string)
2
3console.log(result);

• Neste exemplo, o número 5 é implicitamente convertido para uma string, resultando na string "55".

Conversão Explícita de Tipos

• No TypeScript, use anotações de tipo ou funções de conversão de tipos para realizar conversões com segurança.

1const num: string = "123";
2const convertedNum: number = Number(num); // Converts "123" to the number 123
3
4console.log(typeof num);
5console.log(typeof convertedNum);

• Neste exemplo, a função Number() é usada para converter explicitamente a string "123" no número 123.

Verificação de Tipos

No TypeScript, você pode usar o operador typeof para verificar o tipo de dado de uma variável.

 1// Output: The type of 42 is: number
 2console.log('The type of 42             is:', typeof 42);
 3
 4// Output: The type of 42 is: bigint
 5console.log('The type of 42n            is:', typeof 42n);
 6
 7// Output: The type of "hello" is: string
 8console.log('The type of "hello"        is:', typeof "hello");
 9
10// Output: The type of true is: boolean
11console.log('The type of true           is:', typeof true);
12
13// Output: The type of undefined is: undefined
14console.log('The type of undefined      is:', typeof undefined);
15
16// Output: The type of null is: object
17console.log('The type of null           is:', typeof null);
18
19// Output: The type of Symbol() is: symbol
20console.log('The type of Symbol()       is:', typeof Symbol());
21
22// Output: The type of {} is: object
23console.log('The type of {}             is:', typeof {});
24
25// Output: The type of function () {} is: function
26console.log('The type of function () {} is:', typeof function () {});

• No TypeScript, você pode usar typeof para verificar tipos, mas para uma verificação de tipos mais precisa, também é recomendado usar os operadores instanceof ou is.

Resumo

• Objetos Wrapper são tratados como objetos porque fornecem métodos e propriedades adicionais para tipos primitivos.
• String, Number e Boolean são exemplos representativos de objetos wrapper.
• Ao contrário dos tipos primitivos, os objetos wrapper são identificados como object pelo typeof.

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