Module pattern y namespaces: propiedades privadas en JavaScript

💚 Like si te enamoraste de Object.defineProperty con esta clase 👊

Existe una manera de definir o modificar varias propiedades a la vez 👀. Con la función Object.defineProperties() se puede pasar un objeto con las propiedades de cada key que quieren ser modificadas:

  // Con defineProperty
  Object.defineProperty(public, "readName", {
    writable: false,
    configurable: false,
  });
  Object.defineProperty(public, "changeName", {
    writable: false,
    configurable: false,
  });

  // Con defineProperties  
  Object.defineProperties(public, {
    readName: {
      configurable: false,
      writable: false,
    },
    changeName: {
      configurable: false,
      writable: false,
    },
  });

Que buen maestro es Timothée Chalamet

Otro forma de lllamar lo que se esta realizando en esta clase es el uso de closures para retornar un contexto controlado y poder usar variables privadas en JS vanilla 😄

Module pattern y namespaces: propiedades privadas en JavaScript

JavaScript no es un lenguaje fuertemente tipado, osea, que no tenemos que definir el tipo de nuestras variables. JavaScript entenderá que tipo de variable estamos usando.

En javascript no hay una palabra clave para definir una variable privada por lo que podemos crear una función que nos permita crear esta variable.

Por lo general, podemos usar el Object.defineProperty() para crear la variable publica o privada

Hola! como estan?
Bien, ese pequeno reto del profe para que el usaurio no pueda hacer juan name = “nicolas”, lo resolvi de esta manera:

newName(name) {
            Object.defineProperty(juan, "name", {
                value: name,
                writable: false,
                configurable: true,
                enumerable: true,
            })
        },
        changeName(newName) {
            this.name = newName;
        },

Todo era felicidad y entusiasmo hasta que llegué a estas últimas clases y cada vez me empecé a perder más 😥

Solo como idea: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy

Para el reto del profe deja una solución posible

 function verify(nameVerify){

    let blackList = ["puto","marica","verga","idiota"];
    let verification = true;


    for (ind in blackList){


        if (nameVerify === blackList[ind]){

            verification = false;

            } 

        }
    

        if (verification){

        console.log("Cambio realizado con exito");

        }
        else {

            console.log("El nombre de usuario no esta permitido");
        }

};

Excelente explicación del profesor

actualmente podemos encapsular atributos y metodos privados en JS gracias al ES2022 simplemente agregando un # adelante del nombre de la variable o funcion y estas no entraran en conflicto con los metodos o atributos publicos, facilmente, podriamos tener declarados dos atributos con el mismo nombre y mas aun, una puede contener a la otra y no habra problema alguno, no se si me estoy adelantando pero solo me dio curiosidad jisjis, aqui la ref. 💚

function verify(newName){
    const blackList = ["fuck","Bastard","Berk","Knob","Manky","Minger","Pillock"];
    for(ind in blackList){
        if(newName == blackList[ind]){
            return false;
        }else{
            return true;
        }
    }
}

if(verify(newName)){
                _private["_name"];
            }else{
                throw new Error(newName + " no es una palabra permitida >:(");
            }
        },

en este caso, object.freeze() no es posible usarlo debido al scope de las funciones

changeName(newName){
        
        const nombre = newName.toLowerCase()
        console.log(nombre)
        for(i in malaPalabras){
            if(nombre.includes(malaPalabras[i].toLowerCase())){
                return console.log(`Esta palabra esta prohibida`)
            }
        }
        this.firsName = newName
    }