Typescript - sabrinabm94/javascript GitHub Wiki

O que é?

É um superconjunto (superset) de ferramentas para javascript oferecendo recursos nos quais a linguagem não tem nativamente. Por exemplo, permitindo tornar o código do javascript em fortemente tipado.

Trazendo os conceitos de orientação a objetos ao javascript, sendo possível utilizar classes, interfaces, encapsulamento, herança e mais.

Como surgiu?

O TypeScript começou a ser desenvolvido internamente em 2010 pela equipe da Microsoft. O time foi liderado pelo engenheiro de software Anders Hejlsberg, já conhecido pelo desenvolvimento do Delphi e do Turbo Pascal (Borland), além do .NET (Microsoft).

A Microsoft lançou a linguagem em 2012.

Por que utilizar?

Para escrever um código javascript mais organizado e simplificado, também facilita na identificação de erros e aumentar assim a produtividade.

Funcionalidades

Classe

É uma forma de organizar os dados e funcionalidades, como também melhorar a reutilização destes pela instanciação de novas classes. São blueprints para criar objetos.

class parentClass {
	// atributos
	// construtor
	// getter e setters
	// outros métodos
}

Herança

Permite uma classe filho herdar propriedades e funcionalidades da classe pai pela declaração do extends, além de permitir a criação de novos dados e funcionalidades nesta.

class childClass extends parentClass {
	
	constructor(nome: string) {
	 	super(nome)
	}
	
	print(msg: string = 'I`m the child') {
		super.print(msg);
	}
}

Encapsulamento

É utilizado para proteger informações sigilosas impedindo acessos indevidos.

Os níveis de acesso das variáveis são:

1 - publico: todas as classes podem acessar esse atributo

2 - protegido: somente classes derivantes da original onde o atributo é declarado pode acessar esse atributo

3 - privado: o acesso a esse atributo pode ser feita somente dentro da mesma classe no qual foi declarado.

Caso tenha algum valor inconsistente no atributo, é muito mais fácil de encontrar a origem sendo que só a classe onde é declarada pode alterar seu conteúdo necessitando chamar a função set deste, facilitando a manutenibilidade.

Aplicar o encapsulamento, são criadas variáveis como privates (private) e o acesso/alteração de seus valores é feito dentro da classe onde é declarada, pelos métodos getters (para retornar valores) e setters (alterar valores).

class parentClass {
	private name: string
	
	get name(): string {
		return this.name;
		}

	set name(name: string): void {
		this.name = name;
		}
}

Classe abstrata

É um tipo de classe que não pode ser instanciada, somente herdada, utilizada em situações bem específicas onde existe herança de classes.

É utilizada em situações que a classe pai não faça sentido ser instanciada, e tenha sido criada somente para ser estendidas por outras classes pela reutilização de código por herança.

Por exemplo, temos a classe conta que tem atributos compartilhados por conta corrente e conta poupança, mas a classe conta nunca será instanciada, pois toda conta será ou poupança ou corrente. Nesse caso a classe conta seria uma classe abstrata que serviria somente de modelo de atributos e funcionalidades herdados para conta corrente e poupança.

abstract class classAbstract {
  constructor(public name: string) {}

  print(): void {
    console.log(name + this.name);
  }
}

class childAbstract extends classAbstract {
  constructor() {
    super('I`m the abstract child class');
  }

  override print(): void {
    console.log('Override print from classObstract');
  }

  childPrint(): void {
    console.log('childPrint function');
  }
}

Interface

É onde é especificado um contrato de uma classe, onde é aplicado a tipagem de seus atributos e métodos com nome, retorno, parâmetros e tipos. É usado para fazer a estrutura de subtipos de objetos.

O ideal é toda classe ter uma interface para haver uma boa organização do código.

interface sampleInterface {
	name?: string;
	id: number
	
	print();
}

class childClass implements sampleInterface {
	name?: string = 'child class';
	id: number = 0;
	
	print() {
	console.log(this.name);
	}
}

Modificadores de acesso

As classes podem ter as definições de acesso como:

• público: pode ser acessado por qualquer lugar do sistema
• privado: pode ser acessado somente dentro da classe que foi declarado
• protegido: pode ser acesso somente pela classe que foi declarado e seus tipos derivados

class Person {
  constructor(
    private age: number = 29,
    public name: string = 'Sabrina',
    protected dateBirth: string = '06/01/1994'
  ) {
    this.age = age;
    this.name = name;
    this.dateBirth = dateBirth;
  }

  personData(): string {
    return `${this.name} - ${this.age} - ${this.dateBirth}`;
  }
}

const woman: Person = new Person(18, "Lys", "09/03/2003");

console.log(woman.personData());