No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

ES6: clases

12/35
Recursos

Aportes 89

Preguntas 3

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

鉃★笍 Pienso que es IMPORTANTE no frustrarse si no se comprenden bien estos conceptos de un inicio, compa帽eros.

  • Al tener un sistema funcional y completo es donde se utilizan ya estas estructuras de c贸digo para poder manejar datos reales y pasarlos a bases de datos. Yo hasta ese entonces fue donde termin茅 de comprender y todo me hizo sentido 馃憖馃鉁
  • Por supuesto, investiga m谩s por tu cuenta sobre POO y busca ejemplos de aplicaciones en la vida real. Tambi茅n cu谩les son sus 4 principios:
  1. Abstracci贸n
  2. Encapsulamiento
  3. Herencia
  4. Polimorfismo

Relajate, todo va poco a poco, no te frustres y tampoco juzguemos a 脫scar. A lo mejor en otro curso se puede hacer m谩s 茅nfasis en que consiste cada cosa. Recuerda, ac谩 vemos que sucedi贸 en cada versi贸n de EcmaScript, es lo principal.

Esta clase es dif铆cil de entender si no se tienen unas bases te贸ricas sobre la Programaci贸n Orientada a Objetos y sobre aspectos de JavaScript como el this 馃槹 Intentar茅 definir estos elementos seg煤n lo que conozco para crear el concepto de lo que son las clases para quienes no lo pudieron entender bien:

Comencemos por el aspecto te贸rico:

  • Clases: Es una plantilla. Una definici贸n gen茅rica de algo que tiene atributos (datos/variables) y m茅todos (acciones/funciones) y desde la cual se pueden crear objetos.
  • Objetos: Un elemento real que fue creada con base en una clase (plantilla) y que hereda (contiene) sus atributos y m茅todos.

驴Lo vemos con un ejemplo?:
Tenemos una clase Animal que tiene como atributos: especie, edad, patas y tiene como m茅todos: dormir, comer, caminar. A partir de esa clase gen茅rica podemos instanciar objetos de ese tipo, como los siguientes:

  • Objeto perro: especie: canino, edad: 3, patas: 4. Puede dormir, comer y caminar.
  • Objeto paloma: especie: ave, edad: 1, patas: 2. Puede dormir, comer y caminar.
  • Objeto gato: especie: felino, edad: 2, patas: 4. Puede dormir, comer y caminar.

    Estos tres objetos fueron creados con base en la clase Animal (a esto se le llama instanciar un objeto a partir de una clase), y por ende, cada uno es un objeto de tipo Animal y cada uno tiene los atributos y m茅todos definidos en la clase.


Ahora, a nivel m谩s t茅cnico, utilizamos los siguientes conceptos:

  • Constructor: Es un m茅todo que contiene una serie de instrucciones que se encargan de inicializar un objeto cuando es instanciado a partir de esa clase. B谩sicamente, asigna los valores de los atributos que le enviemos a ese objeto nuevo. Es una funci贸n que se ejecuta autom谩ticamente.
  • Getter y Setter: Son funciones sencillas de entender: obtener el valor de un atributo o establecerlo. Se crean de esta manera por un concepto de la POO denominado encapsulamiento, que consiste, entre otras cosas, en limitar el acceso a las clases para tener mayor control sobre ellas.
  • This: Con este objeto de contexto hacemos referencia al propio objeto que se est谩 instanciando y no a la clase.

    Llevemos entonces el ejemplo de los animales a JavaScript para poder aterrizar todos estos conceptos te贸ricos de las clases:
// Declaraci贸n de la clase Animal
class Animal {

	// Constructor: le enviamos a la clase los valores para los atributos del nuevo objeto (como argumentos) y el constructor se encarga de asignarlos:
	// (Recordar: this hace referencia al objeto).
	constructor(especie, edad, patas) {
		this.especie = especie; // Asignar atributo especie al objeto
		this.edad = edad; // Asignar atributo edad al objeto
		this.patas = patas; // Asignar atributo patas al objeto
	}

	// M茅todos de la clase: pueden contener cualquier l贸gica.
	dormir() {
		return 'Zzzz';
	}

	comer() {
		return 'Yummy!';
	}

	caminar() {
		return '隆Caminando!, la la la';
	}

	// Getter y Setter (solo para edad para no alargar)
	// (Recordar: this hace referencia al objeto)
	get getEdad() {
		return this.edad;
	}

	set setEdad(newEdad) {
		this.edad= newEdad;
	}
}

// Ahora instanciemos los objetos: tendremos perro, paloma y gato como objetos de tipo Animal. Al enviar el valor de los atributos como argumentos, el constructor autom谩ticamente los asigna al nuevo objeto.
const perro = new Animal('canino', 3, 4);
const paloma = new Animal('ave', 1, 2);
const gato = new Animal('felino', 2, 4);

// Podemos acceder a los m茅todos desde cada objeto:
perro.dormir();	// Retorna 'Zzzz'
paloma.comer(); // Retorna 'Yummy!'
gato.caminar(); // Retorna '隆Caminando!, la la la'

// Usamos los getter para obtener los valores de los atributos y los setters para reasignarlos.
perro.getEdad; // Retorna 3
gato.setEdad = 3; // Cambia su atributo edad a 3


S茅 que es largo y tedioso por tanto aspecto te贸rico, pero cuando lo entiendes se abre todo un mundo de posibilidades al momento de programar (no solo con JavaScript). Espero que sea de ayuda 馃槈

Voy a dejar aqu铆 una breve explicaci贸n de como yo lo logre entender, mas sin embargo si me equivoco en algo pido de antemano disculpas.

  • En palabras sencillas, una clase es un plantilla para crear objetos con sus mismos atributos y m茅todos(atributos se refieren en el c贸digo como las variables, y los m茅todos como las funciones; todo esto dentro del objeto).

Como ejemplo podemos visualizar las Clases, como moldes para hacer galletas y sus objetos como las galletas ya listas para su consumo. Aunque debido a su molde (clase) todas las galletas (objeto), tendr铆an la misma forma cada galleta puede tener gomitas, otras crema, entre muchas otras, esto de les podr铆a llamar los atributos de nuestros objetos (galletas).

  • Una INSTANCIA de una CLASE: se refiere al objeto creado a partir de la clase.

  • La sintaxis que utiliza la clase es la siguiente :

//Se declara la clase:

class NombredelaClase {
    //atributos y metodos
}

//Se crea una instancia (objeto), de la clase:

const NuevoObjeto = new NombredelaClase();

El profe Oscar inicia desde los m茅todos(una funci贸n), para explicarnos como crear la instancia (objeto) de la clase User(molde), de la siguiente manera:

class User {
    //Metodos
    greeting(){
        return 'Hello';
    }
}; 
  • El m茅todo greeting es una funci贸n, para m茅todos pr谩cticos vamos a utilizar el nombre 鈥楶epe鈥 en vez de llamar el objeto 鈥榞ndx鈥.

  • Se crea el objeto a partir de la clase User y se llama el m茅todo para mostrarla en consola de la siguiente manera:

const pepe = new User();
console.log(pepe.greeting()); // Hello
  • Se declara el nuevo objeto 鈥榩epe鈥 a partir de la clase user, y se llama a la funci贸n greeting dentro de nuestro objeto 鈥榩epe鈥. En consola tenemos el 鈥楬ello鈥.

  • Cuando se refiere a la herencia, en este caso de las clases, significa que la clase puede tener varios objetos de diferente nombre pero con los mismos atributos y m茅todos de la misma.

  • La palabra reservada 鈥榥ew鈥, es un constructor, que sirve para crear objetos personalizados.

  • El this, b谩sicamente en palabras mas sencillas es decirle a tu c贸digo que cuando le escribes this, es en el contexto, ll谩mese dentro de una funci贸n, dentro de un objeto, que de este mismo requieras. En las clases no es lo mismo traer la asignaci贸n de un atributo del padre (molde), que la asignaci贸n de atributo de un hijo (galletas), aunque tengan un mismo atributo.

En un ejemplo mas practico vamos a recrear un poco un juego (Mario Bros) y vamos a crear con una clase 鈥楶layer鈥 a nuestros personajes como 鈥榩layer1鈥 a Mario y a 鈥榩layer2鈥 como a Luigi. Vamos tomar como atributos nombre y colorSombrero, por ahora, y el m茅todo de saludar.

class Player {
    constructor(nombre, colorSombrero){
        //atributos con su contexto
        this.nombre = nombre;
        this.colorSombrero = colorSombrero;
    }
    //Metodos
    saludar(){
        return `Hola soy ${this.nombre} y mi sombrero es ${this.colorSombrero}`;
    }
}
//Creacion de jugadores (Objetos)

let player1 = new Player('Mario','Rojo');
let player2 = new Player('Luigi', 'Verde');

console.log(player1);//Player {nombre: 'Mario', colorSombrero: 'Rojo'}
console.log(player1);////Player {nombre: 'Luigi', colorSombrero: 'Verde'}

//Llamar metodos de los jugadores (Objetos)

console.log(player1.saludar()); // Hola soy Mario y mi sombrero es Rojo
  • Los metodos Get y Set nos permiten tener acceso a leer o modificar el atributo de un objeto. Siendo Get, para mostrar el nombre del atributo y Set, para modificar ese atributo.En el ejemplo del juego:
class Player {
    constructor(nombre, colorSombrero){
        this.nombre = nombre;
        this.colorSombrero = colorSombrero;
    }
    //Metodos
    saludar(){
        return `Hola soy ${this.nombre} y mi sombrero es ${this.colorSombrero}`;
    }
    get nombre(){
        return this.nombre;
    }
    set nombre(nuevoNombre){
        this.nombre = nuevoNombre;
    }
}

//GET
console.log(player1.nombre); // Mario
//SET 
player1.nombre = 'Alberto';
console.log(player1.nombre);// Alberto

Cabe destacar que parte de informaci贸n aqu铆 mencionada la obtuve de otras fuentes y que si desean les puedo dejar.

Me parece un crimen que ya no est茅n profes como el excelent铆simo profesor del bigote del curso de "introducci贸n al pensamiento computacional con Python" ese man se rifaba unas explicaciones tan pero tan claras. A estas explicaciones les hace falta profundizar en absolutamente todo.

Les dar茅 la explicaci贸n magistral:

Una clase es un molde para galletas, la masa son los datos que y la galleta es el resultado de unir un molde con la masa.

Por nada.

No es por defender al profesor, pero mi recomendaci贸n personal es si no comprenden este v铆deo, miren el curso de POO. Y regresen, en ese punto se hace m谩s f谩cil seg煤n yo. Saludos y no me funen jajaja.

Algo interesante que not茅 - NO se requieren los par茅ntesis para ejecutar los m茅todos getters & setters de una clase. 馃

He tomado el curso de programcion orientada a objetos y ahi todo buen entendi con claridad pero aqui no eniendo absolutamente nada, solo decidi con este curso porque le profe Diego lo sugirio en el de Estrutura de datos con JS pero realmente siento que este curso es para personas expertas en js y no para novatos como nosotros que apenas entramos a este mundo y no se si continuar o dejarlo鈥

馃毃 Veo que mucha gente tiene comentarios a acerca de que no entienden los temas o que el profesor los est谩 dando muy r谩pido. Este curso no es para aprenderse a profundidad cada uno de los cambios de ECMA, sino para hacerles saber que existe, y la funcionalidad b谩sica de cada uno. Cosas como las clases, las explican en el curso de POO de JavaScript. No se frustren. Y si tienen dudas p贸ngalas en las preguntas para ayudarnos entre todos.

Sinceramente algunas personas no saben ni lo que est谩n haciendo. Pretenden que en un curso expliquen todo a profundad cuando existen otros espec铆ficos para ello. Se llama 鈥淐urso de ECMAScript: HISTORIA Y VERSIONES鈥︹. No van a aprender POO en una introducci贸n xD

12/35 ES6: Clases

Las clases son una forma de crear objetos y definir como se comportan. Las clases son una caracter铆stica introducida en ECMAScript 6 que permite a los desarrolladores escribir c贸digo m谩s legible y estructurado.

En terminos simples, una clase es como un plano o un modelo que define c贸mo se crea un objeto y c贸mo funciona. Es una plantilla para crear objeto que tienen propiedades y m茅todos en com煤n.

Por ejemplo, si quisiera crear varios objetos que representan diferentes tipos de autom贸viles, podr铆a definir una clase llamada Automovil que tenga propiedades como marca, modelo, a帽o, etc. y m茅todos como arrancar, y detener. Luego podr铆a crear varios objetos basasdos en esa clase, como un autom贸vil deportivo, un cami贸n, un sed谩n, etc. y cada uno tendr铆a sus propias propiedades y m茅todos espec铆ficos.

La sintaxis de las clases en ES6 es similar a la de otros lenguajes de programaci贸n orientados a objetos, como Java o C#. Para definir una clase, se utiliza la palabra reservada class, seguida del nombre de la clase y un par de llaves que contienen los m茅todos y propiedades de la clase.

class Automovil {
	constructor(marca, modelo, year) {
		this.marca = marca;
		this.modelo = modelo;
		this.year = year;
	}
	
	arrancar() {
		console.log("El automovil ha arrancado.");
	}
	detener() {
		console.log("El automovil se ha detenido.");
	}
}
let miAuto = newAutomovil("Ford", "Mustang", 2021);
miAuto.arracnar(); // Output: "El automovil ha arrancado."

En este ejemplo, la clase 鈥 Automovil 鈥 tiene un constructor que se ejecuta cuando se crea un nuevo objeto de la clase, y define las propiedades 鈥渕arca鈥, 鈥渕odelo鈥 y 鈥測ear鈥. Tambi茅n tiene dos m茅todos, 鈥渁rrancar鈥 y 鈥渄etener鈥, que imprimen un mensaje en la consola cuando se llaman. Finalmente, se crea un obejto 鈥渕iAuto鈥 basado en la clase 鈥淎utomovil鈥 y se llama al m茅todo 鈥渁rrancar鈥.

Las clases son una forma de crear plantillas para objetos que tienen propiedades y m茅todos en com煤n, lo que permite a los desarrolladores escribir c贸digo m谩s legible y estrucutrado.

No se ofendan, pero no entiendo porque se frustran tanto con esta clase. No me puedo imaginar un programador que a estas alturas del siglo XXI NUNCA haya escuchado/le铆do/estudiado los conceptos b谩sicos de programaci贸n Orientada a Objetos. En serio, si quieren ser devs, estudien un poco de POO, antes de criticar.
Adem谩s, es claro que el curso se llama: 鈥淗istoria y versiones de JavaScript鈥. No es un curso espec铆fico de POO en JS, ni de Asincronismo en JS.
Si no entienden lo m谩s b谩sico de POO, en serio, no sigan este curso, y busquen un curso de POO. Por cierto, el curso de POO en JS con JuanDC est谩 muy bueno y s煤per digerible.
S贸lo una recomendaci贸n.

C贸digo de la clase resumido:

class User {

        constructor(userName, userAge) {
                this.userName = userName;
                this.userAge = userAge;
        }

        greeting() {
                return `Hello ${this.userName}!`;
        }

        get _userAge() {
                return this.userAge;
        }

        set _userAge(age) {
                this.userAge = age;
        }
}

const pepito = new User('Pepito', 20);
console.log(pepito.greeting());
console.log(pepito._userAge); // 20
console.log(pepito._userAge = 16); // 16

const mike = new User('Mike', 24);
console.log(mike.greeting());
console.log(mike._userAge); // 24
console.log(mike._userAge = 33); // 33

Les dejo una descripcion para los que nunca hicieron el curso de programacion basica (el nuevo o el viejo), donde explican los conceptos.

//Hablaremos de los objetos, clases, metodos e instancias (para dudas o terminologia ve a one note)
/*
This= hace referencia al elemento padre que lo contiene
intancia = crear un nuevo objeto
metodo= funcion dentro del objeto
contructor= funcion qe se realiza inmediatamente al instanciar ( crear objeto)
clase= es el elemento padre
get= me trae el valor de un objeto, y set me reescribe el valor del objeto
*/


//Declarando una clase (osea el padre el molde de los objetos)
class User0 {};
// para instanciar una clase se usa:
const newUser01 = new User0();

//Ejemplo con 2 instancias y un metodo
class user {
    greetings(){
        return 'Metodo Saludar';
    }
};
const newUser = new user();
console.log(newUser.greetings());
const newUser1 = new user();
console.log(newUser1.greetings());


//
class user {
    //El constructor, costruye o ejecuta una funcion cuando estoy creando una instancia
    constructor(){
        console.log('Creando nuevo usuario');
    }
    greetings(){
        return 'Metodo saludar';
    }
}
const david = new user();
console.log(david.greetings());

//En este ejemplo con this, inicializamos una variable de una clase (de creacion), ademas usamos template literals


    class user {
        constructor(name){
            this.name = name;
        }
        //A帽ado metodos
        speak (){
            return 'Hoy saludamos a: ' ;
        }
        greeting(){
            //uso template literals
            return `${this.speak()} ${this.name}`;
        }
    }

    const jimena = new user('jimena');
    console.log(jimena.greeting());

    //Ejemplo con setter and getters, nos sive para llamar el valor de una variable dentro de un ubjeto creado

    class user {
        //constructor
        constructor(name, age){
            this.name = name;
            this.age = age;
        }
        //metods
        speak(){
            return 'Hola:' ;
        }
        greeting(){
            return `${this.speak()} ${this.name} su edad es : ${this.age}`;
        }
        //A帽ado los getters and setters
        get modifyAge() {
            return this.age;
        }
        set modifyAge(n){
            this.age = n;
        }
    }

    const maria = new user('Maria', 31.6);
    console.log(maria.greeting());
    //con get lo llamo para ver el valor
    console.log(maria.modifyAge);
    //con set lo 
    console.log(maria.modifyAge = 22);

no entendi para que es el Set y Get

En ECMAScript 6 (tambi茅n conocido como ES6 o ES2015), se introdujo el concepto de clases en JavaScript. Las clases son una forma m谩s intuitiva y orientada a objetos de crear objetos y trabajar con herencia en JavaScript.

Antes de ES6, JavaScript utilizaba una sintaxis basada en prototipos para implementar la herencia y la creaci贸n de objetos. Con la introducci贸n de las clases en ES6, ahora tenemos una sintaxis m谩s familiar y similar a otros lenguajes de programaci贸n orientados a objetos, como Java o C++.

Una clase en JavaScript es una plantilla para crear objetos que comparten propiedades y comportamientos comunes. Para definir una clase, utilizamos la palabra clave class, seguida del nombre de la clase y un bloque de c贸digo que contiene los miembros de la clase (propiedades y m茅todos).

Aqu铆 hay un ejemplo b谩sico de c贸mo se ve la sintaxis de una clase en ES6:

class Persona {
  constructor(nombre, edad) {
    this.nombre = nombre;
    this.edad = edad;
  }

  saludar() {
    console.log(`Hola, mi nombre es ${this.nombre} y tengo ${this.edad} a帽os.`);
  }
}
const juanito = new Persona(`Juan David`, 23);
  console.log(juanito.saludar()); //Hola, mi nombre es Juan David y tengo 23 a帽os.

En este ejemplo, creamos una clase llamada Persona. La clase tiene un constructor que se ejecuta cuando se crea una nueva instancia de la clase. El constructor acepta los par谩metros nombre y edad y los asigna a las propiedades correspondientes (this.nombre y this.edad).

La clase tambi茅n tiene un m茅todo llamado saludar(), que imprime un mensaje de saludo en la consola, utilizando los valores de las propiedades nombre y edad.

Para crear un objeto a partir de una clase, utilizamos la palabra clave new, seguida del nombre de la clase y los argumentos necesarios para el constructor. Aqu铆 hay un ejemplo de c贸mo se crea un objeto `persona.

Es un curso de INTRODUCCI脫N. Entiendan.

Los cursos espec铆ficos siguen despu茅s de este.

Me hizo recoradar lo que se hacia con las clases en java, constructor, getters , setter , y el toString , lo bueno que el ide lo genraba mediante unas opciones, el constructor que se se llama cuando se crea un obj de la clase, en php existe el metodo destruct se llama cuando el obj es eliminado , no se si existira en javascript.

Amigos veo que hay gente que se queja por que el docente no 鈥渆xplica adecuadamente鈥, no es que este explicando muy rapido o omita cosas, sucede que este curso solo es para mostrarnos un antes y un despues entre la versiones, sigan la ruta de cursos que plantea Platzi y no tomen cursos solo por tomarlos, veran que con bunas bases este curso es mas una especie de clase de historia de js.

Cree una clase que hace consultas de APIs con el m茅todo de fetch.
![](

Incre铆ble lo de clases. Bien con la programaci贸n orientada a objetos owo

En esta clase aprend铆 a usar los getters y setters por intuici贸n que por explicaci贸n del profe, espero en futuras calses profundicen mas en los conceptos

aimedueleelcebrebro

siento que el profesor se esta llevando muchas criticas de gratis, el solo esta comentando brevemente los cambios y actualizaciones en js. el mismo titulo lo dice

Para reforzar bien estos temas dejo por ac谩 una referencia, espero sea de ayuda:
Prototipos
Herencia Protot铆pica
Clases y Herencia
M茅todos est谩ticos, getters y setters

ES6: clases

En ECMAScript 6, se introdujeron las clases, que son una forma m谩s sencilla y estructurada de crear objetos y trabajar con la programaci贸n orientada a objetos en JavaScript.

Aqu铆 tienes un resumen de c贸mo funcionan las clases en ES6:

  1. Declaraci贸n de una clase:

    Puedes declarar una clase utilizando la sintaxis class. Aqu铆 tienes un ejemplo b谩sico:

    class Persona {
      constructor(nombre, edad) {
        this.nombre = nombre;
        this.edad = edad;
      }
    
      saludar() {
        console.log(`Hola, soy ${this.nombre} y tengo ${this.edad} a帽os.`);
      }
    }
    
  2. Constructor:

    El m茅todo constructor se utiliza para inicializar propiedades de la instancia cuando se crea un nuevo objeto a partir de la clase. Se llama autom谩ticamente al crear un nuevo objeto con new.

  3. M茅todos:

    Puedes definir m茅todos dentro de la clase. Estos m茅todos son compartidos por todas las instancias creadas a partir de la clase.

  4. Herencia:

    Las clases pueden heredar propiedades y m茅todos de otras clases utilizando la palabra clave extends. Aqu铆 tienes un ejemplo:

    class Estudiante extends Persona {
      constructor(nombre, edad, grado) {
        super(nombre, edad);
        this.grado = grado;
      }
    
      estudiar() {
        console.log(`${this.nombre} est谩 estudiando en el grado ${this.grado}.`);
      }
    }
    

    En este caso, la clase Estudiante hereda propiedades y m茅todos de la clase Persona.

  5. Super:

    La palabra clave super se utiliza para llamar a los m茅todos del padre en la clase hija. En el ejemplo anterior, super(nombre, edad) llama al constructor de la clase padre Persona.

  6. Getter y Setter:

    Puedes definir getters y setters utilizando las palabras clave get y set.

    class Rectangulo {
      constructor(ancho, altura) {
        this._ancho = ancho;
        this._altura = altura;
      }
    
      get area() {
        return this._ancho * this._altura;
      }
    
      set ancho(nuevoAncho) {
        if (nuevoAncho > 0) {
          this._ancho = nuevoAncho;
        }
      }
    }
    

    En este ejemplo, area es un getter y ancho es un setter.

  7. M茅todos est谩ticos:

    Los m茅todos est谩ticos son m茅todos que se llaman directamente en la clase, no en las instancias. Se definen utilizando la palabra clave static.

    class Utilidades {
      static sumar(a, b) {
        return a + b;
      }
    }
    
    const resultado = Utilidades.sumar(5, 3);
    


Estos son algunos conceptos b谩sicos sobre c贸mo funcionan las clases en ECMAScript 6. Las clases proporcionan una forma m谩s organizada y legible de trabajar con programaci贸n orientada a objetos en JavaScript.



Sigamos con el aprendizaje. 馃懆鈥嶐煉

Para esta clase creo que era mas recomendable poner como requisito ver el curso de POO para los que est谩n perdidos

en un curso de UDEMY por 79 MXN lo comprend铆 mejor XD

Es muy complicado intentar explicar un tema tan amplio en una clase de 18 min, para poder entenderlo a profundidad se necesita saber como funcionan los objetos, instancias y metodos en js, los que no logran entenderlo a la primera es normal, y si se frustran tanto no pasa nada, solo estan tratando de mostrar algo general que implementaron en el lenguaje, para entenderlo mejor es recomendable esperar y ver el curso de POO鈥

Changos, esto si no es tan b谩sico jeje esto lo v铆 cu谩ndo aprend铆 POO y protocolos en Swift.

Para los que se pregunten, a todo esto se le llama programaci贸n orientada a objetos, hay cursos enteros de este tema, ya que es medio largo y tiene mucho de donde aprender. Si no entienden se los recomiendo! Ya que en serio se utiliza mucho en el mundo laboral.

tu voz en 2x suena como la de Eugenio Derbez jaja

?Porque usar el m茅todo get, si podemos obtener lo valore directo de las variables? al igual que con el m茅todo set que se puede modificar el valor de la variable. ```js class User{ constructor(name, age){ this.name = name; this.age = age; } get uAge(){ return this.age;} set uAge(n){this.age=n;} } const person = new User ('David', 15); console.log(person.uAge); console.log(person.age); console.log(person.age=20); ```
```js // declarando class User {}; // instancia de una class // const newUser = new User(); class user { // metodos greeting(){ return "Hello"; } }; const gndx = new user(); console.log(gndx.greeting()); const bebeloper = new user(); console.log(bebeloper.greeting()); // constructor class user { //constructor constructor() { console.log("Nuevo Usuario"); } greeting(){ return "Hello"; } } const david = new user(); // this class user { constructor(name){ this.name=name; } // metodo speak(){ return "Hello" } greeting(){ return `${this.speak()} ${this.name}`; } } const ana = new user("Ana"); console.log(ana.greeting()); // setters getting class user { // constructor constructor(name, age){ this.name = name; this.age = age; } // metodos speak() { return "Hello"; } greeting(){ return `${this.speak()} ${this.name}`; } get uAge(){ return this.age; } set uAge(n) { this.name = n; } } const bebeloper1 = new user("David", 15); console.log(bebeloper1.uAge); console.log(bebeloper1.uAge = 20); ```// declarandoclass User {}; // instancia de una class// const newUser = new User(); class user {聽 聽 // metodos聽 聽 greeting(){聽 聽 聽 聽 return "Hello";聽 聽 }}; const gndx = new user();console.log(gndx.greeting());const bebeloper = new user();console.log(bebeloper.greeting()); // constructor class user {聽 聽 //constructor聽 聽 constructor() {聽 聽 聽 聽 console.log("Nuevo Usuario");聽 聽 }聽 聽 greeting(){聽 聽 聽 聽 return "Hello";聽 聽 }} const david = new user(); // this class user {聽 聽 constructor(name){聽 聽 聽 聽 this.name=name;聽 聽 }聽 聽 // metodo聽 聽 speak(){聽 聽 聽 聽 return "Hello"聽 聽 }聽 聽 greeting(){聽 聽 聽 聽 return `${this.speak()} ${this.name}`;聽 聽 }} const ana = new user("Ana");console.log(ana.greeting()); // setters getting class user {聽 聽 // constructor聽 聽 constructor(name, age){聽 聽 聽 聽 this.name = name;聽 聽 聽 聽 this.age = age;聽 聽 }聽 聽 // metodos 聽 聽 speak() {聽 聽 聽 聽 return "Hello";聽 聽 }聽 聽 greeting(){聽 聽 聽 聽 return `${this.speak()} ${this.name}`;聽 聽 } 聽 聽 get uAge(){聽 聽 聽 聽 return this.age;聽 聽 }聽 聽 set uAge(n) {聽 聽 聽 聽 this.name = n;聽 聽 }} const bebeloper1 = new user("David", 15);console.log(bebeloper1.uAge);console.log(bebeloper1.uAge = 20);
`// declarandoclass User {};` `// instancia de una class// const newUser = new User();` `class user {聽 聽 // metodos聽 聽 greeting(){聽 聽 聽 聽 return "Hello";聽 聽 }};` `const gndx = new user();console.log(gndx.greeting());const bebeloper = new user();console.log(bebeloper.greeting());` `// constructor` `class user {聽 聽 //constructor聽 聽 constructor() {聽 聽 聽 聽 console.log("Nuevo Usuario");聽 聽 }聽 聽 greeting(){聽 聽 聽 聽 return "Hello";聽 聽 }}` `const david = new user();` `// this` ``class user {聽 聽 constructor(name){聽 聽 聽 聽 this.name=name;聽 聽 }聽 聽 // metodo聽 聽 speak(){聽 聽 聽 聽 return "Hello"聽 聽 }聽 聽 greeting(){聽 聽 聽 聽 return `${this.speak()} ${this.name}`;聽 聽 }}`` `const ana = new user("Ana");console.log(ana.greeting());` `// setters getting` ``class user {聽 聽 // constructor聽 聽 constructor(name, age){聽 聽 聽 聽 this.name = name;聽 聽 聽 聽 this.age = age;聽 聽 }聽 聽 // metodos 聽 聽 speak() {聽 聽 聽 聽 return "Hello";聽 聽 }聽 聽 greeting(){聽 聽 聽 聽 return `${this.speak()} ${this.name}`;聽 聽 }`` `聽 聽 get uAge(){聽 聽 聽 聽 return this.age;聽 聽 }聽 聽 set uAge(n) {聽 聽 聽 聽 this.name = n;聽 聽 }}` `const bebeloper1 = new user("David", 15);console.log(bebeloper1.uAge);console.log(bebeloper1.uAge = 20);`
Clase User y user???, deber铆a preparar mejor sus ejemplos!!!!
Yo me detuve en esta parte y me fui a ver el curso de "Programaci贸n Orientada a Objetos en JavaScript" y se que hay una gran diferencia despeus de ver ese curso y despues esta clase

hola vengo del futuro muchachos si quieren entender a bien esta clase les recomiendo ver el curso de Curso B谩sico de Programaci贸n Orientada a Objetos con JavaScript asi entenderan mucho mejor 馃槇馃槇馃槇馃槇馃槇馃槇馃槇馃槇馃槇
https://platzi.com/cursos/javascript-poo/
![]()

Una vez dominamos las bases de la programaci贸n y nuestro c贸digo va creciendo cada vez m谩s, comprobaremos que las variables y funciones no suelen ser suficiente como para que nuestro c贸digo est茅 bien organizado y los mecanismos que tenemos a nuestro alcance quiz谩s no resultan todo lo pr谩cticos que deber铆an ser.

Tradicionalmente, Javascript no soportaba clases de forma nativa, pero en ES2015 (ECMAScript 6) se introdujo la posibilidad de usar clases simulando como se utilizan en otros lenguajes de programaci贸n. Internamente, Javascript traduce estas clases al sistema basado en prototipos que usa en realidad, sin embargo, los programadores no necesitar谩n saber como funcionan los prototipos, sino que les bastar谩 con utilizar las clases a modo de az煤car sint谩ctico, es decir, un sistema que 芦endulza禄 la forma de trabajar para que sea m谩s agradable y familiar.

鉁煢

Amigos a continuaci贸n les dejo un tutorial donde hablo acerca de las clases, los objetos que las mismas pueden formar y tambi茅n sobre la diferencia con los objetos literales :3, pueden echarle un vistazo si la clase les pareci贸 confusa:
Objeto Literal y Objeto de Clase en Javascript

Incre铆ble clase, igual pienso al igual que los compa帽eros que si no han aprendido programaci贸n orientado a objetos, no van a poder entender muy bien algunas clases. Pero no se desesperen, pueden si gustan despu茅s de esta clase tomar la ruta completa de JavaScript y as铆 tengan lo necesario para continuar. <https://platzi.com/ruta/web-javascript/?school=_escuela_web_>

En el siguiente ejemplo quise imitar el funcionamiento de una clase en caso tal de que sea una agencia de renta de carros y se tenga que tener metodos para mostrar cuando un carro estan rentandolo o cuando esta andando o se detiene.

class car {

    // constructor de el carro 

    constructor(marca, color, anio, kilometraje){
        this.marca = marca;
        this.color = color;
        this.anio = anio;
        this.kilometraje = kilometraje;
    }

    //Metodos getter and setter para las propiedades de la clase 
    get getMarca(){
        return this.marca
    }

    set setMarca(newMarca){
        this.marca = newMarca
    }

    get getColor(){
        return this.color
    }
    set setColor(newColor){
        this.color = newColor
    }


    get getAnio(){
        return this.anio
    }

    set setAnio(newAnio){
        this.anio = newAnio
    }


    get getKilometraje(){
        return this.kilometraje
    }


    set setKilometraje(newKIlometraje){
        this.kilometraje = newKIlometraje
    }


    // Metodos de la clase o funciones 

    rentar(){
        return console.log(`Usted esta rentando el carro ${this.marca} del a帽o ${this.anio} de color ${this.color} con el kilometraje ${this.kilometraje} `)
    };

    andar(){
        return console.log(`El carro ${this.marca} esta andando`)
    };
    detenerse(){
        return console.log(`El carro ${this.marca} se detuvo`)
    };
    bloquearAlarma(){
        return console.log(`El carro ${this.marca} se bloqueo`)
    };
}


const carro1 = new car('Kia', 'Azul', 2023, 500);
const carro2 = new car('BMW', 'Blanco', 2005, 10000);
const carro3 = new car('Chevrolet', 'Negro', 2020, 2000);


carro1.rentar();
carro1.andar();



carro2.detenerse();

carro3.bloquearAlarma();

Con esta imagen es que yo logre entender las clases y como funcionaban en su momento.

Esta clase deja m谩s dudas que conceptos. Por cada minuto de video estoy 10min leyendo cosas en internet 馃榿

Si la clase es una cadena de hamburguesas la instancia es preparar esa hamburguesa que sigue las especificaciones de la clase

En los cursos basicos de javascript, Estaba el tema de Funcion Constructora.

Funcio constructora (similares) Class.

class tiene mas alcane en cuestiones de almacenaje.

If a class only has a constructor, it is not much different from a createX factory function which just creates plain objects. However, the power of classes is that they can be used as 鈥渢emplates鈥 which automatically assign methods to instances.

驴Como es posible en el video que declare 2 clases de user llamandose exactamente igual y no le de error?

En el minuto 7:30 veo
class user {

//metodos
greeting(){
    return "Hello";
}

};

y despues :

class user {
constructor() {

    console.log("Nuevo usuario");
}

  //metodos
greeting(){
    return "Hello";
}

}

No me lo explico

Recomiendo este video explica gr谩ficamente conceptos de esta clase
https://www.youtube.com/watch?v=I848HdWjLMo&pp=ygUPYWJzb2x1dGUgY2xhc2Vz

Compa帽eritos, antes de tomar este curso es importante tomar los cursos anteriores en las rutas , por ejemplo los dos de POO, la ruta de JS es la m谩s efectiva con respecto al orden鈥

comprendi la opcion de setters getters pero de igual manera todas las opciones son correctas

Excelente, he entendido varios conceptos que he trabajado por mucho tiempo y he dado por sentada su funcionalidad y comportamiento, pero sin entender el porqu茅. Esto se debe al aprendizaje apresurado por la marcha que he tenido y en el que no me he detenido a ver que es lo que estoy haciendo y porque as铆 xD

Investigue un poco un Metodo se pude entender que es una Funcion.
.

Cumple como funci贸n por que ya esta definido como una funci贸n por medio de Class.
.

Te daras cuenta que tambien es necesario inicializar el method como una funcion.
.

El constructor es publico y los metodos son privados.
.

Conclucion el metodo de una clase es una funcion definida por la misma clase pero es privada .

Me parece que el profe oscar es muy bueno explicando, sin embargo no todos entienden de la misma manera.
No esta mal buscar en otra parte un tema que no entiendas, por eso les traigo este v铆deo con el que yo entend铆 mucho mejor que son las clases.

https://www.youtube.com/watch?v=9LH_1NDn2RU&t=106s

class user{
    //constructor
    constructor(name,age){
        this.name = name;
        this.age = age;
    }
    //metodos
    speak(){
        return 'Hello';
    }
    greeting(){
        return`${this.speak()} ${this.name}`;
    }
    get uAge(){
        return this.age;
    }
    set uAge(n){
        this.age = n;
    }
}

const bebeloper1 = new user('David',15)
console.log(bebeloper1.uAge);
console.log(bebeloper1.uAge =20);

El c贸digo define una clase llamada user que representa un usuario con propiedades y m茅todos. Veamos c贸mo funciona paso a paso:

  1. Se define la clase user utilizando la palabra clave class.

  2. Dentro de la clase, se define el constructor utilizando el m茅todo especial constructor. El constructor recibe dos par谩metros: name y age. Dentro del constructor, se asignan estos valores a las propiedades this.name y this.age, respectivamente.

  3. Se definen dos m茅todos dentro de la clase user:

    • speak(): Es un m茅todo que devuelve la cadena de texto 'Hello'.
    • greeting(): Es un m茅todo que utiliza el m茅todo speak() para obtener el saludo y luego lo combina con el nombre del usuario para formar una cadena de texto. Utiliza la propiedad this.name para acceder al nombre del usuario.
  4. Se definen dos 鈥渁ccessors鈥 (accesores) utilizando las palabras clave get y set:

    • uAge (get): Es un 鈥渁ccessor鈥 de solo lectura que devuelve el valor de la propiedad this.age.
    • uAge (set): Es un 鈥渁ccessor鈥 de escritura que permite asignar un nuevo valor a la propiedad this.age.
  5. Se crea una instancia de la clase user llamada bebeloper1 utilizando el constructor y se le pasan los valores 'David' y 15 como argumentos.

  6. Se utiliza console.log para imprimir el valor de bebeloper1.uAge, lo cual invoca el 鈥渁ccessor鈥 get y devuelve el valor actual de this.age, que es 15.

  7. Se utiliza console.log para imprimir el resultado de asignar 20 a bebeloper1.uAge. Esto invoca el 鈥渁ccessor鈥 set y actualiza el valor de this.age a 20. Luego, se imprime el valor asignado, que es 20.

En resumen, el c贸digo crea una clase user con propiedades name y age, m茅todos speak() y greeting(), y los 鈥渁ccessors鈥 uAge (get y set). Luego, crea una instancia de la clase y muestra el valor actual de age, seguido de la asignaci贸n de un nuevo valor a age y muestra el valor asignado.

es tema sobre programacion orientada a objetos,

馃摃 Archivos del Proyecto 馃摃


Pasos 馃搶

  • 鈥 Dentro de la carpeta es6, crear el archivo llamado: 07-clases.js
      • 鈼 El c贸digo de los ejercicios queda:
//Compilar: seleccionar el c贸digo + click derecho + Run Code

//Ejercicio #1

/*
//declarando
class User{};

//instancia de una clase
const newUser = new User();

*/

//Ejercicio #2

class user {
	// metodos
	greeting() {
		return 'Hello';
	}
};

const gndx = new user();
console.log(gndx.greeting());
const bebeloper = new user();
console.log(bebeloper.greeting());

/*output:
Hello
Hello
*/

//Ejercicio #3
// constructor
class user2 {
	//Constructor
	constructor(){
		console.log('Nuevo Usuario');
	}
	greeting() {
		return 'Hello';
	}
}

const david = new user2();

/*output:
Nuevo Usuario
*/

//Ejercicio #4
// this
class user3 {
	constructor(name){
		this.name = name;
	}
	// metodos
	speak() {
		return 'Hello';
	}
	greeting() {
		return `${this.speak()} ${this.name}`;
	}
}

const ana = new user3('Ana');
console.log(ana.greeting());

/*output:
Hello Ana
*/

//Ejercicio #5
// setter getters
class user4{
//constructor
	constructor(name,age){
		this.name = name;
		this.age = age;
	}
	//metodos
	speak(){
		return 'Hello';
	}
	greeting(){
		return `${this.speak()} ${this.name}`;
	}
	get uAge(){
		return this.age;
	}
	set uAge(n){
		this.age = n;
	}
}
const bebeloper2 = new user4('David', 15);
console.log(bebeloper2.uAge);
console.log(bebeloper2.uAge = 20);

/*output:
15
20
*/

JavaScript utilizaba principalmente una sintaxis basada en prototipos para implementar la herencia y la programaci贸n orientada a objetos. Con la introducci贸n de ES6, se agreg贸 una sintaxis de clase m谩s familiar y orientada a objetos. Perm铆teme explicarte las caracter铆sticas clave de las clases en ES6:

Declaraci贸n de clases:
La declaraci贸n de una clase en ES6 se realiza utilizando la palabra clave class, seguida del nombre de la clase. Por ejemplo:

class Persona {
  constructor(nombre, edad) {
    this.nombre = nombre;
    this.edad = edad;
  }

  saludar() {
    console.log(`Hola, soy ${this.nombre}`);
  
}
}

En este ejemplo, se declara una clase llamada Persona con un constructor y un m茅todo saludar(). El constructor se utiliza para inicializar las propiedades de la clase, y los m茅todos se definen dentro del cuerpo de la clase.

  • Constructor:
    El constructor es un m茅todo especial dentro de una clase que se llama autom谩ticamente cuando se crea una instancia de la clase. Puedes utilizar el constructor para asignar valores iniciales a las propiedades de la clase. En el ejemplo anterior, el constructor de la clase Persona acepta los par谩metros nombre y edad y los asigna a las propiedades correspondientes.

  • M茅todos de instancia:
    Los m茅todos de instancia son funciones definidas dentro de la clase que se asocian con cada instancia creada. Puedes acceder a las propiedades y otros m茅todos de la instancia utilizando la referencia this. En el ejemplo anterior, el m茅todo saludar() es un m茅todo de instancia que muestra un saludo utilizando el nombre de la persona.

  • Herencia de clases:
    ES6 permite la herencia de clases utilizando la palabra clave extends. Puedes crear una clase hija que herede propiedades y m茅todos de una clase padre. Aqu铆 hay un ejemplo:

class Estudiante extends Persona {
  constructor(nombre, edad, grado) {
    super(nombre, edad);
    this.grado = grado;
  }

  estudiar() {
    console.log(`${this.nombre} est谩 estudiando`);
  }
}

En este ejemplo, la clase Estudiante hereda de la clase Persona utilizando extends. El constructor de la clase Estudiante utiliza super() para llamar al constructor de la clase padre y asignar los valores a las propiedades heredadas. Adem谩s, se define un nuevo m茅todo estudiar() espec铆fico de la clase Estudiante.

Estas son las caracter铆sticas b谩sicas de las clases introducidas en ES6. Proporcionan una sintaxis m谩s clara y orientada a objetos para trabajar con la programaci贸n orientada a objetos en JavaScript. Desde ES6 en adelante, las clases se han convertido en una forma com煤n de definir estructuras de objetos y trabajar con herencia en JavaScript.

La verdad es nefasto que expliquen esto a las carreras sin tener cursos de programaci贸n orientada a objetos en las rutas.
Menos mal yo ya he programado en Java y Python y domino ese concepto, pero me imagino la tremenda confusi贸n que esto le causa a alguien que no sepa esos conceptos tan importantes.
Encima dicen en este video que la herencia es instanciar objetos de una clase cuando no tiene nada que ver, terrible el fallo en este video.

驴En serio bebeloper? 馃槃

Chat GPT explica mucho mejor las clases, lo siento, pero en la ruta no han explicado muchos t茅rminos, y el profesor Oscar da por hecho que los entendemos, he repetido la clase, pero hay cosas que explica muy r谩pido. Tuve que acudir a chat GPT y lo entend铆, d铆ganle a open AI que les ponga ejercicios, y eso les ayudara a practicar.

Mi resumen:

Una pagina que me sirvio un monton para comprender mejor el tema de las clases es esta: https://www.digitalocean.com/community/tutorials/informacion-sobre-clases-de-javascript-es

Entiendo que es preferible usar una clase a una funci贸n para generar elementos, cuando tanto la clase como sus procesos asociados al elemento instanciado se van a utilizar numerosas veces.
La funci贸n est谩 m谩s asociada a un proceso, mientras que la clase estar铆a asociada a un elemento (variable, array, objeto) y sus procesos.

Una clase que ise en el curso de POO que tiene platzi

class Chapter {
    constructor({name, time, documents = []}) {
        this._name = name;
        this._time = time;
        this._documents = documents;
    }


    get name() {
        return this._name;
    }

    set name(value) {
        this._name = value;
    }

    get time() {
        return this._time;
    }

    set time(value) {
        this._time = value;
    }

    get documents() {
        return this._documents;
    }

    set documents(value) {
        this._documents = value;
    }
}

class Lesson {
    constructor({name, time, chapters = []}) {
        this.name = name;
        this.time = time;
        this.chapters = chapters;

    }
}

class Course {
    constructor({name, hours, lessons = []}) {
        this._name = name;
        this._hours = hours;
        this._lessons = lessons;
    }


    get name() {
        return this._name;
    }

    set name(value) {
        this._name = value;
    }

    get hours() {
        return this._hours;
    }

    set hours(value) {
        this._hours = value;
    }

    get lessons() {
        return this._lessons;
    }

    set lessons(value) {
        this._lessons = value;
    }
}

class LearningPath {
    constructor({name, courses = []}) {
        this._name = name;
        this._courses = courses;
    }

    get name() {
        return this._name;
    }

    set name(value) {
        this._name = value;
    }

    get courses() {
        return this._courses;
    }

    set courses(value) {
        this._courses = value;
    }
}

class Student {
    constructor({
                    firstName,
                    lastName,
                    username,
                    email,
                    twitter = undefined,
                    instagram = undefined,
                    facebook = undefined,
                    approvedCourses = [],
                    learningPath = []
                }) {
        this._firstName = firstName;
        this._lastName = lastName;
        this._username = username;
        this._email = email;
        this._twitter = twitter;
        this._instagram = instagram;
        this._facebook = facebook;
        this._approvedCourses = approvedCourses;
        this._learningPath = learningPath;
    }

    get firstName() {
        return this._firstName;
    }

    set firstName(value) {
        this._firstName = value;
    }

    get lastName() {
        return this._lastName;
    }

    set lastName(value) {
        this._lastName = value;
    }

    get username() {
        return this._username;
    }

    set username(value) {
        this._username = value;
    }

    get email() {
        return this._email;
    }

    set email(value) {
        this._email = value;
    }

    get twitter() {
        return this._twitter;
    }

    set twitter(value) {
        this._twitter = value;
    }

    get instagram() {
        return this._instagram;
    }

    set instagram(value) {
        this._instagram = value;
    }

    get facebook() {
        return this._facebook;
    }

    set facebook(value) {
        this._facebook = value;
    }

    get approvedCourses() {
        return this._approvedCourses;
    }

    set approvedCourses(value) {
        this._approvedCourses = value;
    }

    get learningPath() {
        return this._learningPath;
    }

    set learningPath(value) {
        this._learningPath = value;
    }
}

let basica = new Course({name: 'Curso de programaci贸n Basica', hours: 3});
let htmlAndCss = new Course({name: 'Curso Definitivo de HMTL Y CSS', hours: 2});
let practiceHtmlAndCss = new Course({name: 'Curso Practico de HTML Y CSS', hours: 3});
let unity = new Course({name: 'Curso de Unity 3D', hours: 6});
let unrealEngine = new Course({name: 'Curso de Unreal Engine', hours: 5});

let escuelaWeb = new LearningPath({
    name: 'Escuale de Desarrollo Web',
    courses: [
        basica,
        htmlAndCss,
        practiceHtmlAndCss
    ]
});

let escuelaVideoJuegos = new LearningPath({
    name: 'Escuela de Videos Juegos',
    courses: [
        basica,
        unity,
        unrealEngine
    ]
});


let sergio = new Student(
    {
        firstName: 'Sergio',
        lastName: 'ochoa',
        username: 'gnujavasergio',
        email: '[email protected]',
        learningPath: [
            escuelaWeb,
            escuelaVideoJuegos
        ]
    });
console.log(sergio);

Un ejemplo que ise con clases

class Person {
    constructor(firstName, lastName, height) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.height = height;
    }

    greet() {
        console.log(`Hola, me llamo ${this.firstName} ${this.lastName}`);
    }

    imTall() {
        return this.height > 1.80;
    }
}

class Developer extends Person {
    constructor(firstName, lastName, height, favoriteLanguage) {
        super(firstName, lastName, height);
        this.favoriteLanguage = favoriteLanguage;
    }

    greet() {
        console.log(`Hola, me llamo ${this.firstName} ${this.lastName} y soy un Desarrollador`);
    }
}

let sergio = new Person('Sergio Antonio', 'Ochoa Martinez', 1.175);
sergio.greet();
console.log(sergio.imTall());

let angel = new Person('Angel', 'Martinez', 1.92);
angel.greet();
console.log(angel.imTall());

en realidad no comprendi muy bien si es mejor usar class o const

este es un ejemplo que hago con todo lo que explican en la clase.

class Pet {
    constructor({
        name,
        typeAnimal,
        age,
    }){
        this.name = name;
        this.typeAnimal = typeAnimal;
        this.age = age;
        this.owner = owner;
    }
    //metodos
    owner(proprietor){
        this.owner.push(proprietor)
    }
    // getters and setters
    get age() {
        return this.age;
    }
    set age(num) {
       this.age = num;
    }
}

const ragnar = {
    name: 'Ragnar',
    age: 3,
    typeAnimal: 'Perro Criollo',
    
}
console.log(ragnar);
console.log(ragnar.owner = 'Laura');
console.log(ragnar);
console.log(ragnar.age = 6);
console.log(ragnar);

la verdad la clase explica todo muy rapido, ya habia visto el tema de otro curso que repeti dos veces durante una semana para entender, aqui son solo 15 min, te vuela la cabeza.
se que es de introduccion, pero le falta pedagogia o deberia referenciar otro curso para entender

Bastante distorsionada la explicaci贸n 馃槮

馃く馃く馃く

Me voy a buscar info sobre los conceptos de esta clase, esta un poco enredada, un comercial y regreso.馃槃

El curso est谩 mal ubicado dentro de la ruta que escog铆. Deber铆an ponerlo donde ya te hayan explicado varios conceptos (Ya vi un curso B谩sico y uno pr谩ctico de JS y en ninguno explican la diferencia entre una clase y un objeto, y el profesor sale hablando de 鈥渦n objeto como una instancia de una clase鈥 como un conocimiento que ya te han compartido). En fin, aqu铆 yo siento que el profesor salta de un concepto a otro como si uno ya los dominara, cosa que no es cierta. Esto hace muy pesado el curso al tener que parar e ir a buscar que te lo expliquen en otra parte.

/*
    ES6: clases

Declaracion de una clase 
        declarando
class User {    

}
        Instancia de una clase
Hora vamos a crear una instancia de esta misma clase
                aca el newUser utiliza la clase User como funcion
const newUser = new User ();
--------------------------------------

Hora vamos a crear la clase con los metodos que le vamos a agregar 

class user {
    //metodo funcion
    saludo(){
        return 'Hola';
    }
}

Hora vamos ha crar una instancia para poder aceder al metodo y realizar un llamado del mismo 

const instancia = new user(); // instancia 

// usu del metodo que esta dentro 
console.log(instancia.saludo());

//tambien podemos tener varias instancia llamando diferente metodos o uno solo 

        Constructor : donde podemos inicializar elementos de las clase

class user {
    // constructor
    constructor(){
        console.log('nuevo usuario');
    }
    saludo(){
        return 'Hola';
    }
}
    Cueando se cree una instancia de esta clase va a ejecutar o inicializar los elementos dentro del constructor

const jose = new user();

al ejecutar el codigo nos va llamar el constructor y nos arrojara el 
 nuevo usuario

 -------------------------------------------------
        this
this hace referencia al elemento padre que lo contiene 

class user {
    constructor(name){
        this.name = name;
    }
    //metodo
    hablar(){
        return 'hola'
    }
    saludo(){
        return `${this.hablar()} ${this.name}`;
    }
}
const ana = new user ('Ana');
console.log(ana.saludo());
-------------------------------------------------------
    obtener y guardar elementos
setters getters

class user {
    //constructor
    constructor(name, age){
        this.name = name;
        this.age = age;
    }
    //metodos
    hablar(){
        return 'hola'
    }
    saludo(){
        return `${this.hablar()} ${this.name}`;
    }
     //ahora vamos a crear palabras reservadas que van a contener el get

get uAge(){
    return this.age; //para leer un valor tenerlo dentro de la clase 
}
set uAge(n){
    this.age = n; // ahora que se el valor de no
}
}


const carlos = new user('SEba', 12);
console.log(carlos.uAge);// solo quiero mostrar el valor que esta contenido que se le agrego al constructor "nos debe mostrae 12"
console.log(carlos.uAge = 200);// aca le estamos asignamos un valor al age "nos tiene que mostra el 200"
*/

Los getters no reciben par谩metros y retornan algo,
los setters reciben 1 argumento y no retornan nada鈥 馃槂

Me ayuda a pensar en las clases como planos del objeto que queremos construir, y cada objeto puede ser o no diferente como en: color, nombre y tama帽o, pero las bases o el plano(clases) ser谩 el mismo. Entonces tomamos el plano y creamos nuevos objetos(instancias).
Podr铆a ser una clase coche, con atributos como: color, marca puertas y sus m茅todos (funciones dentro de una clase que engloban comportamientos o funcionalidades relacionadas con la clase) encender(), acelerar(), fuerza().
De la clase (plano) coche creamos varios objetos pero con los mismos atributos y m茅todos.

Muchas veces estos cursos va a un ritmo acelerado, que los temas no se ven con profundidad para aprender las bases. A mi me ha servido mucho ver el temario del curso y ver videos en youtube donde expliquen a profunidad cada tema. Yo vengo de experiencia en desarrollo m贸vil y al estar aprendiendo JS siento que los videos podr铆an no ser los correctos para las personas que est谩n iniciando por lo que les sugiero no quedarse con la informaci贸n de aqu铆, vayan a otros recursos.

Totalmente innecesario crear la misma clase User tantas veces. Se pod铆a hacer todo en la misma y el c贸digo era m谩s limpio y ordenado.

Esta clase es especial. Leyendo el historial de comentarios puedo ver las dificultad que compartimos al entender esta parte de la programaci贸n.

Mi aporte es decirles que esta clase de menos de 20 minutos condesa dos semestres de programaci贸n de computadoras en la universidad estatal. Es incre铆ble la diferencia para compartir conocimiento aqu铆 en Platzi.

Todos los que empiezan y todos los que continu谩n. Platzi is the way

No s茅 si sea m谩s f谩cil entenderlo as铆 pero una clase en CSS le da estilos a varias etiquetas de un HTML. En este caso una clase aqu铆 hace lo mismo pero con m茅todos y funciones en cualquier parte del c贸digo donde se necesite correr el mismo proceso

Esto lo vimos en el curso nuevo basico de programacion, no es tan dificil muchachos es cuestion de verlo y verlo para ir comprendiendo, pero tambien creo que gndx no es buen profesor para explicar esto, hay detalles tan raros como llamarle simbolo de interrogacion a los signos de dolar鈥

menos mal me hab铆a saltado este curso, y vi los que ven铆an despu茅s, primero. Me hubieses desanimado totalmente la falta de ganas de explicar del profe 馃槮

Esto de las clases y los m茅todos, tanto constructor como setters y getters lo entend铆 en el curso de Java dictado por la genia de Anah铆 Salgado, que tom茅 previamente por otra ruta que estoy siguiendo. De no ser por eso, creo que esta explicaci贸n no la hubiese entendido en absoluto. Coincido con los compa帽eros que opinan que falta profundizar en los conceptos que se presentan es esta clase.
Les dejo el link a la clase del curso de Java donde se explica esto de las clases y los m茅todos contructor, setters y getters:
M茅todo constructor
M茅todos Getters y Setters

//Clases 
class User { //declaramos una clase
    constructor(name, age) {
        this.name = name,
        this.age = age
    }

    //metodos de la clase
    speak() {
        return "Hello";
    }

    greeting() {
        return `${this.speak()} ${this.name}`;
    }

    //Getters y Setters
    get uAge() {
        return this.age; //Obtenemos el valor de "Age"
    }
    
    set uAge(n) {
        this.age = n; //Seteamos un nuevo valor en "Age"
    }
}

const ana = new User("Ana", 25); //Creamos un nuevo usuario (instancia) que hereda de la clase User
console.log(ana.greeting()); //Accedemos al usuario ana y a su metodo Greeting
console.log(ana.uAge); //Accedemos al usuario ana y a su Getter
console.log(ana.uAge = 30); //Accedemos al usuario ana y a su Setter

CONSTRUCTOR: Es un metodo que permite crear unas condiciones de estado inicial de un objeto o instancia de clase.

Hare mi aporte con el glosario para que puedan tener claro la definicion de algunos conceptos:

  • Una Clase es un modelo donde se escriben los principales rasgos que caracterizan un conjunto de objetos, por ejemplo , la clase ARBOL. Podria ser una clase dado que hay muchas clases de arboles.Otro ejemplo pordria ser MAMIFERO, pues existen varios tipos de mamiferos.

  • Un Objeto es un ejemplo de la clase.En el caso de la clase ARBOL, un objeto seria un tipo especifico de arbol (por ejemplo,Cedro) y en el caso de MAMIFERO, un objeto seria un tipo especifico de mamifero (por ejemplo : Perro).

  • Un Metodo es una funcion que forma parte integral de un objeto.Describe uno de los usos que se le puede dar a dicho objeto.

  • Una Instancia de clase es un ejemplar perteneciente a una clase especifica y que ya se ha definido.

No se si ser茅 yo, pero menudo picatoste de clase. Creo que no me he enterado de nada.

EXPLICACI脫N F脕CIL
Tenemos la clase MOLDE, esta clase trae la informaci贸n de:

  1. Forma del Helado (esto se refiere a la forma que tiene el molde que le dar谩 al helado)

  2. Punta de Chocalate (Los helados resultantes tendran una rica punta de chocolate)

De esta clase MOLDE se generar谩n dos Objetos que ya tendr谩n la informaci贸n previa de la clase, o sea, solo faltar铆a agregar el sabor Base y palillo al helado.
TE RETO A QUE PASES ESTO A C脫DIGO !