TypeScript Cheat Sheets Classes

TypeScript

Cheat Sheets

Classes

Criando uma instância de classe

class ABC { ... }

const abc = new ABC()

Os parâmetros para o novo ABC vêm da função construtora.

private x ou #x

class Bag {
  private item: unknown
}

O prefixo private é uma adição somente de tipo e não tem efeito em tempo de execução.

private x ou #x

class Bag {
  #item: unknown
}

#x que é privado em tempo de execução no JavaScript e só é acessível dentro da classe

Tipo e valor

const a: Bag = new Bag()

Surpresa, uma classe pode ser usada como um tipo ou um valor.

Tipo

Valor

Sintaxe comum

class User extends Account implements Updatable, Serializable {
  id: string
  
  displayName?: boolean
  
  name!: string
  
  #attributes: Map<any, any>
  
  roles = ['user']

  readonly createdAt = new Date()

  constructor(id: string, email: string) {
    super(id)
    this.email = email
  }

  setName(name: string) { this.name = name }
  verifyName = (name: string) => { ... };
  
  sync(): Promise<{ ... }>;
  sync(cb: (result: string) => void): void;
  sync(cb?: (result: string) => void): void | Promise<{ ... }> { ... };
  
  get accountID() { return '' }
  set accountID(value: string) {}

  private makeRequest() {}
  protected handleRequest() {}

  static #userCount = 0
  static registerUser(user: User) {}
  
  static { this.#userCount = -1 }
}

Subclasse desta classe

Garante que a classe se refira a um conjunto de interfaces ou tipos

Um campo

Um campo opcional

Um campo "confie em mim, estará lá"

Um campo privado

Um campo com um padrão

Um campo somente leitura com um padrão

o código que chamamos com "new"

forma de escrever um método de classe

Campo de função de seta

Uma função com 2 definições de sobrecarga

Getters e Setters

O acesso privado é apenas para esta classe,
protegido permite às subclasses. Usado apenas para verificação de tipo e público é o padrão

Blocos estáticos para configurar variáveis
estáticas, "this" refere-se à classe estática

Campos / métodos estáticos

Genéricos

class Box<Type> {
  contents: Type
  constructor(value: Type) {
    this.contents = value;
  }
}
const stringBox = new Box("um pacote")

Declare um tipo que pode mudar em seus métodos de classe.

Parâmetro de tipo de classe

Usado aqui

Propriedades como parâmetros

class Location {
  constructor(
    public x: number,
    public y: number
  ) {}
}
const loc = new Location (20, 40);
loc.× // 20
loc.y // 40

Com classes TypeScript, podemos definir propriedades da instância automaticamente passando parâmetros de entrada no construtor.

Classes abstratas

abstract class Animal {
  abstract getName: string;
  printName() {
    console.log("Hello, " + this.getName ());
  }
}
class Dog extends Animal { getName(): { ... } }

Classes abstratas são classes não instanciáveis, mas existem para ser estendida por outras classes. Da mesma forma para as propriedades da classe.

Decoradores e Atributos

import { Syncable, triggersSync, preferCache, required } from "mylib"

@Syncable
class User {
  @triggersSync()
  save() { ... }

  @preferCache(false)
  get displayName() { ... }
  update(@required info: Partial<User>) { ... }
}

Podemos usar decoradores em classes, métodos de classe, acessores, propriedades e parâmetros para métodos.

Classes

Sintaxe comum

Descubra mais

TypeScript Cheat Sheets