La copia del código es la siguiente:
función foreach (o) {
var html = "";
para (var i en o) {
html+= i+"="+o [i]+"";
}
console.log (html);
console.log (o);
}
// 1
//Object.create(proto)
//Object.create(proto,descriptors)
// Crear un objeto utilizando el prototipo especificado y el atributo
//parámetro:
// Proto: el prototipo del objeto recién creado puede ser nulo
// descriptores: un objeto opcional que mapea los nombres de los atributos a los descriptores de atributos
// Devuelve un objeto recién creado, heredado de Proto, y tiene las propiedades de los descriptores al mismo tiempo.
La copia del código es la siguiente:
var obj = object.create ({x: 1, y: 2}, {
z: {valor: 3, Writable: Verdadero, enumerable: Verdadero, configurable: True}
});
foreach (obj)
obj.z = 5
console.log (obj)
console.log ("======================================================")
// 2
//Object.defineProperties(o,descriptors)
// Crear o configurar múltiples propiedades de un objeto
//parámetro:
// o: el objeto en el que se deben crear o configurar los atributos
// descriptores: el objeto que mapea el nombre del atributo al descriptor de atributos
// Return Object O
La copia del código es la siguiente:
Object.defineProperties (obj, {
A: {valor: "A", Writable: False, Enumerable: True, Configurable: True},
B: {valor: "b", Writable: falso, enumerable: verdadero, configurable: true}
})
foreach (obj);
console.log ("======================================================")
// 3
//Object.defineproperty(o,name,desc)
// Crear o configurar la propiedad de un objeto
//parámetro:
// o: objeto en el que se creará o configurará el atributo
// Nombre: el nombre del atributo que se creará o configurará
// DESC: un objeto descriptor de atributos que describe el nuevo atributo que se creará o modifica a los atributos existentes
// Return Object O
La copia del código es la siguiente:
Object.defineProperty (obj, "c", {valor: "c", witable: false, enumerable: false, configurable: true})
foreach (obj);
console.log ("======================================================")
// 4
//Object.Freeze(o)
// Establecer un objeto para que sea inmutable y no afectará los atributos heredados
//parámetro:
// o: el objeto a congelar
// devolver verdadero | Falso
La copia del código es la siguiente:
var p = {x: 1, y: 2}
Objeto.freeze (p);
Px = 2;
console.log (p);
console.log (object.isfrozen (p)) // Verdadero, no se puede descongelar una vez congelado
console.log ("======================================================")
// 5
//Object.getownpropertyDescriptor(o,Name)
//parámetro:
// o: un objeto
// Nombre: el nombre del atributo a consultar
// Consulta las propiedades de una propiedad
// Devuelve un objeto Descriptor de atributo del atributo especificado del objeto. Si el atributo especificado no existe, devuelve indefinido.
/*
El descriptor de atributos es un objeto JavaScript ordinario que describe las características de cierto objeto. Hay dos tipos de atributos JavaScript. Los atributos de datos tienen un valor y tres propiedades: enumerable,
Writable y configurable. La propiedad del acceso tiene un método Getter y/o Setter, y enumeración.
Descriptores para propiedades de datos:
{
Valor: cualquier valor de JavaScript,
Writable: Verdadero | Falso,
enumerable: verdadero | falso,
Configurable: Verdadero | Falso
}
Descriptor para propiedades de accesorios:
{
Obtener: función o indefinido: reemplazar el valor del atributo
establecer: función o indefinido: reemplazar la escritabilidad
enumerable: verdadero | falso,
Configurable: Verdadero | Falso
}
*/
La copia del código es la siguiente:
var o5 = object.getOwnPropertyDescriptor (obj, "c");
console.log (O5);
foreach (O5);
console.log ("======================================================")
// 6
//Object.getownpropertynames(o)
// devuelve el nombre del atributo no heredado
//parámetro:
// o: un objeto
// Devuelve los nombres de todos los atributos no heredados de O, incluido qué propiedades no son enumerables. {enumerable: falso}
La copia del código es la siguiente:
var o6 = object.getOwnPropertynames (obj);
console.log (O6);
console.log ("======================================================")
// 7
//Object.getPrototypeOf(O)
//parámetro:
// o: un objeto
// Devuelve el prototipo de un objeto
La copia del código es la siguiente:
var o7 = object.getPrototypeOf (obj);
console.log (O7);
console.log ("======================================================")
// 8
//Object.hasownproperty(PropName);
//parámetro:
// PropName contiene el nombre de la propiedad del objeto
// Verifique si se hereda un atributo
// devolver verdadero | Falso
La copia del código es la siguiente:
console.log (obj.hasownproperty ("x")); // => falso
console.log (obj.hasownproperty ("z")); // => verdadero
console.log ("======================================================")
// 9
//Object.ISExtensible(o);
// juzga si se pueden agregar nuevos atributos a un objeto
//parámetro:
// o: objeto a verificar la extensibilidad
// El retorno se puede agregar como verdadero | no puede ser falso
// Descripción: Todos los objetos son extensibles cuando se crean hasta que se pasan a objeto.
La copia del código es la siguiente:
console.log (object.isextensible (obj)); // => verdadero
//Object.preventextensions(obj)/////etslt a no extensible
//console.log(Object.isExtensible(obj)); // => falso
console.log ("======================================================")
// 10
//Object.isfrozen(o)
// juzga si el objeto es inmutable
//parámetro:
// o: objeto a verificar
// Verdadero si O ha sido congelado y no cambia; de lo contrario es falso;
La copia del código es la siguiente:
console.log ("======================================================")
// 11
//object.IsprototypeOf(O)
// Muestra si el objeto actual es el prototipo de otro objeto
//parámetro:
// o: todos los objetos
// Si el objeto es un prototipo de o, es verdadero, si o no es un objeto u objeto no es un prototipo de o, es falso.
La copia del código es la siguiente:
var o = nuevo objeto ();
Object.prototype.IsprototypeOF (O) // Verdadero
Array.prototype.isPrototypeOf ([1,2]) // true;
Object.prototype.isprototypeOf (function.prototype) // verdadero
console.log ("======================================================")
// 12
//Object.issealed(o)
// juzga si las propiedades de un objeto se pueden agregar o eliminar
//parámetro:
// o: objeto a verificar
// Verdadero Si o está encerrado, de lo contrario falso.
// Si no puede agregar una nueva propiedad (no heredada) a un objeto, y la propiedad existente (no heredada) no está eliminada, está adjunta.
// Los métodos comunes para encerrar un objeto son objeto.
console.log ("======================================================")
// 13
//object.keys(o)
// devolver el nombre de atributo enumerable gratuito
//parámetro:
// o: un objeto
La copia del código es la siguiente:
console.log (object.keys ({x: 1, y: 2})) // => [x, y]
console.log ("======================================================")
// 14
//Object.preventextensions(o)
// No agregar nuevos atributos en un objeto
//parámetro:
// o: objeto extensible a configurar
// Una vez que no se puede calificar, ya no se puede cambiar para ser extensible
console.log ("======================================================")
// 15
//object.propertyisenumerable(propName)
// detectar si un cierto atributo es visible en bucle en para/in
//parámetro
// propname: una cadena que contiene el nombre del atributo especificado del objeto
// Devuelve verdadero si el objeto tiene una propiedad no heredada llamada PropName y la propiedad es enumerable.
La copia del código es la siguiente:
var o15 = nuevo objeto ();
O15.x = 15;
o15.propertyisenumerable ("x"); //verdadero;
o15.propertyisenumerable ("y"); //FALSO;
o15.propertyisenumerable ("toString"); //FALSO;
console.log ("======================================================")
// 16
//Object.seal(o)
// bloquea la adición o eliminación de las propiedades de los objetos
//parámetro
// o: objeto para estar encerrado
// devuelve el objeto de parámetro en el estado cerrado o
// 17
//Object.tolocaleString ()
// Devuelve la etiqueta de cadena localizada del objeto local
// El método predeterminado tolocaleString () proporcionado por la clase de objeto es solo un método simple toString ().
// Pero tenga en cuenta que otras clases (matriz, fecha, número, etc.) definen su propia versión de este método. Se usa para realizar una conversión de cadenas localizada. También se puede requerir que este método se anule al definir su propia clase.
// 18
//object.ToString ()
// Defina la representación de una cadena de un objeto
// En los programas JavaScript, el método ToString () no suele llamar. En general, si este método se define en un objeto, el sistema lo llamará automáticamente cuando sea necesario para reemplazar el objeto con una cadena.
// 19
//Object.ValueOf ()
// El valor original del objeto dado
// Devuelve el valor original asociado con el objeto especificado. Si tal valor existe, si no hay ningún valor asociado con el objeto modificado, se devolverá el objeto en sí.