Abstracción en JavaScript: Creación de Clases y Prototipos

Abstraccion:
Podemos reducir la complejidad y permitir una implementación y diseño eficiente de los datos.

Ventajas de uso:

• Evitamos codigo duplicado, es decir, reusamos codigo.
• Podemos crear múltiples instancias con una sola abstracción.
• Al encapsular datos, los estamos protegiendo
• Evitamos código a bajo nivel.
• Podemos cambiar implementaciones en la clase, sin perjudicar su funcionamiento.
  🥵

Qué es ABSTRACCIÓN :

• Es la forma de abstraer los datos esenciales de un objeto, para (con el fin de) crear su molde, su Clase, su Prototipo. Abstraer hace referencia a la forma de separar o aislar los datos, rasgos, cualidades, propiedades o características esenciales, para que se puedan crear y formar instancias de dicho molde, o sea, la clase. Crear el prototipo es el objetivo de la abstracción, pues cada elemento u objeto, debe poderse abstraer para que podamos reutilizar el código, o sea crear instancias de esta clase.

Podemos resumir la finalidad de los pilares de POO de la siguiente manera:

📌 La abstracciónes un proceso u operación mental que tiene como objetivo aislar las propiedades y funciones esenciales en una clase que sirve de molde para crear otros objetos(instancias) que comparten las mismas propiedades y funciones y se pueden personalizar.

Un ejemplo básico de abstracción sería:

class SerVivo {

  constructor(edad, feeder) {
    this.edad = edad;
    this.feeder = feeder;
  }

  alimentarse() {
    feeder.feed(this.edad);
    /* Qué hace el feeder? Y yo que sé. Ni lo sé ni me importa.
     Me importa que lo hace, no el CÓMO lo hace.
     Yo solo sé que le paso la edad a ese método y el ser vivo se alimenta correctamente!
     Esto es abstracción. Sabemos que esto hace lo que necesitamos, pero el funcionamiento interno
     nos es completamente irrelevante. Es decir, abstraemos al programador del funcionamiento
     interno del método para que pueda centrarse en arreglar/hacer lo que necesite e ignorar lo demás*/
  }
}

Básicamente, la abstracción en programación consiste en “ocultar” (abstraer) la lógica de algo que no es necesario mostrar, como por ejemplo algunos cálculos complejos o accesos a la base de datos, de la vista del programador. Esto se consigue mediante el uso de interfaces o clases helper donde podemos encapsular ese pedazo de lógica.

También se suele conocer a este concepto como caja negra, puesto que sabemos que por un lado metemos X variables en una función, y a la salida obtenemos lo que necesitamos, pero no vemos el funcionamiento interno (de ahí lo de caja negra).

Si algo es redundante se puede ✨abstraer✨

Podemos ver a la abstracción como una generalización de los objetos del mundo real.

📦 Qué es abstracción

Ideas/conceptos claves

Abstracción es una manera de reducir la complejidad y permitir un diseño e implementación más eficientes en sistemas de software complejos

Apuntes

• La abstracción consiste en abstraer los datos de un objeto para crear su molde, prototipo o clase. Para posteriormente crear instancias de dichos prototipos y nos ahorremos mucho tiempo
• Cada elemento de nuestro proyecto debe poderse abstraer para no repetir el código

Ventajas de la Abstracción

• Evita duplicar código y aumenta la reusabilidad.
• Se puede cambiar la implementación interna de la clase de forma independiente sin afectar al usuario.
• Ayuda a aumentar la seguridad de la aplicación o programa, ya que solo los detalles importantes son proporcionados al usuario

📌 **RESUMEN:** La abstracción es un pilar de la programación orientada a objetos. Esta consiste en poder abstraer los datos de un objeto para posteriormente crear su molde y crear sus respectivas instancias

Abstracción es cuando separamos los datos de un objeto para generar un molde.

Abstracción es:

• Enfocarnos en la información relevante.
• Separar la información central de los detalles secundarios.

Con la abstracción podemos obtener las propiedades de un objeto, en el caso del estudiante, serian su nombre, edad, cursos aprobados, entre otras cosas.

Para los que no entienden qué es abstraer:

-.-.–.-.-.–.-.–

Abstracción:
La abstracción consiste en abstraer los datos de un objeto para crear ya sea su “moldecido”, clase o prototipo.

La abstracción ya la usamos en las últimas clases con los ejemplos de los estudiantes, es prácticamente dejar de usar código lineal que es estar repitiendo lineas de código, a pasar a crear un código “único” o hacer la abstracción de los objetos que se repiten y sólo cambiar la instancia de cada estudiante (nombre, escuela, redes sociales, etc)

Ventajas de la abstracción:

• Permite una mejor conceptualización y modelado del mundo real.

• Mejora la robustez del sistema.

• Mejora el rendimiento.

• Para sistemas tipificados, el conocimiento de los objetos permite la optimización de tiempo de compilación.

• Separa la implementación de la especificación.

• Permite la modificación y mejora de la implementación sin afectar al interfaz público del tipo abstracto de dato.

• Permite la extensibilidad del sistema. Los componentes reutilizables son más fáciles de crear y mantener.

• Recoge mejor la semántica del tipo.

Si quieren mas información sobre la abstracción les paso este link de un articulo de Google

Abstracción
En programación, una abstracción es una manera de reducir la complejidad y permitir un diseño e implementación más eficientes en sistemas de software complejos.

Ventajas de la Abstracción
• Ayuda al usuario a evitar escribir código de bajo nivel.
• Evita duplicar código y aumenta la reusabilidad.
• Se puede cambiar la implementación interna de la clase de forma independiente sin afectar al usuario.
Ayuda a aumentar la seguridad de la aplicación o programa ya que solo los detalles importantes son proporcionados al usuario.

https://developer.mozilla.org/es/docs/Glossary/Abstraction

Abstraer la realidad y llevarla a codigo ✨

Abstracción es la separación intelectual de datos de objetos para crear su clase o prototipo (con propiedades y métodos).

Podriamos definir la ABSTRACCIÓN como un PROCESO que tiene como objetivo, aislar/separar los metodos y atributos de una clase/prototipo, que servira como Molde para crear otros objetos/instancias con dichos metodos y atributos…

La abstracción consiste en diferenciar las características ( propiedades) y funcionalidades ( métodos) de un elemento en particular en relación al resto, es extraer todo la información útil de un elemento que nos pueda ser funcional al momento de solucionar un problema.

Es así como este concepto, aunque sin saberlo ya lo hemos usado, cuando creamos nuestro prototipo student, abstraemos a una persona, extraemos la información que nos parece relevante.

Abstraccion, obtener la escencia de un objeto para crear una plantilla base y crear instancias(clones) de ella

La abstracción consiste en aislar un elemento de su contexto o del resto de los elementos que lo acompañan. En programación, el término se refiere al énfasis en el “¿qué hace?” más que en el “¿cómo lo hace?” (característica de caja negra). El común denominador en la evolución de los lenguajes de programación, desde los clásicos o imperativos hasta los orientados a objetos, ha sido el nivel de abstracción del que cada uno de ellos hace uso.

Comparto mi código, agregue unas coas extra.

/**
 * Classe para crear objetos escuela
 * 
 */

class LearningPaths{
    constructor(
        {
            nameSchool,
            courses,
        }
    ){
        this.nameSchool = nameSchool;
        this.courses = courses;
    };
}

/**
 * Clase Studient para crear objeto estudiante con sus atributos
 */

class Student {
    constructor({
        name,
        email,
        username,
        twitter = undefined,
        instagram = undefined,
        facebook = undefined,
        approveCourses = [],
        learningPaths = [],

    }){
        this.name = name;
        this.email = email;
        this.username = username;
        this.socialMedia = {
            twitter,
            instagram,
            facebook,
        };
        this.approveCourses = approveCourses;
        this.learningPaths = learningPaths;
    }
}

Student.prototype.courses = function(){
    if(this.learningPaths.length == 0){
        console.log('No tiene Escuelas');
    }
    
    this.learningPaths.forEach(element => {

        console.log(element.nameSchool + ': '+element.courses);
        
    });

}

/**
 * Creamos las escuelas
 */

const DesarrolloWeb = new LearningPaths(
    {
        nameSchool : 'Desarrollo Web',
        courses : ['HTML', 'CSS,', 'PHP', 'Maquetacion web'],
    }
);

const VideJuegos = new LearningPaths(
    {
        nameSchool : 'Desarrollo de videojuegos',
        courses : ['C++', 'Modelado 2d', 'Modelado 3d', 'Unity'],
    }
);

const Matematicas = new LearningPaths(
    {
        nameSchool : 'Escuela de matematicas',
        courses : ['Algebra', 'Pensamiento logico', 'Matematicas dicretas', 'Calculo diferencial'],
    }
);



/**
 * Creamos los alumnos
 */

const alumno1 = new Student(
    {
        name: 'Moises',
        username: 'demon',
        email: '[email protected]',
        twitter: 'demontwit',
        approveCourses: ['C++', 'Java', 'Python'],
        learningPaths: [Matematicas, DesarrolloWeb],
    }
);


const alumno2 = new Student(
    {
        name: 'Viridiana',
        username: 'viri',
        email: '[email protected]',
        twitter: 'viritwit',
        approveCourses: ['BasicPOO', 'Unity', 'HTML'],
        learningPaths: [DesarrolloWeb, VideJuegos, Matematicas],
    }
);


const alumno3 = new Student(
    {
        name: 'Viridiana',
        username: 'viri',
        email: '[email protected]',
        twitter: 'viritwit',
        approveCourses: ['BasicPOO', 'Unity', 'HTML'],
        
    }
);


console.log('=========================================================');
console.log(alumno1);
alumno1.courses()
console.log('=========================================================');
console.log(alumno2);
alumno2.courses()
console.log('=========================================================');
console.log(alumno3);
alumno3.courses();

![](

Abstracción

Un proceso general de abstracción consiste en distinguir las propiedades o características del objeto de estudio del objeto de estudio en sí.
.
Ésto es justo lo que se hace en POO cuando se identifican los elementos que interactúan en un sitema (un programa, aplicación, plataforma, etc) y luego se abstraen los atributos y métodos de dichos elementos para crear con ellos un “molde”.

Cuando decimos que se abstrae, es que en el lenguaje se crean nuevas estructuras que manejan decisiones del tipo de dato, manejo de memoria, callstack y cosas similares, dejándonos mas bien lidiar con variables, objetos, arreglos, estructuras complejas en matemática y computación.

The Clone Wars = Abstracción

Este es el concepto que yo tengo sobre la abstracción La abstracción permite representar propiedades y métodos del mundo real en código 🤓

clases

clases
estudiante
ruta
aportes
chat
docente
cursos
Preguntas
comentario
usuario
niotificaciones
puntuacion

mi código del reto:

class Class {
    constructor ({
        name,
        jornada
    }) {
        this.name = name;
        this.jornada = jornada;
    };
}

const claseProg = new Class({
    name: "Clase Teórica Programación",
    jornada: "Diurna",
})

const clasePracProg = new Class({
    name: "Clase Práctica Programación",
    jornada: "Vespertina",
})

class Course {
    constructor ({
        name,
        classes = [],
    }) {
        this.name = name;
        this.classes = classes;
    }
}

 const cursoProgBasica = new Course({
    name: "Curso Gratis de Programación Básica",
    classes: [claseProg],
 })

const cursoDefinitivoHTML = new Course({
    name: "Curso Definitivo de HTML y CSS",
    classes: [claseProg, clasePracProg],
})

const cursoPracticoHTML = new Course({
    name: "Curso Práctico de HTML y CSS",
    classes: [clasePracProg]
})

class LearningPath {
    constructor ({
        nameCourse = undefined,
        courses = undefined,
    }) {
        this.nameCourse = nameCourse;
        this.courses = courses;
    };
}

const escuelaWeb = new LearningPath({
    nameCourse: "Escuela de Desarrollo Web",
    courses: [
        cursoProgBasica,
        cursoDefinitivoHTML,
        cursoPracticoHTML
    ],
});
const escuelaData = new LearningPath({
    nameCourse: "Escuela de Data Science",
    courses: [
        cursoProgBasica,
    ],
});
const escuelaVgs = new LearningPath({
    nameCourse: "Escuela de Videojuegos",
    courses: [
        cursoProgBasica,
    ],
});

class Student {
    constructor ({
        name,
        email,
        username,
        twitter = undefined,
        instagram = undefined,
        facebook = undefined,
        approvedCourses = [],
        learningPaths = [],
    }) {
        this.name = name;
        this.email = email;
        this.username = username;
        this.socialMedia = {
            twitter,
            instagram,
            facebook
        }
        this.approvedCourses = approvedCourses;
        this.learningPaths = learningPaths;
    };
}

const juan2 = new Student({
    name: "JuanDC",
    username: "juandc",
    email: "[email protected]",
    twitter: "fjuandc",
    learningPaths: [escuelaWeb,escuelaData],
});

const miguelito2 = new Student({
    name: "Miguelito",
    username: "miguelitofeliz",
    email: "[email protected]",
    instagram: "miguelito_feliz",
    learningPaths: [escuelaWeb,escuelaVgs],
});

Abstracción

La abstracción es un concepto que se refiere a la capacidad de representar objetos del mundo real en términos de sus características y comportamientos esenciales, y ocultar los detalles complejos de su implementación. La abstracción permite crear clases y objetos que encapsulan datos y comportamientos relacionados, y proporcionan una interfaz clara y simplificada para interactuar con ellos.

Ejemplos de abstracción:

1. Un objeto “Coche” que tiene propiedades como “marca”, “modelo”, “color”, “velocidad”, “aceleración”, “frenado”, etc.

2. Una clase “Persona” que tiene propiedades como “nombre”, “edad”, “género”, “ocupación”, etc.

Abstracción es lo que hace ella contigo: TE DICE QUE QUIERE DARSE UN TIEMPO EN LA RELACIÓN y tú quieres saber el por qué, pero nunca lo sabrás, solo ves que sucede y punto. Luego borra el objeto de la clase MYLOVE que lleva tu nombre y crea otro con el nombre de tu amigo.