Unknown type

Unknown type

Este tipo de dato es la mejora de any, ya que nos da la flexibilidad que en ocasiones queremos pero sin apagar por completo el análisis de código estático. Unknown nos fuerza a hacer una verificación de tipo.

let foo: unknown = null;

Les comparto mis apuntes. 😄

¿Qué hace?

Este nos dice que la variable es desconocida, es similar a any, pero es la forma recomendable de trabajar para evitar any en los casos que sean necesarios.

Diferencias con any

Con any podemos hacer lo que queramos, no hay restricción alguna, pero con unknown vamos a tener advertencias al momento de usar alguna función o método con variables de tipo unknown.

Para poder pasar las advertencias tenemos que usar un filtro o realizar una verificación, una estructura condicional, para poder hacer lo que queremos con esa variable.

Recomendación

Utilizar unknown siempre por sobre any, pero solo en caso de que sea necesario.

Unknown types

Sabemos que para usar “cualquier tipo de dato” podemos usar el tipo any sin embargo, esto es peligroso ya que le indicamos que puede entrar cualquier tipo de dato.

Es por ello que es una muy buena práctica utilizar el tipo de dato unknown ya que esta nos permite trabajar con cualquier tipo de dato pero en base al tipo de dato podemos asignarla a otra variable o realizar algo en especial.

let x:unknown = 10; 
let v1: number =  x //  Error
let v2: object = x; // Error
let v3: string = x; // Error
let v4: string[] = x; // Error
let v5: {} = x; // Error
let v6: {} | null | undefined = x; // Error
// definimos el tipo 
let v10: number = x as number  // Ok

También nos permite realizar operaciones hasta poder definir un tipo de dato específico:

function sum(a:unknown, b: number) {
    // comprobando el tipo
    if(typeof a === "number"){
        return a + b
    }
   throw new Error(`La variable '${a}' no es un número`);
    
}
sum(10,2) // 12
// Error 
sum("hola",2) // La variable 'hola' no es un número 
sum({a:5},2) // La variable [object Object] no es un númer```

anyVar

ctrl + d
f2
unknown
enter

Usa unknown type. Esto puede colocarte por encima de un dev con experiencia por el sencillo hecho de entender las validaciones en variables.

https://mariusschulz.com/blog/the-unknown-type-in-typescript

usar el tipo unknown en lugar de any en caso de ser necesario (tratar de evitar ambis tipos)

Porfín conozco lo desconocido

Unknown Type

Material de la clase.

let anyVar :any
;
anyVar = true;
anyVar = undefined;
anyVar = null;
anyVar = 1;
anyVar = [];
anyVar = {}; // <-- anyVar a esta altura es un objeto vacio

let isNew:boolean = anyVar;// ❌ asigna el tipo boolean a una variable que esta definida como objeto, y esto puede provocar que tus programas fallen

anyVar.doSomething();// ❌no corrige el tipado erroneo, ya que el metodo  doSometing() no existe
anyVar.touppercase();// ❌tampoco corrige typos, ya que en este caso el metodo touppercase esta mal escrito pero al ser any no lo reconoce.

let unknowVar: unknown;

unknowVar = true;
unknowVar = undefined;
unknowVar = null;
unknowVar = 1;
unknowVar = [];
unknowVar = {};

unknowVar.doSomething(); //✅ reconoce que el metodo no existe. y lo marca como error

// verificacion de tipos
if (typeof unknowVar ==="string") {
  unknowVar.touppercase() //✅ corrige los errores de typos, en este caso nos advierte que el metodo esta mal escrito.
  unknowVar.toUpperCase(); //✅ Si se define de entrada que la variable será un string permite las ayudas de VSC y lo reconoce como string.
}
if (typeof unknowVar ==="boolean") {
  let isNew2:boolean=unknowVar // ✅ si se hace la verificacion, especificando que la variable será un booleano entonces no marca error
}
let isNew2:boolean=unknowVar ✅// si no se hace la verificacion, lo marca como error, ya que unknowVar esta declarada como objeto
//en las funciones

const parse =(str:string):unknown=>{
  return JSON.parse(str); // evita que la funcion explote debido no darle formato adecuado en este caso en formato JSON.
}

“foo” es simplemente un término comúnmente utilizado como un marcador temporal en ejemplos de código, y su significado exacto depende del contexto en el que se utiliza.