Funções são o bloco básico de construção de qualquer aplicação, sejam elas funções locais, importadas de outro módulo ou métodos de uma classe. Elas também são valores e, assim como outros valores, o TypeScript tem várias formas de descrever como funções podem ser chamadas. Vamos aprender a escrever tipos que descrevem funções.
Expressões de Tipo de Função
A forma mais simples de descrever uma função é com uma expressão de tipo de função. Esses tipos são sintaticamente parecidos com arrow functions:
tsTryfunctiongreeter (fn : (a : string) => void) {fn ("Hello, World");}functionprintToConsole (s : string) {console .log (s );}greeter (printToConsole );
A sintaxe (a: string) => void significa “uma função com um parâmetro, chamado a, do tipo string, que não tem valor de retorno”.
Assim como nas declarações de função, se o tipo de um parâmetro não for especificado, ele é implicitamente any.
Observe que o nome do parâmetro é obrigatório. O tipo de função
(string) => voidsignifica “uma função com um parâmetro chamadostringdo tipoany“!
Claro, podemos usar um type alias para dar nome a um tipo de função:
tsTrytypeGreetFunction = (a : string) => void;functiongreeter (fn :GreetFunction ) {// ...}
Assinaturas de Chamada
Em JavaScript, funções podem ter propriedades além de serem chamáveis. No entanto, a sintaxe de expressão de tipo de função não permite declarar propriedades. Se quisermos descrever algo chamável que também tem propriedades, podemos escrever uma assinatura de chamada em um tipo objeto:
tsTrytypeDescribableFunction = {description : string;(someArg : number): boolean;};functiondoSomething (fn :DescribableFunction ) {console .log (fn .description + " returned " +fn (6));}functionmyFunc (someArg : number) {returnsomeArg > 3;}myFunc .description = "default description";doSomething (myFunc );
Observe que a sintaxe é um pouco diferente da expressão de tipo de função: use : entre a lista de parâmetros e o tipo de retorno, em vez de =>.
Assinaturas de Construtor
Funções em JavaScript também podem ser invocadas com o operador new.
O TypeScript chama essas funções de construtores, porque normalmente criam um novo objeto.
Você pode escrever uma assinatura de construtor adicionando a palavra-chave new na frente de uma assinatura de chamada:
tsTrytypeSomeConstructor = {new (s : string):SomeObject ;};functionfn (ctor :SomeConstructor ) {return newctor ("hello");}
Alguns objetos, como o objeto Date do JavaScript, podem ser chamados com ou sem new.
Você pode combinar assinaturas de chamada e de construtor no mesmo tipo da forma que quiser:
tsTryinterfaceCallOrConstruct {(n ?: number): string;new (s : string):Date ;}functionfn (ctor :CallOrConstruct ) {// Passing an argument of type `number` to `ctor` matches it against// the first definition in the `CallOrConstruct` interface.console .log (ctor (10));// Similarly, passing an argument of type `string` to `ctor` matches it// against the second definition in the `CallOrConstruct` interface.console .log (newctor ("10"));}fn (Date );
Funções Genéricas
É comum escrever uma função em que os tipos da entrada se relacionam com o tipo da saída, ou em que os tipos de duas entradas estão relacionados de alguma forma. Vamos considerar por um momento uma função que retorna o primeiro elemento de um array:
tsTryfunctionfirstElement (arr : any[]) {returnarr [0];}
Essa função faz o trabalho, mas infelizmente tem o tipo de retorno any.
Seria melhor se a função retornasse o tipo do elemento do array.
No TypeScript, genéricos são usados quando queremos descrever uma correspondência entre dois valores. Fazemos isso declarando um parâmetro de tipo na assinatura da função:
tsTryfunctionfirstElement <Type >(arr :Type []):Type | undefined {returnarr [0];}
Ao adicionar um parâmetro de tipo Type a essa função e usá-lo em dois lugares, criamos um vínculo entre a entrada da função (o array) e a saída (o valor de retorno).
Agora, quando a chamamos, sai um tipo mais específico:
tsTry// s is of type 'string'consts =firstElement (["a", "b", "c"]);// n is of type 'number'constn =firstElement ([1, 2, 3]);// u is of type undefinedconstu =firstElement ([]);
Inferência
Observe que não precisamos especificar Type neste exemplo.
O tipo foi inferido (escolhido automaticamente) pelo TypeScript.
Também podemos usar vários parâmetros de tipo.
Por exemplo, uma versão independente de map ficaria assim:
tsTryfunctionmap <Input ,Output >(arr :Input [],func : (arg :Input ) =>Output ):Output [] {returnarr .map (func );}// Parameter 'n' is of type 'string'// 'parsed' is of type 'number[]'constparsed =map (["1", "2", "3"], (n ) =>parseInt (n ));
Observe que, neste exemplo, o TypeScript conseguiu inferir tanto o tipo do parâmetro de tipo Input (a partir do array de string fornecido) quanto o do parâmetro Output, com base no valor de retorno da expressão de função (number).
Restrições
Já escrevemos algumas funções genéricas que funcionam com qualquer tipo de valor. Às vezes queremos relacionar dois valores, mas só podemos operar sobre um subconjunto específico de valores. Nesse caso, podemos usar uma restrição para limitar os tipos que um parâmetro de tipo aceita.
Vamos escrever uma função que retorna o maior entre dois valores.
Para isso, precisamos de uma propriedade length que seja um número.
Ao restringir o parâmetro de tipo a esse formato, escrevemos uma cláusula extends:
tsTryfunctionlongest <Type extends {length : number }>(a :Type ,b :Type ) {if (a .length >=b .length ) {returna ;} else {returnb ;}}// longerArray is of type 'number[]'constlongerArray =longest ([1, 2], [1, 2, 3]);// longerString is of type 'alice' | 'bob'constlongerString =longest ("alice", "bob");// Error! Numbers don't have a 'length' propertyconstArgument of type 'number' is not assignable to parameter of type '{ length: number; }'.2345Argument of type 'number' is not assignable to parameter of type '{ length: number; }'.notOK =longest (10 , 100);
Há algumas coisas interessantes a observar neste exemplo.
Deixamos o TypeScript inferir o tipo de retorno de longest.
A inferência do tipo de retorno também funciona em funções genéricas.
Como restringimos Type a { length: number }, podemos acessar a propriedade .length dos parâmetros a e b.
Sem a restrição de tipo, não conseguiríamos acessar essas propriedades, porque os valores poderiam ser de algum outro tipo sem a propriedade length.
Os tipos de longerArray e longerString foram inferidos com base nos argumentos.
Lembre-se: genéricos servem para relacionar dois ou mais valores de mesmo tipo!
Por fim, como esperávamos, a chamada longest(10, 100) é rejeitada porque o tipo number não tem a propriedade .length.
Trabalhando com Valores Restritos
Aqui está um erro comum ao trabalhar com restrições de tipos genéricos:
tsTryfunctionminimumLength <Type extends {length : number }>(obj :Type ,minimum : number):Type {if (obj .length >=minimum ) {returnobj ;} else {Type '{ length: number; }' is not assignable to type 'Type'. '{ length: number; }' is assignable to the constraint of type 'Type', but 'Type' could be instantiated with a different subtype of constraint '{ length: number; }'.2322Type '{ length: number; }' is not assignable to type 'Type'. '{ length: number; }' is assignable to the constraint of type 'Type', but 'Type' could be instantiated with a different subtype of constraint '{ length: number; }'.return {length :minimum };}}
Pode parecer que essa função está correta: Type é restrito a { length: number }, e a função retorna Type ou um valor que atende a essa restrição.
O problema é que a função promete retornar o mesmo tipo de objeto que foi passado, e não apenas algum objeto que atenda à restrição.
Se esse código fosse válido, você poderia escrever um código que certamente não funcionaria:
tsTry// 'arr' gets value { length: 6 }constarr =minimumLength ([1, 2, 3], 6);// and crashes here because arrays have// a 'slice' method, but not the returned object!console .log (arr .slice (0));
Especificando Argumentos de Tipo
O TypeScript normalmente consegue inferir os argumentos de tipo pretendidos em uma chamada genérica, mas nem sempre. Por exemplo, suponha que você escreveu uma função para combinar dois arrays:
tsTryfunctioncombine <Type >(arr1 :Type [],arr2 :Type []):Type [] {returnarr1 .concat (arr2 );}
Normalmente, seria um erro chamar essa função com arrays de tipos incompatíveis:
tsTryconstType 'string' is not assignable to type 'number'.2322Type 'string' is not assignable to type 'number'.arr =combine ([1, 2, 3], ["hello" ]);
Se você pretende fazer isso, no entanto, pode especificar Type manualmente:
tsTryconstarr =combine <string | number>([1, 2, 3], ["hello"]);
Diretrizes para Escrever Boas Funções Genéricas
Escrever funções genéricas é divertido, e é fácil se empolgar com parâmetros de tipo. Ter parâmetros de tipo demais, ou usar restrições onde elas não são necessárias, pode tornar a inferência menos eficiente e frustrar quem chama a sua função.
Empurre os Parâmetros de Tipo para Baixo
Aqui estão duas formas de escrever uma função que parecem semelhantes:
tsTryfunctionfirstElement1 <Type >(arr :Type []) {returnarr [0];}functionfirstElement2 <Type extends any[]>(arr :Type ) {returnarr [0];}// a: number (good)consta =firstElement1 ([1, 2, 3]);// b: any (bad)constb =firstElement2 ([1, 2, 3]);
Essas funções podem parecer idênticas à primeira vista, mas firstElement1 é uma forma muito melhor de escrever essa função.
O tipo de retorno inferido dela é Type, mas o de firstElement2 é any, porque o TypeScript precisa resolver a expressão arr[0] usando o tipo da restrição, em vez de “esperar” para resolver o elemento durante a chamada.
Regra: Sempre que possível, use o próprio parâmetro de tipo em vez de restringi-lo
Use Menos Parâmetros de Tipo
Aqui está outro par de funções parecidas:
tsTryfunctionfilter1 <Type >(arr :Type [],func : (arg :Type ) => boolean):Type [] {returnarr .filter (func );}functionfilter2 <Type ,Func extends (arg :Type ) => boolean>(arr :Type [],func :Func ):Type [] {returnarr .filter (func );}
Criamos um parâmetro de tipo Func que não relaciona dois valores.
Isso é sempre um sinal de alerta, porque significa que quem quiser especificar argumentos de tipo precisa informar manualmente um argumento extra sem motivo.
Func não faz nada além de tornar a função mais difícil de ler e de raciocinar sobre!
Regra: Use sempre o menor número possível de parâmetros de tipo
Parâmetros de Tipo Devem Aparecer Duas Vezes
Às vezes esquecemos que uma função pode não precisar ser genérica:
tsTryfunctiongreet <Str extends string>(s :Str ) {console .log ("Hello, " +s );}greet ("world");
Poderíamos ter escrito facilmente uma versão mais simples:
tsTryfunctiongreet (s : string) {console .log ("Hello, " +s );}
Lembre-se: parâmetros de tipo servem para relacionar os tipos de múltiplos valores.
Se um parâmetro de tipo aparece apenas uma vez na assinatura da função, ele não está relacionando nada.
Isso inclui o tipo de retorno inferido: se Str fizesse parte do tipo de retorno inferido de greet, ele estaria relacionando o argumento e o retorno, e por isso seria usado duas vezes, mesmo aparecendo apenas uma vez no código escrito.
Regra: Se um parâmetro de tipo aparece em apenas um lugar, reconsidere com bastante cuidado se você realmente precisa dele
Parâmetros Opcionais
Funções em JavaScript muitas vezes recebem um número variável de argumentos.
Por exemplo, o método toFixed de number recebe uma quantidade opcional de casas decimais:
tsTryfunctionf (n : number) {console .log (n .toFixed ()); // 0 argumentsconsole .log (n .toFixed (3)); // 1 argument}
Podemos modelar isso no TypeScript marcando o parâmetro como opcional com ?:
tsTryfunctionf (x ?: number) {// ...}f (); // OKf (10); // OK
Embora o parâmetro seja especificado com o tipo number, o parâmetro x terá, na prática, o tipo number | undefined, porque parâmetros não informados em JavaScript recebem o valor undefined.
Você também pode fornecer um valor padrão para o parâmetro:
tsTryfunctionf (x = 10) {// ...}
Agora, no corpo de f, x terá o tipo number, porque qualquer argumento undefined será substituído por 10.
Observe que, quando um parâmetro é opcional, quem chama sempre pode passar undefined, já que isso apenas simula um argumento “ausente”:
tsTry// All OKf ();f (10);f (undefined );
Parâmetros Opcionais em Callbacks
Depois de aprender sobre parâmetros opcionais e expressões de tipo de função, é muito fácil cometer os seguintes erros ao escrever funções que invocam callbacks:
tsTryfunctionmyForEach (arr : any[],callback : (arg : any,index ?: number) => void) {for (leti = 0;i <arr .length ;i ++) {callback (arr [i ],i );}}
O que as pessoas normalmente querem dizer ao escrever index? como parâmetro opcional é que ambas as chamadas abaixo sejam válidas:
tsTrymyForEach ([1, 2, 3], (a ) =>console .log (a ));myForEach ([1, 2, 3], (a ,i ) =>console .log (a ,i ));
O que isso realmente significa é que callback pode ser invocado com apenas um argumento.
Em outras palavras, a definição da função diz que a implementação pode se parecer com isto:
tsTryfunctionmyForEach (arr : any[],callback : (arg : any,index ?: number) => void) {for (leti = 0;i <arr .length ;i ++) {// I don't feel like providing the index todaycallback (arr [i ]);}}
Por consequência, o TypeScript vai aplicar esse significado e emitir erros que não são realmente possíveis:
tsTrymyForEach ([1, 2, 3], (a ,i ) => {'i' is possibly 'undefined'.18048'i' is possibly 'undefined'.console .log (. i toFixed ());});
Em JavaScript, se você chamar uma função com mais argumentos do que parâmetros, os argumentos extras são simplesmente ignorados. O TypeScript se comporta da mesma forma. Funções com menos parâmetros (dos mesmos tipos) sempre podem ocupar o lugar de funções com mais parâmetros.
Regra: Ao escrever um tipo de função para um callback, nunca escreva um parâmetro opcional, a menos que você pretenda chamar a função sem passar aquele argumento
Overloads de Função
Algumas funções em JavaScript podem ser chamadas com diferentes quantidades e tipos de argumentos.
Por exemplo, você pode escrever uma função para produzir um Date que aceita um timestamp (um argumento) ou uma especificação de mês/dia/ano (três argumentos).
No TypeScript, podemos especificar uma função que pode ser chamada de diferentes formas escrevendo assinaturas de overload. Para isso, escreva algumas assinaturas de função (normalmente duas ou mais), seguidas do corpo da função:
tsTryfunctionmakeDate (timestamp : number):Date ;functionmakeDate (m : number,d : number,y : number):Date ;functionmakeDate (mOrTimestamp : number,d ?: number,y ?: number):Date {if (d !==undefined &&y !==undefined ) {return newDate (y ,mOrTimestamp ,d );} else {return newDate (mOrTimestamp );}}constd1 =makeDate (12345678);constd2 =makeDate (5, 5, 5);constNo overload expects 2 arguments, but overloads do exist that expect either 1 or 3 arguments.2575No overload expects 2 arguments, but overloads do exist that expect either 1 or 3 arguments.d3 =(1, 3); makeDate
Neste exemplo, escrevemos dois overloads: um que aceita um argumento e outro que aceita três. Essas duas primeiras assinaturas são chamadas de assinaturas de overload.
Em seguida, escrevemos uma implementação da função com uma assinatura compatível. Funções têm uma assinatura de implementação, mas essa assinatura não pode ser chamada diretamente. Mesmo que tenhamos escrito uma função com dois parâmetros opcionais depois do obrigatório, ela não pode ser chamada com dois parâmetros!
Assinaturas de Overload e a Assinatura de Implementação
Esta é uma fonte comum de confusão. Muitas vezes, as pessoas escrevem código assim e não entendem por que há um erro:
tsTryfunctionfn (x : string): void;functionfn () {// ...}// Expected to be able to call with zero argumentsExpected 1 arguments, but got 0.2554Expected 1 arguments, but got 0.(); fn
De novo: a assinatura usada para escrever o corpo da função não pode ser “vista” de fora.
A assinatura da implementação não é visível de fora. Ao escrever uma função com overloads, você deve sempre ter duas ou mais assinaturas acima da implementação da função.
A assinatura de implementação também precisa ser compatível com as assinaturas de overload. Por exemplo, estas funções têm erros porque a assinatura de implementação não corresponde aos overloads de forma correta:
tsTryfunctionfn (x : boolean): void;// Argument type isn't rightfunctionThis overload signature is not compatible with its implementation signature.2394This overload signature is not compatible with its implementation signature.( fn x : string): void;functionfn (x : boolean) {}
tsTryfunctionfn (x : string): string;// Return type isn't rightfunctionThis overload signature is not compatible with its implementation signature.2394This overload signature is not compatible with its implementation signature.( fn x : number): boolean;functionfn (x : string | number) {return "oops";}
Escrevendo Bons Overloads
Assim como os genéricos, há algumas diretrizes que você deve seguir ao usar overloads de função. Seguir esses princípios vai tornar sua função mais fácil de chamar, de entender e de implementar.
Vamos considerar uma função que retorna o tamanho de uma string ou de um array:
tsTryfunctionlen (s : string): number;functionlen (arr : any[]): number;functionlen (x : any) {returnx .length ;}
Esta função está correta: podemos invocá-la com strings ou com arrays. No entanto, não podemos invocá-la com um valor que pode ser uma string ou um array, porque o TypeScript só consegue resolver uma chamada de função para um único overload:
tsTrylen (""); // OKlen ([0]); // OKNo overload matches this call. Overload 1 of 2, '(s: string): number', gave the following error. Argument of type 'number[] | "hello"' is not assignable to parameter of type 'string'. Type 'number[]' is not assignable to type 'string'. Overload 2 of 2, '(arr: any[]): number', gave the following error. Argument of type 'number[] | "hello"' is not assignable to parameter of type 'any[]'. Type 'string' is not assignable to type 'any[]'.2769No overload matches this call. Overload 1 of 2, '(s: string): number', gave the following error. Argument of type 'number[] | "hello"' is not assignable to parameter of type 'string'. Type 'number[]' is not assignable to type 'string'. Overload 2 of 2, '(arr: any[]): number', gave the following error. Argument of type 'number[] | "hello"' is not assignable to parameter of type 'any[]'. Type 'string' is not assignable to type 'any[]'.len (Math .random () > 0.5 ? "hello" : [0]);
Como os dois overloads têm a mesma quantidade de argumentos e o mesmo tipo de retorno, podemos escrever uma versão sem overloads da função:
tsTryfunctionlen (x : any[] | string) {returnx .length ;}
Isso é muito melhor! Quem chama pode invocá-la com qualquer um dos dois tipos de valor e, como bônus, não precisamos descobrir uma assinatura de implementação correta.
Sempre prefira parâmetros com tipos união em vez de overloads, quando possível
Declarando this em uma Função
O TypeScript vai inferir qual deve ser o this em uma função por meio de análise de fluxo de código, por exemplo no caso a seguir:
tsTryconstuser = {id : 123,admin : false,becomeAdmin : function () {this.admin = true;},};
O TypeScript entende que a função user.becomeAdmin tem um this correspondente, que é o objeto externo user. this, he, he, pode ser suficiente para muitos casos, mas há muitas situações em que você precisa de mais controle sobre qual objeto o this representa. A especificação do JavaScript diz que você não pode ter um parâmetro chamado this, então o TypeScript usa essa posição de sintaxe para permitir que você declare o tipo de this no corpo da função.
tsTryinterfaceDB {filterUsers (filter : (this :User ) => boolean):User [];}constdb =getDB ();constadmins =db .filterUsers (function (this :User ) {return this.admin ;});
Esse padrão é comum em APIs no estilo callback, em que outro objeto normalmente controla quando a sua função é chamada. Observe que você precisa usar function e não arrow functions para obter esse comportamento:
tsTryinterfaceDB {filterUsers (filter : (this :User ) => boolean):User [];}constdb =getDB ();constThe containing arrow function captures the global value of 'this'.Element implicitly has an 'any' type because type 'typeof globalThis' has no index signature.7041admins =db .filterUsers (() =>this .); admin
7017The containing arrow function captures the global value of 'this'.Element implicitly has an 'any' type because type 'typeof globalThis' has no index signature.
Outros Tipos que Você Deve Conhecer
Há alguns tipos adicionais que você vai querer reconhecer, pois aparecem com frequência ao trabalhar com tipos de função. Como todos os tipos, você pode usá-los em qualquer lugar, mas estes são especialmente relevantes no contexto de funções.
void
void representa o valor de retorno de funções que não retornam um valor.
É o tipo inferido sempre que uma função não tem nenhum return ou não retorna nenhum valor explícito nessas instruções:
tsTry// The inferred return type is voidfunctionnoop () {return;}
Em JavaScript, uma função que não retorna nenhum valor vai retornar implicitamente o valor undefined.
No entanto, void e undefined não são a mesma coisa no TypeScript.
Há mais detalhes no final deste capítulo.
voidnão é o mesmo queundefined.
object
O tipo especial object se refere a qualquer valor que não seja primitivo (string, number, bigint, boolean, symbol, null ou undefined).
Ele é diferente do tipo objeto vazio { } e também é diferente do tipo global Object.
É muito provável que você nunca vá usar Object.
objectnão éObject. Sempre useobject!
Observe que, em JavaScript, valores de função são objetos: têm propriedades, têm Object.prototype na cadeia de protótipos, são instanceof Object, você pode chamar Object.keys neles, e assim por diante.
Por esse motivo, tipos de função são considerados objects no TypeScript.
unknown
O tipo unknown representa qualquer valor.
É semelhante ao tipo any, mas é mais seguro, porque não é válido fazer nada com um valor unknown:
tsTryfunctionf1 (a : any) {a .b (); // OK}functionf2 (a : unknown) {'a' is of type 'unknown'.18046'a' is of type 'unknown'.. a b ();}
Isso é útil ao descrever tipos de função porque você pode descrever funções que aceitam qualquer valor sem ter valores any no corpo da função.
Por outro lado, você pode descrever uma função que retorna um valor de tipo unknown:
tsTryfunctionsafeParse (s : string): unknown {returnJSON .parse (s );}// Need to be careful with 'obj'!constobj =safeParse (someRandomString );
never
Algumas funções nunca retornam um valor:
tsTryfunctionfail (msg : string): never {throw newError (msg );}
O tipo never representa valores que nunca são observados.
Em um tipo de retorno, isso significa que a função lança uma exceção ou encerra a execução do programa.
never também aparece quando o TypeScript determina que não sobrou nada em uma união.
tsTryfunctionfn (x : string | number) {if (typeofx === "string") {// do something} else if (typeofx === "number") {// do something else} else {x ; // has type 'never'!}}
Function
O tipo global Function descreve propriedades como bind, call, apply e outras presentes em todos os valores de função em JavaScript.
Ele também tem a propriedade especial de que valores do tipo Function podem sempre ser chamados; essas chamadas retornam any:
tsTryfunctiondoSomething (f :Function ) {returnf (1, 2, 3);}
Esta é uma chamada de função não tipada e, em geral, é melhor evitá-la por causa do tipo de retorno any, que não é seguro.
Se você precisa aceitar uma função arbitrária, mas não pretende chamá-la, o tipo () => void costuma ser mais seguro.
Parâmetros Rest e Argumentos
Leitura complementar:
Parâmetros rest
Sintaxe de spread
Parâmetros Rest
Além de usar parâmetros opcionais ou overloads para criar funções que aceitam uma variedade de quantidades fixas de argumentos, também podemos definir funções que recebem um número ilimitado de argumentos usando parâmetros rest.
Um parâmetro rest aparece depois de todos os outros parâmetros e usa a sintaxe ...:
tsTryfunctionmultiply (n : number, ...m : number[]) {returnm .map ((x ) =>n *x );}// 'a' gets value [10, 20, 30, 40]consta =multiply (10, 1, 2, 3, 4);
No TypeScript, a anotação de tipo desses parâmetros é implicitamente any[] em vez de any, e qualquer anotação de tipo informada deve ter a forma Array<T> ou T[], ou ser um tipo tupla (sobre o qual vamos aprender mais adiante).
Argumentos Rest
Por outro lado, podemos fornecer um número variável de argumentos a partir de um objeto iterável (por exemplo, um array) usando a sintaxe de spread.
Por exemplo, o método push de arrays aceita qualquer número de argumentos:
tsTryconstarr1 = [1, 2, 3];constarr2 = [4, 5, 6];arr1 .push (...arr2 );
Observe que, em geral, o TypeScript não assume que arrays são imutáveis. Isso pode levar a um comportamento surpreendente:
tsTry// Inferred type is number[] -- "an array with zero or more numbers",// not specifically two numbersconstargs = [8, 5];constA spread argument must either have a tuple type or be passed to a rest parameter.2556A spread argument must either have a tuple type or be passed to a rest parameter.angle =Math .atan2 (...args );
A melhor correção para essa situação depende um pouco do seu código, mas, em geral, um contexto const é a solução mais direta:
tsTry// Inferred as 2-length tupleconstargs = [8, 5] asconst ;// OKconstangle =Math .atan2 (...args );
Usar argumentos rest pode exigir ativar downlevelIteration ao compilar para runtimes mais antigos.
Desestruturação de Parâmetros
Leitura complementar:
Atribuição via desestruturação
Você pode usar a desestruturação de parâmetros para desempacotar de forma conveniente objetos fornecidos como argumento em uma ou mais variáveis locais no corpo da função. Em JavaScript, fica assim:
jsfunction sum({ a, b, c }) {console.log(a + b + c);}sum({ a: 10, b: 3, c: 9 });
A anotação de tipo do objeto vai depois da sintaxe de desestruturação:
tsTryfunctionsum ({a ,b ,c }: {a : number;b : number;c : number }) {console .log (a +b +c );}
Isso pode parecer um pouco verboso, mas você também pode usar um tipo nomeado aqui:
tsTry// Same as prior exampletypeABC = {a : number;b : number;c : number };functionsum ({a ,b ,c }:ABC ) {console .log (a +b +c );}
Compatibilidade de atribuição de funções
Tipo de retorno void
O tipo de retorno void para funções pode produzir alguns comportamentos incomuns, mas esperados.
A tipagem contextual com tipo de retorno void não obriga as funções a não retornarem nada. Dito de outra forma: um tipo de função contextual com retorno void (type voidFunc = () => void), quando implementado, pode retornar qualquer outro valor, mas esse valor será ignorado.
Assim, as seguintes implementações do tipo () => void são válidas:
tsTrytypevoidFunc = () => void;constf1 :voidFunc = () => {return true;};constf2 :voidFunc = () => true;constf3 :voidFunc = function () {return true;};
E quando o valor de retorno de uma dessas funções é atribuído a outra variável, ele mantém o tipo void:
tsTryconstv1 =f1 ();constv2 =f2 ();constv3 =f3 ();
Esse comportamento existe para que o código a seguir seja válido, mesmo que Array.prototype.push retorne um número e o método Array.prototype.forEach espere uma função com tipo de retorno void.
tsTryconstsrc = [1, 2, 3];constdst = [0];src .forEach ((el ) =>dst .push (el ));
Há mais um caso especial a conhecer: quando uma definição de função literal tem tipo de retorno void, essa função não deve retornar nada.
tsTryfunctionf2 (): void {// @ts-expect-errorreturn true;}constf3 = function (): void {// @ts-expect-errorreturn true;};
Para saber mais sobre void, consulte estas outras entradas da documentação: