/**
* Object descriptor
**/
var a = {
prop1 : 14
}
var descriptorObj1 = Object.getOwnPropertyDescriptor(a, 'prop1');
// Property defined in 'regular' way has descriptor that looks like that
descriptorObj1 is {
value : 14, // object's value
get : undefined, // getter function, it's undefined by default
set : undefined, // setter function, it's undefined by default
writable : true // can value be changed, true by default
enumerable : true // will it be visible in for..in loop, true by default
configurable : true // can you change the descriptor, true
}
/**
* Define single property descriptor
**/
Object.defineProperty(a, 'prop2', { // equivalent of a.prop2 = 'abc'
value : 'abc',
writable : true,
enumerable : true,
configurable : true
});
Object.defineProperty(a, 'prop3', {})
var descriptorObj3 = Object.getOwnPropertyDescriptor(a, 'prop3');
// Property defined with defineProperty() has different defaults
descriptorObj3 is {
value : undefined,
get : undefined,
set : undefined,
writable : false
enumerable : false
configurable : false
}
var obj = { prop1 : 'aaa' }
Object.defineProperty(obj, '_prop2', {
get : function() { return this.prop1 }, // it's get and/or set XOR writable
set : function(val) { this.prop1 = val }, // without set value can't be changed
enumerable : false,
configurable : false
})
var obj = {}; // better example from David :)
(function(){
var __test = 42;
Object.defineProperty(obj, "test", {
get: function(){ return __test; },
set: function(x){ __test=x; }
});
})();
/**
* Define multiple property descriptors
**/
Object.defineProperties(a, {
prop5 : descriptorObj,
prop6 : descriptorObj,
prop7 : descriptorObj
})
/**
* Create object with given prototype
**/
Object.create(proto [, propertiesObject ]);
var obj, oObj;
obj = Object.create(Object.prototype) // equivalent of obj = {}
obj = Object.create(Constructor.prototype) // equivalent of obj = new Contructor()
obj = Object.create(oObj, { prop1 : descriptorObj }) // defaults are the same as in Object.defineProperty()
obj.prop1 // descriptorObj.value
//to specify an ES3 property
obj = Object.create({}, {
p: {
value : 42,
writable : true,
enumerable : true,
configurable : true
}
});
/**
* Get all enumerable properties
**/
Object.keys(obj) // enumerable only, doesn't go into the prototype chain
var arr = ["a", "b", "c"];
Object.keys(arr); // ["0", "1", "2"]
var obj = { 0 : "a", 1 : "b", 2 : "c"};
Object.keys(obj); // ["0", "1", "2"]
var obj = Object.create({}, { prop1 : { value : 42 } });
obj.prop2 = 24;
Object.keys(obj); // ['prop2']
/**
* Get all properties, enumerable or not
**/
Object.getOwnPropertyNames(obj); // enumerable and not, only on the obj, not deeper
var arr = ['a', 'b', 'c'];
Object.getOwnPropertyNames(arr); // ["0", "1", "2", "length"]
var obj = { 0 : "a", 1 : "b", 2 : "c"};
Object.getOwnPropertyNames(obj) // ["0", "1", "2"]
var obj1 = Object.create(obj, { prop1 : { value : 42 } });
obj1.prop2 = 24;
Object.getOwnPropertyNames(obj1) // ['prop2', 'prop1']
Object.keys(obj1) // ['prop2']
for(var i in obj1) {console.log(i)} // 'prop2', '0', '1', '2'
/**
* Get prototype of specified object
**/
Object.getPrototypeOf(obj)
Object.getPrototypeOf({}) // Object
Object.getPrototypeOf('123') // TypeError
/**
* Prevent any extension of the object
**/
Object.preventExtensions(obj);
// prevent adding new properties
// existing properties can be modified
// existing properties can be deleted
// prototypes can be modified
var obj = { 0 : "a", 1 : "b", 2 : "c"};
var obj1 = Object.create(obj, { prop1 : { value : 42 } });
Object.preventExtensions(obj1);
obj1.prop2 = 2 // undefined or TypeError in strict mode
obj1.prop2 // undefined
obj.prop2 = 2 // ok
obj1.prop2 // 2
/**
* Check if object can be extended
**/
Object.isExtensible(obj); // true if preventExtensions(), seal() or freeze() was used,
// false otherwise
/**
* Prevent any extensions, deletions and property changes
**/
Object.seal(obj)
// prevent adding new properties
// existing properties descriptors can't be modified
// existing properties values can be modified
// existing properties can't be deleted
// prototypes can be modified
var obj = { prop1 : 'aaa' }
Object.seal(obj)
obj.prop2 = 'bbb' // TypeError
obj.prop1 = 'bbb' // ok, property value changed
delete obj.prop1 // TypeError
Object.defineProperty(obj, { prop1 : { get : function() { retun 'ccc' } } }) // TypeError
/**
* Check if object is sealed
**/
Object.isSealed(obj); // true if can't be extended and
// properties aren't deletable or configurable,
// false otherwise
/**
* Prevent any changes to the object
**/
Object.freeze(obj);
// object is immutable
// prevent adding new properties
// existing properties descriptors can't be modified
// existing properties values can't be modified
// existing properties can't be deleted
// prototypes can be modified
var obj = { prop1 : 'aaa' }
Object.defineProperty(obj, 'prop2', {
get : function() { return this.prop1 },
set : function(val) { this.prop1 = val }
})
Object.freeze(obj)
obj.prop3 = 'bbb' // TypeError
obj.prop2 = 'bbb' // undefined - obj1.prop1 is still 'aaa'
obj.prop1 = 'bbb' // TypeError
delete obj.prop2 // TypeError
Object.defineProperty(obj, 'prop1', { get : function() { return 'ccc' } } ) // TypeError
/**
* Check if object is immutable
**/
Object.isFrozen(obj); // true if obj properties can't be deleted, added nor changed
// (both descriptor properties and property value)
// false otherwise
