Búsqueda de sitios web

¿Necesitamos anotaciones de tipo incluso después de agregar aserciones de tipo en Typescript?

¿Realmente necesitamos especificar el tipo de una variable si especificamos as en Typescript?

Por ejemplo: El siguiente código me da el mismo tipo de objeto. Pero, quiero saber la manera correcta de hacer esto.

const x: Student = {
  name: "John"
}

// is the above same as below

const x = {
  name: "John"
} as Student;

// or do we need to specify both

const x: Student = {
  name: "John"
} as Student;

export interface Student {
  name: string,
  id?: string
}

Respuesta #1

Las anotaciones de tipo y las afirmaciones de tipo sirven para necesidades diferentes pero parcialmente superpuestas; de hecho, es raro que alguna vez quieras usar ambos.

Una anotación de tipo te permite elegir explícitamente el tipo de una variable. A menudo es innecesaria; sin una anotación de tipo explícita, el tipo de la variable a menudo puede inferirse por el tipo de su valor inicial. Si el tipo de ese valor es suficiente para tus necesidades, entonces una anotación es esencialmente redundante. Si el tipo de ese valor es insuficiente, entonces una anotación es útil. Por ejemplo en

const x = { name: "John" }
/* const x: { name: string; } */

el compilador infiere el tipo de x como {name: string}. Esto es asignable a Student, y por lo tanto, dependiendo de tu caso de uso, podría ser suficiente:

function acceptStudent(s: Student) { }
acceptStudent(x); // works

Pero deberías sentirte libre de usar una anotación si lo prefieres:

const x: Student = {
  name: "John"
}

Las anotaciones de tipo se verifican con bastante estrictidad. Si anotas una variable con un tipo incompatible con su inicializador, obtendrás un error:

const x: Student = { // error!
  id: "John",
}

Una afirmación de tipo, por otro lado, te permite declarar que una expresión es de un cierto tipo. Esto se utiliza principalmente cuando sabes más sobre el tipo de una expresión de lo que el compilador puede verificar... tú lo afirmas, a pesar de la incapacidad del compilador para ver que la afirmación es verdadera. En realidad, otro caso de uso es cuando necesitas mentir deliberadamente al compilador sobre el tipo de una expresión para poder continuar. Nuevamente, también es bastante frecuente que sea innecesario, ya que los tipos inferidos por el compilador para tales expresiones suelen ser razonables. Pero hay ocasiones en que quieres cambiar la visión del compilador sobre el tipo de una expresión:

const x = {
  id: "John"
} as Student; // no error

Aquí el compilador no se queja, aunque {id: "John"} no sea un Student válido. Sin embargo, es lo suficientemente cercano para que el compilador acepte tu afirmación.

Así que depende de cuáles sean tus necesidades. El consejo general aquí es más o menos: prefiere anotaciones sobre afirmaciones, y prefiere inferencia sobre anotaciones. Si la inferencia es suficiente, úsala. Si no, entonces anota. Si eso todavía no funciona, considera afirmar (pero con cuidado). Y usar ambos casi con seguridad es excesivo. Una vez que afirmas el tipo de una expresión de inicialización, ese tipo será el tipo inferido para la variable, y por lo tanto, una anotación es redundante.

Enlace de Playground al código

Artículos relacionados