tutorial - javascript injection attack

¿Cómo funciona object.create en JavaScript?

Question

Dime si estoy equivocado:

Un prototipo es un objeto normal. Cuando un objeto hereda un prototipo, no solo copia las propiedades del prototipo, el objeto almacena una referencia al prototipo.

En Firefox, puedo hacer:

var food = {fruit:"apple"};
var more_food = {vegetable:"celery"};
food.__proto__ = more_food;
food.vegetable // celery
food.fruit // apple

Puedo usar la propiedad __proto__ para establecer manualmente la referencia al objeto prototipo.

También puedo usar Object.create :

var food = {fruit:"apple"};
var more_food = {vegetable:"celery"};
food = Object.create(more_food);
food.vegetable // celery
food.fruit // undefined

¿Qué está haciendo exactamente Object.create ? ¿Se asigna a la variable food la referencia al prototipo more_food, o es Object.create simplemente devolviendo una copia del objeto more_food? Si Object.create solo está haciendo una copia, ¿cómo funciona la cadena del prototipo si la variable food no tiene ninguna referencia a more_food?

Answer 1

Un prototipo es un objeto normal. Cuando un objeto hereda un prototipo, no solo copia las propiedades del prototipo, el objeto almacena una referencia al prototipo.

Tienes razón, el prototipo de un objeto, es solo otro objeto al que se hace referencia a través de la cadena de prototipos.

La diferencia entre tus dos fragmentos es que con __proto__ estás mutando el prototipo de food . En su segundo ejemplo, simplemente está asignando un nuevo objeto que se hereda de more_food , por eso food.fruit se resuelve en undefined , porque su asignación original ha perdido su objeto de food original.

¿Qué está haciendo exactamente Object.create?

Object.create crea un nuevo objeto que hereda del objeto pasado como su primer argumento (solo puede ser un objeto o un null ).

¿Se asigna a la variable food la referencia al prototipo more_food, o es Object.create simplemente devolviendo una copia del objeto more_food?

Su variable de food tendrá un nuevo objeto, que se hereda de more_food , no hay ninguna copia en esta operación.

Por ejemplo:

var food = {fruit:"apple"};
var more_food = Object.create(food, {
vegetable: { value: "celery" }
});
more_food.fruit; // "apple"
more_food.vegetable; // "celery"

En el ejemplo anterior, more_food hereda de los food , en otras palabras, food es el prototipo de more_food , esta referencia prototípica se almacena en una propiedad interna llamada [[Prototype]] . El segundo argumento de Object.create permite inicializar propiedades en este nuevo objeto.

No hay copia, es simplemente la delegación en el ejemplo anterior. more_food.fruit puede more_food.fruit través de la cadena de prototipos. El proceso de búsqueda de propiedades es realmente simple. Si una propiedad no se encuentra en un objeto, se busca de nuevo (¡delegación!) En el el prototipo del objeto, recursivamente, hasta que se encuentra un objeto cuyo prototipo es null (como Object.prototype ).

Entonces, more_food.fruit es una propiedad heredada:

more_food.hasOwnProperty(''fruit''); // false, inherited
''fruit'' in more_food; // true

Mientras que el vegetable es una propiedad propia de more_food :

more_food.hasOwnProperty(''vegetable''); // true

El ejemplo anterior se ve gráficamente así:

+---------------------+ [[Prototype]] +---------------+ | more_food |+--------------->| food | |---------------------| |---------------| | vegetable: "celery" | | fruit: "apple | +---------------------+ +---------------+

Si Object.create solo está haciendo una copia, ¿cómo funciona la cadena del prototipo si la variable food no tiene ninguna referencia a more_food?

Object.create no crea copias de objetos, solo configura el prototipo de un nuevo objeto en el momento de su creación.

Tenga en cuenta que __proto__ es una función estándar y que se eliminará de las implementaciones en el futuro, ya se ha incluido como obsoleto en la Documentación de Mozilla , la razón principal de esto, y también es la razón por la que el idioma nunca tenga una La forma de mutar la cadena del prototipo de la forma en que __proto__ permite es que causa problemas de optimización y seguridad, a nivel de VM y JIT.