Differencebetween Native Objects and Host Objects

What is the difference between native objects and host objects?

Both terms are defined in the ECMAScript specification:

native object

object in an ECMAScript implementation whose semantics are fully
defined by this specification rather than by the host environment.

NOTE Standard native objects are defined in this specification. Some
native objects are built-in; others may be constructed during the
course of execution of an ECMAScript program.

Source: http://es5.github.com/#x4.3.6

host object

object supplied by the host environment to complete the
execution environment of ECMAScript.

NOTE Any object that is not native is a host object.

Source: http://es5.github.com/#x4.3.8

---

A few examples:

Native objects: Object (constructor), Date, Math, parseInt, eval, string methods like indexOf and replace, array methods, ...

Host objects (assuming browser environment): window, document, location, history, XMLHttpRequest, setTimeout, getElementsByTagName, querySelectorAll, ...

`new Object` vs `Object` in the ECMAScript spec

Object(window) will never clone window but new Object(window) might. All current -- potentially all known -- implementations just return the same reference, although the spec allows for implementation-defined behavior.

The steps for 15.2.1.1 say:

1. If value is null, undefined or not supplied, create and return a new Object object exactly as if the standard built-in Object constructor had been called with the same arguments
2. Return ToObject(value).

The definition of ToObject (9.9) lists a few types that will be caught by step 1 (in table 14), but for Object has a very simple definition:

The result is the input argument (no conversion).

It explicitly states that the input argument will be returned as-is, so they should be equal references (===).

The definition for new Object (15.2.2.1) has a similar chain of type-checks in step 1, but the step for objects (1.a) is:

i. If the value is a native ECMAScript object, do not create a new object but simply return value.

ii. If the value is a host object, then actions are taken and a result is returned in an implementation-dependent manner that may depend on the host object.

That is, for any host object foo, the call Object(foo) must === foo but new Object(foo) may === foo.

Host objects are defined in 4.3.8 to be

object supplied by the host environment to complete the execution environment of ECMAScript.

This answer lists a few host objects to include window, history, etc. Running those through new Object(foo) should (but doesn't have to) return a different object.

In any case but passing a host object, new Object(foo) seems to be a more complicated chain that defers to ToObject in much the same way as Object(foo).

Unfortunately, 15.2.2.1.1.a.ii states that the "result is returned in an implementation-dependent manner" and has no specifics as to the "actions [that] are taken" and it appears that Chrome will return the same object (equal references) for all of the listed "host objects."

Using this script to check:

var objects = [
  /* Native objects */
  'Object', 'Date', 'Math', 'parseInt', 'eval',
  /* Host objects */
  'window', 'document', 'location', 'history', 'XMLHttpRequest', 'setTimeout'
];

function getDefinedReference(name) {
  if (eval('typeof ' + name) !== 'undefined') {
    return eval(name);
  } else {
    throw new Error('' + name + ' is not defined.');
  }
}

function checkIdentity(name) {
  try {
    var ref = getDefinedReference(name);
    var no = new Object(ref);
    var o = Object(ref);

    console.log(name, ref === no, ref === o, no === o);

    if (ref === o && no !== o) {
      // Make sure ref === Object(ref) but not new Object(ref)
      console.log(name, 'returns different references.');
    }
  } catch (e) {
    console.warn(e);
  }
}

objects.forEach(checkIdentity);

if (typeof window !== 'undefined') {
  for (var f in window) {
    checkIdentity(f);
  }
}

In ECMAScript, how are some of native objects also built-in?

Here is what ES5 shows:

4.3.6
native object # Ⓣ
object in an ECMAScript implementation whose semantics are fully defined by this specification rather than by the host environment.

NOTE Standard native objects are defined in this specification. Some native objects are built-in; others may be constructed during the course of execution of an ECMAScript program.

4.3.7
built-in object # Ⓣ
object supplied by an ECMAScript implementation, independent of the host environment, that is present at the start of the execution of an ECMAScript program.

NOTE Standard built-in objects are defined in this specification, and an ECMAScript implementation may specify and define others. Every built-in object is a native object. A built-in constructor is a built-in object that is also a constructor.

As you can see, it's different that what you've shown.

Built-in objects are native objects made available by the ECMAScript-compliant engine. For example:

• String
• Object
• Array
• Undefined
• Boolean
• etc.

A native object is, for example:

var obj = {};

Or the list shown before. Built-in objects are native.

Also, you didn't show it, but a host object is an object dependant on the environment. For example, in browsers, the host object is window. There are other host objects such as document or XMLHttpRequest though.

What is the difference between a 'standard object' and an 'ordinary object' in ECMAScript?

 const user = { firstname: "Jonas" };

That's an ordinary object (as it is not exotic), however it is not a standard object, as the semantics are defined by me and not by the specification. Its behavior, however, is specified (e.g. user.firstname will evaluate to "Jonas").

What is an ECMAScript native object?

They're "native" because they come with the ECMAScript implementation. A host environment in generally an application consisting of an ECMAScript implementation and several other interfaces that work together. For instance,

• Web Browser — a host environment consisting of ECMAScript implementation, DOM interface, Rendering engine, UI, etc.
• Windows Script Host — a host environment consisting of ECMAScript implementation, VBScript implementation, etc.
• Node.js — a host environment consisting of ECMAScript implementation (V8), HTTP interfaces, etc.

"Built-in" objects are required to inherit from Object or Function, whereas host objects — objects provided by the host environment, but not necessarily present at the start of execution — are not required to but may (and sometimes do).

Examples of native objects defined by ECMA-262

• Object(), Array(), Date()
• Math, JSON, the Global object.

Examples of native, built-in objects not defined by ECMA-262

• Mozilla's numerous JavaScript extensions — such as WeakMap() or __proto__
• JScript's ActiveXObject() constructor and (undocumented) CollectGarbage() function

Examples of host objects

• DOM objects, document and window
• console

---

Related Topics