Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Object

13/32
Recursos

Aportes 53

Preguntas 10

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Like si ves los videos de Luis en 1.5x

Estaría bien que Luis comentara para qué usaría object.

No tengo la más absoluta idea de como y que casos usar object.

Se tenia que decir y se dijo.

Se me ocurre que puede ser de utilidad cuando uno quiere evitar mutar una variable. En el ejemplo voy a guardar user en una variable auxiliar newUser, luego voy a actualizar el nombre del primer usuario y finalmente voy a mostrar sus resultados.

caso 1) Object

const user = { 
  id: 1, 
  name: 'Harry' 
}

const newUser = user
user.name = 'Henry'; 
console.log('user', user); // user { id: 1, name: 'Henry' }
console.log('newUser', newUser); // newUser { id: 1, name: 'Henry' }

caso 2): object

let user: object;
user = {}
user = { 
  id: 1, 
  name: 'Harry' 
}

const newUser = user
// user.name = 'Henry' // Error
user = {...user, name: 'Henry'} 
console.log('user', user); // user { id: 1, name: 'Henry' }
console.log('newUser', newUser); // newUser { id: 1, name: 'Harry' }

Como podemos observar debido a que en el caso 1 es posible acceder a la propiedad name se puede llegar a mutar la variable lo que puede causar errores, mientras que para el caso 2 debido a que no es posible acceder a las propiedades del objeto nos vemos forzados a buscar otra alternativa que causa que las variables no muten.

El profesor debería haber aclarado los usos de object de TS. No ha quedado claro de para que usar el tipo de dato TS. Ese era el tema del capitulo. no instanciar un Object de JS.

Esta lectura les puede ayudar a comprender mejor la diferencia https://2ality.com/2020/01/typing-objects-typescript.html#object-vs.-object-in-typescript

  • Object

    Es un tipo de dato no primitivo.

    Declarar a una variable con el tipo object no es lo mismo que crear un Object nativo de JS

    Si tenemos un objeto declarado con el object de TS no podremos acceder a sus atributos mientras que si lo hacemos regularmente como en vanilla JS si podremos hacerlo.

    Por lo tanto declarar una variable como object de TS nos puede llegar a servir para una situacion en la que no querramos que el objeto pueda mutar.

    Sintaxis:

    //Explicito
    let user: object = { id: 234, name: "Federico"}
    
    //Implicito
    //Este objeto sera creado como un objeto nativo de JS
    let user = { id: 234, name: "Federico"}
    
// ------ Tipo: object ------
// explicito
let user: object;
user = {}; // Object
user = {
    id: 1,
    username: 'paparazzi',
    firstname: 'Pablo',
    isPro: true
};
console.log('user', user);
// console.log('user.username', user.username); // --> no se puede acceder al dato username

/*
 * Object: instancia de la clase Object de JavaScript
 * object: tipo para valores no primitivos
 */

// ---- Object vs object (Clase JS vs tipo TS) ----
// considera como tipo instancia Object de JavaScript
const myObj = {
    id: 1,
    username: 'paparazzi',
    firstname: 'Pablo',
    isPro: true
};
const isInstance = myObj instanceof Object; // trueo o false
console.log('isInstance : ', isInstance); // clase Object JavaScript
console.log('myObj.username : ', myObj.username); // --> se puede acceder al dato username

Diferencias entre object y Object.
Object: instancia de la clase Object de Javascript
object: tipo para valores no primitivos. Con este tipo no se puede acceder a las propiedades del objeto.

Siento que la object de TypeScript solo la usaría para mostrar un Objeto que no tenga que editar ni acceder a sus atributos. De resto la gracia de un objeto es acceder a sus atributos.

Muy mal, el profesor deberia responder su propia pregunta al final de la clase, no puede ser que se tome todo el tiempo del mundo para explicar algo tan basico como tipos de datos primitivos (Que sinceramente deberia darse por sabido en el curso) y no se tome ni 2 minutos en responder algo tan importante y confuso como el uso de este ‘object’ de typescript que no parece tener ninguna ventaja por sobre ‘Object’ de js.
Por favor, no tengan miedo en comentar sus opiniones y en especial de puntuar este curso con las estrellas que merece.

Siento que veníamos divinamente y en las últimas 3 clases no he entendido nada.

Object en JS viene siendo una clase cual se ha manejado toda la vida en POO, cuando hablamos de object en TS nos estamos refiriendo simplemente un tipo, como un string, o un number, que viene siendo algo más abstracto, por lo cual object en TS no hereda nada de un Object en JS.
Si estoy mal me corrigen please jejeje

Una alternativa para usar el tipado en un objeto similar es crear una interface: const user: IUser; interface IUser { name: string; age: number; }

Para que lo tengan en cuenta… si te lo preguntas, en el minuto 6:52, el profesor solo cambio uno de los dos parametros que recibe el console.log, el segundo parametro paso de ser user.username a myObj.username pero se olvido de hacer el cambio en el primer parametro, ese console.log que realizo al final deberia haber quedado asi console.log( 'myObj.username', myObj.username )

Es primera vez que veo dos veces un vídeo en Platzi. El profesor domina la materia claramente, pero no logra ser lo suficientemente claro para que yo domine el entendimiento de su explicación… Pienso que deberían agregar una clase adicional para ejemplificar de mejor manera el uso.

la verdad no le encuentro mucho sentido a object
Pues typescript se creo precisamente para tener control de las variables. Esta propiedad no permite acceder a las propiedades, sooooooo

Se me ocurre, que se podría usar en casos en los que quieras asigna a un objeto la información de un usuario que sea secreto y que quisieras proteger el acceso a la información de el usuario para que no pueda ser accedida.

le estoy dando una repasada al curso ya que realmente para usar POO en JS si es necesario usar TS, ya que el POO en JS es algo basico por lo que para usar los principios de solid creo que si necesito TS para entenderlos al 100 los comprendo JS pero no al 100

Si tenemos en cuenta el paradigma orientado a objetos, se puede inferir que el tipo <object> de typescript se puede usar para encapsular valores como si de un <private> se tratara; y el tipo Object de JavaScript como si fuera un <public>.

tipo object para no permitir el acceso a los atributos del objeto.

  • Object: instancia de la clase Object en JavaScript
  • object: tipo para valores no primitivos

Con este tipo no se puede acceder a las propiedades del objecto

Esto es lo que dice la documentacion de typescript: Generally, you won’t need to use this. En pocas palabras, ignoren el tipo object.

Tengo entendido que {}, es decir, Object, es mejor que object.

El tipo object de typescript se utiliza cuando queremos validar la estructura interna de nuestros objetos.

Es decir, cuando queramos tener una estructura definida. Por ejemplo:

let user: {
  id: number,
  username: string,
  firstName: string,
  isProd: boolean
};

user = {
  id: 1,
  username: 'hola',
  firstName: 'Samy',
  isProd: true
};

console.log('user ', user);
console.log('user.username', user.username); // No salta error porque es una propieda establecida en el tipado

console.log('user.username', user.somethingElse); // Salta error porque somethingElse no fue definida durante el tipado

un poco raro este concepto de object

No lo sé, dime tú.

No es clara la diferencia entre object y Object.

Encontré una manera de acceder a las propiedades de un object

No lo veo práctico ni útil. Quizás en casos donde la inmutabilidad se imprescindible.

Este es el método:

let user: object = {
    id: 1
}

let userCopy:any = Object.entries(myObj)
userCopy = Object.fromEntries(userCopy)

Tener en cuenta que:

  • En tsconfig.json “target” debe ser mayor o igual a “es2017”
  • La nueva variable tiene que ser de tipo any

.

En caso de que simplemente queramos acceder desde consola

console.log(Object.fromEntries(Object.entries(user)))

console.log(Object.fromEntries(Object.entries(user)).id) // 1

Para no escribir tanto podrían hacer una función.
También se puede usar deepcopy, pero esto es todavía más trabajo

/*** 
 * Object (JS) vs object (TS)
 * - Object (JS): Instancia de la clase Object de JS
 * - object (TS): tipo para valores no primitivos -> Este tipo de dato no puede acceder a las propiedades del objeto
*/

/** Objects on TS */
let myObjectTS: object;
myObjectTS = {}
myObjectTS = {
    id: 1,
    name: 'Andrés Eslava',
    username: 'afelipelds',
    isPro: true
}
// console.log('myObject en Typescript-> ', myObject) // tipo opbjeto de TS

/** Objects on JS */
const myObjectJS = {
    id: 1,
    name: 'Andrés Eslava',
    username: 'afelipelds',
    isPro: true
}

const isInstanceOfJS: boolean = myObjectJS instanceof Object
const isInstanceOfTS: boolean = myObjectTS instanceof Object
console.log('Instancia de un Objeto TS ? -> ',isInstanceOfTS) // Arroja true, porque persiste en ser un objeto, solo que no es primitivo
console.log('Instancia de un Objeto JS ? -> ',isInstanceOfJS) // Arroja true, porque es un Objeto instancia de Js ( con valores primitivos de JS )

Tal como lo leí de un compañero en los comentarios. Ayuda mucho a tener el control sobre la variable objeto. Lo que significa que no es tan fácil acceder a la variable como ya lo sabemos en JS. Se deben buscar una mejor forma para poder hacer que quiera acceder a ésta variable

Tener en cuenta que tanto el Object myObj como en object user dan true si se consulta si son de instancia Object.

console.log(myObj instanceof Object); // true
console.log(user instanceof Object); // true

Así que realmente no entendí la diferencia. Es decir no nos indica nada consultar si uno u otro son de instancia Object de JS pues ambos dice que lo son 🤷🏻‍♂️😅

Interesante y algo confuso tambien 😵‍💫

Las primeras clases explicitó muy bien. Ahora (la clase pasada y está) dice muchas cosas y no dice nada ☹️

Igual ojo porque hice un:
console.log("oject de typescript: ", user instanceof Object);
Y me tiró true por consola, por lo visto no termina de comprobar correctamente.

Con el tipo “object” se esta definiendo que la variable no pertenece a un dato primitivo, en JavaScript todo lo que no sea un valor primitivo se considera un objeto o sea los arrays, las funciones, los objetos, etc. Al definir el tipo de la variable con “Object”, estamos diciendo que esta variable se está instanciando con la clase Object, propia de JavaScript, así TS y por ende JS entenderá que no es un array, ni una función y por lo tanto podremos acceder a sus propiedades.

Lo usaría para las peticiones de la API y asegurarme de que me estan llegando los atributos tal cual los necesito en el Frontend ☜(゚ヮ゚☜)

Tipo: object

  • Object es un tipo de dato que representa un valor no primitivo
  • Es el tipo de variable que no sea number, string, boolean, null, undefined, etc.
let user: object;
user = {}; // Object
user = {
	id: 1,
	username: "paparezzi",
	firstName: "Pablo",
	isPro: true
}
  • Object: Instancia de la clase Object de JavaScript
  • object (TypeScript) tipo para valores no primitivos

Con este tipo o se puede acceder a las propiedades del objecto

prueba de marcador

A mi se me ocurre usar el tipo object para hacer un boxing-unboxing, aunque no es de mucha utilidad puede ser que se haya implementado ya que el creador de Typescript es el mismo que c#, siendo de ayuda a poder operar con esa lógica para los que ya están familizarizados.

Objetos
Diccionarios del tipo objetc.
Puedo acceder a las propiedades/atributos/ valores por medio de las llaves.
Object = Instancia de clases JS, object = Tipo de dato no primitivo TS.

Según lo entiendo en el video la clase Object no puede ser accedida porque allí se podrían modelar los datos que luego podría instanciar con un object y darles un valor según lo definido en Object.

“object”: tipo para valores no primitivos

Mientras que object(en minúsculas) representa todos los tipos no primitivos, Object (en mayúsculas) describe la funcionalidad que es común a todos los objetos JavaScript.

Object javaScript: instancia de la clase Object de Javascript
object TypeScript: tipo para valores no primitivos. Con este tipo no se puede

  1. Object. Este tipo de dato representa a un valor no primitivo (como los ejemplos anteriores)

    // Explícito
    const user: object = {
      id: 1,
      userName: 'paparazzi',
      firstName: 'Pablo',
      isPro: true
    }
    
    console.log(user)
    

    No confundir el tipo de dato object con la clase Object de JavaScript

Cuando tipamos object y asignamos object, es ts.
Cuando tipamos una varia y definimos un objeto en {} sin signarle object, se entiende en automatico como la clase Object de js.

Me encanto la forma de instaciar y validar las intancia de un objeto en ts

Supongo que conforme vaya experimentando hallare como utilizar object, aún no lo he encontrado como comprobación en una función.

tal vez crear un object que mande dentro de un payload como llamada o en una funcion que retorne un object y que de ser contrario la turne o marque como falsa esa función

esos serian mis soluciones o las ideas que mas pronto se me vienen a la cabeza

String, Array y Object con mayus son clases de JS, no tipos, tienen que estar atentos a eso

La única razón que se me ocurre es por respetar el principio de inmutabilidad. Yo recibo un objeto de tipo ‘object’ y despues creo una instancia de este con ‘new’ que ya es de tipo Object. De esta manera siempre protejo al objeto original. Algo como lo que se hace con las funciones map, reduce y filter que iteran sobre un arreglo pero te regresan una nueva instancia.

object en JavaScript se compila como tipo any.

Object en JavaScript se compila como un objeto.

object puede ser útil para regresar al navegador el objeto en modo texto, por ejemplo para una API que regresa valores en JSON.

yo creo que Object de javascript tiene mas funcionalidad como objeto ya que se puede acceder a sus propiedades, mientras que el object de TS es un simple tipo de dato.

MY NOTES OBJECT

  • object es el tipo de dato que representa un valor no primitivo
  • Es el tipo para variable que no sea number, string, boolean, null, undefined, etc.
// Type: Object
let user: object;
user = {}; // Objeti

user = {

  id:1,
  username: 'paparazzi',
  firstName: 'Pablo',
  isPro: true
}

console.log(user);
//Al tratar de acceder a una key de ese objeto da error dice que la propiedad name no existe en el objeto
console.log(user.name);

Object vs object

  • Object: instancia de la clase Object de javascript
  • object tipo para valores no primitivos

Con este tipo no se puede acceder a las propiedades del objeto

// Type: Object
let user: object;
user = {}; // Objeti

user = {

  id:1,
  username: 'paparazzi',
  firstName: 'Pablo',
  isPro: true
}

console.log(user);
//Al tratar de acceder a una key de ese objeto da error dice que la propiedad name no existe en el objeto
//      console.log(user.name);

//Object vs object (Clase JS vs tipo Ts)
  // Cuando acercamos el cursor para ver el tipo de dato que tiene nuestra variable a la que le asignamos
    // Un objeto  vemos que no tiene especificado ningun tipo de dato
      //Esto sucede porque typescript esta considerando al tipo que representa la variable como
        //Una instancia de la clase objeto

const myObj = {

  id:1,
  username: 'paparazzi',
  firstName: 'Pablo',
  isPro: true
}

//Para berificarlo haremos una instancia de nuestra variable que contiene un objeto

const isInstance = myObj instanceof Object; 
console.log('isInstance', isInstance); //true

//Utilizando Object si podremos acceder a los atributos de mi objeto

console.log('isInstance', isInstance)

No le veo sentido usar, a no ser que se quiera tenerla información de ese objeto de una forma restringida. de resto no tiene sentido pienso yo. igual son cosas que hay que saber.

Yo creo que el tipo object, al igual que los tipos null, undefined, void o never, no tiene sentido utilizarlo al momento de declarar una variable, pero sí es útil al declarar funciones, por ejemplo, para “avisarle” al compilador de typescript cual será el tipo de dato que retornará la función o cuales serán los tipos de datos de los diferentes parámetros de dicha función.

Ejemplo:

const myFunct = (user: object): object => {
  return user;
};