Scribd
Carregar
31 visualizações5 páginas

Type

O TypeScript é uma linguagem de programação que adiciona recursos de tipagem estática ao JavaScript, permitindo detectar erros de tipo mais cedo e produzir código mais robusto.

Enviado por

vitor zarde
Direitos autorais
© © All Rights Reserved
Levamos muito a sério os direitos de conteúdo. Se você suspeita que este conteúdo é seu, reivindique-o aqui.
Formatos disponíveis
Baixe no formato PDF, TXT ou leia on-line no Scribd
31 visualizações5 páginas

Type

O TypeScript é uma linguagem de programação que adiciona recursos de tipagem estática ao JavaScript, permitindo detectar erros de tipo mais cedo e produzir código mais robusto.

Enviado por

vitor zarde
Direitos autorais
© © All Rights Reserved
Levamos muito a sério os direitos de conteúdo. Se você suspeita que este conteúdo é seu, reivindique-o aqui.
Formatos disponíveis
Baixe no formato PDF, TXT ou leia on-line no Scribd
Você está na página 1/ 5

Introdução ao TypeScript:

O TypeScript é uma linguagem de programação desenvolvida pela Microsoft que é uma extensão do
JavaScript. Ele adiciona recursos de tipagem estática ao JavaScript, o que permite aos
desenvolvedores detectar erros mais cedo e obter um código mais robusto.

Com o TypeScript, é possível declarar explicitamente os tipos das variáveis, argumentos de função e
retornos de função. Essas informações de tipo ajudam a evitar erros comuns, como passar o tipo
errado de dado para uma função ou acessar propriedades inexistentes em um objeto.

Aqui está um exemplo simples que mostra a diferença entre JavaScript e TypeScript:

```javascript

// JavaScript

function greet(name) {

return "Hello, " + name;

console.log(greet("John")); // Saída: Hello, John

console.log(greet(42)); // Saída: Hello, 42

```

No código acima, a função `greet` pode receber qualquer tipo de argumento. O JavaScript não impõe
restrições em relação aos tipos. Como resultado, podemos passar tanto uma string quanto um
número como argumento.

Agora, vamos reescrever esse código em TypeScript:

```typescript

// TypeScript

function greet(name: string): string {

return "Hello, " + name;


}

console.log(greet("John")); // Saída: Hello, John

console.log(greet(42)); // Erro de compilação: Argumento do tipo 'number' não é atribuível ao


parâmetro do tipo 'string'

```

No código TypeScript, adicionamos a anotação de tipo `: string` após o parâmetro `name` e antes do
retorno da função. Isso indica que o parâmetro `name` deve ser uma string e a função deve retornar
uma string.

Ao tentar chamar a função `greet` com um número como argumento, o TypeScript gera um erro de
compilação. Isso ocorre porque o argumento não é do tipo esperado. Essa verificação de tipo em
tempo de compilação ajuda a evitar erros comuns durante a execução do código.

Portanto, o TypeScript oferece a vantagem de detectar erros de tipo antes mesmo de executar o
código, fornecendo um ambiente de desenvolvimento mais seguro e produtivo.
Claro! Aqui estão alguns exemplos de código em TypeScript:

1. Exemplo de declaração de tipos:

```typescript

// Declaração de tipos para variáveis

let age: number = 25;

let name: string = "John";

let isStudent: boolean = true;

// Declaração de tipos para arrays

let numbers: number[] = [1, 2, 3, 4, 5];

let fruits: Array<string> = ["apple", "banana", "orange"];

// Declaração de tipos para objetos

let person: { name: string, age: number } = {

name: "John",

age: 25

};

```

2. Exemplo de uso de funções:

```typescript

// Declaração de tipo para função

function greet(name: string): string {

return "Hello, " + name;

}
console.log(greet("John")); // Saída: Hello, John

// Função com parâmetro opcional

function greetOptional(name?: string): string {

if (name) {

return "Hello, " + name;

} else {

return "Hello, anonymous";

console.log(greetOptional()); // Saída: Hello, anonymous

console.log(greetOptional("John")); // Saída: Hello, John

```

3. Exemplo de uso de classes:

```typescript

class Person {

name: string;

age: number;

constructor(name: string, age: number) {

this.name = name;

this.age = age;

greet(): string {

return "Hello, my name is " + this.name + " and I'm " + this.age + " years old.";

}
let person = new Person("John", 25);

console.log(person.greet()); // Saída: Hello, my name is John and I'm 25 years old.

```

Esses são apenas alguns exemplos para ilustrar a sintaxe do TypeScript e a declaração de tipos. O
TypeScript oferece muitos recursos adicionais, como interfaces, tipos genéricos, enumerações, entre
outros, que podem ser explorados para criar código mais robusto e legível.

Você também pode gostar