Início / coding / Perguntas / 78939508
Accepted
LeoPkm2-1
Asked: 2024-09-02 16:14:08 +0800 CST

Por que as funções Contravariância com seus parâmetros no TypeScript?

  • 772

Estudei recentemente os conceitos genéricos em Typescript. Tenho um problema em entender "Por que as funções contravariância com seus parâmetros?" . Eu sei que:

  1. Covarianceé se T extends U( Té atribuível a U), é verdade que G<T> extends G<U>( G<T>também é atribuível a G<U>)

  2. Contravarianceé se T extends U, é certo concluir que G<U> extends G<T>(agora G<U>é atribuível a G<T>).

antes de fazer a pergunta neste fórum, li as seguintes postagens. No entanto, ainda tenho dificuldade em entender por que as funções no Typescript são contravariantes em seus parâmetros :

Vejo que não apenas funções são contravariantes com seus parâmetros em TypeScript, mas algumas outras linguagens também são verdadeiras.

Sinto-me tão frustrado por aceitar isso sem descobrir por que é verdade. Você poderia me ajudar a explicar ou se eu estiver faltando conhecimento relacionado, por favor me diga o que é.

typescript

1 respostas

  1. Best Answer

    Usarei o exemplo concreto de Animale Dog.

    class Animal {
  move(distanceInMeters: number = 0) {
    console.log(`Animal moved ${distanceInMeters}m.`);
  }
}
 
class Dog extends Animal {
  bark() {
    console.log("Woof! Woof!");
  }
}

    Há duas opções para permitir a atribuição entre Doge Animal, podemos substituir Dogpor Animale podemos substituir Animalpor Dog.

    const animal: Animal = new Dog; 
animal.move(10);

    Porque extendssignifica que temos os membros da base, isso é bom. O Typescript permite isso

    const dog: Dog = new Animal;
dog.bark();

    Não há um barkmétodo em Animal, então isso falharia em tempo de execução. Typescript proíbe isso.

    Agora vamos dar uma olhada nos tipos de função.

    const dog: Dog = new Dog;
const animal: Animal = new Animal;

type UseAnimal: (animal: Animal) => void;
type UseDog: (dog: dog) => void;

const useAnimal: UseAnimal = (animal: Animal) => { animal.move(10); }
const useDog: UseDog = (dog: Dog) => { dog.bark() }

    Os designers de linguagem têm a mesma escolha sobre parâmetros de função. Vamos ver o que acontece quando permitimos os dois casos

    const dogFn: UseDog = useAnimal;
dogFn(dog);

    Porque estamos passando um Dogpara useAnimalele está bom, pode move(10)como acima. Typescript permite isso.

    const animalFn: UseAnimal = useDog;
animalFn(animal)

    O Animalwe pass to useDogcausaria uma falha de tempo de execução, porque falta bark(). Typescript proíbe isso.

    • 3

relate perguntas