Leitura de apoio:
Classes (MDN)
O TypeScript oferece suporte completo à palavra-chave class, introduzida no ES2015.
Assim como outros recursos da linguagem JavaScript, o TypeScript acrescenta anotações de tipo e outras sintaxes para que você possa expressar relações entre classes e outros tipos.
Membros de classe
Aqui está a classe mais básica possível, uma vazia:
tsTryclassPoint {}
Essa classe ainda não é muito útil, então vamos começar a adicionar alguns membros.
Campos
Uma declaração de campo cria uma propriedade pública e gravável na classe:
tsTryclassPoint {x : number;y : number;}constpt = newPoint ();pt .x = 0;pt .y = 0;
Assim como em outros lugares, a anotação de tipo é opcional, mas, se não for especificada, será um any implícito.
Os campos também podem ter inicializadores; eles serão executados automaticamente quando a classe for instanciada:
tsTryclassPoint {x = 0;y = 0;}constpt = newPoint ();// Prints 0, 0console .log (`${pt .x }, ${pt .y }`);
Assim como acontece com const, let e var, o inicializador de uma propriedade de classe será usado para inferir o seu tipo:
tsTryconstpt = newPoint ();Type 'string' is not assignable to type 'number'.2322Type 'string' is not assignable to type 'number'.pt .x = "0";
--strictPropertyInitialization
A configuração strictPropertyInitialization controla se os campos da classe precisam ser inicializados no construtor.
tsTryclassBadGreeter {Property 'name' has no initializer and is not definitely assigned in the constructor.2564Property 'name' has no initializer and is not definitely assigned in the constructor.: string; name }
tsTryclassGoodGreeter {name : string;constructor() {this.name = "hello";}}
Observe que o campo precisa ser inicializado dentro do próprio construtor. O TypeScript não analisa os métodos que você invoca a partir do construtor para detectar inicializações, porque uma classe derivada pode sobrescrever esses métodos e deixar de inicializar os membros.
Se você pretende inicializar um campo de forma definitiva por outro meio que não o construtor (por exemplo, uma biblioteca externa que preenche parte da classe para você), pode usar o operador de asserção de atribuição definida, !:
tsTryclassOKGreeter {// Not initialized, but no errorname !: string;}
readonly
Campos podem ter o modificador readonly como prefixo.
Isso impede atribuições ao campo fora do construtor.
tsTryclassGreeter {readonlyname : string = "world";constructor(otherName ?: string) {if (otherName !==undefined ) {this.name =otherName ;}}err () {this.Cannot assign to 'name' because it is a read-only property.2540Cannot assign to 'name' because it is a read-only property.= "not ok"; name }}constg = newGreeter ();Cannot assign to 'name' because it is a read-only property.2540Cannot assign to 'name' because it is a read-only property.g .= "also not ok"; name
Construtores
Leitura de apoio:
Construtor (MDN)
Os construtores de classe são muito parecidos com funções. Você pode adicionar parâmetros com anotações de tipo, valores padrão e overloads:
tsTryclassPoint {x : number;y : number;// Normal signature with defaultsconstructor(x = 0,y = 0) {this.x =x ;this.y =y ;}}
tsTryclassPoint {x : number = 0;y : number = 0;// Constructor overloadsconstructor(x : number,y : number);constructor(xy : string);constructor(x : string | number,y : number = 0) {// Code logic here}}
Há apenas algumas diferenças entre as assinaturas de construtores de classe e as assinaturas de funções:
- Construtores não podem ter parâmetros de tipo - estes pertencem à declaração da classe externa, que veremos mais adiante
- Construtores não podem ter anotações de tipo de retorno - o tipo da instância da classe é sempre o que é retornado
Chamadas a super
Assim como no JavaScript, se você tiver uma classe base, precisará chamar super(); no corpo do construtor antes de usar qualquer membro this.:
tsTryclassBase {k = 4;}classDerived extendsBase {constructor() {// Prints a wrong value in ES5; throws exception in ES6'super' must be called before accessing 'this' in the constructor of a derived class.17009'super' must be called before accessing 'this' in the constructor of a derived class.console .log (this .k );super();}}
Esquecer de chamar super é um erro fácil de cometer em JavaScript, mas o TypeScript avisa quando essa chamada é necessária.
Métodos
Leitura de apoio:
Definições de métodos (MDN)
Uma propriedade de função em uma classe é chamada de método. Métodos podem usar todas as mesmas anotações de tipo que funções e construtores:
tsTryclassPoint {x = 10;y = 10;scale (n : number): void {this.x *=n ;this.y *=n ;}}
Além das anotações de tipo habituais, o TypeScript não acrescenta nada de novo aos métodos.
Observe que, dentro do corpo de um método, ainda é obrigatório acessar campos e outros métodos por meio de this..
Um nome sem qualificação no corpo de um método sempre se refere a algo do escopo externo:
tsTryletx : number = 0;classC {x : string = "hello";m () {// This is trying to modify 'x' from line 1, not the class propertyType 'string' is not assignable to type 'number'.2322Type 'string' is not assignable to type 'number'.= "world"; x }}
Getters / Setters
Classes também podem ter acessadores:
tsTryclassC {_length = 0;getlength () {return this._length ;}setlength (value ) {this._length =value ;}}
Observe que um par get/set apoiado em um campo, sem lógica extra, raramente é útil em JavaScript. Não há problema em expor campos públicos se você não precisar adicionar lógica extra nas operações de get/set.
O TypeScript tem algumas regras especiais de inferência para acessadores:
- Se existir
getmas nãoset, a propriedade será automaticamentereadonly - Se o tipo do parâmetro do setter não for especificado, ele é inferido a partir do tipo de retorno do getter
Desde o TypeScript 4.3, é possível ter acessadores com tipos diferentes para leitura e escrita.
tsTryclassThing {_size = 0;getsize (): number {return this._size ;}setsize (value : string | number | boolean) {letnum =Number (value );// Don't allow NaN, Infinity, etcif (!Number .isFinite (num )) {this._size = 0;return;}this._size =num ;}}
Assinaturas de índice
Classes podem declarar assinaturas de índice; elas funcionam da mesma forma que as assinaturas de índice de outros tipos de objeto:
tsTryclassMyClass {[s : string]: boolean | ((s : string) => boolean);check (s : string) {return this[s ] as boolean;}}
Como o tipo da assinatura de índice também precisa capturar os tipos dos métodos, não é fácil usar esses tipos de forma útil. Em geral, é melhor guardar dados indexados em outro lugar, em vez de na própria instância da classe.
Herança de classes
Assim como em outras linguagens com recursos orientados a objetos, classes em JavaScript podem herdar de classes base.
Cláusulas implements
Você pode usar uma cláusula implements para verificar se uma classe satisfaz uma determinada interface.
Um erro será emitido se a classe não implementar corretamente a interface:
tsTryinterfacePingable {ping (): void;}classSonar implementsPingable {ping () {console .log ("ping!");}}classClass 'Ball' incorrectly implements interface 'Pingable'. Property 'ping' is missing in type 'Ball' but required in type 'Pingable'.2420Class 'Ball' incorrectly implements interface 'Pingable'. Property 'ping' is missing in type 'Ball' but required in type 'Pingable'.implements Ball Pingable {pong () {console .log ("pong!");}}
Classes também podem implementar várias interfaces, por exemplo, class C implements A, B {.
Cuidados
É importante entender que uma cláusula implements é apenas uma verificação de que a classe pode ser tratada como o tipo da interface.
Ela não altera de forma alguma o tipo da classe nem dos seus métodos.
Uma fonte comum de erros é supor que uma cláusula implements mudará o tipo da classe - ela não muda!
tsTryinterfaceCheckable {check (name : string): boolean;}classNameChecker implementsCheckable {Parameter 's' implicitly has an 'any' type.7006Parameter 's' implicitly has an 'any' type.check () { s // Notice no error herereturns .toLowerCase () === "ok";}}
Neste exemplo, talvez esperássemos que o tipo de s fosse influenciado pelo parâmetro name: string de check.
Não é: cláusulas implements não mudam a forma como o corpo da classe é verificado nem como o seu tipo é inferido.
Da mesma forma, implementar uma interface com uma propriedade opcional não cria essa propriedade:
tsTryinterfaceA {x : number;y ?: number;}classC implementsA {x = 0;}constc = newC ();Property 'y' does not exist on type 'C'.2339Property 'y' does not exist on type 'C'.c .= 10; y
Cláusulas extends
Leitura de apoio:
Palavra-chave extends (MDN)
Classes podem usar extends para herdar de uma classe base.
Uma classe derivada tem todas as propriedades e métodos da sua classe base e também pode definir membros adicionais.
tsTryclassAnimal {move () {console .log ("Moving along!");}}classDog extendsAnimal {woof (times : number) {for (leti = 0;i <times ;i ++) {console .log ("woof!");}}}constd = newDog ();// Base class methodd .move ();// Derived class methodd .woof (3);
Sobrescrevendo métodos
Leitura de apoio:
Palavra-chave super (MDN)
Uma classe derivada também pode sobrescrever um campo ou propriedade da classe base.
Você pode usar a sintaxe super. para acessar métodos da classe base.
Observe que, como as classes do JavaScript são apenas um objeto de consulta simples, não existe o conceito de “campo super”.
O TypeScript garante que uma classe derivada seja sempre um subtipo da sua classe base.
Por exemplo, esta é uma forma válida de sobrescrever um método:
tsTryclassBase {greet () {console .log ("Hello, world!");}}classDerived extendsBase {greet (name ?: string) {if (name ===undefined ) {super.greet ();} else {console .log (`Hello, ${name .toUpperCase ()}`);}}}constd = newDerived ();d .greet ();d .greet ("reader");
É importante que uma classe derivada respeite o contrato da sua classe base. Lembre-se de que é muito comum (e sempre válido!) referenciar uma instância de classe derivada por meio de uma referência de classe base:
tsTry// Alias the derived instance through a base class referenceconstb :Base =d ;// No problemb .greet ();
E se Derived não seguisse o contrato de Base?
tsTryclassBase {greet () {console .log ("Hello, world!");}}classDerived extendsBase {// Make this parameter requiredProperty 'greet' in type 'Derived' is not assignable to the same property in base type 'Base'. Type '(name: string) => void' is not assignable to type '() => void'. Target signature provides too few arguments. Expected 1 or more, but got 0.2416Property 'greet' in type 'Derived' is not assignable to the same property in base type 'Base'. Type '(name: string) => void' is not assignable to type '() => void'. Target signature provides too few arguments. Expected 1 or more, but got 0.( greet name : string) {console .log (`Hello, ${name .toUpperCase ()}`);}}
Se compilássemos esse código apesar do erro, este exemplo acabaria falhando:
tsTryconstb :Base = newDerived ();// Crashes because "name" will be undefinedb .greet ();
Declarações de campo somente de tipo
Quando target >= ES2022 ou useDefineForClassFields é true, os campos da classe são inicializados depois que o construtor da classe pai termina, sobrescrevendo qualquer valor definido pela classe pai. Isso pode ser um problema quando você só quer declarar novamente um tipo mais preciso para um campo herdado. Para esses casos, você pode escrever declare para indicar ao TypeScript que essa declaração de campo não deve ter efeito em tempo de execução.
tsTryinterfaceAnimal {dateOfBirth : any;}interfaceDog extendsAnimal {breed : any;}classAnimalHouse {resident :Animal ;constructor(animal :Animal ) {this.resident =animal ;}}classDogHouse extendsAnimalHouse {// Does not emit JavaScript code,// only ensures the types are correctdeclareresident :Dog ;constructor(dog :Dog ) {super(dog );}}
Ordem de inicialização
A ordem em que as classes JavaScript são inicializadas pode ser surpreendente em alguns casos. Vamos considerar este código:
tsTryclassBase {name = "base";constructor() {console .log ("My name is " + this.name );}}classDerived extendsBase {name = "derived";}// Prints "base", not "derived"constd = newDerived ();
O que aconteceu aqui?
A ordem de inicialização de classes, como definida pelo JavaScript, é:
- Os campos da classe base são inicializados
- O construtor da classe base é executado
- Os campos da classe derivada são inicializados
- O construtor da classe derivada é executado
Isso significa que o construtor da classe base viu o seu próprio valor de name durante o seu construtor, porque as inicializações dos campos da classe derivada ainda não tinham sido executadas.
Herdando tipos integrados
Observação: se você não pretende herdar de tipos integrados como
Array,Error,Map, etc., ou se o seu alvo de compilação for explicitamenteES6/ES2015ou superior, você pode pular esta seção
No ES2015, construtores que retornam um objeto substituem implicitamente o valor de this para qualquer chamador de super(...).
É necessário que o código de construtor gerado capture qualquer possível valor de retorno de super(...) e o substitua por this.
Como consequência, a subclasse de Error, Array e outros pode deixar de funcionar como esperado.
Isso acontece porque as funções construtoras de Error, Array e similares usam o new.target do ECMAScript 6 para ajustar a cadeia de protótipos;
porém, não há como garantir um valor para new.target ao invocar um construtor no ECMAScript 5.
Outros compiladores de downleveling geralmente têm a mesma limitação por padrão.
Para uma subclasse como a seguinte:
tsTryclassMsgError extendsError {constructor(m : string) {super(m );}sayHello () {return "hello " + this.message ;}}
você pode descobrir que:
- métodos podem estar
undefinedem objetos retornados ao instanciar essas subclasses, então chamarsayHelloresultará em erro. instanceofdeixará de funcionar entre instâncias da subclasse e as suas instâncias, então(new MsgError()) instanceof MsgErrorretornaráfalse.
Como recomendação, você pode ajustar manualmente o protótipo imediatamente após qualquer chamada a super(...).
tsTryclassMsgError extendsError {constructor(m : string) {super(m );// Set the prototype explicitly.Object .setPrototypeOf (this,MsgError .prototype );}sayHello () {return "hello " + this.message ;}}
No entanto, qualquer subclasse de MsgError também terá que definir o protótipo manualmente.
Para ambientes de execução que não suportam Object.setPrototypeOf, talvez você consiga usar __proto__.
Infelizmente, essas soluções alternativas não funcionam no Internet Explorer 10 e versões anteriores.
É possível copiar manualmente os métodos do protótipo para a própria instância (ou seja, de MsgError.prototype para this), mas a cadeia de protótipos em si não pode ser corrigida.
Visibilidade de membros
Você pode usar o TypeScript para controlar se determinados métodos ou propriedades ficam visíveis para código fora da classe.
public
A visibilidade padrão dos membros de classe é public.
Um membro public pode ser acessado em qualquer lugar:
tsTryclassGreeter {publicgreet () {console .log ("hi!");}}constg = newGreeter ();g .greet ();
Como public já é o modificador de visibilidade padrão, você nunca precisa escrevê-lo em um membro de classe, mas pode optar por fazê-lo por questões de estilo ou legibilidade.
protected
Membros protected só são visíveis para subclasses da classe em que foram declarados.
tsTryclassGreeter {publicgreet () {console .log ("Hello, " + this.getName ());}protectedgetName () {return "hi";}}classSpecialGreeter extendsGreeter {publichowdy () {// OK to access protected member hereconsole .log ("Howdy, " + this.getName ());}}constg = newSpecialGreeter ();g .greet (); // OKProperty 'getName' is protected and only accessible within class 'Greeter' and its subclasses.2445Property 'getName' is protected and only accessible within class 'Greeter' and its subclasses.g .(); getName
Exposição de membros protected
Classes derivadas precisam respeitar o contrato de suas classes base, mas podem optar por expor um subtipo da classe base com mais capacidades.
Isso inclui tornar public os membros protected:
tsTryclassBase {protectedm = 10;}classDerived extendsBase {// No modifier, so default is 'public'm = 15;}constd = newDerived ();console .log (d .m ); // OK
Observe que Derived já conseguia ler e escrever m livremente, então isso não altera de forma significativa a “segurança” da situação.
O ponto principal a notar aqui é que, na classe derivada, devemos ter cuidado para repetir o modificador protected se essa exposição não for intencional.
Acesso protected entre hierarquias
O TypeScript não permite acessar membros protected de uma classe irmã dentro de uma hierarquia de classes:
tsTryclassBase {protectedx : number = 1;}classDerived1 extendsBase {protectedx : number = 5;}classDerived2 extendsBase {f1 (other :Derived2 ) {other .x = 10;}f2 (other :Derived1 ) {Property 'x' is protected and only accessible within class 'Derived1' and its subclasses.2445Property 'x' is protected and only accessible within class 'Derived1' and its subclasses.other .= 10; x }}
Isso acontece porque acessar x em Derived2 deveria ser legal apenas a partir das subclasses de Derived2, e Derived1 não é uma delas.
Além disso, se acessar x por uma referência de Derived1 é ilegal (como de fato deveria ser!), então acessá-lo por uma referência de classe base nunca deveria melhorar a situação.
Veja também Por que não consigo acessar um membro protegido a partir de uma classe derivada?, que explica melhor o raciocínio do C# sobre o mesmo tema.
private
private é como protected, mas não permite acesso ao membro nem mesmo a partir de subclasses:
tsTryclassBase {privatex = 0;}constb = newBase ();// Can't access from outside the classProperty 'x' is private and only accessible within class 'Base'.2341Property 'x' is private and only accessible within class 'Base'.console .log (b .); x
tsTryclassDerived extendsBase {showX () {// Can't access in subclassesProperty 'x' is private and only accessible within class 'Base'.2341Property 'x' is private and only accessible within class 'Base'.console .log (this.); x }}
Como membros private não são visíveis para classes derivadas, uma classe derivada não pode aumentar a visibilidade deles:
tsTryclassBase {privatex = 0;}classClass 'Derived' incorrectly extends base class 'Base'. Property 'x' is private in type 'Base' but not in type 'Derived'.2415Class 'Derived' incorrectly extends base class 'Base'. Property 'x' is private in type 'Base' but not in type 'Derived'.extends Derived Base {x = 1;}
Acesso private entre instâncias
Diferentes linguagens orientadas a objetos discordam sobre se instâncias diferentes da mesma classe podem acessar os membros private umas das outras.
Enquanto linguagens como Java, C#, C++, Swift e PHP permitem isso, Ruby não permite.
O TypeScript permite o acesso private entre instâncias:
tsTryclassA {privatex = 10;publicsameAs (other :A ) {// No errorreturnother .x === this.x ;}}
Ressalvas
Como outros aspectos do sistema de tipos do TypeScript, private e protected são aplicados apenas durante a verificação de tipos.
Isso significa que construções do ambiente de execução do JavaScript, como in ou a simples busca de propriedade, ainda podem acessar um membro private ou protected:
tsTryclassMySafe {privatesecretKey = 12345;}
js// In a JavaScript file...const s = new MySafe();// Will print 12345console.log(s.secretKey);
private também permite acesso por notação de colchetes durante a verificação de tipos. Isso torna os campos declarados como private potencialmente mais fáceis de acessar para coisas como testes unitários, com a desvantagem de que esses campos são soft private (privado flexível) e não impõem privacidade de forma estrita.
tsTryclassMySafe {privatesecretKey = 12345;}consts = newMySafe ();// Not allowed during type checkingProperty 'secretKey' is private and only accessible within class 'MySafe'.2341Property 'secretKey' is private and only accessible within class 'MySafe'.console .log (s .); secretKey // OKconsole .log (s ["secretKey"]);
Diferentemente do private do TypeScript, os campos privados do JavaScript (#) continuam privados após a compilação e não oferecem as saídas mencionadas anteriormente, como o acesso por notação de colchetes, por isso são hard private (privado rígido).
tsTryclassDog {#barkAmount = 0;personality = "happy";constructor() {}}
tsTry"use strict";class Dog {#barkAmount = 0;personality = "happy";constructor() { }}
Ao compilar para ES2021 ou inferior, o TypeScript usará WeakMaps no lugar de #.
tsTry"use strict";var _Dog_barkAmount;class Dog {constructor() {_Dog_barkAmount.set(this, 0);this.personality = "happy";}}_Dog_barkAmount = new WeakMap();
Se você precisar proteger valores da sua classe contra agentes mal-intencionados, deve usar mecanismos que ofereçam privacidade rígida em tempo de execução, como closures, WeakMaps ou campos privados. Observe que essas verificações de privacidade adicionais em tempo de execução podem afetar o desempenho.
Membros estáticos
Leitura de apoio:
Membros estáticos (MDN)
Classes podem ter membros static.
Esses membros não estão associados a uma instância específica da classe.
Eles podem ser acessados pelo próprio objeto construtor da classe:
tsTryclassMyClass {staticx = 0;staticprintX () {console .log (MyClass .x );}}console .log (MyClass .x );MyClass .printX ();
Membros estáticos também podem usar os mesmos modificadores de visibilidade public, protected e private:
tsTryclassMyClass {private staticx = 0;}Property 'x' is private and only accessible within class 'MyClass'.2341Property 'x' is private and only accessible within class 'MyClass'.console .log (MyClass .); x
Membros estáticos também são herdados:
tsTryclassBase {staticgetGreeting () {return "Hello world";}}classDerived extendsBase {myGreeting =Derived .getGreeting ();}
Nomes estáticos especiais
Em geral, não é seguro/possível sobrescrever propriedades do protótipo Function.
Como as próprias classes são funções que podem ser invocadas com new, certos nomes static não podem ser usados.
Propriedades de função como name, length e call não são válidas para definir como membros static:
tsTryclassS {staticStatic property 'name' conflicts with built-in property 'Function.name' of constructor function 'S'.2699Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'S'.= "S!"; name }
Por que não existem classes estáticas?
O TypeScript (e o JavaScript) não têm um construto chamado static class, como o que existe em C#, por exemplo.
Esses construtos só existem porque essas linguagens obrigam todos os dados e funções a ficarem dentro de uma classe; como essa restrição não existe no TypeScript, não há necessidade deles. Uma classe com apenas uma instância normalmente é representada simplesmente como um objeto normal em JavaScript/TypeScript.
Por exemplo, não precisamos de uma sintaxe de “classe estática” no TypeScript, porque um objeto comum (ou até mesmo uma função de nível superior) faz o mesmo trabalho tão bem:
tsTry// Unnecessary "static" classclassMyStaticClass {staticdoSomething () {}}// Preferred (alternative 1)functiondoSomething () {}// Preferred (alternative 2)constMyHelperObject = {dosomething () {},};
Blocos static em classes
Blocos estáticos permitem escrever uma sequência de instruções com escopo próprio, que pode acessar campos privados da classe que os contém. Isso significa que podemos escrever código de inicialização com todos os recursos de instruções, sem vazamento de variáveis e com acesso total aos internos da nossa classe.
tsTryclassFoo {static #count = 0;getcount () {returnFoo .#count;}static {try {constlastInstances =loadLastInstances ();Foo .#count +=lastInstances .length ;}catch {}}}
Classes genéricas
Classes, assim como interfaces, podem ser genéricas.
Quando uma classe genérica é instanciada com new, seus parâmetros de tipo são inferidos da mesma forma que em uma chamada de função:
tsTryclassBox <Type > {contents :Type ;constructor(value :Type ) {this.contents =value ;}}constb = newBox ("hello!");
Classes podem usar restrições e valores padrão de genéricos da mesma forma que interfaces.
Parâmetros de tipo em membros estáticos
Este código não é válido, e pode não ser óbvio o motivo:
tsTryclassBox <Type > {staticStatic members cannot reference class type parameters.2302Static members cannot reference class type parameters.defaultValue :; Type }
Lembre-se de que tipos são sempre totalmente apagados!
Em tempo de execução, existe apenas um espaço de propriedade Box.defaultValue.
Isso significa que definir Box<string>.defaultValue (se isso fosse possível) também alteraria Box<number>.defaultValue - não é bom.
Os membros static de uma classe genérica nunca podem se referir aos parâmetros de tipo da classe.
this em tempo de execução nas classes
Leitura de apoio:
Palavra-chave this (MDN)
É importante lembrar que o TypeScript não altera o comportamento em tempo de execução do JavaScript, e que o JavaScript é conhecido por ter alguns comportamentos peculiares em tempo de execução.
O tratamento de this no JavaScript é de fato incomum:
tsTryclassMyClass {name = "MyClass";getName () {return this.name ;}}constc = newMyClass ();constobj = {name : "obj",getName :c .getName ,};// Prints "obj", not "MyClass"console .log (obj .getName ());
Resumindo, por padrão, o valor de this dentro de uma função depende de como a função foi chamada.
Neste exemplo, como a função foi chamada pela referência obj, seu valor de this foi obj em vez da instância da classe.
Isso raramente é o que se deseja! O TypeScript oferece algumas formas de mitigar ou prevenir esse tipo de erro.
Funções arrow
Leitura de apoio:
Funções arrow (MDN)
Se você tem uma função que frequentemente será chamada de um jeito que perde o seu contexto de this, pode fazer sentido usar uma propriedade de função arrow em vez de uma definição de método:
tsTryclassMyClass {name = "MyClass";getName = () => {return this.name ;};}constc = newMyClass ();constg =c .getName ;// Prints "MyClass" instead of crashingconsole .log (g ());
Isso tem algumas compensações:
- O valor de
thisé garantido como correto em tempo de execução, mesmo para código não verificado pelo TypeScript - Isso usará mais memória, porque cada instância da classe terá sua própria cópia de cada função definida dessa forma
- Você não pode usar
super.getNameem uma classe derivada, porque não há entrada na cadeia de protótipos de onde buscar o método da classe base
Parâmetros this
Em uma definição de método ou função, um parâmetro inicial chamado this tem um significado especial no TypeScript.
Esses parâmetros são apagados durante a compilação:
tsTry// TypeScript input with 'this' parameterfunctionfn (this :SomeType ,x : number) {/* ... */}
js// JavaScript outputfunction fn(x) {/* ... */}
O TypeScript verifica se a chamada de uma função com parâmetro this é feita com o contexto correto.
Em vez de usar uma função arrow, podemos adicionar um parâmetro this às definições de método para garantir estaticamente que o método é chamado corretamente:
tsTryclassMyClass {name = "MyClass";getName (this :MyClass ) {return this.name ;}}constc = newMyClass ();// OKc .getName ();// Error, would crashconstg =c .getName ;The 'this' context of type 'void' is not assignable to method's 'this' of type 'MyClass'.2684The 'this' context of type 'void' is not assignable to method's 'this' of type 'MyClass'.console .log (g ());
Este método tem as compensações opostas à abordagem da função arrow:
- Chamadores JavaScript ainda podem usar o método da classe de forma incorreta sem perceber
- Apenas uma função por definição de classe é alocada, em vez de uma por instância da classe
- Definições de métodos da base ainda podem ser chamadas via
super.
Tipos this
Em classes, um tipo especial chamado this se refere dinamicamente ao tipo da classe atual.
Vamos ver como isso é útil:
tsTryclassBox {contents : string = "";set (value : string) {this.contents =value ;return this;}}
Aqui, o TypeScript inferiu o tipo de retorno de set como this, em vez de Box.
Agora vamos criar uma subclasse de Box:
tsTryclassClearableBox extendsBox {clear () {this.contents = "";}}consta = newClearableBox ();constb =a .set ("hello");
Você também pode usar this em uma anotação de tipo de parâmetro:
tsTryclassBox {content : string = "";sameAs (other : this) {returnother .content === this.content ;}}
Isso é diferente de escrever other: Box — se você tiver uma classe derivada, seu método sameAs passará a aceitar apenas outras instâncias dessa mesma classe derivada:
tsTryclassBox {content : string = "";sameAs (other : this) {returnother .content === this.content ;}}classDerivedBox extendsBox {otherContent : string = "?";}constbase = newBox ();constderived = newDerivedBox ();Argument of type 'Box' is not assignable to parameter of type 'DerivedBox'. Property 'otherContent' is missing in type 'Box' but required in type 'DerivedBox'.2345Argument of type 'Box' is not assignable to parameter of type 'DerivedBox'. Property 'otherContent' is missing in type 'Box' but required in type 'DerivedBox'.derived .sameAs (); base
Type guards baseados em this
Você pode usar this is Type na posição de retorno de métodos em classes e interfaces.
Quando combinado com um estreitamento de tipo (por exemplo, instruções if), o tipo do objeto alvo será estreitado para o Type especificado.
tsTryclassFileSystemObject {isFile (): this isFileRep {return this instanceofFileRep ;}isDirectory (): this isDirectory {return this instanceofDirectory ;}isNetworked (): this isNetworked & this {return this.networked ;}constructor(publicpath : string, privatenetworked : boolean) {}}classFileRep extendsFileSystemObject {constructor(path : string, publiccontent : string) {super(path , false);}}classDirectory extendsFileSystemObject {children :FileSystemObject [];}interfaceNetworked {host : string;}constfso :FileSystemObject = newFileRep ("foo/bar.txt", "foo");if (fso .isFile ()) {fso .content ;} else if (fso .isDirectory ()) {fso .children ;} else if (fso .isNetworked ()) {fso .host ;}
Um caso de uso comum para um type guard baseado em this é permitir a validação preguiçosa de um campo específico. Por exemplo, este caso remove um undefined do valor guardado dentro de box quando hasValue foi verificado como verdadeiro:
tsTryclassBox <T > {value ?:T ;hasValue (): this is {value :T } {return this.value !==undefined ;}}constbox = newBox <string>();box .value = "Gameboy";box .value ;if (box .hasValue ()) {box .value ;}
Propriedades de parâmetro
O TypeScript oferece uma sintaxe especial para transformar um parâmetro do construtor em uma propriedade de classe com o mesmo nome e valor.
Essas são chamadas de propriedades de parâmetro e são criadas prefixando um argumento do construtor com um dos modificadores de visibilidade public, private, protected ou readonly.
O campo resultante recebe esse(s) modificador(es):
tsTryclassParams {constructor(public readonlyx : number,protectedy : number,privatez : number) {// No body necessary}}consta = newParams (1, 2, 3);console .log (a .x );Property 'z' is private and only accessible within class 'Params'.2341Property 'z' is private and only accessible within class 'Params'.console .log (a .); z
Expressões de classe
Leitura de apoio:
Expressões de classe (MDN)
Expressões de classe são muito parecidas com declarações de classe. A única diferença real é que expressões de classe não precisam de nome, embora possamos nos referir a elas pelo identificador ao qual foram associadas:
tsTryconstsomeClass = class<Type > {content :Type ;constructor(value :Type ) {this.content =value ;}};constm = newsomeClass ("Hello, world");
Assinaturas de construtor
Classes em JavaScript são instanciadas com o operador new. Dado o tipo da própria classe, o tipo utilitário InstanceType modela essa operação.
tsTryclassPoint {createdAt : number;x : number;y : numberconstructor(x : number,y : number) {this.createdAt =Date .now ()this.x =x ;this.y =y ;}}typePointInstance =InstanceType <typeofPoint >functionmoveRight (point :PointInstance ) {point .x += 5;}constpoint = newPoint (3, 4);moveRight (point );point .x ; // => 8
Classes e membros abstract
Classes, métodos e campos no TypeScript podem ser abstract.
Um método abstrato ou campo abstrato é aquele que não teve uma implementação fornecida. Esses membros devem existir dentro de uma classe abstrata, que não pode ser instanciada diretamente.
O papel das classes abstratas é servir como classe base para subclasses que implementam todos os membros abstratos. Quando uma classe não tem membros abstratos, diz-se que ela é concreta.
Vamos ver um exemplo:
tsTryabstract classBase {abstractgetName (): string;printName () {console .log ("Hello, " + this.getName ());}}constCannot create an instance of an abstract class.2511Cannot create an instance of an abstract class.b = newBase ();
Não podemos instanciar Base com new porque ela é abstrata.
Em vez disso, precisamos criar uma classe derivada e implementar os membros abstratos:
tsTryclassDerived extendsBase {getName () {return "world";}}constd = newDerived ();d .printName ();
Observe que, se esquecermos de implementar os membros abstratos da classe base, receberemos um erro:
tsTryclassNon-abstract class 'Derived' does not implement inherited abstract member getName from class 'Base'.2515Non-abstract class 'Derived' does not implement inherited abstract member getName from class 'Base'.extends Derived Base {// forgot to do anything}
Assinaturas de construtor abstratas
Às vezes você quer aceitar alguma função construtora de classe que produza uma instância de uma classe derivada de alguma classe abstrata.
Por exemplo, você pode querer escrever este código:
tsTryfunctiongreet (ctor : typeofBase ) {constCannot create an instance of an abstract class.2511Cannot create an instance of an abstract class.instance = newctor ();instance .printName ();}
O TypeScript está corretamente avisando que você está tentando instanciar uma classe abstrata.
Afinal, dada a definição de greet, é perfeitamente válido escrever este código, que acabaria construindo uma classe abstrata:
tsTry// Bad!greet (Base );
Em vez disso, você quer escrever uma função que aceite algo com uma assinatura de construtor:
tsTryfunctiongreet (ctor : new () =>Base ) {constinstance = newctor ();instance .printName ();}greet (Derived );Argument of type 'typeof Base' is not assignable to parameter of type 'new () => Base'. Cannot assign an abstract constructor type to a non-abstract constructor type.2345Argument of type 'typeof Base' is not assignable to parameter of type 'new () => Base'. Cannot assign an abstract constructor type to a non-abstract constructor type.greet (); Base
Agora o TypeScript informa corretamente quais funções construtoras de classe podem ser invocadas - Derived pode, porque é concreta, mas Base não pode.
Relações entre classes
Na maioria dos casos, classes no TypeScript são comparadas de forma estrutural, como qualquer outro tipo.
Por exemplo, estas duas classes podem ser usadas no lugar uma da outra porque são idênticas:
tsTryclassPoint1 {x = 0;y = 0;}classPoint2 {x = 0;y = 0;}// OKconstp :Point1 = newPoint2 ();
Da mesma forma, relações de subtipo entre classes existem mesmo sem herança explícita:
tsTryclassPerson {name : string;age : number;}classEmployee {name : string;age : number;salary : number;}// OKconstp :Person = newEmployee ();
Isso parece simples, mas há alguns casos que parecem mais estranhos do que outros.
Classes vazias não têm membros. Em um sistema de tipos estrutural, um tipo sem membros é geralmente um supertipo de qualquer outro. Então, se você escrever uma classe vazia (não faça isso!), qualquer coisa pode ser usada no lugar dela:
tsTryclassEmpty {}functionfn (x :Empty ) {// can't do anything with 'x', so I won't}// All OK!fn (window );fn ({});fn (fn );