Javascript no necesita presentación, sin embargo, para cumplir con el protocolo podemos recordar que es un lenguaje interpretado, basado en prototipos (sin clases o basado en instancias) cuyo estándar es defino por ECMAScript.

Javascript se considera un lenguaje de programación multiparadigma, esto quiere decir, que a pesar de sus particularidades puede moldearse a diferentes enfoques, como programación funcional, procedural, Reactiva e incluso orientado a objetos.

En mi caso particular escucho con frecuencia decir “JavaScript no es POO (programación orientada a objetos) es basada en prototipos” haciendo referencia a la distancia que guarda con lenguajes POO tradicionales como C++ o java. Esta y otras miles de afirmaciones que derivan en debates donde todos tienen la razón son comunes en el área.

Se procede a compartir a través de un ejemplo una propuesta de POO en javaScript, que puede ser adaptada a las necesidades de cada quien.


// Podemos ver las funciones como Clase/Constructor
function Guerrero(nombre,fuerza){
//Atributos, usamos la nomenclatura “_nombreVariable” para indicar que su objetivo es ser usada como variable privada,
this._nombre=nombre;
this._fuerza=fuerza;

    // Métodos getter y setter
    this.getNombre=function(){
        return this._nombre;
    }
    this.getFuerza=function(){
        return this._fuerza;
    }
    

    this.setNombre=function(nuevoNombre) {
        this._nombre=nuevoNombre;
    }
    this.setFuerza=function(nuevaFuerza) {
        this._fuerza=nuevaFuerza;
    }
} 

// Definimos los métodos públicos haciendo uso de prototype fuera de la clase
Guerrero.prototype.entrenar=function(){
    console.log('Entrenando...');
    this.setFuerza((this.getFuerza()+1));
}

//Atributo estáticos 
Guerrero.SONIDO_DE_PELEA='BAM, BOOM, AHHH, POW, AAARGH';



//Método estático 
Guerrero.presentar=function(Guerrero1,Guerrero2){
    console.log('EL PROXIMO ENCUENTRO ES ENTRE EL PODEROSO '+Guerrero1+' Y EL GRAN '+Guerrero2);
}

//Metodo publico
Guerrero.prototype.calcularNivel= function(fuerza){
    console.log('Calculando Nivel...');
    if(fuerza >= 10){
        console.log('Guerrero Digno');
    }else{
        console.log('sigue entrenando insecto');
    }
}



//Creando una clase Hija
function Saiyajin(nombre,fuerza){
    //llamamos al constructor de padre
    Guerrero.prototype.constructor.call(this, nombre, fuerza); 
    // Aquí creamos los atributos y métodos getter y setter de la clase hija si se requieren
}

Saiyajin.prototype= new Guerrero(); // Indicamos la herencia 
Saiyajin.prototype.constructor= Saiyajin; //actualizamos el constructor, dado que se perdió con la instrucción anterior 

//Creando otra clase hija, necesitamos a otro guerrero 
 function Kryptoniano(nombre,fuerza){
    Guerrero.prototype.constructor.call(this,nombre,fuerza);
 }

 Kryptoniano.prototype=new Guerrero();
 Kryptoniano.prototype.constructor=Kryptoniano;

//Función autoejecutable para fines prácticos
(function CampoDeBatalla(){

//relación entre clases agregación/composición
var goku = new Saiyajin("kakaroto",20);
var superMan = new Kryptoniano ('Clark kent', 10);

//Polimorfismo
superMan.entrenar();
goku.entrenar();

//...

Guerrero.presentar(goku.getNombre(),superMan.getNombre());

//goku.atacar();
//superMan.atacar();

console.log(Guerrero.SONIDO_DE_PELEA);

} )();

Como se mencionó antes, este ejemplo es una propuesta que se puede adaptar y ajustar a criterio. Como ejercicio práctico puedes implementar métodos “defender” y “atacar” e incluso crear más guerreros para construir una batalla más interesante.

Si tienes inclinación por POO de seguro te interesara googlear un poco sobre las bondades que ofrece ECMAScript 6 en términos de legibilidad para el enfoque clásico de POO.

Si esta publicación te pareció útil puedes alentar la creación de más contenido votando y comentando.