La copie de code est la suivante:
fonction foreach (o) {
var html = "";
for (var i in o) {
html + = i + "=" + o [i] + "";
}
console.log (html);
console.log (o);
}
// 1
//Object.create(proto)
//Object.create(proto,descriptors)
// Créer un objet en utilisant le prototype et l'attribut spécifié
//paramètre:
// proto: le prototype de l'objet nouvellement créé peut être nul
// Descripteurs: un objet facultatif qui mappe les noms d'attribut aux descripteurs d'attribut
// Renvoie un objet nouvellement créé, hérité de Proto, et a les propriétés des descripteurs en même temps.
La copie de code est la suivante:
var obj = object.create ({x: 1, y: 2}, {
z: {Value: 3, Writable: True, Énumérable: True, configurable: true}
});
foreach (OBJ)
obj.z = 5
Console.log (OBJ)
console.log ("================================================================================
// 2
//Object.defineProperties(O,Descriptors)
// Créer ou configurer plusieurs propriétés d'un objet
//paramètre:
// o: l'objet sur lequel les attributs doivent être créés ou configurés
// Descripteurs: l'objet qui mappe le nom d'attribut au descripteur d'attribut
// Retour objet o
La copie de code est la suivante:
Object.defineproperties (obj, {
a: {valeur: "a", écrivable: false, énumérable: true, configurable: true},
B: {Value: "B", Writable: False, Énumérable: Vrai, configurable: true}
})
foreach (obj);
console.log ("================================================================================
// 3
//Object.defineproperty(o,name,desc)
// Créer ou configurer la propriété d'un objet
//paramètre:
// o: objet sur lequel l'attribut sera créé ou configuré
// Nom: le nom d'attribut qui sera créé ou configuré
// desc: un objet de descripteur d'attribut qui décrit le nouvel attribut à créer ou les modifications aux attributs existants
// Retour objet o
La copie de code est la suivante:
Object.defineproperty (obj, "c", {valeur: "c", écrivable: false, énumérable: false, configurable: true})
foreach (obj);
console.log ("================================================================================
// 4
//Object.freeze(o)
// Définit un objet inchangeable et n'affectera pas les attributs héréditaires
//paramètre:
// o: l'objet à gelé
// Renvoie true | false
La copie de code est la suivante:
var p = {x: 1, y: 2}
Object.freeze (p);
px = 2;
console.log (p);
console.log (object.isfrozen (p)) // vrai, il ne peut pas être décongelé une fois congelé
console.log ("================================================================================
// 5
//Object.getownpropertyDescriptor(o,Name)
//paramètre:
// o: un objet
// Nom: le nom d'attribut à interroger
// interroge les propriétés d'une propriété
// Renvoie un objet de descripteur d'attribut de l'attribut spécifié de l'objet. Si l'attribut spécifié n'existe pas, il renvoie non défini.
/ *
Le descripteur d'attribut est un objet JavaScript ordinaire qui décrit les caractéristiques d'un certain objet. Il existe deux types d'attributs JavaScript. Les attributs de données ont une valeur et trois propriétés: énumérable,
Écrivable et configurable. La propriété Accessor a une méthode Getter et / ou Setter et l'énumération.
Descripteurs pour les propriétés de données:
{
Valeur: Toute valeur JavaScript,
Écrivable: vrai | Faux,
Énumérable: vrai | faux,
configurable: vrai | faux
}
Descripteur pour les propriétés accessoires:
{
get: fonction ou indéfini: remplacer la valeur d'attribut
Ensemble: fonction ou indéfini: remplacer l'écrivabilité
Énumérable: vrai | faux,
configurable: vrai | faux
}
* /
La copie de code est la suivante:
var o5 = object.getownPropertyDescriptor (obj, "c");
console.log (O5);
foreach (O5);
console.log ("================================================================================
// 6
//Object.getownpropertyNames(o)
// Renvoie le nom de l'attribut non hérité
//paramètre:
// o: un objet
// Renvoie les noms de tous les attributs non hérités de O, y compris quelles propriétés ne sont pas énumérées. {Énumérable: faux}
La copie de code est la suivante:
var o6 = object.getownpropertyNames (obj);
console.log (O6);
console.log ("================================================================================
// 7
//Object.getprototypeof(O)
//paramètre:
// o: un objet
// retourne le prototype d'un objet
La copie de code est la suivante:
var o7 = object.getPrototypeOf (obj);
console.log (O7);
console.log ("================================================================================
// 8
//Object.HasownProperty(propname);
//paramètre:
// propName contient le nom de propriété de l'objet
// Vérifiez si un attribut est hérité
// Renvoie true | false
La copie de code est la suivante:
console.log (obj.hasownproperty ("x")); // => false
console.log (obj.hasownproperty ("z")); // => true
console.log ("================================================================================
// 9
//Object.isextenible(O);
// jugez si de nouveaux attributs peuvent être ajoutés à un objet
//paramètre:
// o: objet à vérifier pour l'extensibilité
// Le retour peut être ajouté comme vrai | ne peut pas être faux
// Description: Tous les objets sont extensibles lorsqu'ils sont créés jusqu'à ce qu'ils soient transmis dans Object.Pretentextensions (o) object.seal (o) ou object.freeze (o);
La copie de code est la suivante:
console.log (object.isextenible (obj)); // => true
//Object.pretentextensions(obj)//set-le à ne pas extensible
//console.log(Object.isextenible(OBJ)); // => false
console.log ("================================================================================
// 10
//Object.isfrozen(o)
// juger si l'objet est immuable
//paramètre:
// o: objet à vérifier
// vrai si O a été gelé et ne change pas; Sinon, c'est faux;
La copie de code est la suivante:
console.log ("================================================================================
// 11
//object.isprototypeof(O)
// Affichez si l'objet actuel est le prototype d'un autre objet
//paramètre:
// o: tous les objets
// Si l'objet est un prototype d'O, il est vrai, si O n'est pas un objet ou un objet n'est pas un prototype d'O, il est faux.
La copie de code est la suivante:
var o = nouvel objet ();
Object.prototype.isprototypeof (o) // true
Array.prototype.isprototypeof ([1,2]) // true;
Object.prototype.isprototypeof (function.prototype) // true
console.log ("================================================================================
// 12
//Object.issealed(O)
// juger si les propriétés d'un objet peuvent être ajoutées ou supprimées
//paramètre:
// o: objet à vérifier
// Vrai si O est enfermé, autrement faux.
// Si vous ne pouvez pas ajouter une nouvelle propriété (non héritée) à un objet et que la propriété existante (non héritée) n'est pas supprimée, elle est jointe.
// Les méthodes courantes pour entourer un objet sont objet.Seal (o) ou objet.freeze (o)
console.log ("================================================================================
// 13
//object.keys(o)
// retourne le nom d'attribut énumérable gratuit
//paramètre:
// o: un objet
La copie de code est la suivante:
console.log (object.keys ({x: 1, y: 2})) // => [x, y]
console.log ("================================================================================
// 14
//Object.pretentextensions(O)
// N'ajoute pas de nouveaux attributs sur un objet
//paramètre:
// o: objet extensible à définir
// Une fois qu'il est défini comme non échelonable, il ne peut plus être changé pour être extensible
console.log ("================================================================================
// 15
//Object.propertyiSenumable(propname)
// Détection si un certain attribut est visible en boucle pour / in
//paramètre
// propname: une chaîne contenant le nom d'attribut spécifié de l'objet
// Renvoie True si l'objet a une propriété non héritée nommée PropName et que la propriété est énumérable.
La copie de code est la suivante:
var o15 = nouveau objet ();
O15.x = 15;
O15.PropertySenumableable ("x"); //vrai;
O15.PropertySenumableable ("Y"); //FAUX;
O15.PropertySenumablem ("tostring"); //FAUX;
console.log ("================================================================================
// 16
//Object.seal(o)
// bloque l'addition ou la suppression des propriétés des objets
//paramètre
// o: objet à enfermer
// Renvoie l'objet de paramètre à l'état fermé o
// 17
//Object.tolocalestring ()
// Renvoie l'étiquette de chaîne localisée de l'objet local
// La méthode par défaut tolocalestring () fournie par la classe d'objets n'est qu'une méthode simple d'appel toString ().
// mais notez que d'autres classes (tableau, date, numéro, etc.) définissent chacune leur propre version de cette méthode. Utilisé pour effectuer une conversion de chaîne localisée. Cette méthode peut également être obligée d'être remplacée lors de la définition de votre propre classe.
// 18
//Object.ToString ()
// définir la représentation de chaîne d'un objet
// Dans les programmes JavaScript, la méthode toString () n'est pas souvent appelée. Généralement, si cette méthode est définie dans un objet, le système l'appellera automatiquement si nécessaire pour remplacer l'objet par une chaîne.
// 19
//Object.ValueOf ()
// la valeur d'origine de l'objet donné
// Renvoie la valeur d'origine associée à l'objet spécifié. Si une telle valeur existe, s'il n'y a aucune valeur associée à l'objet modifié, l'objet lui-même sera renvoyé.