param - typescript should i use any




'any' vs 'Object' (5)

Adicionando a resposta de Alex e simplificando-o:

Objetos são mais rigorosos com seu uso e, portanto, dão ao programador mais poder de "avaliação" de tempo de compilação e, portanto, em muitos casos fornecem mais "capacidade de verificação" e podem evitar vazamentos, enquanto qualquer é um termo mais genérico e muito compilar as verificações de tempo podem, portanto, ser ignoradas.

Eu estou olhando para o código TypeScript e notei que eles usam:

interface Blablabla {

   field: Object;

}

Qual é o benefício de usar o Object vs any , como em:

interface Blablabla {

  field: any;

}

Ao contrário do .NET, onde todos os tipos derivam de um "objeto", no TypeScript, todos os tipos derivam de "qualquer". Eu só queria adicionar essa comparação, pois acho que será uma versão comum feita com mais desenvolvedores .NET dando uma chance ao TypeScript.


Pouco antigo, mas não faz mal para adicionar algumas notas.

Quando você escreve algo assim

var a: any;
var b: Object;
var c: {};
  • a não tem nenhuma interface, pode ser qualquer coisa, o compilador não sabe nada sobre seus membros, então uma verificação de tipo mínima é feita ao acessar / atribuir ambos a si e seus membros. Basicamente, você está dizendo ao compilador para " recuar, eu sei o que estou fazendo, então apenas confie em mim ";
  • b tem a interface Object, portanto, APENAS os membros definidos nessa interface estão disponíveis para b . Ainda é JavaScript, então tudo estende o Object;
  • c estende o Object, como qualquer outra coisa no TypeScript, mas não adiciona membros. Como a compatibilidade de tipos no TypeScript é baseada na subtipagem estrutural, não na subtipagem nominal, c acaba sendo o mesmo que b porque eles têm a mesma interface: a interface Object.

E é por causa disso

a.doSomething(); // Ok: the compiler trusts you on that
b.doSomething(); // Error: Object has no doSomething member
c.doSomething(); // Error: c neither has doSomething nor inherits it from Object

e porque

a.toString(); // Ok: whatever, dude, have it your way
b.toString(); // Ok: toString is defined in Object
c.toString(); // Ok: c inherits toString from Object

Portanto, tanto Object quanto {} são equivalentes para o TypeScript. Eu não vejo ninguém realmente usando isso. Muito restritivo.

Se você declarar funções como estas

function fa(param: any): void {}
function fb(param: Object): void {}

com a intenção de aceitar qualquer coisa para param (talvez você esteja indo para verificar os tipos em tempo de execução para decidir o que fazer com ele), lembre-se que

  • dentro do fa , o compilador permitirá que você faça o que quiser com o param ;
  • dentro do fb , o compilador só vai deixar você acessar os membros do Object, e você vai acabar tendo que fazer muita typecasting lá ...

Então, basicamente, quando você não conhece o tipo, execute qualquer verificação de tipo em tempo de execução.

Obviamente, as regras de herança OO ainda se aplicam, portanto, se você quiser aceitar instâncias de classes derivadas e tratá-las com base em seu tipo base, como em

interface IPerson {
    gender: string;
}

class Person implements IPerson {
    gender: string;
}

class Teacher extends Person {}

function func(person: IPerson): void {
    console.log(person.gender);
}

func(new Person());     // Ok
func(new Teacher());    // Ok
func({gender: 'male'}); // Ok
func({name: 'male'});   // Error: no gender..

o tipo base é o caminho para isso, não qualquer . Mas isso é OO, fora de escopo, eu só queria esclarecer que qualquer um só deve ser usado quando você não sabe o que está vindo, e para qualquer outra coisa você deve anotar o tipo correto.

ATUALIZAR:

O Typescript 2.2 adicionou um tipo de object , que especifica que um valor é não-primitivo: (ou seja, não é um number , string , boolean , symbol , undefined ou null ).

Considere funções definidas como:

function b(x: Object) {}
function c(x: {}) {}
function d(x: object) {}

x terá as mesmas propriedades disponíveis dentro de todas essas funções, mas é um erro de tipo para chamar d com qualquer coisa não primitiva:

b("foo"); //Okay
c("foo"); //Okay
d("foo"); //Error: "foo" is a primitive

tente isso:

private a: Object<any> = {};

constructor() {
    a.name = "foo";
}

any é algo específico para o TypeScript é explicado muito bem pela resposta de alex.

Object refere-se ao tipo de object JavaScript. Comumente usado como {} ou às vezes new Object . A maioria das coisas no javascript são compatíveis com o tipo de dados do objeto, pois herdam dele. Mas any é específico do TypeScript e compatível com tudo em ambas as direções (não baseado em herança). por exemplo :

var foo:Object; 
var bar:any;
var num:number;

foo = num; // Not an error
num = foo; // ERROR 

// Any is compatible both ways 
bar = num;
num = bar;  




typescript