No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Objects

23/30
Recursos

Un objeto es una estructura de datos que permite almacenar valores mediante propiedad - valor a través de la sintaxis de llaves ({}) y separados por comas.

En las propiedades del objeto es opcional colocar las comillas. En el caso de que haya espacios, es obligatorio.

var objeto = {
    clave1: "valor1",
   "clave 2": "valor2",
}

Excepto por los primitivos y las funciones, todo es un objeto en JavaScript.

Qué son los atributos y métodos

En programación orientada a objetos, un objeto es una representación de la realidad, en el cual sus características propias se definen como atributos y sus acciones se definen como métodos.

En otras palabras, los atributos son las variables y los métodos son las funciones propias de cada objeto.

Por ejemplo, definamos el objeto miAuto. Se coloca entre comillas la propiedad año porque el lenguaje no admite caracteres especiales del español. Aunque en ciertas situaciones si admite.

var miAuto = {
    marca: "Toyota",
    modelo: "Corolla",
    "año": 2020,
    detalle: function () {
        console.log("Es un auto")
    }
}

Las propiedades marca, modelo y "año" son los atributos del objeto miAuto. La propiedad detalle es un método del objeto miAuto.

Cómo acceder a los valores de un objeto

A diferencia de los arrays, únicamente es necesario saber la propiedad del objeto para acceder a su valor.

Existen tres formas para acceder al valor de un objeto:

  • Mediante la notación de corchetes
  • Mediante la notación de punto

Qué es la notación de corchetes

La notación de corchetes ya ese familiar para ti, similar a los arrays, indicamos entre corchetes la propiedad del objeto entre comillas.

objeto["propiedad"]

Por ejemplo, accedamos a las propiedades del objeto miAuto creado anteriormente.

miAuto["marca"] // "Toyota"
miAuto["modelo"] // "Corolla"
miAuto["año"] // 2020
miAuto["detalle"] // ƒ detalle()

Observa que cuando accedes a un método, únicamente muestra la función, esto sucede porque la propiedad guarda dicha función que aún no es ejecutada. Para ejecutarla hay que utilizar los paréntesis.

miAuto["detalle"]() // "Es un auto"

Finalmente, ten cuidado con las comillas, si nos las usas, estás haciendo referencia a una variable. En este caso existirán tres posibilidades:

  • Si existe la variable y su valor coincide con una propiedad del objeto, entonces mostrará su respectivo valor.
  • Si existe la variable, pero su valor no coincide con una propiedad del objeto, entonces mostrará undefined.
  • Si no existe la variable, entonces mostrará un error de referencia.
var propiedad1 = "marca"
miAuto[propiedad1] // "Toyota"

var propiedad2 = "nombre"
miAuto[propiedad2] // undefined

miAuto[modelo] // ReferenceError: modelo is not defined

Qué es la notación de punto

La notación de punto indicamos con un punto la propiedad del objeto. Si existen espacios, la única forma de acceder a esa propiedad es mediante la notación de corchetes.

objeto.propiedad

Por ejemplo, accedamos a las propiedades del objeto miAuto creado anteriormente.

miAuto.marca // "Toyota"
miAuto.modelo // "Corolla"
miAuto.añó // 2020
miAuto.detalle // ƒ detalle()

Igualmente, para ejecutar el método hay que utilizar los paréntesis.

miAuto.detalle() // "Es un auto"

Los arrays también son objetos

La notación punto te debe de parecer familiar, ya que así usábamos los diferentes atributos y métodos de los arrays, como length o map.

Esto es debido a que los arrays también son objetos en JavaScript. Por esta razón, también podemos utilizar la notación de corchetes, pero no es recomendable.

var array = [1, 2, 3]
array["length"] // 3
var newArray = array["map"](function (el) {
  return el * 2
})
newArray // [2,4,6]

Cómo añadir propiedades de un objeto

Para añadir propiedades de un objeto, utilizamos la notación de corchetes o de punto con la nueva propiedad, asignándole su respectivo valor.

Por ejemplo, añadamos la propiedad color del objeto miAuto.

miAuto["color"] = "rojo"
// o 
miAuto.color = "rojo"

console.log(miAuto)
/* {
  marca: 'Toyota',
  modelo: 'Corolla',
  'año': 2020,
  detalle: ƒ detalle(),
  color: 'rojo'  <---- nueva propiedad
} */

Cómo modificar propiedades de un objeto

Para modificar propiedades de un objeto, utilizamos la notación de corchetes o de punto con la propiedad específica, asignándole su nuevo valor.

Por ejemplo, modifiquemos la propiedad marca, de "Toyota" a "Ford", del objeto miAuto.

miAuto["marca"] = "Ford"
// o 
miAuto.marca = "Ford"

console.log(miAuto)
/* {
  marca: 'Ford', <--- Cambió de valor
  modelo: 'Corolla',
  'año': 2020,
  detalle: ƒ detalle(),
} */

Cómo eliminar propiedades de un objeto

Para eliminar propiedades de un objeto, utilizamos la palabra reservada delete seguido de la propiedad del objeto.

Por ejemplo, eliminemos la propiedad marca del objeto miAuto.

delete miAuto["marca"]
// o 
delete miAuto.marca

console.log(miAuto)
/* { 
  modelo: 'Corolla', <--- No existe la propiedad marca
  'año': 2020,
  detalle: ƒ detalle(),
} */

El objeto contexto this

En JavaScript, el objeto contexto this hace referencia a diferentes valores según su contexto de ejecución. Como es un tema complejo de programación orientada a objetos, no profundizaré.

En objetos, el contexto this hace referencia al propio objeto. Esto sirve para acceder a los atributos y métodos propios del objeto.

Por ejemplo, cambiemos la función detalle del objeto miAuto para mostrar un mensaje personalizado.

var miAuto = {
    marca: "Toyota",
    modelo: "Corolla",
    "año": 2020,
    detalle: function () {
        console.log(`Auto ${modelo} del ${año}.`)
    }
}

miAuto.detalle() //ReferenceError: modelo is not defined

Si ejecutamos la función miAuto.detalle() mostrará un error de referencia, que modelo no está definido.

Hagamos un pequeño cambio, utilicemos la notación de punto para acceder a los valores de la propiedad.

var miAuto = {
  //...
  detalle: function () {
    console.log(`Auto ${miAuto.modelo} del ${miAuto.año}.`)
  },
}

miAuto.detalle() // 'Auto Corolla del 2020.'

¡Funcionó! Sin embargo, necesito crear otro objeto con el mismo código.

var otroAuto = {
    marca: "Toyota",
    modelo: "Corolla",
    "año": 2020,
    detalle: function () {
    console.log(`Auto ${miAuto.modelo} del ${miAuto.año}.`)
  },
}

otroAuto.detalle() //ReferenceError: miAuto is not defined

Ahora muestra nuevamente un error de referencia del objeto miAuto. ¿Pero cambio miAuto por otroAuto y problema resuelto? Sí, pero como programador no debemos cambiar manualmente el código que puede ser reutilizado.

Realicemos otro cambio, utilicemos el objeto contexto this para hacer referencia a nuestro objeto.

var miAuto = {
  //...
  detalle: function () {
    console.log(`Auto ${this.modelo} del ${this.año}.`)
  },
}

miAuto.detalle() //'Auto Corolla del 2020.'

¡Funcionó! Ahora creemos otro objeto.

var otroAuto = {
  // ...
  detalle: function () {
    console.log(`Auto ${this.modelo} del ${this.año}.`)
  },
}

otroAuto.detalle() //'Auto Corolla del 2020.'

¡Volvió a funcionar! Ahora podremos crear varios objetos sin cambiar una y otra vez la referencia al objeto this. En el objeto miAuto, this es igual a miAuto; mientras que en el objeto otroAuto, this es igual a otroAuto. Por eso podemos acceder a los atributos y métodos, independientemente del objeto creado.

Crear varios objetos a partir de un código base se denomina crear una instancia.

Contribución creada por Andrés Guano (Platzi Contributor).

Aportes 433

Preguntas 51

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Objetos: JS es un lenguaje que está diseñado en un paradigma de objetos.

Ejemplo de Objeto:

var miAuto = {
marca: "Toyota",
modelo: "Corolla",
año: 2020
}

Acceder a una propiedad del objeto:

miAuto.marca 
// "Toyota"

Se pueden agregar propiedades que van a ser una función, se les llama métodos de objetos.

var miAuto = {
marca: "Toyota",
modelo: "Corolla",
año: 2020, 
detallesDelAuto: function () {
	console.log(`Auto ${this.modelo} ${this.año}`);
}

// miAuto.detallesDelAuto();
//Auto Corolla 2020

¿Quién es this?
Es una variable que hace referencia al objeto. En este caso: this = miAuto.

Para palabras mas sencillas…
Un objeto en programación es una representación abstracta de un objeto en la vida real, sin embargo también puede entenderse como un contenedor de datos.
Ejemplo:
Una botella de refresco tiene ciertas características y acciones.-
Características: altura, volumen, color, contenido, dureza etc…
Acciones: beber, reciclar, rehusar, aventar, abrir tapa, etc…

Respectivamente a estas características y acciones se les conoce como atributos(características) y métodos(acciones) en programación.

Los objetos son usados para almacenar ciertos datos que de otra manera serían muy sensibles al hackeo, por otro lado un objeto también puede ser el valor de una variable.

A modo de adelanto una clase a su vez es un molde que puede almacenar objetos y esta también como el objeto tiene atributos y métodos que puede heredar a cada uno de esos objetos conocida esta propiedad como herencia, en base a eso la clase this, es la clase principal desde la cual se ejecuta javascript a modo de ejemplo puedes consultar en consola del navegador console.log(this); y te darás una mejor idea.

Un saludo a todos.😃😃😃😃😃😃

Hay cosas que el no menciona que creo son importantes.

  • los key values se representan como string para JS esto quiere decir que si colocan una propiedad por ejemplo marca : “toyota” es lo mismo decir “marca” : “toyota”

  • Debido a que los key values JS los interpreta como strings significa que tambien pueden acceder a una propiedad usando llaves y dentro especificando el key value

  • Lo que menciono anterior mente lo digo por que por ejemplo si colocan un key value tipo numero, no van a poder acceder a esta propiedad de la forma tradicional.


Ahora converti el juego en un Objeto

var piedrasPapelTijeras = {
  // Marcador del juego
  puntoMaquina: 0,
  puntoUsuario: 0,

  mostrarMarcador: function () {
    console.log(`Maquina: ${this.puntoMaquina} - Usuario: ${this.puntoUsuario}`)
  },

  // Opciones Validas
  opciones: ["piedra", "papel", "tijeras"],

  // Mostrar opciones validas
  mostrarOpciones: function () {
    for (var opcion of this.opciones) {
      console.log(`"${opcion}"`);
    }
  },

  // --------AQUI COMIENZA EL JUEGO----------//
  // entrada de la maquina
  maquina: "",
  // entrada del usuario
  usuario: "",

  validarMaquina: -1,
  validarUsuario: -1,

  // Funcion principal
  jugar: function () {

    while ((this.puntoMaquina < 10) && (this.puntoUsuario < 10)) {
      console.log("¡A jugar!");
      // Asinga un valor aleatorio a la entrada de maquina
      this.maquina = this.opciones[Math.round(Math.random() * 3)];
      // Asinga un valor aleatorio a la entrada de usuario
      this.usuario = this.opciones[Math.round(Math.random() * 3)];
      // Muestra las entradas
      console.log(`Maquina: ${this.maquina}`);
      console.log(`Usuario: ${this.usuario}`);
      // busca las entradas en las opciones validas
      this.validarMaquina = this.opciones.indexOf(this.maquina);
      this.validarUsuario = this.opciones.indexOf(this.usuario);

      // Revisa si las entradas son opciones validas
      if ((this.validarMaquina >= 0) && (this.validarUsuario >= 0)) {
        switch (true) {

          // valida si hay empate
          case (this.maquina === this.usuario):
            console.log("Hay un empate");
            this.mostrarMarcador();
            this.jugar();
            break;
            //casos donde gana la maquina
          case (((this.maquina === "piedra") && (this.usuario === "tijeras")) ||
            ((this.maquina === "papel") && (this.usuario === "piedra")) ||
            ((this.maquina === "tijeras") && (this.usuario === "papel"))):

            console.log("La maquina ha ganado");
            this.puntoMaquina++;
            this.mostrarMarcador();
            this.jugar();
            break;

          default: //si la maquina no gano, el usuario si

            console.log("El usuario ha ganado");
            this.puntoUsuario++;
            this.mostrarMarcador();
            this.jugar();
        }
      } else {
        console.log(`Opcion no valida ingresa una de las siguientes opciones:`);
        this.mostrarOpciones();
        this.jugar();
      }
    }


  },
  // Resultados
  resultados: function () {
    this.puntoMaquina == 10 ? console.log("Lo siento la Maquina ha ganado :(") : console.log("¡Felicidades eres el campeón del juego!");
  }
}

piedrasPapelTijeras.jugar();
piedrasPapelTijeras.resultados();
var miLaptop = {
    Modelo: "15-dw0004la",
    Procesador: "Intel Core i7",
    MemoriaRAM: "8GB",
    DiscoDuro: "256GB",
    Peso: "1.74 kg",
    caracteristicas: function(){
        console.log(`Mi laptop tiene las siguientes caracteristicas ${this.Modelo} ${this.Procesador} ${this.MemoriaRAM} ${this.DiscoDuro} ${this.Peso}`)
    }
}

miLaptop.caracteristicas()

Objetos en JS

Los objetos son uno de los conceptos bases de JS, (básicamente todo JS funciona basado en objetos).

Un objeto es una estructura de datos (al igual que los array), con la diferencia que en los objetos no existe el índice numérico, lo que hay son propiedades, con ellas accedemos a cada uno de los valores.

{
propiedad: valor,
propiedad2: valor2,
propiedad3, valor3,...
}

Los valores del objeto pueden ser de todo tipo, es decir que podemos tener un number, un string, una función, un array, incluso otro objeto que contenga otros valores.

  • Los objetos son importantes porque de algún modo imitan el comportamiento en el mundo real, los objetos tienen propiedades y tienen métodos.

  • Propiedades:

    • Es una característica.
  • Método:

    • Algo que el objeto puede hacer.
let perro = {
    nombre: "Terry",
    edad: 2,
    color: "cafe",
    sexo: "macho",
    vacunas: true,
    correr(){
        console.log(`${this.nombre} corre`)
    },
}

Las propiedades de este objeto son su nombre, color, sexo, etc.
Y tiene un método, este método es correr. Para llamarlos lo hacemos así:

perro.nombre
//imprime Terry

perro.correr()
//imprime Terry corre

Para ejecutar un método o función usamos los paréntesis.

Propiedades

Las propiedades de los objetos, es recomendable como buena practica que tengan las mismas reglas que las variables, ya que funcionan como variables.

  • Otra forma de acceder a los valores de las propiedades es así:
    • perro.[“nombre”]
      • con corchetes y comillas.
        También podemos definir expresiones como propiedades, (valores de variables que estén por fuera del objeto).
        Y también podemos igualar variables.
let a = "hola", b = "mundo";
let myObject = {a,b}

Y así ya tiene dos propiedades
a: “hola”,
b: “mundo”

Operadores

  • delete: es un operador unario que borra una propiedad de un objeto. Ejm:
    • Devuelve un boolean. Y si modifica el objeto.
delete perro.edad
//devuelve true porque lo encontro, y lo borro.
ahora el objeto perro ya no tiene, no existe en el la propiedad edad.

Para agregar una propiedad lo hacemos así:

perro.edad = 2
//ahora el objeto perro tiene una nueva propiedad que es perro: 2
//TAMBIEN SE PUEDE CON CORCHETES
perro["edad"] = 2
//y obtenemos el mismo resultado.

Bien, si alguien quiere profundizar un poco más sobre this, puede leer esta documentación.
https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Operadores/this

la POO, es una manera de diseñar y desarrollar software que trata de imitar la realidad tomando algunos conceptos esenciales de ella.

el primero de estos es, precisamente, el de objeto, cuyo rasgos son la identidad, el estado y el comportamiento.
la identidad es el Que distingue a un objeto de otro. posteriormente tenemos, el estado, que son las características que lo describen al objeto y finalmente tenemos el comportamiento que es lo que puede hacer nuestro objeto.

en conclusión, Un identificador es el nombre del objeto, las variables son las características del objeto y, los métodos son el comportamiento de nuestro objeto

con this.elementName nos estamos refiriendo a que vamos acceder un elemento del propio objeto (osea, del mismo), se traduciría así (deEsteObjetoAccederAlElementoConElNombre.elementName). Lo sé, es un poco larga su traducción literal, pero es una forma efectiva para entender el trabajo real de this

Suerte, compañeros 😉

Tengo una duda por ejemplo, si tenemos un base de datos de usuarios, tenemos su nombre,sexo, fecha de nacimiento, correo, etc. cada usuario representaria un objeto?

/*Objetos*/
var miAuto = {
	marca: "BMW",
	modelo: "X5",
	anio: 2020,
	puertas: 4,
	color: "Rojo"
};

/*En consola, la forma de consultar los datos del objeto es la siguiente: nombre del objeto . atributo. Por ejemplo*/
miAuto.marca;
/*El resultado es BMW*/

/*Se pueden generar funciones dentro del objeto. A estas se les llaman métodos*/
var miAuto = {
	marca: "BMW",
	modelo: "X5",
	anio: 2020,
	puertas: 4,
	color: "Rojo",
	detalleDelAuto: function(){
		console.log(`Auto ${this.marca} ${this.anio}`);
	}
};

/*Para mandar llamar la función dentro del objeto se crea la llamada de forma normal.*/
miAuto.detalleDelAuto();```

Un objeto tiene características y metodos. y va de la mano con THIS que hace referencia a el objeto global.

Platziamigos, les comparto algunas notas de la clase:
.

.
Espero que les ayuden.
(⌐■_■)

📦 Los objetos en JavaScript nos permiten agrupar información. Un objeto no es más que un conjunto de propiedades.

Objetos

  • Para declarar un objeto la sintaxis es:
    var myObject = {property : “value”}
    Ejemplo:
    var myCar = {
    color: “Red”,
    year: 2015,
    }

  • Para acceder a un objeto:
    myCar.year;

JavaScript permite otra manera de acceder a una propiedad del objeto y es como se haría en un Array.

miAuto.marca;
miAuto['marca'];

Excelente la forma de entender this.

//this hace referencia a un objeto, en este caso el objeto papa que es el objeto miAuto.

var miAuto = {
    marca: "Chevrolet",
    modelo: "Spark",
    annio: 2019,
    detalleDelAuto: function() {
        console.log(`Auto ${this.modelo} ${this.annio}`)
    }
};


Aquí hay mucha más información sobre Objetos en JS.
https://developer.mozilla.org/es/docs/Web/JavaScript/Guide/Trabajando_con_objectos

Diego explica de forma simple y entendible estos conceptos abstractos, gracias!

Un tip si eres nuevo, intenta hacer todo tu código en inglés.
La industria funciona en ese idioma. Ademas aprendes en el intento 😄

Un objeto no es más que una representación abstracta de una entidad del mundo real, mediante la cual modelamos características (atributos) y comportamientos (métodos). El paradigma orientado a objetos no solo es una forma de escribir código, es una forma completamente distinta de pensar y modelar programas.

Cuando estamos trabajando un objeto, podemos hacer que una de las propiedades (PALABRA CLAVE) se convierta en una función, las cuales se llaman MÉTODOS, a la cual nombramos según lo que vaya a contener.

*Esta función puede hacer cosas con una de las propiedades que tenemos dentro de ese objeto.

*Esta función tiene la misma sintaxis de cualquier function.

***Aquí mi ejemplo, pero desde VSCode, donde uso la terminal para validar si lo que estructure si esta correcto:

PASOS:
—Indicamos la palabra reservada RETURN

—Seguido del RETURN, generamos unos Backticks ( `` ) y dentro de ellos escribimos lo que queremos que nos retorne.

—Concatenamos dentro de ese texto las PALABRAS CLAVE que necesitamos sean ejecutadas.

—Con la ayuda de “this” = El “this” es una palabra reservada que hace referencia al objeto (“su padre”). Esto ---------this.modelo---------, sería lo mismo que decir ------ miAuto.modelo ---------

—Para verificar si el código está correcto, imprimimos por Consola, el nombre de mi objeto + punto (para poder acceder al valor del objeto) + la PALABRA CLAVE (método) + paréntesis vacíos (porque como es una función la debemos activar así, como se hace cualquier otra función) .

muuuuuy interesante

var miAuto = {
    marca: "Toyota",
    modelo: "Corolla",
    year: 2020,
    //Metodo de objeto
    detalleDelAuto: function(){
        //this hace referencia al objeto
        console.log(`Auto ${this.modelo} ${this.year}`);
    } 
};

miAuto.marca; //acceder a valor del objeto.
miAuto.year;

miAuto.detalleDelAuto(); //Acceder al metodo del objeto.```
var miAuto = {
  marca: "Mini",
  modelo: "Cabrio",
  año: 2020,
  detalleDelAuto: function() {
    console.log(`Auto ${this.modelo} ${this.año}`);
  }
};
//This es una variable que hace referencia a su padre (miAuto)
//this.modelo = miAuto.modelo```

Los objetos te permiten envolver piezas de datos relacionados y funcionalidad en un solo contenedor. Los objetos tienen:

  • Propiedades que muestran información sobre el objeto.
  • Métodos que son funciones o capacidades que tiene el objeto.
let c = console.log //guardamos en una variable "c" la funcion 
let myCar = { //declaramos el objeto y sus detalles
  brand: "Toyota", // caracterisitcas o valores del objeto
  model: "Corolla",
  color: "Black",
  year: 2020,
  start: function(){ // funcion para arrancar
      return ` ${this.brand} ignition`
  },
  detailsCar: function(){// funcion para mostrar datos el auto
      return` List of details
      ${this.brand}
      ${this.model}
      ${this.color}
      ${this.year}`
  }
};
c(myCar.detailsCar())// llamando a la funcion del objeto lista de detalles
class Carro {
    constructor(marca,modelo, annio){
        this.marca = marca;
        this.modelo = modelo;
        this.annio = annio;

    }
}

var carro = new Carro(prompt("Cual es la marca de tu carro"),prompt("Que modelo es?"),prompt("De que año es tu carro"));
console.log(`Mi carro es un: ${carro.marca} ${carro.modelo} ${carro.annio}`);```

No queda muy claro lo del this

Mucha información, pero entendiendo poco a poco 😃

en plena pandemia tuve la oportunidad de hacer un curso de javascript. No se si fue porque no tenia muy fuertes las bases de html y css, pero cada vez que voy viendo este curso , me doy cuenta que aquel profesor no tenia mucha pedagogia. En cambio, con De Granda estoy cogiendo el hilo muy facil, hasta ahora genial el curso

let misListas = {
   frutas: ["Manzana","Banana","Pera","Frutilla","Melon","Naranja","Uva","Patilla"],

   verduras: ['Papa','Boniato','Cebolla','Tomate','Lechuga','Zanahoria','Aguacate'],
   
fullList : function sumarListas() {
               let concatenarListas= this.frutas.concat(this.verduras);
               console.log(`Debes comprar, ${concatenarListas}`)}
}
misListas.fullList(); 

Retorna:
Debes comprar, Manzana,Banana,Pera,Frutilla,Melon,Naranja,Uva,Patilla,Papa,Boniato,Cebolla,Tomate,Lechuga,Zanahoria,Aguacate

Objetos 😉

Un objeto es una colección de propiedades, y una propiedad es una asociación entre un nombre (o clave) y un valor key: value. El valor de una propiedad puede ser un valor como tal (string, number, float, etc) o una función.

var persona = {
		// key: value
    name: "Keneth",
    age: 21,
    sexo: 'M',
    mostrarDetalles: function(){
        console.log(`Soy ${this.name}, tengo ${this.age} años`);
    }
}

console.log(persona.name); // "Keneth"
persona.mostrarDetalles(); // Soy Keneth, tengo 21 años

Más info: https://developer.mozilla.org/es/docs/Web/JavaScript/Guide/Working_with_Objects

Es genial cuando todo lo que habías visto alguna vez y no entendías qué significaba, poco a poco va tomando sentido 😄

Los objetos contienen:

  • Métodos: Son funciones dentro de un objeto.
    (Cuando una función está dentro de un objeto).

  • Atributo o propiedad: Son variables internas que almacenan valores.
    (Cuando una variable está dentro de un objeto).

Les dejo mis apuntes.
Introducción
JavaScript es un lenguaje de programación que está diseñado en un paradigma de objetos.
Es como llevar un objeto del mundo físico a este paradigma de objetos.

¿Qué es un objeto?
Un objeto es una colección de datos relacionados y/o funcionalidad (que generalmente consta de algunas variables y funciones, que se denominan propiedades y métodos cuando están dentro de objetos).
Los objetos se manejan con propiedades, que es una combinación de palabras claves y valores.
Sintaxis

var name-objeto = {
	propiedades
};

// ejemplo más grafico.
var name-objeto = {
	palabra-clave: valor,
	palabra-clave: valor
};

Ejemplo

var miAuto = {
    marca: "Toyota",
    modelo: "Corolla",
    annio: 2020
};

Acceder a un objeto
Para acceder a todo el objeto usamos el nombre del objeto.
Ejemplo

miAuto;

// resultado:
// {marca: "Toyota", modelo: "Corolla", annio: 2020}

Para acceder a una propiedad en particular de nuestro objeto usamos su nombre seguido de .propiedad.
Ejemplo

miAuto.marca;

// resultado:
// "Toyota"

Método de objetos
Cuando trabajamos con la estructura de un objeto, podemos generar una propiedad del objeto sea una función y que la misma pueda hacer cosas con las demás propiedades del objeto.

Ejemplo

var miAuto = {
    marca: "Toyota",
    modelo: "Corolla",
    annio: 2020,
    detalleDelAuto: function name(params) {
        console.log(`Auto ${this.modelo} ${this.annio}`);
    }
};

La forma para ingresar al método es colocar el nombre del objeto junto a .nombre-de-metodo.
Ejemplo

miAuto.detalleDelAuto();

// resultado:
// Auto Corolla 2020

¿Qué es this?
this es una variable (con la que podés acceder a ciertos valores del objeto) que hace referencia al objeto, en el caso del ejemplo, hace caso al padre_ miAuto_. Es como si estuviésemos escribiendo_ miAuto.modelo_ o miAuto.annio.
Fuente de donde saque algunos conceptos.

por que al nombrar el string usa comillas diagonales, en lugar de las comillas simple. ¿a que se debe esto?

En la Programación Orientada a Objetos, los objetos tienen:

  • Atributos, que describe como el es objeto (color, tamaño, marca, etc.)
  • Metodos, que son las funcionalidades del objetos, ósea que puede hacer. Y esto se hace mediante funciones. en el ejemplo del auto, este puede acelerar, frenar, encender, apagar, ir hacia adelante, tener reversa, etc…

Fanatico de Initial D aparece jajajaja

var miAuto = {
    marca: "Toyota",
    modelo:"Corolla Sprinter Trueno",
    annio: 1986,
};

console.log(`I love my ${miAuto.marca} ${miAuto.modelo}`)

Que confuso porque los llaman objetos? vengo de python y esto seria un diccionario, por otro lado, objeto lo entinedo por una instancia de una clase 😕

Se utiliza this. cuando estas dentro del Objeto y no es necesario hacer referencia explícita con su nombre si no utilizando solo this

Javascript es orientado a objetos, pero es multi paradigma (permite varios estilos de programación), soporta la programación funcional, orientada a objetos e imperativa. Fuente: https://developer.mozilla.org/es/docs/Web/JavaScript

Super interesante.

Despues de aqui me ire directo al Curso de POO

El Objeto en JavaScript es una variable con parejas de { llave : valor }

Un ejemplo de objeto puede ser un PC, el cual será la suma de sus propiedades:

  • Tarjeta Madre.
  • Procesador.
  • Ram.
  • Grafica.
  • Disco duro.
  • Chasis.
  • Fuente.

Lo expresariamos con la siguiente Sintaxis:

quedaría así:

Paso aporte de como ingresar varios valores de auto en una misma variable y cambiar la visualización a tipo tabla (y)

Revise entre los aportes y las preguntas, y al no encontrar algo similar a lo que estoy por decir, me atrevo a escribir este aporte.

No sean como yo y vayan a creer que todo es posible con las Arrow functions. En mi caso, como me gusta escribir código con la sintaxis mas reciente de EcmaScript, pensé que un método de objeto también se podía escribir como arrow function y poder seguir accediendo a las propiedades del objeto actual como lo hace el profesor en la clase:

const vehiculoUno = {
  tipo: 'Automóvil',
  marca: 'Fiat',
  modelo: 'Panda',
  annio: 2015,
  detalle: () => {
    console.log(`${this.tipo}: ${this.marca} ${this.modelo}, ${this.annio}`)
  }
}

Sin embargo, al llamar a la función detalle del objeto, siempre me devolvía Undefined, undefined, undefined… y es que dentro de los objetos, una función de flecha siempre toma el this como el alcance del documento, y no como un alcance del objeto, ya que prácticamente este no declara ningún alcance en si mismo.
Por lo que, si queremos hacer métodos de objeto que accedan a sus mismas variables, podemos usar la declaración de función “clásica”, que siempre ha servido y servirá, y entiende lo que es this dentro del alcance de un objeto en si mismo.

const vehiculoUno = {
  tipo: 'Automóvil',
  marca: 'Fiat',
  modelo: 'Panda',
  annio: 2015,
  detalle: function() {
    console.log(`${this.tipo}: ${this.marca} ${this.modelo}, ${this.annio}`)
  }
}

Siento mucho no explicar bien lo que significa this, pero sigo adelante con mis estudios para poder entender quien es this en los proximos cursos.

Fuente: Arrow functions tutorial on Digital Ocean

Resumen

Objects

Esto es un paradigma en JavaScript que nos sirve para representar en el código propiedades de la vida real de un elemento, un objeto, una persona, etc…

Por ejemplo si tenemos un auto podemos ver sus propiedades y sus características como la marca, el modelo, el año de fabricación, etc…

Para crear un objeto primero debemos declarar una variable asignandole { }, en donde irán las propiedades y características de nuestro objeto.

Las propiedades son combinaciones entre palabras clave y valores, por ejemplo la palabra clave sería la marca y el valor “Toyota”.

Así se escribe:

>var miAuto = {
	marca:"Toyota",
	modelo: "Corolla",
	año: 2020
};

Para acceder al valor de una propiedad de un objeto se llama a la variable seguido de la palabra clave separados por un punto.

>miAuto.marca
<"Toyota"

Dentro de las propiedades de un objeto se puede almacenar una función. Vamos a agregarla.

>var miAuto = {
	marca:"Toyota",
	modelo: "Corolla",
	año: 2020,
	detalleDelAuto: function(){
		console.log("Auto ${this.modelo} ${this.año}");
	}
};
//La palabra this hace referencia al objeto global, es decir a la variable.

Para llamar una función que está en las propiedades de un objeto se la llama de la misma forma pero se le agregan los ( ) de la función.

>miAuto.detalleDelAuto();
<Auto Corolla 2020

Ejercicio del CASE!!!

var piedra = 1;
var papel = 2;
var tijera = 3;

function getRandomInt(min, max) {
return Math.floor(Math.random() * (max - min)) + min;
}
var maquinaRandom = getRandomInt(1,4);

var valor = prompt(“Ingresa un numero del 1 al 3”);

console.log(maquinaRandom);

function GanaGabi(){
if (maquinaRandom == 1 && valor ==2){
return true;
}else if (maquinaRandom == 2 && valor == 3){
return true;
}else if (maquinaRandom == 3 && valor == 1){

    return true;

}
console.log(“NO”)
}

function Juego(){
console.log(maquinaRandom);
if (valor !“1” && valor !“2” && valor !==“3”){
alert(“Numero incorrecto”)
return;
}

if (maquinaRandom == valor){
    alert("Hubo empate")
    return;
} 

switch (GanaGabi()){
    case true:
        alert("Gabi gana")
        break;
    default:
        alert("Gano maquina")
}  

}
Juego();

var MisDatos ={
Nombre: “Gabriela”,
Apellido: “Solorzano”,
Edad: 28,
estatura: 1.57,
Informacion: function(){
console.log(Mi nombre es ${this.Nombre} ${this.Apellido} y tengo ${this.Edad} años);
}
}

MisDatos.Informacion();

Ejemplo…

var auto = {
marca:“Audi”,
modelo:“A1”,
annio:2021,
color: “Azul”,
detalledauto: function(){
console.log(Auto ${this.modelo} ${this.annio});
}

};

Yo había escuchado que JavaSript era un lenguaje orientado a prototipos no a objetos. Realmente o entiendo que significa eso. Si alguien lo sabe se lo agradezco 🙏🏽🙏🏽

```js var MyAuto = { marca:"Lamborghini", modelo:"Corolla", año: 2020, detalles: function(){ console.log(`Auto ${this.marca} ${this.modelo} ${this.año}`)} } ```var MyAuto = { marca:"Lamborghini", modelo:"Corolla", año: 2020, detalles: function(){ console.log(`Auto ${this.marca} ${this.modelo} ${this.año}`)} }

¡Hola! Quería hacer un aporte hablando de la diferencia entre una clase y un objeto en programación. El ejemplo que escribiré fue el que hizo que entendiera de una vez por todas este concepto tan abstracto de la Programación Orientada a Objetos.

“Existen los moldes de galletas, y existen las galletas. Los moldes serán las clases, y los objetos las galletas”. Simple, ¿No?

El molde definirá la forma de nuestra galleta, y también su grosor, es decir que el molde define la apariencia y comportamiento de la galleta. Las galletas son objetos reales que creamos con ese molde, y mueden ser llamadas objetos o instancias de una clase.

OBJETOS

  • Tienen propiedades con las que trabajamos

Crearlo

var auto = {
      marca: "Toyota", //propiedad
      modelo: "Corolla",
      annio: 2023
};

Acceder a una propiedad

auto.modelo

Función dentro de un objeto

var auto = {
      modelo: "Corolla",
      annio: 2023,
      detalle: function(){
                         console.log("Auto ${this.modelo} ${this.annio}");
                   }
};

NOTA:

  • this hace referencia a él mismo, al objeto.

Que gran clase, lo deja todo muy claro.

22/30 Objects

Un objeto es una estructura de datos en JavaScript que permite almacenar valores mediante propiedad-valor, separados por comas y utilizando la sintaxis de llaves.

Los atributos de un objeto son sus variables y los métodos son sus funciones.

Para acceder a los valores de un objeto, se puede utilizar la notación de corchetes o la notación de punto.

Los arrays también son objetos en JavaScript y se pueden acceder a sus propiedades y métodos mediante la notación de punto

Para añadir o modificar propiedades de un objeto, se utiliza la notación de corchetes o de punto, asignando un nuevo valor a la propiedad correspondiente.

Ejemplo de objeto persona:

var persona = {
nombre: "Juan",
edad: 30,
genero: "Masculino",
ciudad: "Bogotá",
saludar: function() {
		console.log("Hola, mi nombre es " + this.nombre + " y tengo " + 
		this.edad + " años. ");
	}
};

persona.saludar(); // Hola, mi nombre es Juan y tengo 30 años.

var presentacion = {
Nombre : “Melisa”,
Apellido : “Franco”,
Edad : 32,
detalle : function () {
console.log (Hola yo soy ${this.Nombre} ${this.Apellido} y tengo ${this.Edad} años)
}
}

presentacion.detalle()
// Hola yo soy Melisa Franco y tengo 32 años

los objetos en JavaScript se parecen mucho a los diccionarios en Python, por eso amo ambos lenguajes!

let miAuto = {marca:“Toyota”,
modelo:“corolla”,
annio:2021,
detalleDelAuto : function(){
console.log(Auto ${this.modelo} ${this.annio})
}
};

En coclusion, que es objects?

var persona = {
    nombre: "Patricio",
    nacionalidad: "ecuatoriano",
    edad: 23,
    saludar: function(){
        console.log(`Hola, soy  ${this.nombre} y tengo ${this.edad} años`);
    }
};

Otra forma de acceder a las propiedades de los objetos:

<var miAuto={
    marca:'Toyota',
    modelo: 'Corolla',
    año:2020,
    color: 'Black',
    detalleDelAuto: function(){
        console.log(`Auto ${this.modelo} ${this.año}`);
    }
}> 

hola buenas tardes gente de platzi aqui vengo a mandar un aporte con este ejemplo parecido al del profesor pero con los componentes de una pc alta gama xd aqui el codigo

var micompu = {
grafica:“3070”,
procesador:“ryzen55600x”,
tarjetamadre:“b550 tuf gaming”,
memoriaram:“16gb ddr5”,
almacenamiento:“ssd de 480gb/1tb de hdd”,
fuentedepoder:“evga de 700wts”,
case:“aerocool bolt”,
monitor:“1080p de 144hz ips”,
annio: 2025,
detalledelacompu: function(){
console.log(compu ${this.grafica} ${this.procesador} ${this.case} ${this.annio});
}
}

Hey hola, cree mi primer objeto y le puse un método como enseñó el profe en esta clase :
var carro = {
marca: ‘Dodge’,
modelo: ‘Stratus’,
annio: 2022,
color: ‘rojo’,
ponTodoJunto: function(){
console.log(Es un ${this.marca} ${this.modelo} ${this.color} del año ${this.annio})
}
};

carro.ponTodoJunto();
Es un Dodge Stratus rojo del año 2022

JavaScript está diseñado en un paradigma simple basado en Objetos.
Un Objeto es una Colección de Propiedades, y una Propiedad es una asociación entre un nombre (o clave) y un valor.
El Valor de una Propiedad puede ser una Función, en cuyo caso la Propiedad es conocida como un Método.
var miAuto = {
marca: ‘Ford’,
modelo: ‘Mustang’,
annio: 1969,
detalleDelAuto: function() {
console.log(Auto: ${this.marca} ${this.modelo} ${this.annio});
}
};

Para ejecutar el método teclear: miAuto.detalleDelAuto();
Muestra => Auto: Ford Mustang 1969
Además de los objetos que están predefinidos en el navegador, puedes definir tus propios objetos.
Un Objeto de JavaScript tiene Propiedades asociadas a él.
Una Propiedad de un objeto se puede explicar como una variable adjunta al objeto.
Las Propiedades de un Objeto básicamente son lo mismo que las variables comunes de JavaScript, excepto por el nexo con el Objeto.
Las Propiedades de un Objeto definen las características del Objeto.
Las Propiedades no asignadas de un objeto son undefined (y no null).
Accedes a las Propiedades de un Objeto con una simple notación de puntos:
NombreObjeto.NombrePropiedad
miAuto.marca; Muestra => 'Ford’
También se puede acceder o establecer las Propiedades de los Objetos en JavaScript mediante la notación de corchetes [ ].
Los Objetos, a veces son llamados Arreglos Asociativos, debido a que cada Propiedad está asociada con un valor de cadena que se puede utilizar para acceder a ella.
Por lo tanto, por ejemplo, puedes acceder a las Propiedades del Objeto miCarro de la siguiente manera:
miAuto[‘marca’] = ‘Ford’;
miAuto[‘modelo’] = ‘Mustang’;
miAuto['annio] = 1969;

También se puede acceder a las propiedades mediante el uso de un valor de cadena que se almacena en una variable:
var nombrePropiedad = ‘marca’;
miAuto[nombrePropiedad] = ‘Ford’; usa el valor que contiene la variable (marca)

nombrePropiedad = ‘modelo’;
miAuto[nombrePropiedad] = ‘Mustang’;

Tomado de: https://developer.mozilla.org/es/docs/Web/JavaScript/Guide/Working_with_Objects

Código de la clase 😃

//Ejemplo de objeto:

var miAuto = {
    marca: "Toyota",
    modelo: "Corolla",
    annio: 2020,
    detalle: function(){
        console.log(`Auto: ${this.modelo} ${this.annio}`) //this esuna variable que hace referencia al objeto
    }
}

//Para acceder a una propiedad del objecto
miAuto.marca;
//Toyota

miAuto.annio;
//2020

miAuto.detalle();
//Auto: Corolla 2020

Holaaaa, aquí les dejo mi aporte

HOLA SI QUIERES PRACTICAR CODIGOS ENTRA EN ESTE LINK //www.codewars.com

var miAuto = {
marca: “Toyota”,
modelo: “Corolla”,
annio: 2020,
detallesDelAuto: function () {
console.log(Auto ${this.modelo} ${this.annio});
}
};
miAuto.detallesDelAuto();

Podemos borrar una propiedad dentro de un objeto:

const miPerro = {
nombre: “azul”,
piernas: 4,
cola: 1,
ladrido: “woof”
};

delete miPerro.cola;

Objects u objetos

Javascript es un lenguaje que está diseñado en paradigma de objetos, así que si logras entender bien que es esto y logras aplicarlo, logramos entender bastante del lenguaje Javascript.
Para entender el tema sobre objetos, podemos pensar en cómo llevar un objeto del mundo físico a el paradigma de objetos del lenguaje de programación Javascript.
Por ejemplo: tenemos un auto o carro en el mundo físico, con sus propiedades, para llevarlo al mundo de la programación en JS, generaríamos una variable llamada carro y le agregaríamos estas propiedades, las cuales pueden ser la marca, color, año de fabricación, nombre de modelo, etc.

Cómo generamos un objeto:

  1. Creamos una variable.

  2. Esta variable va a ser un objeto, le damos un nombre.

  3. El valor o los valores de la variable van dentro de llaves { };

  4. Le vamos a agregar al objeto ciertas propiedades. Los objetos se manejan con propiedades y estas son una combinación entre palabras claves y valores. Por ejemplo:

var miAuto = { 
	marca: "Toyota",
	modelo: "Corolla",
	annio: 2022;
}

La primer propiedad que le agregamos al objeto es la marca, es como la palabra clave y la forma de asignarle el valor, es colocar dos puntos " : " luego de la palabra clave, y coloco el valor.En este caso “Toyota”. Para agregar más propiedades con sus valores, coloco coma " , " y agrego las mismas. Recordar que usamos comillas para los strings o cadenas de texto. Y en el ejemplo se coloca “annio”, porque la “ñ” es un carácter especial que en lenguaje de programación no se entiende.

  1. Ya tenemos el objeto con 3 propiedades, ¿Cómo comenzamos a acceder a la información de este objeto?.
    Una vez guardado el objeto en la consola del navegador, colocamos el nombre de la variable o nombre del objeto y nos arroja como resultado sus propiedades.
    ¿Cómo acceder a algo específico del objeto?
mi Auto.marca

Colocamos el nombre de la variable, punto y el nombre de la propiedad. Y en la consola nos devuelve el valor de la propiedad.

También podemos colocarle al objeto una función como propiedad, y ésa función puede hacer otras cosas con otras propiedades que estén dentro del objeto.

var miAuto = { 
	marca: "Toyota",
	modelo: "Corolla",
	annio: 2022,
	detalleDelAuto: function(){
		console.log(`Auto ${this.modelo} 		 
                ${this.annio}`);
}

En el ejemplo se agrega una propiedad y como valor colocamos una función, la cual se denomina “método de objeto”. Esta función va a imprimir en la consola el string con el modelo y el año del carro.

this es una variable que hace referencia al objeto, en éste caso hace referencia a su padre, que sería “miAuto” . La forma de entenderlo es que “this.modelo” es “miAuto.modelo”.

Lamamos en la consola el método para que se ejecute su código:

miAuto.detalleDelAuto()

Le colocamos los paréntesis porque adentro tiene una función.

var miCarro = 
{
    marca: "kia",
    modelo: "picanto",
    año: 2020,
    detalleDelAuto: function () {
        console.log("auto "+ this.marca + " " + this.modelo + " " + this.año)
        
    }

}

let car = {
    brand: "Toyota",
    model: "Corolla",
    year: 2021,
    type: "luxury"
}

console.log(car);
//Get data from objects
console.log('Car\'s brand is '+car.brand) // Get Brand
//Add property to Object
car.details = function(){
    console.log(`Car ${this.model} ${this.year}`)
}
console.log(car);

//Get Function
console.log(car.details());

Un objeto es un entidad independiente con propiedades y tipos. Los objetos de JavaScript pueden tener propiedades que definan sus características.

var miAuto = {
  marca : "Nissan",
  modelo: "Corolla",
  año: 2005,
  detalleAuto: function(){
  console.log(`Auto ${this.modelo} ${this.año}`);
}
}

Conceptos básicos

  • JS es un lenguaje que está diseñado en un paradigma de objetos.

  • Significa que los valores tipo objeto vienen a representar objetos del mundo real

  • Los objetos son del tipo de dato no primitivo.

  • Por lo tanto puede contener más de un valor.

  • Los valores se escriben como pares de nombre: valor (nombre y valor separados por dos puntos).

var car = {type:"Fiat", model:"500", color:"white"};

Propiedades del objeto
Los pares nombre:valor en los objetos JavaScript se denominan propiedades:
Ejemplo

var miAuto = {
    marca:"Toyota",
    modelo:"Corolla",
    annio:2020
}

Acceso a propiedades de objeto
Puede acceder a las propiedades del objeto de dos maneras:

objectName.propertyName
o
objectName["propertyName"]

Ejemplo:

miAuto.marca

Métodos de objeto

  • Los métodos son acciones que se pueden realizar en objetos.

  • Los métodos se almacenan en propiedades como definiciones de funciones.
    Ejemplo

var miAuto = {
    marca:"Toyota",
    modelo:"Corolla",
    annio:2020,
    detalleAuto: function(){
        console.log(`Auto ${this.modelo} ${this.annio}`);
    }
}

Acceso a métodos de objetos
Accede a un método de objeto con la siguiente sintaxis:

objectName.methodName()
name = person.fullName();

Ejemplo:

miAuto.detalleAuto();

Si accede a un método sin los paréntesis (), devolverá la definición de la función:

name = person.fullName;

La palabra clave this

  • En una definición de función, esto se refiere al “propietario” de la función.
    En el ejemplo anterior, este es el objeto persona que “posee” la función fullName.
    En otras palabras, this.firstName significa la propiedad firstName de este objeto.

No olviden poner la como después de 2020

let bombon = {
nombre : “paula andrea”,
apellido: “hayle”,
profesion: “ingeniera de software”
};

uwu 😗

El modelo de un vehículo es el año.

Un aporte para los que todavia tienen problema con entender la sentencia ‘this’, se utiliza ‘this…’ para referirte a una propiedad de un objeto desde dentro del mismo, cuando te refieres a una propiedad desde fuera, lo haces nadamas con ‘nombreObjeto.propiedad’, espero les sirva, animo!!

| Objetos
Son lo que en otros lenguajes se denominarían diccionarios.
Pueden contener funciones se les denominan métodos.
|| Métodos
Permiten implementar funcionalidades propias de una clase.
Con la palabra clave this se puede acceder a los atributos tal como en una clase.
this.atributo

ALT +96 para que saquen las comillas simples invertidas en windows

En realidad, JavaScript no es solamente orientado a objetos, también es funcional. Así que JavaScript es más bien multiparadigmático.

JS es un lenguaje que está diseñado en un paradigma de objetos, así que al entender este concepto y su implemenytación habrá un acercamiento considerable a qué es JS y cómo funciona. Ahora, puntualmente, se trata de cómo llevamos un objeto del mundo físico a este paradigma de objetos de JS.
Ejemplo:

Un carro específico en el mundo (que tiene ciertas propiedades)

Se traslada por medio de la variable “carro” a la que se le agregan dichas propiedades como marca, modelo, cantidad de puertas, llantas, etc.

var miCarro = {
    marca: "Toyota", 
    modelo: "Corolla",
    annio: 2020,
};
miCarro
//{marca: "Toyota", modelo: "Corolla", annio: 2020}

Los objetos se manejan con propiedades y estas son una combinación entre palabras clave y valores.

Pero, ¿cómo acceder a una propiedad específica y no a todo el conjunto de propiedades de, pongamos por caso, 30 objetos, es decir, 30 carros?:

miCarro.marca
"Toyota"

miCarro.annio
2020

Es posible hacer que una de las propiedades del objeto, sea una función que pueda ejecutar acciones con las demás propiedades del objeto, a esto se le llama métodos de objetos:

var miCarro = {
    marca: "Toyota", 
    modelo: "Corolla",
    annio: 2020,
    detalleDelCarro: function(){
        colsole.log(`Carro ${this.modelo} ${this.annio}`);
    }
};
//this es una variable que hace referencia al 
//objeto global-padre, equivale a miCarro.annio

La forma de acceder a este método (la función del objeto) es:

miCarro.detalleDelCarro();
Carro Corolla 2020

Utilizamos el this, para referirnos a la instancia.

Es un buen curso pero en mi caso no es suficiente, siento que necesito mas explicaciones que me dejen asimilar mejor los conceptos. Pensé que con este contenido bastaba pero tengo que apoyarme con Youtube. Gracias por el curso Diego. Espero aprender pronto lo que transmites a los demas.

var miMoto = {
marca: “Yamaha”,
modelo: "yamalube"
año: 2021
}

hola comunidad les comparto esta pagina que nos sirve como consola de javascript y es fácil de usar y es dedicada a esto ya que hacerlo sobre el navegador me parece algo complejo no deja hacer algunas cosas los saltos de lineas todo es mas complicado y aquí podes ir guardando tus repositorios es interesante póngale gafa

https://repl.it/

this cambia dependiendo del scope donde se utilice

Representacion de un numero complejo:

codigo

let complex = {
    real: 0,
    imaginary: 0,
    toString: function(){
                  console.log(`(${this.real} + ${this.imaginary}i)`);
              }
};
complex.real = 4;
complex.imaginary = 5;
complex.toString()

ejecucion: (4 + 5i)

POO
Abstracción de la realidad.
Atributos(propiedades: llaves & valores) & métodos(funciones)
Declarar
let nombreObj = { llave : “Valor” , llave1 : “Valor1”, nombreFunción : function(){Algoritmo}};
Acceder
nombreObj.llave
nombreObj.llaveFunción

let persona = {
    nombre : "Manuel",
    apellido : "Hevia",
    edad : 26,
    carrera : "IA",
    hablar : function(){
        console.log(`Hola, me llamo ${this.nombre} ${this.apellido}. Tengo ${this.edad} y me dedico a la ${this.carrera}.`);
    }
}

persona.nombre;
persona.hablar();