Eu escrevi este código
interface Foo {
abcdef: number;
}
let x: Foo | string;
if (x instanceof Foo) {
// ...
}
Mas o TypeScript me deu este erro:
'Foo' only refers to a type, but is being used as a value here.
Por que isso está acontecendo? Achei que isso instanceofpoderia verificar se meu valor tem um determinado tipo, mas o TypeScript parece não gostar disso.
Respostas:
O problema é que instanceof é uma construção do JavaScript e, em JavaScript, instanceofespera um valor para o operando do lado direito. Especificamente, no x instanceof FooJavaScript irá executar uma verificação de tempo de execução para ver se Foo.prototypeexiste em qualquer lugar na cadeia de protótipos de x.
No entanto, no TypeScript, interfaces não têm emit. Isso significa que Foonem Foo.prototypeexiste nem em tempo de execução, portanto, este código irá falhar definitivamente.
O TypeScript está tentando dizer que isso nunca funcionaria. Fooé apenas um tipo, não é um valor!
instanceof?"Você pode examinar os protetores de tipo e os protetores de tipo definidos pelo usuário .
interface para um class?"Você pode ficar tentado a mudar de um interfacepara um class, mas você deve perceber que no sistema de tipo estrutural do TypeScript (onde as coisas são principalmente baseadas na forma ), você pode produzir qualquer objeto que tenha a mesma forma de uma determinada classe:
class C {
a: number = 10;
b: boolean = true;
c: string = "hello";
}
let x = new C()
let y = {
a: 10, b: true, c: "hello",
}
// Works!
x = y;
y = x;
Nesse caso, você tem xe yque tem o mesmo tipo, mas se tentar usar instanceofem um deles, obterá o resultado oposto no outro. Então, instanceofnão vai realmente dizer muito sobre o tipo se você está aproveitando tipos estruturais à máquina.
instanceoffunciona com classes, não interfaces. Pensei que isso precisava ser enfatizado.
Fazer a verificação de tipo em tempo de execução com uma interface é usar protetores de tipo , se as interfaces que você deseja verificar têm propriedades / funções diferentes .
Exemplo
let pet = getSmallPet();
if ((pet as Fish).swim) {
(pet as Fish).swim();
} else if ((pet as Bird).fly) {
(pet as Bird).fly();
}
Duck, você digita guarda, ele se torna Fish, mas ainda sem exceção de tempo de execução quando você invoca swim(). Sugiro que você crie 1 nível de interface comum (por exemplo Swimmable) e mova suas swim()funções para lá, então digite guard ainda ficará bem com ((pet as Swimmable).swim.
'swim' in petcondição. Ele vai reduzi-lo a um subconjunto que tem de ter swimdefinido (ex: Fish | Mammal)
Daniel Rosenwasser pode estar certo e elegante, mas estou com vontade de fazer uma alteração à sua resposta. É totalmente possível verificar a instância de x, consulte o trecho de código.
Mas é igualmente fácil atribuir x = y. Agora, x não seria uma instância de C, pois y só tinha a forma de C.
class C {
a: number = 10;
b: boolean = true;
c: string = "hello";
}
let x = new C()
let y = {
a: 10, b: true, c: "hello",
}
console.log('x is C? ' + (x instanceof C)) // return true
console.log('y is C? ' + (y instanceof C)) // return false
Foo | string.