A cópia do código é a seguinte:
função foreach (o) {
var html = "";
para (var i em o) {
html+= i+"="+o [i]+"";
}
console.log (html);
console.log (O);
}
// 1
//Object.create(proto)
//Object.create(proto,Descriptores)
// Crie um objeto usando o protótipo e atributo especificado
//parâmetro:
// proto: o protótipo do objeto recém -criado pode ser nulo
// descritores: um objeto opcional que mapeia nomes de atributos para atribuir descritores
// retorna um objeto recém -criado, herdado da Proto, e possui as propriedades dos descritores ao mesmo tempo.
A cópia do código é a seguinte:
var obj = object.create ({x: 1, y: 2}, {
Z: {Value: 3, gravável: verdadeiro, enumerável: verdadeiro, configurável: true}
});
foreach (obj)
obj.z = 5
Console.log (OBJ)
console.log ("=======================================================)
// 2
//Object.defineproperties(o,Descriptores)
// Crie ou configure várias propriedades de um objeto
//parâmetro:
// o: o objeto em que os atributos devem ser criados ou configurados
// descritores: o objeto que mapeia o nome do atributo para o descritor de atributo
// Retornar objeto o
A cópia do código é a seguinte:
Object.DefineProperties (Obj, {
A: {value: "A", gravável: falso, enumerável: verdadeiro, configurável: verdadeiro},
B: {value: "b", gravável: falso, enumerável: verdadeiro, configurável: true}
})
foreach (obj);
console.log ("=======================================================)
// 3
//Object.defineProperty(o,name,Desc)
// Crie ou configure a propriedade de um objeto
//parâmetro:
// o: objeto no qual o atributo será criado ou configurado
// Nome: o nome do atributo que será criado ou configurado
// DEC: um objeto de descritor de atributo que descreve o novo atributo a ser criado ou modificações nos atributos existentes
// Retornar objeto o
A cópia do código é a seguinte:
Object.DefineProperty (OBJ, "C", {Value: "C", gravável: false, enumerável: falso, configurável: true})
foreach (obj);
console.log ("=======================================================)
// 4
//Object.freeze(o)
// Defina um objeto como imutável e não afetará os atributos herdados
//parâmetro:
// o: o objeto a ser congelado
// retorna verdadeiro | false
A cópia do código é a seguinte:
var p = {x: 1, y: 2}
Object.Freeze (P);
px = 2;
console.log (P);
console.log (object.isfrozen (p)) // true, ele não pode ser descongelado uma vez congelado
console.log ("=======================================================)
// 5
//Object.getownPropertyDescriptor(o,name)
//parâmetro:
// o: um objeto
// Nome: o nome do atributo a ser consultado
// consulta as propriedades de uma propriedade
// Retorna um objeto de descritor de atributo do atributo especificado do objeto. Se o atributo especificado não existir, ele retornará indefinido.
/*
O descritor de atributo é um objeto JavaScript comum que descreve as características de um determinado objeto. Existem dois tipos de atributos JavaScript. Os atributos de dados têm um valor e três propriedades: enumerável,
gravável e configurável. A propriedade Acessor possui um método getter e/ou setter e enumeração.
Descritores para propriedades de dados:
{
Valor: qualquer valor JavaScript,
gravável: verdadeiro | falso,
enumerável: verdadeiro | falso,
Configurável: Verdadeiro | Falso
}
Descritor para propriedades de acessórios:
{
Get: Função ou indefinido: Substitua o valor do atributo
Conjunto: Função ou indefinido: Substitua a escritura
enumerável: verdadeiro | falso,
Configurável: Verdadeiro | Falso
}
*/
A cópia do código é a seguinte:
var o5 = object.getownPropertyDescriptor (obj, "c");
console.log (O5);
foreach (O5);
console.log ("=======================================================)
// 6
//Object.getownPropertyNames(o)
// Retornar o nome do atributo não-ingerido
//parâmetro:
// o: um objeto
// Retorna os nomes de todos os atributos não-ingeridos de O, incluindo quais propriedades não são enumeráveis. {enumerável: false}
A cópia do código é a seguinte:
var o6 = object.GetownPropertyNames (OBJ);
console.log (O6);
console.log ("=======================================================)
// 7
//Object.getPrototypeof(o)
//parâmetro:
// o: um objeto
// retorna o protótipo de um objeto
A cópia do código é a seguinte:
var o7 = object.getProTypeOf (obj);
console.log (O7);
console.log ("=======================================================)
// 8
//Object.HasownProperty(PropName);
//parâmetro:
// proname contém o nome da propriedade do objeto
// Verifique se um atributo é herdado
// retorna verdadeiro | false
A cópia do código é a seguinte:
console.log (obj.hasownProperty ("x")); // => false
console.log (obj.hasownProperty ("z")); // => true
console.log ("=======================================================)
// 9
//Object.isextensible(o);
// julga se novos atributos podem ser adicionados a um objeto
//parâmetro:
// o: objeto a ser verificado quanto à extensibilidade
// O retorno pode ser adicionado como verdadeiro | não pode ser falso
// Descrição: Todos os objetos são extensíveis quando criados até serem passados para o objeto.PreventExtensions (o) Object.seal (o) ou objeto.Freeze (O);
A cópia do código é a seguinte:
console.log (object.isextensible (obj)); // => true
//Object.preventExtensions(obj)//et It para não extensível
//console.log(Object.isextensible(obj)); // => false
console.log ("=======================================================)
// 10
//Object.isfrozen(o)
// julga se o objeto é imutável
//parâmetro:
// o: objeto a ser verificado
// true se O foi congelado e não muda; Caso contrário, é falso;
A cópia do código é a seguinte:
console.log ("=======================================================)
// 11
//object.isprototypeof(o)
// exibe se o objeto atual é o protótipo de outro objeto
//parâmetro:
// O: todos os objetos
// Se o objeto for um protótipo de O, é verdade, se o não for um objeto ou objeto não for um protótipo de O, é falso.
A cópia do código é a seguinte:
var o = new Object ();
Object.prototype.isPrototypeof (o) // true
Array.prototype.isprototypeof ([1,2]) // true;
Object.prototype.isPrototypeof (function.prototype) // true
console.log ("=======================================================)
// 12
//Object.issealed(o)
// julga se as propriedades de um objeto podem ser adicionadas ou excluídas
//parâmetro:
// o: objeto a ser verificado
// true se O for fechado, caso contrário, falsa.
// Se você não puder adicionar uma nova propriedade (não-ingerida) a um objeto, e a propriedade existente (não-i-herdada) não é excluída, ela será fechada.
// Os métodos comuns de envolver um objeto são objeto.seal (o) ou objeto.Freeze (O)
console.log ("=======================================================)
// 13
//object.keys(o)
// Retornar nome de atributo enumerável gratuito
//parâmetro:
// o: um objeto
A cópia do código é a seguinte:
console.log (object.keys ({x: 1, y: 2})) // => [x, y]
console.log ("=======================================================)
// 14
//Object.preventExtensions(o)
// não adicionando novos atributos em um objeto
//parâmetro:
// o: objeto extensível a ser definido
// Uma vez que está definido para não ser escalável, não pode mais ser alterado para ser extensível
console.log ("=======================================================)
// 15
//object.propertyisenumerable(propName)
// Detecção se um determinado atributo é visível em loop em para/in
//parâmetro
// propName: uma string que contém o nome do atributo especificado do objeto
// Retorne true se o objeto tiver uma propriedade não-inetçada chamada proname e a propriedade for enumerável.
A cópia do código é a seguinte:
var o15 = new Object ();
o15.x = 15;
o15.Propertyisenumerable ("X"); //verdadeiro;
o15.Propertyisenumerable ("y"); //falso;
o15.Propertyisenumerable ("ToString"); //falso;
console.log ("=======================================================)
// 16
//Object.seal(o)
// bloqueia a adição ou remoção das propriedades dos objetos
//parâmetro
// o: objeto a ser fechado
// retorna o objeto do parâmetro no estado fechado O
// 17
//Object.tolocalestring ()
// retorna a etiqueta de string localizada do objeto local
// O método TOLOCALESTRING () padrão fornecido pela classe de objeto é apenas um método simples de chamada tostring ().
// Mas observe que outras classes (matriz, data, número, etc.) definem cada uma de sua própria versão desse método. Usado para executar conversão de string localizada. Esse método também pode ser necessário substituir ao definir sua própria classe.
// 18
//object.toString ()
// Defina a representação da string de um objeto
// Nos programas JavaScript, o método ToString () não é chamado com frequência. Geralmente, se esse método for definido em um objeto, o sistema o chamará automaticamente quando necessário para substituir o objeto por uma string.
// 19
//Object.valueof ()
// o valor original do objeto dado
// retorna o valor original associado ao objeto especificado. Se esse valor existir, se não houver valor associado ao objeto modificado, o próprio objeto será retornado.