The only substantive change since the previous draft is a rename of __createProperty__ to __defineProperty__ in order to mirror the names __defineSetter__ and __defineGetter__. The latter two are not in ES4 but in some browsers and could be expanded to accept additional flags to control enumerability and so on.
--larsTitle: The class "Object"
The class Object
NAME: "The class 'Object'" FILE: spec/library/Object.html CATEGORY: Pre-defined classes (E262-3 Chapter 15) SOURCES: REFERENCES [1], [2] SPEC AUTHOR: Lars DRAFT STATUS: LAST CALL - 2008-03-20 REVIEWED AGAINST ES3: YES REVIEWED AGAINST ERRATA: YES REVIEWED AGAINST BASE DOC: YES REVIEWED AGAINST PROPOSALS: YES REVIEWED AGAINST CODE: YES IMPLEMENTATION STATUS: ES4RI TEST CASE STATUS: ? LAST CALL NOTES * There will eventually be some editorial changes when the RI code is updated. - The names of the magic methods manipulating attributes will be 'positive' instead of 'negative' (eg, 'magic::getEnumerable' instead of 'magic::getDontEnum') - The use of 'Private' below will become uses of 'private' (ticket #368) CHANGES SINCE DRAFT 3 (2008-03-14) * (name cleanup) __createProperty__ renamed as __defineProperty__ to mirror non-ES4 __defineGetter__ and __defineSetter__ * (typo) prototype __defineProperty__ arguments are really called 'enumerable', 'removable', 'deletable'. CHANGES SINCE DRAFT 2 (2008-03-10) * Removed a "note" below * Fixed the spec for Object.prototype.toString (there needs to be a space preceding the class name) * Removed the optional second argument on 'propertyIsEnumerable' * Added the method __createProperty__ CHANGES SINCE DRAFT 1 (2008-03-05) * More elaborate status block above * Prototype methods do not delegate to the corresponding intrinsic methods, but to shared private methods that are also called by the intrinsic method. In this fashion, prototype method behavior is invariant of subclassing * Introduction of a specification-only protocol helper::getClassName for overriding class names for ES3 compatibility REFERENCES [1] http://wiki.ecmascript.org/doku.php?id=proposals:enumerability [2] builtins/Name.es in the ES4 RI
The class Object
is a dynamic non-final class that does not
subclass any other objects: it is the root of the class hierarchy.
All values in ECMAScript except undefined and null are
instances of the class Object
or one of its subclasses.
NOTE Host objects may not be instances of Object
or its
subclasses, but must to some extent behave as if they are (see Host objects).
Synopsis
The class Object
provides this interface:
public dynamic class Object { public function Object(value=undefined) static meta function invoke(value=undefined) static public const length = 1 intrinsic function toString() : string intrinsic function toLocaleString() : string intrinsic function valueOf() : Object intrinsic function hasOwnProperty(name: EnumerableId): boolean intrinsic function isPrototypeOf(value): boolean intrinsic function propertyIsEnumerable(name: EnumerableId): boolean intrinsic function __defineProperty__(name: EnumerableId, value, enumerable:boolean=true, removable:boolean=true, writable:boolean=true): void }
The Object
prototype object provides these direct properties:
toString: function () toLocaleString: function () valueOf: function () hasOwnProperty: function (name) isPrototypeOf: function (value) propertyIsEnumerable: function (name) __defineProperty__: function (name, value, enumerable=undefined, removable=undefined, writable=undefined)
The Object
prototype object is itself an instance of the class
Object
, with the exception that the value of its [[Prototype]]
property is null.
Methods on the Object
class object
new Object ( value= )
Description
When the Object
constructor is called with an argument
value (defaulting to undefined) as part of a new
_expression_, it transforms the value to an object in a way that
depends on the type of value.
Returns
The Object
constructor returns an object (an instance of
Object
or one of its subclasses, or a host object).
NOTE The Object
constructor is the only constructor function
defined on a class in the language whose result may be a value of a
different class than the one in which the constructor is defined.
Implementation
The Object
constructor can't be expressed as a regular
ECMAScript constructor. Instead it is presented below as a helper
function makeObject
that the ECMAScript implementation will invoke
when it evaluates new Object
.
The helper function makeObject
only is invoked on native ECMAScript
values. If new Object
is evaluated on a host object, then actions
are taken and a result is returned in an implementation dependent
manner that may depend on the host object.
helper function makeObject(value=undefined) { switch type (value) { case (s: string) { return new String(s); } case (b: boolean) { return new Boolean(b); } case (n: (int|uint|double|decimal)) { return new Number(n); } case (x: (null|undefined)) { return magic::createObject(); } case (o: Object) { return o; } } }
Object ( value= )
Description
When the Object
class object is called as a function with zero
or one arguments it performs a type conversion.
Returns
It returns the converted value.
Implementation
static meta function invoke(value=undefined) new Object(value);
Methods on Object
instances
The intrinsic methods on Object
instances delegate to private
methods that are also called by the prototype methods.
intrinsic::toString ( )
Description
The intrinsic toString
method converts the this
object
to a string.
Returns
The intrinsic toString
method returns the concatenation of
"["
, "object"
, a single space character (U+0032), the class
name of the object, and "]"
.
Implementation
intrinsic function toString() : string Private::toString();
Private function toString(): string "[object " + helper::getClassName() + "]";
The helper function getClassName
returns the name for the
class. This method is overridden in some of the pre-defined classes
in order to provide backward compatibility with the 3rd Edition of this
Standard: It is overridden by the class Error.
helper function getClassName() magic::getClassName(this);
The function magic::getClassName
extracts the class name
from the object. See magic:getClassName.
intrinsic::toLocaleString ( )
Description
The intrinsic toLocaleString
method calls the public
toString
method on the this
object.
NOTE This method is provided to give all objects a generic
toLocaleString
interface, even though not all may use it.
Currently, Array
, Number
, and Date
provide their own
locale-sensitive toLocaleString
methods.
NOTE The first parameter to this function is likely to be used in a future version of this standard; it is recommended that implementations do not use this parameter position for anything else.
Returns
The intrinsic toLocaleString
method returns a string.
Implementation
intrinsic function toLocaleString() : string Private::toLocaleString();
Private function toLocaleString() this.toString();
intrinsic::valueOf ( )
Description
The intrinsic valueOf
method returns its this
value.
If the object is the result of calling the Object constructor with
a host object (see Host objects), it is
implementation-defined whether valueOf
returns its this
value
or another value such as the host object originally passed to the
constructor.
Returns
The intrinsic valueOf
method returns an object value.
Implementation
intrinsic function valueOf() : Object Private::valueOf();
Private function valueOf(): Object this;
intrinsic::hasOwnProperty ( name )
Description
The intrinsic hasOwnProperty
method determines whether the
this
object contains a property with a certain name, without
considering the prototype chain.
NOTE Unlike [[HasProperty]]
(see HasProperty-defn), this
method does not consider objects in the prototype chain.
Returns
The intrinsic hasOwnProperty
method returns true
if the
object contains the property, otherwise it returns false
.
Implementation
intrinsic function hasOwnProperty(name: EnumerableId): boolean magic::hasOwnProperty(this, name);
Private function hasOwnProperty(name: EnumerableId): boolean magic::hasOwnProperty(this, name);
The function magic::hasOwnProperty
tests whether the object
contains the named property on its local property list (the prototype
chain is not considered). See magic:hasOwnProperty.
The helper function toEnumerableId
returns its argument if it
is one of the member types of EnumerableId
(int
, uint
,
string
, and Name
) and otherwise converts the argument to
string
.
helper function toEnumerableId(x) { switch type (x) { case (x: EnumerableId) { return x; } case (x: *) { return string(x); } } }
intrinsic::isPrototypeOf ( value )
Description
The intrinsic isPrototypeOf
method determines whether its
this
object is a prototype object of the argument value.
Returns
The intrinsic isPrototypeOf
method returns true
if the
this
object is on the prototype chain of value, otherwise it
returns false
.
Implementation
intrinsic function isPrototypeOf(value): boolean Private::isPrototypeOf(value);
Private function isPrototypeOf(value): boolean { if (!(value is Object)) return false; let obj = value; while (true) { obj = magic::getPrototype(obj); if (obj === null || obj === undefined) return false; if (obj === this) return true; } }
The function magic::getPrototype
extracts the [[Prototype]]
property
from the object. See magic:getPrototype.
intrinsic::propertyIsEnumerable ( name )
Description
The intrinsic propertyIsEnumerable
method retrieves the
enumerability flag for a property with a certain name on the
this
object, without considering the prototype chain.
Returns
The intrinsic propertyIsEnumerable
method returns false
if the property does not exist on the this
object; otherwise it
returns the value of the enumerability flag.
Implementation
intrinsic function propertyIsEnumerable(name: EnumerableId): boolean Private::propertyIsEnumerable(name);
Private function propertyIsEnumerable(name) { if (!magic::hasOwnProperty(this, name)) return false; return !magic::getPropertyIsDontEnum(this, name); }
The function magic::hasOwnProperty
tests whether the object
contains the named property on its local property list. See magic:hasOwnProperty.
The function magic::getPropertyIsDontEnum
gets the DontEnum
flag of the property. See magic:getPropertyIsDontEnum.
intrinsic::__defineProperty__ ( name, value, enumerable= , removable= , writable= )
Description
The intrinsic __defineProperty__
method creates a new
dynamic property named name on this object, giving it the value
value and attributes determined by the parameters enumerable,
removable, and writable. If the property already exists, or
if a non-writable property with the same name exists on an object in
the prototype chain of this object, then a TypeError exception is
thrown.
NOTE The name __defineProperty__
(with the leading and trailing
underscores) has been chosen in order to minimize the risk of name
collisions with existing content on the web.
IMPLEMENTATION NOTE The name __defineProperty__
mirrors the names of the
non-standard methods __defineGetter__
and __defineSetter__
that are provided by some implementations. Those implementations may
wish to extend the non-standard methods so that they provide control
of at least enumerability and deletability in a manner compatible with
__defineProperty__
.
Returns
The intrinsic __defineProperty__
method returns nothing.
Implementation
intrinsic function __defineProperty__(name: EnumerableId, value, enumerable:boolean=true, removable:boolean=true, writable:boolean=true): void Private::__defineProperty__(name, value, enumerable, removable, writable);
Private function __defineProperty__(name, value, enumerable, removable, writable) { if (!magic::hasOwnProperty(this, name)) throw new TypeError(/* Property exists */); let obj = magic::getPrototype(this); while (obj != null) { if (magic::hasOwnProperty(obj, name) && magic::getPropertyIsReadOnly(obj, name)) throw new TypeError(/* Property is ReadOnly in prototype chain */); obj = magic::getPrototype(obj); } this[name] = value; magic::setPropertyIsDontEnum(this, name, !enumerable); magic::setPropertyIsDontDelete(this, name, !removable); magic::setPropertyIsReadOnly(this, name, !writable); }
The function magic::hasOwnProperty
tests whether the object
contains the named property on its local property list. See magic:hasOwnProperty.
The function magic::getPrototype
extracts the [[Prototype]]
property
from the object. See magic:getPrototype.
The functions magic::getPropertyIsDontEnum
,
magic::getPropertyIsDontDelete
, and magic::getPropertyIsReadOnly
retrieve the attribute flags of the property. See
magic:getPropertyIsDontEnum,
magic:getPropertyIsDontDelete, and
magic:getPropertyIsReadOnly.
The functions magic::setPropertyIsDontEnum
,
magic::setPropertyIsDontDelete
, and magic::setPropertyIsReadOnly
set the attribute flags of the property. See
magic:setPropertyIsDontEnum,
magic:setPropertyIsDontDelete, and
magic:setPropertyIsReadOnly.
Methods on the Object
prototype object
Description
The methods on the Object
prototype object all perform
simple type adjustments and then perform the same actions as the
corresponding intrinsic methods.
Returns
The prototype methods return what their corresponding intrinsic methods return.
Implementation
prototype function toString() this.Private::toString();
prototype function toLocaleString() this.Private::toLocaleString();
prototype function valueOf() this.Private::valueOf();
prototype function hasOwnProperty(name) this.Private::hasOwnProperty(helper::toEnumerableId(name));
prototype function isPrototypeOf(value) this.Private::isPrototypeOf(value);
prototype function propertyIsEnumerable(name) this.Private::propertyIsEnumerable(helper::toEnumerableId(name));
prototype function __defineProperty__(name, value, enumerable=undefined, removable=undefined, writable=undefined) this.Private::__defineProperty__(helper::toEnumerableId(name), value, enumerable === undefined ? true : boolean(enumerable), removable === undefined ? true : boolean(removable), writable === undefined ? true : boolean(writable));
_______________________________________________ Es4-discuss mailing list Es4-discuss@mozilla.org https://mail.mozilla.org/listinfo/es4-discuss