Estoy declarando myDictionary como un objeto que llena el usuario (clave/valores)
Pero por el tema de la programación defensiva, quiero asegurarme de que si el usuario da __proto__ como clave para el objeto del diccionario, con el valor de "some value" , podrá usarlo, pero como saben cuando llamando a myDictionary.__proto__ al setter/getter del prototipo de objeto.
Una solución que he encontrado para esto es crear el objeto con null como prototipo, por lo que no habrá __proto__ setter/getter en su prototipo. Pero el problema es que tampoco tendrás los métodos del otro Objeto.
Estoy deseando ver si alguien aquí puede resolver la pregunta (¿alguna forma de rellenar los métodos de Objeto mientras se guarda el rendimiento?)
Intentan definir el __proto__ como clave en el diccionario.
let myDictionary = {}; let key = prompt("What's the key?", "__proto__"); myDictionary [key] = "some value"; alert(myDictionary [key]); // [object Object], not "some value"! resolviendo el problema creando el objeto con null como prototipo:
let myDictionary = Object.create(null); let key = prompt("What's the key?", "__proto__"); myDictionary[key] = "some value"; alert(myDictionary[key]); // "some value" ¿O hay alguna manera de asignar propiedades con la clave __proto__ sin interferir con el getter/setter del prototipo de objeto?
Puede usar un proxy para ocultar propiedades no deseadas en el objeto.
Dado que desea tener ciertas propiedades con valores personalizados, se puede proporcionar un mapa de ellos (un objeto no funciona). El retorno de la función createObject será un nuevo objeto que verifica cada clave y la compara con el mapa provisto de claves definidas. De esta manera, esencialmente puede tener propiedades personalizadas en su objeto sin sacrificar sus métodos prototípicos como toString() .
La implementación de este comportamiento o realizada con un Proxy que acepta un getter por cada búsqueda en el objeto, dentro del getter se intercepta la propiedad accedida y si está definida se devuelve ese valor, de lo contrario se devuelve el valor normal.
function protectedObject(target = {}, definedKeys = new Map()) { const handler = { get(target, prop) { if (definedKeys.has(prop)) return definedKeys.get(prop); return target[prop]; } }; return new Proxy(target, handler); } const obj = protectedObject({ test: 123 }, new Map([ ["__proto__", "some value"] ])); console.log(obj.test); console.log(obj.__proto__); console.log(obj.toString()); alert(obj[prompt("What's the key?", "__proto__")]); Todos los métodos Object.prototype están intactos ya que esto crea un objeto real (solo proxy).